Is there a way to enter the class namespace in Python?

Question

I found myself writing the following code:

def dlt(translation):
    del translation.strands[translation.active][translation.locus]

I would rather prefer something like:

def dlt(translation):
    *something*(translation):
        del strands[active][locus]

Is there a way to achieve this?

Answer 1

Namespaces are just Python objects, and you can assign objects (including the result of attribute lookups) to local variable names:

strands = translation.strands
active = translation.active
locus = translation.locus

Alternatively, you'd have to hack together a context manager that modifies locals(), as shown in this answer.

Something like this would do that:

import inspect

class Namespace(object):
    def __init__(self, namespaced):
        self.namespaced = namespaced

    def __enter__(self):
        """store the pre-contextmanager scope"""
        ns = globals()
        namespaced = self.namespaced.__dict__
        # keep track of what we add and what we replace
        self.scope_added = namespaced.keys()
        self.scope_before = {k: v for k, v in ns.items() if k in self.scope_added}
        globals().update(namespaced)
        return self

    def __exit__(self):
        ns = globals()
        # remove what we added, then reinstate what we replaced
        for name in self.scope_added:
            if name in ns:
                del ns[name]
        ns.update(self.scope_before)

then use it like this:

with Namespace(translation):
     del strands[active][locus]

where all items in the translation.__dict__ are made available globally while in the while block.

Note that this is not thread-safe, and has the potential to create lots of confusion for anyone trying to read code that uses this in future, including yourself. Personally, I wouldn't use this.

Answer 2

You should probably use Martijn's answer. But if you really want to do what you asked for, I think this (untested) snippet will do it:

exec "del strands...", translation.__dict__

If you don't like that: Good, you have taste. :-)

Here's another option:

def within(obj, func):
    return func(**obj.__dict__)

Call it like this:

def dostuff(strands, active, locus, **ignored):
    del ...
within(translation, dostuff)