Using metaclassed to dynamically generate a class based on a parameter to the objects init function.

[sashang]

Hi

I'd like to use metaclasses to dynamically generate a class based on a
parameter to the objects init function.

For example:

class MetaThing(type) :
def __init__(cls, name, bases, dict, extra_informati on):
super(MetaThing , cls).__init__(n ame, bases, dict)
#setup the class based on the parameter extra_informati on

class Thing:
__metaclass__ = MetaThing
def __init__(self, extra_informati on):
#Somehow pass extra_informati on to the MetaThing

extra_informati on = 1
t = Thing(extra_inf ormation)

The above sample won't work but I hope it demonstrates what I'm trying
to do.

[Bruno Desthuilliers]

sa*****@gmail.c om wrote:

Hi

I'd like to use metaclasses to dynamically generate a class based on a
parameter to the objects init function.
Do you really need a metaclass for this ?
For example:

class MetaThing(type) :
def __init__(cls, name, bases, dict, extra_informati on):
super(MetaThing , cls).__init__(n ame, bases, dict)
#setup the class based on the parameter extra_informati on

class Thing:
__metaclass__ = MetaThing
def __init__(self, extra_informati on):
#Somehow pass extra_informati on to the MetaThing

extra_informati on = 1
t = Thing(extra_inf ormation)
Why would you want a new *class* here ?
The above sample won't work but I hope it demonstrates what I'm trying
to do.

Not enough, I'm afraid - unless it's just me being dumb. From what I see
here, you just can add the extra informations on the object in the
initializer. What's your *real* use case ?


--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'o****@xiludom. gro'.split('@')])"

[sashang]

Bruno Desthuilliers wrote:

sa*****@gmail.c om wrote:

Hi

I'd like to use metaclasses to dynamically generate a class based on a
parameter to the objects init function.

Do you really need a metaclass for this ?

For example:

class MetaThing(type) :
def __init__(cls, name, bases, dict, extra_informati on):
super(MetaThing , cls).__init__(n ame, bases, dict)
#setup the class based on the parameter extra_informati on

class Thing:
__metaclass__ = MetaThing
def __init__(self, extra_informati on):
#Somehow pass extra_informati on to the MetaThing

extra_informati on = 1
t = Thing(extra_inf ormation)

Why would you want a new *class* here ?

The above sample won't work but I hope it demonstrates what I'm trying
to do.

Not enough, I'm afraid - unless it's just me being dumb. From what I see
here, you just can add the extra informations on the object in the
initializer. What's your *real* use case ?

The extra_informati on is used in MetaThing to tell it what attributes
to add to the class. For example:

class MetaThing(type) :
def __init__(cls, name, bases, dict, extra_informati on):
super(MetaThing , cls).__init__(n ame, bases, dict)
#setup the class based on the parameter extra_informati on
setattr(cls, make_name(extra _information),
make_object(ext ra_information) )

Does that clarify things? I might have the wrong approach - I'm new to
metaclasses. However I do think the solution to my problem lies with
them since I have to dynamically generate a class and metaclasses
provide a mechanism for doing this.

[Michele Simionato]

sa*****@gmail.c om wrote:

However I do think the solution to my problem lies with
them since I have to dynamically generate a class and metaclasses
provide a mechanism for doing this.

You rarely need a custom metaclass to generate classes. A class factory

def makeclass(class name, *attributes):
cls = type(classname, mybases, mydic)
for name, value in attributes:
setattr(cls, name, attr)
return cls

is the typical solution for your use case.

OTOH, if you are looking for use classes for metaclasses, look at the
Python Wiki
and use Google.

Michele Simionato

[Bruno Desthuilliers]

sa*****@gmail.c om wrote:

Bruno Desthuilliers wrote:

sa*****@gmail .com wrote:

Hi

I'd like to use metaclasses to dynamically generate a class based on a
parameter to the objects init function.
Do you really need a metaclass for this ?

For example:

class MetaThing(type) :
def __init__(cls, name, bases, dict, extra_informati on):
super(MetaThing , cls).__init__(n ame, bases, dict)
#setup the class based on the parameter extra_informati on

class Thing:
__metaclass__ = MetaThing
def __init__(self, extra_informati on):
#Somehow pass extra_informati on to the MetaThing

extra_inform ation = 1
t = Thing(extra_inf ormation)

Why would you want a new *class* here ?

The above sample won't work but I hope it demonstrates what I'm trying
to do.

Not enough, I'm afraid - unless it's just me being dumb. From what I see
here, you just can add the extra informations on the object in the
initializer . What's your *real* use case ?

The extra_informati on is used in MetaThing to tell it what attributes
to add to the class. For example:

class MetaThing(type) :
def __init__(cls, name, bases, dict, extra_informati on):
super(MetaThing , cls).__init__(n ame, bases, dict)
#setup the class based on the parameter extra_informati on
setattr(cls, make_name(extra _information),
make_object(ext ra_information) )

Does that clarify things? I might have the wrong approach

There's at least something wrong here : the metaclass code is executed
when the class statement (the one for a class having this metaclass) is
eval'd. It won't be called on class instanciation.

http://www.python.org/download/relea...intro/#__new__

Also, you need to understand that modifying a class with impact all it's
instances.
- I'm new to
metaclasses. However I do think the solution to my problem lies with
them since I have to dynamically generate a class
You don't have to create classes for this - it's perfectly legal to set
attributes (data or methods) on a per-object basis. Classes are more
object-factories than rigid types. Just add the needed extra attributes
in the __init__ (the class one, not the metaclass) and you should be done.
and metaclasses
provide a mechanism for doing this.

Metaclasses provides a hook on class creation process. But AFAICT, you
don't necessarily need metaclasses to dynamically create classes...


--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'o****@xiludom. gro'.split('@')])"

[Carl Banks]

sa*****@gmail.c om wrote:

Hi

I'd like to use metaclasses to dynamically generate a class based on a
parameter to the objects init function.

For example:

class MetaThing(type) :
def __init__(cls, name, bases, dict, extra_informati on):
super(MetaThing , cls).__init__(n ame, bases, dict)
#setup the class based on the parameter extra_informati on

class Thing:
__metaclass__ = MetaThing
def __init__(self, extra_informati on):
#Somehow pass extra_informati on to the MetaThing

extra_informati on = 1
t = Thing(extra_inf ormation)
Tricky. First of all, __init__ belongs to the class, not the object.
(Sometimes it's convenient to say it's the object's __init__ method,
but when mucking around with metaclasses it's important be precise
about what belongs to who, otherwise everyone gets confused.) Because
__init__ belongs to the class, the object's class must already exist
before calling it, which is contrary to what you seem to want to do.

It seem as if, when creating an object, you want to create it's very
own class to go with it. I suppose there could be use case for it, but
I highly recommend you consider whether features like instance methods
or classmethods can accomplish what you want. If you'd still rather
that a Thing have its very own class, I recommend you forget about
metaclasses and use a factory function with a closure:

def create_thing(ex tra_information ):
class Thing(object):
def __init__(self):
# use extra_informati on here
...
return Thing()

If you don't like this, or if you insist on using a metaclass, and you
don't care that you'll be confusing the hell out of anyone reading the
code, the answer is to override the class's __new__ method. Unlike
__int__, the __new__ method can return any object it wants, including
an object of a different class. The class should subclass itself in
its __new__ method, providing the passed extra_informati on to the
constructor of the new subclass, then return an object created from
that subclass. The subclass should override __new__ so as not to
repeat the hijinks of the class's __new__.

Don't follow? The actual source code won't be much easier. Here's an
example.

class MetaThing(type) :
def __new__(metacls ,name,bases,cls dict,extra_info rmation):
# use extra_informati on
return type.__new__(me tacls,name,base s,clsdict)

class Thing(object):
def __new__(cls,ext ra_information) :
clsdict = {'__new__':obje ct.__new__}
my_very_own_cla ss = MetaThing(
"Subthing",(Thi ng,),clsdict,ex tra_information )
return object.__new__( my_very_own_cla ss)

Note that Thing doesn't and shouldn't define __metaclass__, since it
creates its subclass directly from the metaclass's constructor. You
could, of course, also use the closure method I demonstrated above in
Thing's __new__ method--essentially you'd be using Thing's __new__
method as the factory function.

The above sample won't work but I hope it demonstrates what I'm trying
to do.

Again, I highly recommend you consider whether what you're "trying to
do" can be done more easily with instance or class methods.
Carl Banks

[Carl Banks]

sa*****@gmail.c om wrote:

The extra_informati on is used in MetaThing to tell it what attributes
to add to the class. For example:

class MetaThing(type) :
def __init__(cls, name, bases, dict, extra_informati on):
super(MetaThing , cls).__init__(n ame, bases, dict)
#setup the class based on the parameter extra_informati on
setattr(cls, make_name(extra _information),
make_object(ext ra_information) )

Does that clarify things?

Why do the extra attributes need to be part of the class? ISTM each
instance has its own class; therefore there it doesn't matter whether a
member is a class member or an instance member.
Carl Banks

[Alex Martelli]

Carl Banks <in**********@a erojockey.com> wrote:

sa*****@gmail.c om wrote:

The extra_informati on is used in MetaThing to tell it what attributes
to add to the class. For example:

class MetaThing(type) :
def __init__(cls, name, bases, dict, extra_informati on):
super(MetaThing , cls).__init__(n ame, bases, dict)
#setup the class based on the parameter extra_informati on
setattr(cls, make_name(extra _information),
make_object(ext ra_information) )

Does that clarify things?

Why do the extra attributes need to be part of the class? ISTM each
instance has its own class; therefore there it doesn't matter whether a
member is a class member or an instance member.

It matters for a "member" that is actually a special-method: Python's
automatic search for special methods (except on old-style classes) does
NOT look at per-instance members, only at per-class ones.

But, as many have already said, a custom metaclass is probably not the
optimal tool for this task (and it's definitely wrong to alter a
metaclass's __init__'s signature in incompatible ways -- you would never
be able to make classes with metaclass MetaThing with a normal class
statement, since the intrinsic call to the metaclass's __init__ fails!).
Alex

[Maric Michaud]

Le Vendredi 23 Juin 2006 16:03, Carl Banks a écrit*:

Don't follow? *The actual source code won't be much easier. *Here's an
example.

* * class MetaThing(type) :
* * * * def __new__(metacls ,name,bases,cls dict,extra_info rmation):
* * * * * * # use extra_informati on
* * * * * * return type.__new__(me tacls,name,base s,clsdict)

* * class Thing(object):
* * * * *def __new__(cls,ext ra_information) :
* * * * * * *clsdict = {'__new__':obje ct.__new__}
* * * * * * *my_very_own_cl ass = MetaThing(
* * * * * * * * *"Subthing",(Th ing,),clsdict,e xtra_informatio n)
* * * * * * *return object.__new__( my_very_own_cla ss)

Hmmm, rigourously speaking, metaclasses in OOP are classes whose instances are
class.
Something like that :

In [114]: class MetaClass(objec t) :
.....: def __new__(cls, name, bases=(), **some_attribut es) :
.....: return type('newtype %s' % name, bases, some_attributes )
.....:
.....:
Let's play with it :
In [115]: Concrete1 = MetaClass('conc 1', (), classprop=1, method=lambda
s : "fun")

In [116]: Concrete2 = MetaClass('conc 1', (), classprop=1, method=lambda
s : "fun")

In [117]: isinstance(Conc rete1(), Concrete2)
Out[117]: False

In [118]: isinstance(Conc rete1(), Concrete1)
Out[118]: True

In [119]: Concrete1().met hod()
Out[119]: 'fun'

In [120]: Concrete1.class prop
Out[120]: 1

In [121]: class Abstract(object ) :
.....: def __init__(self) : self._attr = self._attr_type ()
.....:
.....:

In [122]: Concrete = MetaClass('conc rete_with_list' , (Abstract,),
_attr_type=list )

In [123]: Concrete()._att r
Out[123]: []

In [124]: Concrete = MetaClass('conc rete_with_int', (Abstract,),
_attr_type=int)

In [125]: Concrete()._att r
Out[125]: 0

In [126]: type(Concrete)
Out[126]: <type 'type'>

In [127]: type(Concrete() )
Out[127]: <class '__main__.newty pe concrete_with_i nt'>
regards,

--
_____________

Maric Michaud
_____________

Aristote - www.aristote.info
3 place des tapis
69004 Lyon
Tel: [phone]

[Maric Michaud]

Le Vendredi 23 Juin 2006 17:09, Maric Michaud a écrit*:

Hmmm, rigourously speaking, metaclasses in OOP are classes whose instances
are class.

Ooops, sorry i didn't notice you were calling type's __new__ (and not
object'sone).
--
_____________

Maric Michaud
_____________

Aristote - www.aristote.info
3 place des tapis
69004 Lyon
Tel: [phone]