add hg and python

1 files changed, 118 insertions, 0 deletions

diff --git a/sys/src/cmd/python/Demo/metaclasses/Meta.py b/sys/src/cmd/python/Demo/metaclasses/Meta.py
new file mode 100644
index 000000000..580f5821c
--- /dev/null
+++ b/sys/src/cmd/python/Demo/metaclasses/Meta.py
@@ -0,0 +1,118 @@
+"""Generic metaclass.
+
+XXX This is very much a work in progress.
+
+"""
+
+import types
+
+class MetaMethodWrapper:
+
+    def __init__(self, func, inst):
+        self.func = func
+        self.inst = inst
+        self.__name__ = self.func.__name__
+
+    def __call__(self, *args, **kw):
+        return apply(self.func, (self.inst,) + args, kw)
+
+class MetaHelper:
+
+    __methodwrapper__ = MetaMethodWrapper # For derived helpers to override
+
+    def __helperinit__(self, formalclass):
+        self.__formalclass__ = formalclass
+
+    def __getattr__(self, name):
+        # Invoked for any attr not in the instance's __dict__
+        try:
+            raw = self.__formalclass__.__getattr__(name)
+        except AttributeError:
+            try:
+                ga = self.__formalclass__.__getattr__('__usergetattr__')
+            except (KeyError, AttributeError):
+                raise AttributeError, name
+            return ga(self, name)
+        if type(raw) != types.FunctionType:
+            return raw
+        return self.__methodwrapper__(raw, self)
+
+class MetaClass:
+
+    """A generic metaclass.
+
+    This can be subclassed to implement various kinds of meta-behavior.
+
+    """
+
+    __helper__ = MetaHelper             # For derived metaclasses to override
+
+    __inited = 0
+
+    def __init__(self, name, bases, dict):
+        try:
+            ga = dict['__getattr__']
+        except KeyError:
+            pass
+        else:
+            dict['__usergetattr__'] = ga
+            del dict['__getattr__']
+        self.__name__ = name
+        self.__bases__ = bases
+        self.__realdict__ = dict
+        self.__inited = 1
+
+    def __getattr__(self, name):
+        try:
+            return self.__realdict__[name]
+        except KeyError:
+            for base in self.__bases__:
+                try:
+                    return base.__getattr__(name)
+                except AttributeError:
+                    pass
+            raise AttributeError, name
+
+    def __setattr__(self, name, value):
+        if not self.__inited:
+            self.__dict__[name] = value
+        else:
+            self.__realdict__[name] = value
+
+    def __call__(self, *args, **kw):
+        inst = self.__helper__()
+        inst.__helperinit__(self)
+        try:
+            init = inst.__getattr__('__init__')
+        except AttributeError:
+            init = lambda: None
+        apply(init, args, kw)
+        return inst
+
+
+Meta = MetaClass('Meta', (), {})
+
+
+def _test():
+    class C(Meta):
+        def __init__(self, *args):
+            print "__init__, args =", args
+        def m1(self, x):
+            print "m1(x=%r)" % (x,)
+    print C
+    x = C()
+    print x
+    x.m1(12)
+    class D(C):
+        def __getattr__(self, name):
+            if name[:2] == '__': raise AttributeError, name
+            return "getattr:%s" % name
+    x = D()
+    print x.foo
+    print x._foo
+##     print x.__foo
+##     print x.__foo__
+
+
+if __name__ == '__main__':
+    _test()