Python: Modify variable bindings in calling scope

Question

Is it possible to replace the function foo below with real code such that

def foo():
    #calling_scope()['a']=2
def bar(a):
    print(a)
    foo()
    print(a)
bar(1)

prints

1
2

?

---

To avoid an XY problem, what I really want is to have foo be part of an external module that summarizes common parsing code. At the moment, I solve the parsing as follows: I have a module parse_args that contains a bunch of functions such as

def bool(arg):
  if arg in [True,'True','true']:
     return True
  if arg in [False,'False','false']:
     return False
  raise ValueError('Did not understand boolean value')
def nonnegative(arg):
  if arg<0:
    raise ValueError('Argument cannot be negative')
  return arg  

and I do the following in bar:

def bar(arg1,arg2)
    arg1=parse_args.bool(arg1)
    arg2=parse_args.nonnegative(arg2)

What I would like to be able to do instead is:

def bar(arg1,arg2)
    parse_args(arg1='bool',arg2='nonnegative')

where the pseudocode of parse_args is

def parse_args(**kwargs)
    #cs=calling_scope()
    #for arg in kwargs:
    #    cs[arg]=globals()[kwargs[arg]](cs[arg])

I know this is only marginally less wordy, and I understand that there are probably reasons to favor my current approach over what I aim for, but as someone still learning Python, I am really mainly interested in the feasibility here.

Answer 1

No, it's not possible. You can't alter the local namespace of a function from further down the stack, because the CPython implementation has highly optimised the local namespace in such a way that makes any manipulation impossible.

You are going about your problem the wrong way. Rather than rely on the standard local namespace, create your own in the form of a dictionary. You can then just pass that dictionary around:

def bar(arg1, arg2)
    namespace = {'arg1': arg1, 'arg2': arg2}
    parse_args(namespace, arg1='bool', arg2='nonnegative')

Answer 2

I found a way to do the parsing that I want in a way that is more beautiful than I hoped for, using function annotations and decorators. (Effectively this actually modifies variable bindings in the function where I want them modified, technically this is possible because through the use of decorators the caller becomes the callee.)

I now write

@validated()
def f(a:'nonnegative integer',b:'bool|function', c:'float in_range(0,1)', d:'{float}', e:'{integer:any}',f:'bool'):  
    print(a,b,c,d,e,f)

and get

>>f(a=2,b=lambda x: x>2, c=0,d=[1.2, 2.3], e={1:'foo',2:'bar'},f='true')
2 <function <lambda> at 0x7f4779ae8400> 0.0 [1.2, 2.3] {1: 'foo', 2: 'bar'} True

Note that the integer argument c=0 got converted to the float 0.0 and the string 'true' got converted to the bool True. Curly braces in the annotations indicate any iterable, with colons they indicate dictionaries. Vertical bars indicate alternatives. Different requirements can be concatenated by spaces, as done for parameters a and c. If any of the specifications is not met, for example a=-1, a well-founded error is thrown:

swutil.validation.ValidationError: Invalid argument for parameter 'a': -1 was rejected by 'nonnegative integer' (-1 was rejected by 'nonnegative')

Finally, the decorator takes arguments that can be used to specify which arguments must be passed. For example, @validated('a^b') and @validated('a|b') specify that (exactly) one of a and b must be passed. The other one will be filled with a NotPassed instance.

If anyone is interested in the code, leave a comment and I'll share.