How to set custom locals for function call?

[Andras Tantos]

On 9/1/20 1:42 PM, Chris Angelico wrote:
> On Wed, Sep 2, 2020 at 5:00 AM Andras Tantos
> <python-list at andras.tantosonline.com> wrote:
>> All,
>>
>> I'm new here, so please direct me to the right forum, if this is not the
>> one...
>>
>> What I'm trying to do is to call a function, but monitor all the local
>> variable accesses within that function. What I thought I would need to
>> do, is to |exec| the function with a custom |locals| dictionary. The
>> code below attempts to do it.
>>
>> |classMySymbolTable(dict):defset_type(self,t):self.type =t
>> def__getitem__(self,key):print(f"Requesting key {key} from {self.type}
>> table")returnsuper().__getitem__(key)def__setitem__(self,key,value):print(f"Setting
>> key {key} from {self.type} table to value
>> {value}")returnsuper().__setitem__(key,value)defmylocals(func):defwrapper(*args,**kwargs):loc
>> =MySymbolTable()glob
>> =MySymbolTable(globals())loc.set_type("local")glob.set_type("global")exec(func.__code__,glob,loc)returnwrapper
>> @mylocalsdeffun1():print(f"fun1 with locals: {type(locals())} and
>> globals: {type(globals())}")a =1b =2c =3a =b c =5fun1()|
> Your code's messed up in the post, so I'm guessing on how this is
> actually meant to be written. Most of your whitespace has been
> destroyed.

Indeed. That's annoying, lemme see if I can copy-paste something in...

class MySymbolTable(dict):
     def set_type(self, t):
         self.type = t
     def __getitem__(self, key):
         print(f"Requesting key {key} from {self.type} table")
         return super().__getitem__(key)
     def __setitem__(self, key, value):
         print(f"Setting key {key} from {self.type} table to value {value}")
         return super().__setitem__(key, value)

def mylocals(func):
     def wrapper(*args, **kwargs):
         loc = MySymbolTable()
         glob = MySymbolTable(globals())
         loc.set_type("local")
         glob.set_type("global")
         exec(func.__code__, glob, loc)
     return wrapper

@mylocals
def fun1():
     print(f"fun1 with locals: {type(locals())} and globals: 
{type(globals())}")
     a = 1
     b = 2
     c = 3
     a = b
     c = 5

fun1()

>> That is to say, global accesses are redirected to my custom dict, but
>> local assignments are not. You can even see that in the types of the two
>> objects printed in the last line.
>>
>> My hunch is that since I'm using the functions |__code__| member, I end
>> up executing pre-compiled byte-code which has already assumptions about
>> the locals dict built into it.
> Yes; and furthermore, CPython generally doesn't even use a dictionary
> for a function's locals. Instead, it uses cells in a special array;
> you can poke around with this by disassembling the code (see the
> built-in "dis" module for details) and looking at the
> LOAD_FAST/STORE_FAST opcodes.
>
> You might be able to mess with this by using a closure, but local
> variable references are generally considered to be an implementation
> detail of the function, and it's not going to be easy to mess with
> them from the outside reliably. What's the goal here?
>
> ChrisA

I did see these macros in the CPython source code. What it seems to 
imply is that if I wanted to do what I intend, that is to hook every 
local variable assignment, I would have to modify the AST. That seems 
rather more effort than simply supplying my own locals dictionary. I 
will try to look myself as well, but do you have an inkling as to how 
complex would it be to convince CPython to optimize locals only if no 
custom locals is provided during exec?

To my untrained eye, it seems to be an unsafe optimization that breaks 
the contract of the exec API.

Andras