Getting the block of commands that are to be executed in the with statement

Question

In reading the specifications for the with statement (link), I have some things I'd like to play around with. This isn't for any production code or anything, I'm just exploring, so please don't be too harsh if this is a bad idea.

What I'd like to do is grab the piece called "BLOCK" in the linked docs above, and actually tinker around with it inside of the call to __enter__. (See the linked doc, just after the start of the motivation and summary section.)

The idea is to create my own sort of on-the-fly local namespace. Something like this:

with MyNameSpace(some_object):
    print a #Should print some_object.a
    x = 4 #Should set some_object.x=4

Basically, I want the statements inside of the with block to be subordinate to the local variables and assignment conventions of some_object.

In my specific case, some_object might be a special data array that has my own column-wise operations or something. In which case saying something like x = y + 5 if y > 4 else y - 2 might be some fancy NumPy vectorized operation under the hood, but I don't need to explicitly call some_object's interface to those methods. In the namespace, the expressions should "just work" (however I define them to be inferred in the MyNameSpace class.

My first idea is to somehow interrupt the with process and get a hold of the code that goes in the try block. Then interpret that code when __enter__ gets called, and replace the code in the try block with something else (perhaps pass if that would work, but possibly something that restores some_object back to the original variable scope with its new changed variables preserved).

A simple test case would be something like this:

my_dict = {'a':3, 'b':2}
with MyNameSpace(my_dict):
    print a # Should print 3
    x = 5 # When the block finishes, my_dict['x'] should now be 5

I'm interested if this idea exists somewhere already.

I am aware of best practices things for assigning variables. This is a pet project, so please assume that, just for the sake of this idea, we can ignore best practices. Even if you wouldn't like assigning variables this way, it could be useful in my current project.

Edit

To clarify the kinds of tricky stuff I might want to do, and to address the answer below claiming that it can't be done, consider the example file testLocals.py below:

my_dict = {'a':1, 'b':2}
m = locals()
print m["my_dict"]['a']
m["my_dict"]['c'] = 3
print my_dict

class some_other_scope(object):
    def __init__(self, some_scope):
        x = 5
        g = locals()
        some_scope.update(g)
        some_scope["my_dict"]["d"] = 4

sos = some_other_scope(m)
print my_dict
print x

which gives the following when I run it non-interactively:

ely@AMDESK:~/Desktop/Programming/Python$ python testLocals.py
1
{'a': 1, 'c': 3, 'b': 2}
{'a': 1, 'c': 3, 'b': 2, 'd': 4}
5

Answer 1

Try this.

import sys 
class MyNameSpace(object):
    def __init__(self,ns):
        self.ns = ns
    def __enter__(self):
        globals().update(self.ns)
    def __exit__(self, exc_type,exc_value,traceback):
        self.ns.update(sys._getframe(1).f_locals)

my_dict = {'a':3, 'b':2} 
with MyNameSpace(my_dict) as ns:
    print(a) # Should print 3
    x = 5 # When the block finishes, my_dict['x'] should now be 5 

print(my_dict['x'])

Answer 2

Here is something similar I tried a few months ago:

import sys
import inspect
import collections

iscallable = lambda x: isinstance(x, collections.Callable)

class Namespace(object):
    def __enter__(self):
        """store the pre-contextmanager scope"""
        f = inspect.currentframe(1)
        self.scope_before = dict(f.f_locals)
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        """determine the locally declared objects"""
        f = inspect.currentframe(1)
        scope_after = dict(f.f_locals)
        scope_context = set(scope_after) - set(self.scope_before)

        # capture the local scope, ignoring the context manager itself
        self.locals = dict(
            (k, scope_after[k]) for k in scope_context if not isinstance(scope_after[k], self.__class__)
        )

        for name in self.locals:
            obj = scope_after[name]
            if iscallable(obj):
                # closure around the func_code with the appropriate locals
                _wrapper = type(lambda: 0)(obj.func_code, self.locals)
                self.__dict__[name] = _wrapper
                # update locals so the calling functions refer to the wrappers too
                self.locals[name] = _wrapper
            else:
                self.__dict__[name] = obj

            # remove from module scope
            del sys.modules[__name__].__dict__[name]

        return self

with Namespace() as Spam:
    x = 1
    def ham(a):
        return x + a      
    def cheese(a):
        return ham(a) * 10

It uses inspect to modify locals while within the context manager and then to re-assign back to the original values when done.

It's not perfect - I can't remember where it hits issues, but I'm sure it does - but it might help you get started.