By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
455,595 Members | 1,433 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 455,595 IT Pros & Developers. It's quick & easy.

Question on metaclasses

P: n/a
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

Jul 19 '05 #1
Share this Question
Share on Google+
9 Replies


P: n/a
Steffen Glückselig wrote:
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__

--
Regards,

Diez B. Roggisch
Jul 19 '05 #2

P: n/a
> 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.
--
Regards,

Diez B. Roggisch
Jul 19 '05 #3

P: n/a
Diez B. Roggisch wrote:
Steffen Glückselig wrote:
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
Jul 19 '05 #4

P: n/a
Diez B. Roggisch wrote:
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
Jul 19 '05 #5

P: n/a
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

Jul 19 '05 #6

P: n/a
Steffen Glückselig wrote:
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
Jul 19 '05 #7

P: n/a
Reinhold Birkenfeld wrote:
Diez B. Roggisch wrote:
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)

--
Regards,

Diez B. Roggisch
Jul 19 '05 #8

P: n/a
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

Jul 19 '05 #9

P: n/a
Diez B. Roggisch wrote:
Reinhold Birkenfeld wrote:
Diez B. Roggisch wrote:
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
Jul 19 '05 #10

This discussion thread is closed

Replies have been disabled for this discussion.