retracesoftware-proxy 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

retracesoftware/proxy/proxytype.py

@@ -1,8 +1,10 @@
-import retracesoftware_utils as utils
+import retracesoftware.utils as utils
 import retracesoftware.functional as functional
 
 import types
 
+from retracesoftware.proxy.stubfactory import StubMethodDescriptor
+
 class Proxy:
     __slots__ = []
 
@@ -18,6 +20,44 @@ class ExtendingProxy(Proxy):
 class InternalProxy:
     __slots__ = []
 
+@functional.memoize_one_arg
+def unproxy_type(cls):
+    if not issubclass(cls, Proxy):
+        return cls
+
+    # Prefer attribute on the class, not on the mappingproxy
+    target = getattr(cls, '__retrace_target_class__', None)
+    if target is not None:
+        return unproxy_type(target)
+
+    # Rebuild with unproxied bases, preserving metaclass and critical dunder attrs
+    new_bases = tuple(map(unproxy_type, cls.__bases__))
+
+    # Copy attrs, but omit implementation-managed ones
+    attrs = {}
+    classcell = None
+    for k, v in cls.__dict__.items():
+        if k in ('__dict__', '__weakref__'):
+            continue
+        if k == '__classcell__':
+            # must be passed through at class creation for zero-arg super()
+            classcell = v
+            continue
+        attrs[k] = v
+
+    # Ensure module/doc are kept (in case they weren't in __dict__)
+    attrs.setdefault('__module__', cls.__module__)
+    attrs.setdefault('__doc__', cls.__doc__)
+
+    # Use types.new_class if you want full class-creation protocol
+    def exec_body(ns):
+        ns.update(attrs)
+        if classcell is not None:
+            ns['__classcell__'] = classcell
+
+    return types.new_class(cls.__name__, new_bases, {'metaclass': type(cls)}, exec_body)
+
+
 def superdict(cls):
     result = {}
     for cls in list(reversed(cls.__mro__))[1:]:
@@ -27,7 +67,9 @@ def superdict(cls):
 
 def is_method_descriptor(obj):
     return isinstance(obj, types.FunctionType) or \
-           (isinstance(obj, (types.WrapperDescriptorType, types.MethodDescriptorType)) and obj.__objclass__ != object)
+           (isinstance(obj, (types.WrapperDescriptorType, 
+                             types.MethodDescriptorType,
+                             StubMethodDescriptor)) and obj.__objclass__ != object)
 
 def proxy_method_descriptors(cls, handler):
     for name, target in cls.__dict__.items():
@@ -86,7 +128,7 @@ def dynamic_stubtype(handler, cls):
 
     assert not issubclass(cls, BaseException)
 
-    blacklist = ['__getattribute__', '__hash__', '__del__', '__init__', '__call__']
+    blacklist = ['__getattribute__', '__hash__', '__del__', '__call__']
 
     to_proxy = [m for m in methods(cls) if m not in blacklist]
 
@@ -102,86 +144,203 @@ def dynamic_stubtype(handler, cls):
         spec['__call__'] = handler
 
     spec['__retrace_target_class__'] = cls
-    spec['__class__'] = property(functional.repeatedly(cls))
 
-    name = f'retrace.proxied.{cls.__module__}.{cls.__name__}'
+    target_type = functional.sequence(utils.unwrap, functional.typeof)
+    spec['__class__'] = property(target_type)
+
+    spec['__module__'] = cls.__module__
+    spec['__qualname__'] = cls.__name__
+    
+    # name = f'retrace.proxied.{cls.__module__}.{cls.__name__}'
+
+    return type(cls.__name__, (Stub, DynamicProxy), spec)
+
+class DescriptorProxy:
+    __slots__ = ['target', 'handler']
+
+    def __init__(self, handler, target):
+        self.handler = handler
+        self.target = target
+
+    def __get__(self, obj, cls):
+        return self.handler(self.target.__get__, obj, cls)
+
+    def __set__(self, obj, value):
+        return self.handler(self.target.__set__, obj, value)
+    
+    def __delete__(self, obj):
+        return self.handler(self.target.__delete__, obj)
+
+class ExtendingDescriptorProxy:
+
+    __slots__ = ['handler', 'proxytype', 'name']
+
+    def __init__(self, proxytype, handler, name):
+        self.proxytype = proxytype
+        self.handler = handler
+        self.name = name
+
+    def __get__(self, instance, owner):
+        inst = owner if instance is None else instance
+        getter = functional.partial(getattr, super(self.proxytype, inst))
+        return self.handler(getter, self.name)
+
+    def __set__(self, instance, value):
+        setter = functional.partial(setattr, super(self.proxytype, instance))
+        return self.handler(setter, self.name, value)
+
+    def __delete__(self, instance):
+        deleter = functional.partial(delattr, super(self.proxytype, instance))
+        return self.handler(deleter, self.name)
 
-    return type(name, (Stub, DynamicProxy), spec)
 
 def dynamic_proxytype(handler, cls):
 
+    print(f'Creating dynamic_proxytype from {cls} {cls.__dict__}')
+
+    assert not issubclass(cls, Proxy)
     assert not issubclass(cls, BaseException)
 
-    blacklist = ['__getattribute__', '__hash__', '__del__', '__init__', '__call__']
+    blacklist = ['__getattribute__', '__hash__', '__del__', '__call__']
 
-    to_proxy = [m for m in methods(cls) if m not in blacklist]
+    spec = {}
+
+    for name in superdict(cls).keys():
+        if name not in blacklist:
+            value = getattr(cls, name)
+            if is_descriptor(value):
+                print(f'Adding: {name} {value} {type(value).__mro__}')
 
-    def wrap(target): return utils.wrapped_function(handler = handler, target = target)
+                if utils.is_method_descriptor(value):
+                    print(f'Adding method descriptor: {name} {value}')
+                    spec[name] = utils.wrapped_function(handler = handler, target = value)
+                else:
+                    spec[name] = DescriptorProxy(handler = handler, target = value)
+
+    # to_proxy = [m for m in methods(cls) if m not in blacklist]
+
+    # def wrap(target): return utils.wrapped_function(handler = handler, target = target)
     
-    spec = { name: wrap(getattr(cls, name)) for name in to_proxy }
+    # spec = { name: wrap(getattr(cls, name)) for name in to_proxy }
 
-    spec['__getattr__'] = wrap(getattr)
-    spec['__setattr__'] = wrap(setattr)
+    # spec['__getattr__'] = wrap(getattr)
+    # spec['__setattr__'] = wrap(setattr)
     
     if utils.yields_callable_instances(cls):
         spec['__call__'] = handler
 
     spec['__retrace_target_class__'] = cls
 
-    target_type = functional.compose(utils.unwrap, functional.typeof)
+    target_type = functional.sequence(utils.unwrap, functional.typeof)
     spec['__class__'] = property(target_type)
-
+    
     name = f'retrace.proxied.{cls.__module__}.{cls.__name__}'
 
     return type(name, (utils.Wrapped, DynamicProxy), spec)
 
+def dynamic_from_extended(cls):
+    
+    base = cls.__base__
+
+    name = f'retrace.proxied.{base.__module__}.{base.__name__}'
+
+    spec = dict(cls.__dict__)
+
+    spec['__retrace_target_class__'] = base
+
+    del spec['__init_subclass__']
+    # del spec['__new__']
+
+    target_type = functional.sequence(utils.unwrap, functional.typeof)
+    spec['__class__'] = property(target_type)
+    
+    print(f'dynamic_from_extended {spec}')
+
+    return type(name, (utils.Wrapped, DynamicProxy), spec)
+
+
+def instantiable_dynamic_proxytype(handler, cls, thread_state, create_stub = False):
+
+    proxytype = dynamic_proxytype(handler = handler, cls = cls)
+
+    def create_original(proxytype, *args, **kwargs):
+        instance = cls(*args, **kwargs)
+        instance.__init__(*args, **kwargs)
+        return instance
+    
+    def __new__(proxytype, *args, **kwargs):
+        print(f'instantiable_dynamic_proxytype: {cls}')
+
+        instance = utils.create_stub_object(cls) if create_stub else cls(*args, **kwargs)
+        return utils.create_wrapped(proxytype, instance)
+
+    proxytype.__new__ = thread_state.dispatch(create_original, internal = __new__)
+
+    return proxytype    
+
 def dynamic_int_proxytype(handler, cls, bind):
     proxytype = dynamic_proxytype(handler = handler, cls = cls)
     proxytype.__new__ = functional.sequence(proxytype.__new__, functional.side_effect(bind))
     return proxytype
                                     
-class DescriptorProxy:
 
-    __slots__ = ['handler', 'proxytype', 'name']
+blacklist = ['__getattribute__', '__hash__', '__del__', '__dict__']
 
-    def __init__(self, proxytype, handler, name):
-        self.proxytype = proxytype
-        self.handler = handler
-        self.name = name
+# if the type can be patched, thats better, all new instances must be of correct type
 
-    def __get__(self, instance, owner):
-        inst = owner if instance is None else instance
-        getter = functional.partial(getattr, super(self.proxytype, inst))
-        return self.handler(getter, self.name)
+# def make_extensible(thread_state, proxy_method_descriptor, cls):
 
-    def __set__(self, instance, value):
-        setter = functional.partial(setattr, super(self.proxytype, instance))
-        return self.handler(setter, self.name, value)
+#     @functional.memoize_one_arg
+#     def proxy_subclass(subclass):
+#         if '__retrace_target_type__' in subclass.__dict__:
+#             return subclass
+        
+#         attrs = {k: proxy_method_descriptor(v) for k, v in subclass.__dict__.items() if is_method_descriptor(v) }
 
-    def __delete__(self, instance):
-        deleter = functional.partial(delattr, super(self.proxytype, instance))
-        return self.handler(deleter, self.name)
+#         # Ensure module/doc are kept (in case they weren't in __dict__)
+#         attrs.setdefault('__module__', subclass.__module__)
+#         attrs.setdefault('__doc__', subclass.__doc__)
+#         attrs['__retrace_target_type__'] = subclass
 
+#         return type(subclass.__name__, (subclass,), attrs)
 
-blacklist = ['__getattribute__', '__hash__', '__del__']
+#     orig__new__ = cls.__new__
 
-# if the type can be patched, thats better, all new instances must be of correct type
+#     def proxied__new__(subclass, *args, **kwargs):
+#         nonlocal orig__new__
+#         return orig__new__(proxy_subclass(subclass), *args, **kwargs)
+                    
+#     def unproxied__new__(subclass, *args, **kwargs):
+#         return unproxy_type(subclass)(*args, **kwargs)
+    
+#     # Dispatch which constructor to use based on your thread_state policy
+#     cls.__new__ = thread_state.dispatch(unproxied__new__, internal = proxied__new__)
+
+def create_unproxied_type(cls):
 
-def extending_proxytype(cls, thread_state, ext_handler, int_handler, on_subclass_new, is_stub = False):
+    def unproxy_type(cls):
+        return cls.__dict__.get('__retrace_unproxied__', cls)
+
+    return type(cls.__name__, tuple(map(unproxy_type, cls.__bases__)), dict(cls.__dict__))
+
+def extending_proxytype(cls, base, thread_state, ext_handler, int_handler, on_subclass_new):
 
     assert not issubclass(cls, BaseException)
 
     def init_subclass(subclass, **kwargs):
-        print(f'In init_subclass: {subclass} {kwargs}')
-        # subclass.__retrace_unproxied__ = create_unproxied_type(subclass)
+        # print(f'In init_subclass: {subclass} {kwargs}')
+        subclass.__retrace_unproxied__ = create_unproxied_type(subclass)
 
         proxy_method_descriptors(cls = subclass, handler = int_handler)
 
         if not issubclass(subclass, InternalProxy):
-            subclass.__new__ = functional.compose(subclass.__new__, functional.side_effect(on_subclass_new))
+            subclass.__new__ = functional.sequence(subclass.__new__, functional.side_effect(on_subclass_new))
             subclass.__bases__ = subclass.__bases__ + (InternalProxy,)
 
-    slots = { "__slots__": (), "__init_subclass__": init_subclass }
+    slots = { "__slots__": (), 
+              "__retrace_unproxied__": cls,
+              "__module__": cls.__module__,
+              "__init_subclass__": init_subclass }
 
     def wrap(target): return utils.wrapped_function(handler = ext_handler, target = target)
 
@@ -194,87 +353,67 @@ def extending_proxytype(cls, thread_state, ext_handler, int_handler, on_subclass
             elif is_descriptor(value):
                 descriptors.append(name)
 
-    name = f'retrace.extended.{cls.__module__}.{cls.__name__}'
-
-    extended = type(name, (cls, ExtendingProxy), slots)
+    extended = type(cls.__name__, (base, ExtendingProxy), slots)
 
     for name in descriptors:
-        proxy = DescriptorProxy(handler = ext_handler, name = name, proxytype = extended)
+        proxy = ExtendingDescriptorProxy(handler = ext_handler, name = name, proxytype = extended)
         setattr(extended, name, proxy)
-
-    # def disabled__new__(subcls, *args, **kwargs):
-    #     print('IN Diabled new!!!')
-        
-    #     instance = cls.__new__(subcls.__retrace_unproxied__, *args, **kwargs)
-    #     instance.__init__(*args, **kwargs)
-    #     return instance
-
-    # __new__ = functional.compose(cls.__new__, functional.side_effect(on_new))
-    if is_stub:
-        def __new__(cls, *args, **kwargs):
-            instance = utils.create_stub_object(cls)
-            # print(instance is None)
-            # utils.sigtrap(None)
-            return instance
-        
-        extended.__new__ = thread_state.dispatch(cls.__new__, internal = __new__, external = __new__)
-    
-    # extended.__retrace_unproxied__ = cls
+                    
+    def unproxied__new__(subclass, *args, **kwargs):
+        return subclass.__retrace_unproxied__(*args, **kwargs)
+      
+    extended.__new__ = thread_state.dispatch(unproxied__new__, internal = base.__new__)
 
     return extended
 
 
-def stubtype(cls, result, thread_state, handler):
+# def stubtype(cls, result, thread_state, handler):
     
-    name = f'retrace.stub.{cls.__module__}.{cls.__name__}'
+#     name = f'retrace.stub.{cls.__module__}.{cls.__name__}'
 
-    slots = {}
+#     slots = {}
 
-    def wrap(name):
-        return utils.wrapped_function(
-            handler = handler, 
-            target = StubMethodDescriptor(name = name, result = result))
+#     def wrap(name):
+#         return utils.wrapped_function(
+#             handler = handler, 
+#             target = StubMethodDescriptor(name = name, result = result))
 
-    for name,value in superdict(cls).items():
-        if name not in blacklist:
-            if is_method_descriptor(value):
-                slots[name] = wrap(name)
-            elif is_descriptor(value):
-                slots[name] = DescriptorStub(handler = handler, name = name)
+#     for name,value in superdict(cls).items():
+#         if name not in blacklist:
+#             if is_method_descriptor(value):
+#                 slots[name] = wrap(name)
+#             elif is_descriptor(value):
+#                 slots[name] = DescriptorStub(handler = handler, name = name)
 
-    def disabled__new__(subcls, *args, **kwargs):
-        instance = cls.__new__(subcls.__retrace_unproxied__, *args, **kwargs)
-        instance.__init__(*args, **kwargs)
-        return instance
+#     def disabled__new__(subcls, *args, **kwargs):
+#         instance = cls.__new__(subcls.__retrace_unproxied__, *args, **kwargs)
+#         instance.__init__(*args, **kwargs)
+#         return instance
 
-    stub = type(name, (Stub,), slots)
+#     stub = type(name, (Stub,), slots)
 
-    stub.__new__ = thread_state.dispatch(disabled__new__, internal = stub.__new__, external = stub.__new__)
+#     stub.__new__ = thread_state.dispatch(disabled__new__, internal = stub.__new__, external = stub.__new__)
 
-    stub.__retrace_unproxied__ = cls
+#     stub.__retrace_unproxied__ = cls
+
+#     return stub
 
-    return stub
 
-def create_unproxied_type(cls):
-    name = f'{cls.__module__}.{cls.__name__}'
 
-    def unproxy_type(cls):
-        return cls.__retrace_unproxied__ if issubclass(cls, ExtendingProxy) else cls
 
-    return type(name, tuple(map(unproxy_type, cls.__bases__)), dict(cls.__dict__))
 
-def make_extensible(cls, handler, on_new):
+# def make_extensible(cls, handler, on_new):
 
-    cls.__retrace_unproxied__ = cls.__base__
+#     cls.__retrace_unproxied__ = cls.__base__
 
-    def init_subclass(*args, **kwargs):
-        print(f'In init_subclass: {args} {kwargs}')
-        # subclass.__retrace_unproxied__ = create_unproxied_type(subclass)
+#     def init_subclass(*args, **kwargs):
+#         print(f'In init_subclass: {args} {kwargs}')
+#         # subclass.__retrace_unproxied__ = create_unproxied_type(subclass)
 
-        # proxy_method_descriptors(cls = subclass, handler = handler)
+#         # proxy_method_descriptors(cls = subclass, handler = handler)
 
-        # if not issubclass(subclass, InternalProxy):
-        #     cls.__new__ = functional.compose(cls.__new__, functional.side_effect(on_new))
-        #     cls.__bases__ = cls.__bases__ + (InternalProxy,)
+#         # if not issubclass(subclass, InternalProxy):
+#         #     cls.__new__ = functional.compose(cls.__new__, functional.side_effect(on_new))
+#         #     cls.__bases__ = cls.__bases__ + (InternalProxy,)
 
-    cls.__init_subclass__ = init_subclass
+#     cls.__init_subclass__ = init_subclass