Examples of metaprogramming in pure Python.

diff --git a/Demo/metaclasses/Enum.py b/Demo/metaclasses/Enum.py
new file mode 100644 (file)
index 0000000..71a8e52
--- /dev/null
+++ b/Demo/metaclasses/Enum.py
@@ -0,0 +1,165 @@
+"""Enumeration metaclass."""
+
+import string
+
+class EnumMetaClass:
+    """Metaclass for enumeration.
+
+    To define your own enumeration, do something like
+
+    class Color(Enum):
+       red = 1
+       green = 2
+       blue = 3
+
+    Now, Color.red, Color.green and Color.blue behave totally
+    different: they are enumerated values, not integers.
+
+    Enumerations cannot be instantiated; however they can be
+    subclassed.
+
+    """
+
+    def __init__(self, name, bases, dict):
+       """Constructor -- create an enumeration.
+
+       Called at the end of the class statement.  The arguments are
+       the name of the new class, a tuple containing the base
+       classes, and a dictionary containing everything that was
+       entered in the class' namespace during execution of the class
+       statement.  In the above example, it would be {'red': 1,
+       'green': 2, 'blue': 3}.
+
+       """
+       for base in bases:
+           if base.__class__ is not EnumMetaClass:
+               raise TypeError, "Enumeration base class must be enumeration"
+       bases = filter(lambda x: x is not Enum, bases)
+       self.__name__ = name
+       self.__bases__ = bases
+       self.__dict = {}
+       for key, value in dict.items():
+           self.__dict[key] = EnumInstance(name, key, value)
+
+    def __getattr__(self, name):
+       """Return an enumeration value.
+
+       For example, Color.red returns the value corresponding to red.
+
+       XXX Perhaps the values should be created in the constructor?
+
+       This looks in the class dictionary and if it is not found
+       there asks the base classes.
+
+       The special attribute __members__ returns the list of names
+       defined in this class (it does not merge in the names defined
+       in base classes).
+
+       """
+       if name == '__members__':
+           return self.__dict.keys()
+
+       try:
+           return self.__dict[name]
+       except KeyError:
+           for base in self.__bases__:
+               try:
+                   return getattr(base, name)
+               except AttributeError:
+                   continue
+
+       raise AttributeError, name
+
+    def __repr__(self):
+       s = self.__name__
+       if self.__bases__:
+           s = s + '(' + string.join(map(lambda x: x.__name__,
+                                         self.__bases__), ", ") + ')'
+       if self.__dict:
+           list = []
+           for key, value in self.__dict.items():
+               list.append("%s: %s" % (key, int(value)))
+           s = "%s: {%s}" % (s, string.join(list, ", "))
+       return s
+
+
+class EnumInstance:
+    """Class to represent an enumeration value.
+
+    EnumInstance('Color', 'red', 12) prints as 'Color.red' and behaves
+    like the integer 12 when compared, but doesn't support arithmetic.
+
+    XXX Should it record the actual enumeration rather than just its
+    name?
+
+    """
+
+    def __init__(self, classname, enumname, value):
+       self.__classname = classname
+       self.__enumname = enumname
+       self.__value = value
+
+    def __int__(self):
+       return self.__value
+
+    def __repr__(self):
+       return "EnumInstance(%s, %s, %s)" % (`self.__classname`,
+                                            `self.__enumname`,
+                                            `self.__value`)
+
+    def __str__(self):
+       return "%s.%s" % (self.__classname, self.__enumname)
+
+    def __cmp__(self, other):
+       return cmp(self.__value, int(other))
+
+
+# Create the base class for enumerations.
+# It is an empty enumeration.
+Enum = EnumMetaClass("Enum", (), {})
+
+
+def _test():
+
+    class Color(Enum):
+       red = 1
+       green = 2
+       blue = 3
+
+    print Color.red
+    print dir(Color)
+
+    print Color.red == Color.red
+    print Color.red == Color.blue
+    print Color.red == 1
+    print Color.red == 2
+
+    class ExtendedColor(Color):
+       white = 0
+       orange = 4
+       yellow = 5
+       purple = 6
+       black = 7
+
+    print ExtendedColor.orange
+    print ExtendedColor.red
+
+    print Color.red == ExtendedColor.red
+
+    class OtherColor(Enum):
+       white = 4
+       blue = 5
+
+    class MergedColor(Color, OtherColor):
+       pass
+
+    print MergedColor.red
+    print MergedColor.white
+
+    print Color
+    print ExtendedColor
+    print OtherColor
+    print MergedColor
+
+if __name__ == '__main__':
+    _test()

diff --git a/Demo/metaclasses/Trace.py b/Demo/metaclasses/Trace.py
new file mode 100644 (file)
index 0000000..ed3944f
--- /dev/null
+++ b/Demo/metaclasses/Trace.py
@@ -0,0 +1,126 @@
+"""Tracing metaclass."""
+
+import types
+
+class TraceMetaClass:
+    """Metaclass for tracing.
+
+    Classes defined using this metaclass have an automatic tracing
+    feature -- by setting the __trace_output__ instance (or class)
+    variable to a file object, trace messages about all calls are
+    written to the file.  The trace formatting can be changed by
+    defining a suitable __trace_call__ method.
+
+    """
+
+    __inited = 0
+
+    def __init__(self, name, bases, dict):
+       self.__name__ = name
+       self.__bases__ = bases
+       self.__dict = dict
+       # XXX Can't define __dict__, alas
+       self.__inited = 1
+
+    def __getattr__(self, name):
+       try:
+           return self.__dict[name]
+       except KeyError:
+           for base in self.__bases__:
+               try:
+                   return getattr(base, name)
+               except AttributeError:
+                   pass
+           raise AttributeError, name
+
+    def __setattr__(self, name, value):
+       if not self.__inited:
+           self.__dict__[name] = value
+       else:
+           self.__dict[name] = value
+
+    def __call__(self, *args, **kw):
+       inst = TracingInstance()
+       inst.__meta_init__(self)
+       try:
+           init = inst.__getattr__('__init__')
+       except AttributeError:
+           init = lambda: None
+       apply(init, args, kw)
+       return inst
+
+    __trace_output__ = None
+
+class TracingInstance:
+    """Helper class to represent an instance of a tracing class."""
+
+    def __trace_call__(self, fp, fmt, *args):
+       fp.write((fmt+'\n') % args)
+
+    def __meta_init__(self, klass):
+       self.__class = klass
+
+    def __getattr__(self, name):
+       # Invoked for any attr not in the instance's __dict__
+       try:
+           raw = self.__class.__getattr__(name)
+       except AttributeError:
+           raise AttributeError, name
+       if type(raw) != types.FunctionType:
+           return raw
+       # It's a function
+       fullname = self.__class.__name__ + "." + name
+       if not self.__trace_output__ or name == '__trace_call__':
+           return NotTracingWrapper(fullname, raw, self)
+       else:
+           return TracingWrapper(fullname, raw, self)
+
+class NotTracingWrapper:
+    def __init__(self, name, func, inst):
+       self.__name__ = name
+       self.func = func
+       self.inst = inst
+    def __call__(self, *args, **kw):
+       return apply(self.func, (self.inst,) + args, kw)
+
+class TracingWrapper(NotTracingWrapper):
+    def __call__(self, *args, **kw):
+       self.inst.__trace_call__(self.inst.__trace_output__,
+                                "calling %s, inst=%s, args=%s, kw=%s",
+                                self.__name__, self.inst, args, kw)
+       try:
+           rv = apply(self.func, (self.inst,) + args, kw)
+       except:
+           t, v, tb = sys.exc_info()
+           self.inst.__trace_call__(self.inst.__trace_output__,
+                                    "returning from %s with exception %s: %s",
+                                    self.__name__, t, v)
+           raise t, v, tb
+       else:
+           self.inst.__trace_call__(self.inst.__trace_output__,
+                                    "returning from %s with value %s",
+                                    self.__name__, rv)
+           return rv
+
+Traced = TraceMetaClass('Traced', (), {'__trace_output__': None})
+
+
+def _test():
+    import sys
+    class C(Traced):
+       def __init__(self, x=0): self.x = x
+       def m1(self, x): self.x = x
+       def m2(self, y): return self.x + y
+    C.__trace_output__ = sys.stdout
+    x = C(4321)
+    print x
+    print x.x
+    print x.m1(100)
+    print x.m1(10)
+    print x.m2(33)
+    print x.m1(5)
+    print x.m2(4000)
+    print x.x
+
+if __name__ == '__main__':
+    _test()