Question on metaclasses

[=?iso-8859-1?q?Steffen_Gl=FCckselig?=]

Hello,

I've been experimenting with metaclasses a bit (even though I am quite
a newbie to python) and stumpled over the following problem in my code:

class Meta(type):
def __init__(cls, name, bases, dct):
for attr, value in dct.items():
if callable(value):
dct[attr] = wrapper(value)

wrapper adds debugging-information to methods of the class (at least
that is my plan).

Using dct[attr] = wrapper(value) does not result in wrapped methods,
though. Using setattr(cls, attr, wrapper(value)) creates the desired
effect, though.

Why are the changes to dct not visible in the instantiated class? Is
dct not the namespace of the class currently instantiated?


best regards
Steffen

 

[Diez B. Roggisch]

Hello,

I've been experimenting with metaclasses a bit (even though I am quite
a newbie to python) and stumpled over the following problem in my code:

class Meta(type):
def __init__(cls, name, bases, dct):
for attr, value in dct.items():
if callable(value):
dct[attr] = wrapper(value)

wrapper adds debugging-information to methods of the class (at least
that is my plan).

Using dct[attr] = wrapper(value) does not result in wrapped methods,
though. Using setattr(cls, attr, wrapper(value)) creates the desired
effect, though.

Why are the changes to dct not visible in the instantiated class? Is
dct not the namespace of the class currently instantiated?

You don't use metaclasses correctly I believe. Usage should look like this:

class Foo(type):
def __new__(cls, name, bases, dict):

for k,v in [(k, v) for k,v in dict.items() if callable(v)]:
cls.wrap(k,v,cls.get_directives(v), dict)

return super(Foo, self).__new__(self, name, bases, dict)

Notice the __new__ instead of __init__, and the call to (actually, through
super) type.__new__

 

[Reinhold Birkenfeld]

Hello,

I've been experimenting with metaclasses a bit (even though I am quite
a newbie to python) and stumpled over the following problem in my code:

class Meta(type):
def __init__(cls, name, bases, dct):
for attr, value in dct.items():
if callable(value):
dct[attr] = wrapper(value)

wrapper adds debugging-information to methods of the class (at least
that is my plan).

Using dct[attr] = wrapper(value) does not result in wrapped methods,
though. Using setattr(cls, attr, wrapper(value)) creates the desired
effect, though.

Why are the changes to dct not visible in the instantiated class? Is
dct not the namespace of the class currently instantiated?

You don't use metaclasses correctly I believe. Usage should look like this:

class Foo(type):
def __new__(cls, name, bases, dict):

for k,v in [(k, v) for k,v in dict.items() if callable(v)]:
cls.wrap(k,v,cls.get_directives(v), dict)

return super(Foo, self).__new__(self, name, bases, dict)

^^^^ ^^^^
self is not bound in your method; use

return super(Foo, cls).__new__(name, bases, dict)

Reinhold

 

[Reinhold Birkenfeld]

class Foo(type):
def __new__(cls, name, bases, dict):

for k,v in [(k, v) for k,v in dict.items() if callable(v)]:
cls.wrap(k,v,cls.get_directives(v), dict)

return super(Foo, self).__new__(self, name, bases, dict)

There is a confusion of self and cls above - rename self with cls.

And remove the first argument to __new__.

Reinhold

 

[Diez B. Roggisch]

class Foo(type):

def __new__(cls, name, bases, dict):

for k,v in [(k, v) for k,v in dict.items() if callable(v)]:
cls.wrap(k,v,cls.get_directives(v), dict)

return super(Foo, self).__new__(self, name, bases, dict)

There is a confusion of self and cls above - rename self with cls.

 

[=?iso-8859-1?q?Steffen_Gl=FCckselig?=]

Are wrap and get_directives somehow built-in? I couldn't find
references to them.

I've noticed, too, that using __new__ I can manipulate the dictionary
resulting in the behavior I intented.

I'd rather like to know: Why does it work in __new__ but not in
__init__?

And, stimulated by your response: Why is using __new__ superior to
__init__?


best regards
Steffen

 

[Reinhold Birkenfeld]

Are wrap and get_directives somehow built-in? I couldn't find
references to them.

I've noticed, too, that using __new__ I can manipulate the dictionary
resulting in the behavior I intented.

I'd rather like to know: Why does it work in __new__ but not in
__init__?

And, stimulated by your response: Why is using __new__ superior to
__init__?

At short, __new__ is called on the class and must return the instance; that
means that the instance isn't created yet.

__init__, on the other hand, is called on the instance which is already created
at that point. So changing dct in __init__ is pointless, because the instance
(which is a class actually) is already created.

Reinhold

 

[Diez B. Roggisch]

class Foo(type):
def __new__(cls, name, bases, dict):

for k,v in [(k, v) for k,v in dict.items() if callable(v)]:
cls.wrap(k,v,cls.get_directives(v), dict)

return super(Foo, self).__new__(self, name, bases, dict)

There is a confusion of self and cls above - rename self with cls.

And remove the first argument to __new__.

Ehm, no, I don't think so. The code was copied and pasted from a working
metaclass (at least I hope so...), and in the original code a underscore
was used for the first argument. I've been following that bad habit for a
while but recently started to be more following to the established
conventions. So I rewrote that code on the fly.

This is the full metaclass:

class TransactionAware(type):
TAS_REX = re.compile("tas:[^, ]+(, *[^, ]+)*)")


WRAPPERS = {
"create" : w_create,
"active" : w_active,
"bind" : w_bind,
"sync" : w_sync,
"autocommit" : w_autocommit,
}
def __new__(_, name, bases, dict):

for k,v in [(k, v) for k,v in dict.items() if callable(v)]:
_.wrap(k,v,_.get_directives(v), dict)

return super(TransactionAware, _).__new__(_, name, bases, dict)

def wrap(_, name, fun, ds, dict, level=0):
if ds:
d, rest = ds[0], ds[1:]
key = "_taw_%s_%i" % (name, level)
try:
w_fun = _.WRAPPERS[d](key)
dict[key] = fun
_.wrap(name, w_fun, rest, dict, level+1)
except KeyError, e:
print "No transaction aware property named %s" % d
raise e
else:

dict[name] = fun

wrap = classmethod(wrap)

def get_directives(_, v):
try:
doc = v.__doc__
res = []
if doc:
for l in doc.split("\n"):
m = _.TAS_REX.match(l.strip())
if m:
res += [s.strip() for s in m.group(1 ).split(",")]
res.reverse()
return res
except KeyError:
return []
get_directives = classmethod(get_directives)

 

[=?iso-8859-1?q?Steffen_Gl=FCckselig?=]

So dct is something like a template rather than the __dict__ of the
actual class?

I'd assume that changing the content of a dict would be possible even
after it has been assigned to some object (here, a class).


thanks and best regards
Steffen

 

[Reinhold Birkenfeld]

class Foo(type):
def __new__(cls, name, bases, dict):

for k,v in [(k, v) for k,v in dict.items() if callable(v)]:
cls.wrap(k,v,cls.get_directives(v), dict)

return super(Foo, self).__new__(self, name, bases, dict)

There is a confusion of self and cls above - rename self with cls.

And remove the first argument to __new__.

Ehm, no, I don't think so. The code was copied and pasted from a working
metaclass (at least I hope so...), and in the original code a underscore
was used for the first argument. I've been following that bad habit for a
while but recently started to be more following to the established
conventions. So I rewrote that code on the fly.

Oh yes. I forgot that __new__ is a staticmethod anyhow.

Reinhold