Which you would then use like:
conn = create_conn()
with new_transaction(conn) as tran:
rows_affected = do_query_stuff(tran)
if rows_affected == 42:
tran.commit()
Yep. There's a problem, though, when you bring in subtransactions. The
logic wants to be like this: [snip hideous code]
I don't like the look of this. It might work, but it's hardly ideal.
This is why I like to be able to nest usages of the same name.
Yes, and the obvious way to nest usages of the same name is to use a
instance with a class attribute and instance attribute of the same name:
class Example:
attr = 23
x = Example()
x.attr = 42
print(x.attr)
del x.attr
print(x.attr)
If you need more than two levels, you probably ought to re-design your
code to be less confusing, otherwise you may be able to use ChainMap to
emulate any number of nested scopes.
One interesting trick is you can use a ChainMap as function globals.
Here's a sketch for what you can do in Python 3.3:
from types import FunctionType
from collections import ChainMap
class _ChainedDict(ChainMap, dict):
# Function dicts must be instances of dict :-(
pass
def chained_function(func, *dicts):
"""Return a new function, copied from func, using a
ChainMap as dict.
"""
dicts = dicts + (func.__globals__, builtins.__dict__)
d = _ChainedDict(*dicts)
name = func.__name__
newfunc = FunctionType(
func.__code__, d, name, closure=func.__closure__)
newfunc.__dict__.update(func.__dict__)
newfunc.__defaults__ = func.__defaults__
return newfunc
And in use:
py> f = chained_function(lambda x: x+y, {'y': 100})
py> f(1)
101
py> f.__globals__.maps.insert(0, {'y': 200})
py> f(1)
201
py> del f.__globals__.maps[0]['y']
py> f(1)
101
