Question

I want to have a function in a different module, that when called, has access to all variables that its caller has access to, and functions just as if its body had been pasted into the caller rather than having its own context, basically like a C Macro instead of a normal function. I know I can pass locals() into the function and then it can access the local variables as a dict, but I want to be able to access them normally (eg x.y, not x[“y”] and I want all names the caller has access to not just the locals, as well as things that were ‘imported’ into the caller’s file but not into the module that contains the function.

Is this possible to pull off?

Edit 2 Here’s the simplest possible example I can come up with of what I’m really trying to do:

def getObj(expression)
  ofs = expression.rfind(".")
  obj = eval(expression[:ofs])  
  print "The part of the expression Left of the period is of type ", type(obj), 

Problem is that ‘expression’ requires the imports and local variables of the caller in order to eval without error.In reality theres a lot more than just an eval, so I’m trying to avoid the solution of just passing locals() in and through to the eval() since that won’t fix my general case problem.

Answer 1

I don’t presume this is the answer that you wanted to hear, but trying to access local variables from a caller module’s scope is not a good idea. If you normally program in PHP or C, you might be used to this sort of thing?

If you still want to do this, you might consider creating a class and passing an instance of that class in place of locals():

#other_module.py
def some_func(lcls):
    print(lcls.x)

Then,

>>> import other_module
>>> 
>>> 
>>> x = 'Hello World'
>>> 
>>> class MyLocals(object):
...     def __init__(self, lcls):
...             self.lcls = lcls
...     def __getattr__(self, name):
...             return self.lcls[name]
... 
>>> # Call your function with an instance of this instead.
>>> other_module.some_func(MyLocals(locals()))
'Hello World'

Give it a whirl.