Replace Whole Object Through Object Method

[digitalorganics]

How can an object replace itself using its own method? See the
following code:

class Mixin:
def mixin(object, *classes):
NewClass = type('Mixin', (object.__class __,) + classes, {})
newobj = NewClass()
newobj.__dict__ .update(object. __dict__)
return newobj

def isClass(object) :
if 'classobj' in str(type(object )):
return 1
elif "'type'" in str(type(object )):
return 1
else:
return 0
def listClasses():
classes = []
for eachobj in globals().keys( ):
if isClass(globals ()[eachobj]):
classes.append( globals()[eachobj])
print eachobj
return classes

def MixInto(Class, Mixin):
if Mixin not in Class.__bases__ :
Class.__bases__ += (Mixin,)
------------------------------------------------------------------------

Okay, so the mixin function becomes part of whatever class I choose and
hence its instances, but the problem is that the way I currently have
it setup mixin() returns a new object, instead of replacing whatever
class instance that calls it into that new object. I hope I'm making
sense here.

Basically what I need is for the method to be able to find out the name
of the instance, then I can just go to the globals dictionary to do the
replacement.

Advance thanks to all who can help...

[Maric Michaud]

Le lundi 26 juin 2006 17:57, di************* @gmail.com a écrit*:

How can an object replace itself using its own method? See the
following code:

class Mixin:
def mixin(object, *classes):
NewClass = type('Mixin', (object.__class __,) + classes, {})
newobj = NewClass()
newobj.__dict__ .update(object. __dict__)
return newobj

Variables in python are names, not the objects, and instances shouldn't know
nothing about how they are referenced.

I guess what you want to do is, in fact, very simple somethig like :

a = SomeClass()
a = a.some_method_w ich_return_a_ne w_object()

or :

for k, v in globals().iteri tems() :
if isinstance(v, SomeClass) :
globlals()[k] = v.some_method_w ich_return_a_ne w_object()

def isClass(object) : Don't mask builtin names. if 'classobj' in str(type(object )): Why don't you test the type directly ? return 1 Python has boolean for clarity.
elif "'type'" in str(type(object )):
return 1
else:
return 0 should be :

import types

def isClass(object_ ) :
if isinstance(obje ct_, type) :
return True # new style class
elif isinstance(obje ct_, types.ClassType ) :
return True # old-style class
else : return False

or if you don't need to diferentiate the cases :

def isClass(object_ ) :
return isinstance(obje ct_, type) or \
isinstance(obje ct_, types.ClassType )
def listClasses():
classes = []
for eachobj in globals().keys( ):
if isClass(globals ()[eachobj]):
classes.append( globals()[eachobj])
print eachobj
return classes

def MixInto(Class, Mixin):
if Mixin not in Class.__bases__ :
Class.__bases__ += (Mixin,)
This doesn't work in most cases (with new style classes), better recreat a
type which inherit from Class and Mixin, or Class.__dict__ with
Mixin.__dict__.
------------------------------------------------------------------------

Okay, so the mixin function becomes part of whatever class I choose and
hence its instances, but the problem is that the way I currently have
it setup mixin() returns a new object, instead of replacing whatever
class instance that calls it into that new object. I hope I'm making
sense here.

Basically what I need is for the method to be able to find out the name
of the instance, then I can just go to the globals dictionary to do the
replacement.

Advance thanks to all who can help...

--
_____________

Maric Michaud
_____________

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

[Bruno Desthuilliers]

di************* @gmail.com wrote:

How can an object replace itself using its own method?
AFAIK, It can't (but I can be wrong - some guru around ?).
See the
following code:

class Mixin:
def mixin(object, *classes):
NewClass = type('Mixin', (object.__class __,) + classes, {})
newobj = NewClass()
newobj.__dict__ .update(object. __dict__)
return newobj

def isClass(object) :
if 'classobj' in str(type(object )):
return 1
elif "'type'" in str(type(object )):
return 1
else:
return 0
def listClasses():
classes = []
for eachobj in globals().keys( ):
if isClass(globals ()[eachobj]):
classes.append( globals()[eachobj])
print eachobj
return classes
FWIW:
Python 2.4.3 (#1, Jun 3 2006, 17:26:11)
[GCC 3.4.6 (Gentoo 3.4.6-r1, ssp-3.4.5-1.0, pie-8.7.9)] on linux2
Type "help", "copyright" , "credits" or "license" for more information.

def dumbfactory(): .... class Dumb(object): pass
.... class Dummy: pass
.... return Dumb, Dummy
.... globals() {'__builtins__' : <module '__builtin__' (built-in)>, '__name__':
'__main__', '__doc__': None, 'dumbfactory': <function dumbfactory at
0x2aaaaab66e60> } def fun(): .... dumb, dummy = dumbfactory()
.... return
.... fun()
globals() {'__builtins__' : <module '__builtin__' (built-in)>, '__name__':
'__main__', 'fun': <function fun at 0x2aaaaab66ed8> , '__doc__': None,
'dumbfactory': <function dumbfactory at 0x2aaaaab66e60> }
Looks like dumb and dummy won't get listed... And also:
class Mymeta(type): .... pass
.... class Foo(object): .... __metaclass__ = Mymeta
.... "'type'" in str(type(global s()['Mymeta']))

True

Looks like this will list metaclasses too... May or may not be a problem...
def MixInto(Class, Mixin):
You're aware that in this function's scope, the 'Mixin' arg name will
shadow the Mixin class name ? (sorry for asking dumb question).
if Mixin not in Class.__bases__ :
Class.__bases__ += (Mixin,)
------------------------------------------------------------------------

Okay, so the mixin function becomes part of whatever class I choose and
hence its instances, but the problem is that the way I currently have
it setup mixin() returns a new object, instead of replacing whatever
class instance that calls it into that new object. I hope I'm making
sense here.

Basically what I need is for the method to be able to find out the name
of the instance, then I can just go to the globals dictionary to do the
replacement.

Advance thanks to all who can help...

Instead of exposing problems with your solution, you may want to expose
the real use case ?
--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'o****@xiludom. gro'.split('@')])"

[digitalorganics]

Maric Michaud wrote:

Le lundi 26 juin 2006 17:57, di************* @gmail.com a écrit :

How can an object replace itself using its own method? See the
following code:

class Mixin:
def mixin(object, *classes):
NewClass = type('Mixin', (object.__class __,) + classes, {})
newobj = NewClass()
newobj.__dict__ .update(object. __dict__)
return newobj

Variables in python are names, not the objects, and instances shouldn't know
nothing about how they are referenced.

I guess what you want to do is, in fact, very simple somethig like :

a = SomeClass()
a = a.some_method_w ich_return_a_ne w_object()

or :

for k, v in globals().iteri tems() :
if isinstance(v, SomeClass) :
globlals()[k] = v.some_method_w ich_return_a_ne w_object()

def isClass(object) :

Don't mask builtin names.

You mean "object"? The shadow/mask only exists within the scope of the
function. But anyhow, point well taken.

if 'classobj' in str(type(object )):

Why don't you test the type directly ?

Thanks.

return 1

Python has boolean for clarity.

Thanks.

elif "'type'" in str(type(object )):
return 1
else:
return 0 should be :

import types

def isClass(object_ ) :
if isinstance(obje ct_, type) :
return True # new style class
elif isinstance(obje ct_, types.ClassType ) :
return True # old-style class
else : return False

or if you don't need to diferentiate the cases :

def isClass(object_ ) :
return isinstance(obje ct_, type) or \
isinstance(obje ct_, types.ClassType )

Very clean! Thank you.

def listClasses():
classes = []
for eachobj in globals().keys( ):
if isClass(globals ()[eachobj]):
classes.append( globals()[eachobj])
print eachobj
return classes

def MixInto(Class, Mixin):
if Mixin not in Class.__bases__ :
Class.__bases__ += (Mixin,)
This doesn't work in most cases (with new style classes), better recreat a
type which inherit from Class and Mixin, or Class.__dict__ with
Mixin.__dict__.

What doesn't work exactly? The whole purpose of the mixin is to add
functionality to the class and hence to all its instances on the fly.
Creating a new type would not achieve this, unless there's something
I'm missing (a very real possibility!). And what do you mean doesn't
work in most newstyleclass cases? Seems to be working just fine...

------------------------------------------------------------------------

Okay, so the mixin function becomes part of whatever class I choose and
hence its instances, but the problem is that the way I currently have
it setup mixin() returns a new object, instead of replacing whatever
class instance that calls it into that new object. I hope I'm making
sense here.

Basically what I need is for the method to be able to find out the name
of the instance, then I can just go to the globals dictionary to do the
replacement.
Any answers my primary question though?

Advance thanks to all who can help...

--
_____________

Maric Michaud
_____________

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

[digitalorganics]

Bruno Desthuilliers wrote:

di************* @gmail.com wrote:

How can an object replace itself using its own method?
AFAIK, It can't (but I can be wrong - some guru around ?).

...

FWIW:
Python 2.4.3 (#1, Jun 3 2006, 17:26:11)
[GCC 3.4.6 (Gentoo 3.4.6-r1, ssp-3.4.5-1.0, pie-8.7.9)] on linux2
Type "help", "copyright" , "credits" or "license" for more information.

def dumbfactory(): ... class Dumb(object): pass
... class Dummy: pass
... return Dumb, Dummy
... globals() {'__builtins__' : <module '__builtin__' (built-in)>, '__name__':
'__main__', '__doc__': None, 'dumbfactory': <function dumbfactory at
0x2aaaaab66e60> } def fun(): ... dumb, dummy = dumbfactory()
... return
... fun()
globals() {'__builtins__' : <module '__builtin__' (built-in)>, '__name__':
'__main__', 'fun': <function fun at 0x2aaaaab66ed8> , '__doc__': None,
'dumbfactory': <function dumbfactory at 0x2aaaaab66e60> }
Looks like dumb and dummy won't get listed... And also:
class Mymeta(type): ... pass
... class Foo(object): ... __metaclass__ = Mymeta
... "'type'" in str(type(global s()['Mymeta'])) True

Looks like this will list metaclasses too... May or may not be a problem...

def MixInto(Class, Mixin):

You're aware that in this function's scope, the 'Mixin' arg name will
shadow the Mixin class name ? (sorry for asking dumb question).

No sorry necessary, but yes, I am aware of it. Poor programming
practice I'm sure...
....
Basically what I need is for the method to be able to find out the name
of the instance, then I can just go to the globals dictionary to do the
replacement.

Advance thanks to all who can help...

Instead of exposing problems with your solution, you may want to expose
the real use case ?

***
I'm working with a team that's doing social modeling, and for example,
I need to model workers that at some point in the program may or may
not also become employers. Now, I want the workers to take on all
behaviors and attributes of an employer in addition to their
pre-existing "worker" behaviors and attributes. Also, as I'm sure you
guessed, the workers' attributes need to retain their values at that
point in the program, so a brand new worker-employer object wouldn't in
itself do the trick.
***


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

[digitalorganics]

Maric Michaud wrote:
....

def MixInto(Class, Mixin):
if Mixin not in Class.__bases__ :
Class.__bases__ += (Mixin,)

This doesn't work in most cases (with new style classes), better recreat a
type which inherit from Class and Mixin, or Class.__dict__ with
Mixin.__dict__.

I think I've discovered precisely what you mean about problem with new
style classes. Do you know why it doesn't work for them? As I pointed
out, creating a new type doesn't achieve the same thing. Any
workarounds? Thanks.

[Bruno Desthuilliers]

di************* @gmail.com wrote:

Maric Michaud wrote:

(snip)

This doesn't work in most cases (with new style classes), better recreat a
type which inherit from Class and Mixin, or Class.__dict__ with
Mixin.__dict_ _.

What doesn't work exactly? The whole purpose of the mixin is to add
functionality to the class and hence to all its instances on the fly.

very naïve solution:

def mixin(obj):

def someFunc(self, ...)
# code here
def someOtherFunc(s elf, ...)
# code here

cls = obj.__class__
cls.someFunc = someFunc
cls.someOtherFu nc = someOtherFunc

Just a bit less nïave solution:

def mixin(func):
func._mixin = True
return func

def mixable(func):
return getattr(attr, '_mixin', False):

class Mixin(object):
@mixin
def someFunc(self, ...):
# code here

@mixin
def someOtherFunc(s elf, ...)
# code here
def mix(cls, mixincls):
for name in dir(mixincls):
attr = getattr(mixincl s, name)
if callable(attr) and mixable(attr):
setattr(cls, name, attr)
Of course, one can do much better...
--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'o****@xiludom. gro'.split('@')])"

[Bruno Desthuilliers]

di************* @gmail.com a écrit :

Bruno Desthuilliers wrote: (snip)

Instead of exposing problems with your solution, you may want to expose
the real use case ?

I'm working with a team that's doing social modeling, and for example,
I need to model workers that at some point in the program may or may
not also become employers.

If I understand correctly, only some of the existing workers will become
employers ?
Now, I want the workers to take on all
behaviors and attributes of an employer in addition to their
pre-existing "worker" behaviors and attributes.
wrt/ behaviors, it's easy as pie. Attributes (I mean instance
attributes) are another problem, but I don't have enough informations to
deal with this problem here.
Also, as I'm sure you
guessed, the workers' attributes need to retain their values at that
point in the program, so a brand new worker-employer object wouldn't in
itself do the trick.

Here's a simple stupid possible solution:

class Worker(object):
def __init__(self, ...)
# init code here

# behaviours here

def becomeEmployer( self):
self.___class__ = Employer

class Employer(Worker ):
# behaviours here
w = Worker(...)
w.becomeEmploye r()

Note that there's no initializer in the Employer class - it wouldn't get
called anyway (not automatically at least).

[digitalorganics]

Bruno Desthuilliers wrote:

di************* @gmail.com a écrit :

Bruno Desthuilliers wrote:

(snip)

Instead of exposing problems with your solution, you may want to expose
the real use case ?

I'm working with a team that's doing social modeling, and for example,
I need to model workers that at some point in the program may or may
not also become employers.

If I understand correctly, only some of the existing workers will become
employers ?

Now, I want the workers to take on all
behaviors and attributes of an employer in addition to their
pre-existing "worker" behaviors and attributes.

wrt/ behaviors, it's easy as pie. Attributes (I mean instance
attributes) are another problem, but I don't have enough informations to
deal with this problem here.

Also, as I'm sure you
guessed, the workers' attributes need to retain their values at that
point in the program, so a brand new worker-employer object wouldn't in
itself do the trick.

Here's a simple stupid possible solution:

class Worker(object):
def __init__(self, ...)
# init code here

# behaviours here

def becomeEmployer( self):
self.___class__ = Employer

class Employer(Worker ):
# behaviours here
w = Worker(...)
w.becomeEmploye r()

Note that there's no initializer in the Employer class - it wouldn't get
called anyway (not automatically at least).

Won't work because there will be employers that aren't workers.
And yes, only some workers will become employers, but also only some
employers will also be workers (at some point in program). Let me be
more clear:

workers
--> subset of workers --become--> employers
employers
--> subset of employers --become--> workers

It is very important that both should maintain attribute values,
regardless of whether they take on new "roles". Furthermore, this is a
very simple case and ultimately in my program an object should be able
to dynamically take on a multitude of roles (classes of behavior)
without mucking at all with their pre-existing states.

[Bruno Desthuilliers]

di************* @gmail.com a écrit :

Bruno Desthuilliers wrote:

di*********** **@gmail.com a écrit :

Bruno Desthuilliers wrote:
(snip)

Instead of exposing problems with your solution, you may want to expose
the real use case ?
I'm working with a team that's doing social modeling, and for example,
I need to model workers that at some point in the program may or may
not also become employers.

If I understand correctly, only some of the existing workers will become
employers ?

Now, I want the workers to take on all
behaviors and attributes of an employer in addition to their
pre-existing "worker" behaviors and attributes.

wrt/ behaviors, it's easy as pie. Attributes (I mean instance
attributes) are another problem, but I don't have enough informations to
deal with this problem here.

Also, as I'm sure you
guessed, the workers' attributes need to retain their values at that
point in the program, so a brand new worker-employer object wouldn't in
itself do the trick.

Here's a simple stupid possible solution:

(snip)
Won't work because there will be employers that aren't workers.
Then don't subclass Employer from Worker !-)

(don't mind, just kidding)
And yes, only some workers will become employers,

but also only some
employers will also be workers (at some point in program). Let me be
more clear:

workers
--> subset of workers --become--> employers
employers
--> subset of employers --become--> workers

It is very important that both should maintain attribute values,
regardless of whether they take on new "roles".
Seems obvious. But just a question, BTW: do workers and employers share
the same attributes ? And if not, how do you intend to initialize the
employers attributes on workers (and the other way round) ?
Furthermore, this is a
very simple case and ultimately in my program an object
*Any* object ?-)
should be able
to dynamically take on a multitude of roles (classes of behavior)
without mucking at all with their pre-existing states.

Multiple roles at the same time, or sequentially ? And in the first case
(which I assume), do you have the case of overriding behaviors ? And if
yes, how should the resolution order be defined ? And what about
attributes ? (I mean, do your 'roles' have specific attributes ?)
FWIW, just another simple (and very Q&D) snippet:

class ObjectWithRoles (object):
def _change(self, *bases):
self.__class__ = type(self.__cla ss__.__name__, bases, {})

def has_role(self, role):
return role in self.__class__. __bases__

def add_role(self, role):
if not self.has_role(r ole):
self._change(se lf.__class__, role)

def remove_role(sel f, role):
if self.has_role(r ole):
self._change(*( cls for cls in self.__class__. __bases__ \
if cls is not role))
NB : Not tested (and not sure what it'll do) with roles subclassing
other roles, or ObjectWithRoles as roles...

wrt/ per-role attributes, you'd of course need to pass them to
add_role(). A convenient way of maintaining some sanity here would be to
use descriptors for all of these attributes, and store their values in a
per-role dict, with the role name as attribute name.