# metaclass.py
from pyke.unique import unique
'''
this metaclass is intended to be used by deriving from tracked_object as base class
pros:
- probably works with IronPython or Jython
- easier to understand
cons:
- __setattr__ defined by classes poses problems
'''
class metaclass_option1(type): # this _must_ be derived from 'type'!
_ignore_setattr = False
def __init__(self, name, bases, dict):
# This gets called when new derived classes are created.
#
# We don't need to define an __init__ method here, but I was just
# curious about how this thing works...
print "metaclass: name", name, ", bases", bases, \
", dict keys", tuple(sorted(dict.keys()))
super(metaclass_option1, self).__init__(name, bases, dict)
def __call__(self, *args, **kws):
# This gets called when new instances are created (using the class as
# a function).
obj = super(metaclass_option1, self).__call__(*args, **kws)
del obj._ignore_setattr
print "add instance", obj, "to", self.knowledge_base
return obj
'''
this metaclass requires the __metaclass__ = metaclass_option2 attribute of
classes to be used with the object knowledge base of pyke
pros:
- solves the problem of classes defining their own __setattr__ method
- does not require any multiple inheritance
cons:
- hard to understand
- possibly does not work with IronPython or Jython
'''
class metaclass_option2(type): # this _must_ be derived from 'type'!
def __new__(mcl, name, bases, clsdict):
print "metaclass_option2.__new__: class dict before __new__: name", name, ", bases", bases, \
", dict keys", tuple(clsdict.keys()), ", dict values", tuple(clsdict.values())
def __setattr__(self, attr, value):
# This gets called when any attribute is changed. We would need to
# figure out how to ignore attribute setting by the __init__
# function...
#
# Also the check to see if the attribute has actually changed by doing
# a '!=' check could theoretically lead to problems. For example this
# would fail to change the attribute to another value that wasn't
# identical to the first, but '==' to it: for example, 4 and 4.0.
if self.__instance__.get(self, False) :
if getattr(self, attr) != value:
print "metaclass.__new__: notify knowledge base", \
"of attribute change: (%s, %s, %s)" % (self, attr, value)
if self.__cls__setattr__ != None:
self.__cls__setattr__(attr, value)
else:
super(self.__class__, self).__setattr__(attr, value)
else:
# does not work to call super.__setattr__
#super(self.__class__, self).__setattr__(attr, value)
#
self.__dict__[attr] = value
def __getattr__(self, name):
return self.__dict__[name]
cls__setattr__ = None
if clsdict.get('__setattr__', None) != None:
cls__setattr__ = clsdict['__setattr__']
clsdict['__setattr__'] = __setattr__
clsdict['__getattr__'] = __getattr__
clsdict['__cls__setattr__'] = cls__setattr__
clsdict['__instance__'] = {}
print "metaclass_option2.__new__: class dict after __new__: name", name, ", bases", bases, \
", dict keys", tuple(sorted(clsdict.keys())), ", dict values", tuple(clsdict.values())
return super(metaclass_option2, mcl).__new__(mcl, name, bases, clsdict)
'''
def __init__(cls, name, bases, clsdict):
# This gets called when new derived classes are created.
#
# We don't need to define an __init__ method here, but I was just
# curious about how this thing works...
super(metaclass_option2, cls).__init__(name, bases, clsdict)
print "class dict after __init__: name", name, ", bases", bases, \
", dict keys", tuple(sorted(clsdict.keys()))
# does not work to create __instance class member here
#clsdict['__instance__'] = {}
'''
def __call__(cls, *args, **kws):
# This gets called when new instances are created (using the class as
# a function).
obj = super(metaclass_option2, cls).__call__(*args, **kws)
obj.__instance__[obj] = True
print "add instance of class", cls.__name__, "to knowledge base"
return obj
class tracked_object(object):
r'''
All classes to be tracked by an object base would be derived from this
one:
>>> class foo(tracked_object):
... def __init__(self, arg):
... super(foo, self).__init__()
... print "foo.__init__:", arg
... self.x = arg # should be ignored
... # doctest: +NORMALIZE_WHITESPACE
metaclass: name foo , bases (<class 'experimental.metaclass.tracked_object'>,) ,
dict keys ('__init__', '__module__')
And we can keep deriving classes:
>>> class bar(foo):
... def __init__(self, arg1, arg2):
... super(bar, self).__init__(arg1)
... print "bar.__init__:", arg1, arg2
... self.y = arg2 # should be ignored
... # doctest: +NORMALIZE_WHITESPACE
metaclass: name bar , bases (<class 'experimental.metaclass.foo'>,) ,
dict keys ('__init__', '__module__')
We can't do the next step directly in the class definition because the
knowledge_engine.engine hasn't been created yet and so the object
bases don't exist at that point in time.
So this simulates adding the knowledge_base to the class later, after
the knowledge_engine.engine and object bases have been created.
>>> foo.knowledge_base = 'foo base'
>>> bar.knowledge_base = 'bar base'
And now we create some instances (shouldn't see any attribute change
notifications here!):
>>> f = foo(44) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
tracked_object.__setattr__ called on object
<experimental.metaclass.foo object at 0x...>
with property _ignore_setattr and value True
tracked_object.__setattr__ called on object
<experimental.metaclass.foo object at 0x...>
with property knowledgebase and value None
foo.__init__: 44
tracked_object.__setattr__ called on object
<experimental.metaclass.foo object at 0x...>
with property x and value 44
add instance <experimental.metaclass.foo object at 0x...> to foo base
>>> b = bar(55, 66) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
tracked_object.__setattr__ called on object
<experimental.metaclass.bar object at 0x...>
with property _ignore_setattr and value True
tracked_object.__setattr__ called on object
<experimental.metaclass.bar object at 0x...>
with property knowledgebase and value None
foo.__init__: 55
tracked_object.__setattr__ called on object
<experimental.metaclass.bar object at 0x...>
with property x and value 55
bar.__init__: 55 66
tracked_object.__setattr__ called on object
<experimental.metaclass.bar object at 0x...>
with property y and value 66
add instance <experimental.metaclass.bar object at 0x...> to bar base
And modify some attributes:
>>> f.x = 'y' # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
tracked_object.__setattr__ called on object
<experimental.metaclass.foo object at 0x...>
with property x and value y
tracked_object.__setattr__: notify foo base of attribute change:
(<experimental.metaclass.foo object at 0x...>, x, y)
>>> b.y = 'z' # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
tracked_object.__setattr__ called on object
<experimental.metaclass.bar object at 0x...>
with property y and value z
tracked_object.__setattr__: notify bar base of attribute change:
(<experimental.metaclass.bar object at 0x...>, y, z)
>>> b.y = 'z' # should be ignored
... # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
tracked_object.__setattr__ called on object
<experimental.metaclass.bar object at 0x...>
with property y and value z
>>> b.z = "wasn't set" # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
tracked_object.__setattr__ called on object
<experimental.metaclass.bar object at 0x...>
with property z and value wasn't set
tracked_object.__setattr__: notify bar base of attribute change:
(<experimental.metaclass.bar object at 0x...>, z, wasn't set)
'''
__metaclass__ = metaclass_option1
_not_bound = unique('_not_bound') # a value that should != any other value!
def __init__(self):
self._ignore_setattr = True
self.knowledgebase = None
def __setattr__(self, attr, value):
# This gets called when any attribute is changed. We would need to
# figure out how to ignore attribute setting by the __init__
# function...
#
# Also the check to see if the attribute has actually changed by doing
# a '!=' check could theoretically lead to problems. For example this
# would fail to change the attribute to another value that wasn't
# identical to the first, but '==' to it: for example, 4 and 4.0.
print "tracked_object.__setattr__ called on object %s with property %s and value %s" % (self, attr, value)
if getattr(self, attr, self._not_bound) != value:
super(tracked_object, self).__setattr__(attr, value)
if not hasattr(self, '_ignore_setattr'):
print "tracked_object.__setattr__: notify", self.knowledge_base, \
"of attribute change: (%s, %s, %s)" % (self, attr, value)
''' tracked_object and foo_tracked use metaclass_option1
'''
class foo_tracked(tracked_object):
def __init__(self, arg):
super(foo_tracked, self).__init__()
self.prop = arg
''' the following classes use metaclass_option2
'''
class foo_base(object):
def __setattr__(self, attr, value):
print "foo_base.__setattr__ called on object %s with property %s and value %s" % (self, attr, value)
class foo_attribute_base(foo_base):
__metaclass__ = metaclass_option2
def __init__(self, arg):
super(foo_attribute_base, self).__init__()
self.prop = arg
class foo_attribute(object):
__metaclass__ = metaclass_option2
def __init__(self, arg):
super(foo_attribute, self).__init__()
self.prop = arg
def __setattr__(self, attr, value):
print "foo_attribute.__setattr__ called on object %s with property %s and value %s" % (self, attr, value)
class foo(object):
__metaclass__ = metaclass_option2
def __init__(self, arg):
super(foo, self).__init__()
self.prop = arg
#self.knowledge_base = "foo"
def foo_method(self):
print "foo_method called"
def test_foo_option2():
f1 = foo(1) # should add instance to knowledge base
f1.prop = 2 # should notify knowledge base of property change
f2 = foo("egon") # should add instance to knowledge base
f2.prop = "ralf" # should notify knowledge base of property change
f3 = foo_attribute(3)
f3.prop = 4
f4 = foo_attribute("karin")
f4.prop = "sabine"
f5 = foo_attribute_base(5)
f5.prop = 6
f6 = foo_attribute_base("sebastian")
f6.prop = "philipp"
def test_foo_option1():
import sys
import doctest
sys.exit(doctest.testmod(optionflags = doctest.ELLIPSIS
| doctest.NORMALIZE_WHITESPACE)
[0])
if __name__ == "__main__":
#test_foo_option1()
test_foo_option2()