retracesoftware-proxy 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

retracesoftware/proxy/proxysystem.py

@@ -1,23 +1,19 @@
 import retracesoftware.functional as functional
 import retracesoftware_utils as utils
 import types
-from retracesoftware.proxy.gateway import adapter_pair1
+from retracesoftware.proxy.gateway import adapter_pair
 from types import SimpleNamespace
-from retracesoftware.proxy.proxytype import ExtendingProxy
+from retracesoftware.proxy.proxytype import *
+from retracesoftware.proxy.stubfactory import Stub
+import sys
+import gc
 
-from retracesoftware.proxy.proxytype import extending_proxytype, make_extensible, dynamic_proxytype, dynamic_int_proxytype, instantiable_dynamic_proxytype
+class RetraceError(Exception):
+    pass
 
 def proxy(proxytype):
-    def set_type(cls, obj):
-        obj.__class__ = cls
-        return obj
-
-    def can_set_type(cls, obj): return issubclass(cls, ExtendingProxy)
-
-    create = functional.if_then_else(can_set_type, set_type, utils.create_wrapped)
-    
     return functional.spread(
-        create,
+        utils.create_wrapped,
         functional.sequence(functional.typeof, proxytype),
         None)
 
@@ -31,9 +27,23 @@ unproxy_execute = functional.mapargs(starting = 1,
                                      transform = functional.walker(utils.try_unwrap), 
                                      function = functional.apply)
 
+def resolve(obj):
+    try:
+        return getattr(sys.modules[obj.__module__], obj.__name__)
+    except:
+        return None
+
+def is_function_type(cls):
+    return cls in [types.BuiltinFunctionType, types.FunctionType]
+
 class ProxySystem:
     
-    def wrap_int_to_ext(self, obj): return obj
+    def bind(self, obj): pass
+
+    def wrap_int_to_ext(self, obj): 
+        return obj
+        # return functional.sequence(functional.side_effect(functional.repeatedly(gc.collect)), obj)
+    
     def wrap_ext_to_int(self, obj): return obj
     
     def on_int_call(self, func, *args, **kwargs):
@@ -45,18 +55,13 @@ class ProxySystem:
     def on_ext_error(self, err_type, err_value, err_traceback):
         pass
 
-    def ext_apply(self, func, *args, **kwargs):
-        return func(*args, **kwargs)
-    
-    def int_apply(self, func, *args, **kwargs):
-        return func(*args, **kwargs)
-
     def __init__(self, thread_state, immutable_types, tracer):
         
         self.thread_state = thread_state
         self.fork_counter = 0
         self.tracer = tracer
         self.immutable_types = immutable_types
+        self.on_proxytype = None
         
         def is_immutable_type(cls):
             return issubclass(cls, tuple(immutable_types))
@@ -67,53 +72,32 @@ class ProxySystem:
             return functional.walker(functional.when_not(is_immutable, maybe_proxy(proxytype)))
 
         int_spec = SimpleNamespace(
-            proxytype = self.int_proxytype,
-            proxy = proxyfactory(self.int_proxytype),
+            apply = thread_state.wrap('internal', functional.apply),
+            proxy = proxyfactory(thread_state.wrap('disabled', self.int_proxytype)),
             on_call = tracer('proxy.int.call', self.on_int_call),
             on_result = tracer('proxy.int.result'),
             on_error = tracer('proxy.int.error'),
-            apply = self.int_apply,
         )
 
         ext_spec = SimpleNamespace(
-            proxytype = self.ext_proxytype,
-            proxy = proxyfactory(self.ext_proxytype),
+            apply = thread_state.wrap('external', functional.apply),
+            proxy = proxyfactory(thread_state.wrap('disabled', self.dynamic_ext_proxytype)),
             on_call = tracer('proxy.ext.call'),
             on_result = self.on_ext_result,
             on_error = self.on_ext_error,
-            apply = self.ext_apply
         )
 
-        int2ext, ext2int = adapter_pair1(int_spec, ext_spec)
-
-        # self.ext_handler = thread_state.dispatch(default, internal = internal, external = external)
+        int2ext, ext2int = adapter_pair(int_spec, ext_spec)
 
         def gateway(name, internal = functional.apply, external = functional.apply):
             default = tracer(name, unproxy_execute)
             return thread_state.dispatch(default, internal = internal, external = external)
     
-        self.ext_handler = gateway('proxy.int.disabled.event', internal = self.wrap_int_to_ext(int2ext))
-        self.int_handler = gateway('proxy.ext.disabled.event', external = self.wrap_ext_to_int(ext2int))
-
-    # return (gateway('proxy.int.disabled.event', internal = wrap_int_to_ext(int_to_ext)),
-    #         gateway('proxy.ext.disabled.event',
-    #                 external = tracer('proxy.ext_to_int.wrap', ext_to_int)))
-
-    #     # def adapter_pair1(int, ext):
-
-
-    #     self.ext_handler, self.int_handler = gateway_pair(
-    #         thread_state,
-    #         self.tracer,
-    #         immutable_types = immutable_types,
-    #         wrap_int_to_ext = wrap_int_to_ext,
-    #         int_proxytype = self.int_proxytype,
-    #         ext_proxytype = self.ext_proxytype,
-    #         ext_apply = ext_apply,
-    #         on_int_call = on_int_call,
-    #         on_ext_result = on_ext_result,
-    #         on_ext_error = on_ext_error)
+        self.ext_handler =  self.wrap_int_to_ext(int2ext)
+        self.int_handler =  self.wrap_ext_to_int(ext2int)
 
+        self.ext_dispatch = gateway('proxy.int.disabled.event', internal = self.ext_handler)
+        self.int_dispatch = gateway('proxy.ext.disabled.event', external = self.int_handler)
 
     def new_child_path(self, path):
         return path.parent / f'fork-{self.fork_counter}' / path.name
@@ -134,48 +118,80 @@ class ProxySystem:
         
     def int_proxytype(self, cls):
         return dynamic_int_proxytype(
-                handler = self.int_handler,
+                handler = self.int_dispatch,
                 cls = cls,
                 bind = self.bind)
 
+    def dynamic_ext_proxytype(self, cls):
+
+        proxytype = dynamic_proxytype(
+            handler = self.ext_dispatch,
+            cls = cls)
+        if self.on_proxytype:
+            self.on_proxytype(proxytype)
+        
+        return proxytype
+        
+        # resolved = resolve(cls)
+        # if isinstance(resolved, ExtendingProxy):
+        #     return dynamic_from_extended(resolved)
+        # elif isinstance(resolved, DynamicProxy):
+        #     return resolved
+        # else:
+        #     return dynamic_proxytype(handler = self.ext_dispatch, cls = cls)
+
     def ext_proxytype(self, cls):
         assert isinstance(cls, type)
         if utils.is_extendable(cls):
             return self.extend_type(cls)
         else:    
             return instantiable_dynamic_proxytype(
-                    handler = self.ext_handler, 
+                    handler = self.ext_dispatch, 
                     cls = cls,
                     thread_state = self.thread_state,
                     create_stub = self.create_stub())
 
-    def extend_type(self, base):
+    def extend_type(self, cls):
 
         extended = extending_proxytype(
-            cls = base,
+            cls = cls,
+            base = Stub if self.create_stub() else cls,
             thread_state = self.thread_state, 
-            ext_handler = self.ext_handler,
-            int_handler = self.int_handler,
-            on_subclass_new = self.bind,
-            is_stub = self.create_stub())
+            ext_handler = self.ext_dispatch,
+            int_handler = self.int_dispatch,
+            on_subclass_new = self.bind)
         
         self.immutable_types.add(extended)
 
         return extended
 
+    def function_target(self, obj): return obj
+
+    def proxy_function(self, obj):
+        return utils.wrapped_function(handler = self.ext_handler,  target = obj)
+        
     def __call__(self, obj):
         assert not isinstance(obj, BaseException)
+        assert not isinstance(obj, Proxy)
         assert not isinstance(obj, utils.wrapped_function)
             
         if type(obj) == type:
+            if obj in self.immutable_types or issubclass(obj, tuple):
+                return obj
+            
             return self.ext_proxytype(obj)
             
-        elif type(obj) == types.BuiltinFunctionType:
-            return utils.wrapped_function(handler = self.ext_handler, target = obj)
+        elif type(obj) in self.immutable_types:
+            return obj
+        
+        elif is_function_type(type(obj)):
+
+            return self.thread_state.dispatch(
+                obj, 
+                internal = self.proxy_function(obj))
         
         else:
-            proxytype = dynamic_proxytype(handler = self.ext_handler, cls = type(obj))
+            proxytype = dynamic_proxytype(handler = self.ext_dispatch, cls = type(obj))
 
             return utils.create_wrapped(proxytype, obj)
             # raise Exception(f'object {obj} was not proxied as its not a extensible type and is not callable')
-    

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,26 +144,82 @@ 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):
 
+    assert not issubclass(cls, Proxy)
     assert not issubclass(cls, BaseException)
 
     blacklist = ['__getattribute__', '__hash__', '__del__', '__call__']
 
-    to_proxy = [m for m in methods(cls) if m not in blacklist]
+    spec = {}
 
-    def wrap(target): return utils.wrapped_function(handler = handler, target = target)
+    for name in superdict(cls).keys():
+        if name not in blacklist:
+            value = getattr(cls, name)
+            if is_descriptor(value):
+                if utils.is_method_descriptor(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
@@ -135,6 +233,25 @@ def dynamic_proxytype(handler, cls):
 
     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)
+    
+    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)
@@ -145,8 +262,6 @@ def instantiable_dynamic_proxytype(handler, cls, thread_state, create_stub = Fal
         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)
 
@@ -159,40 +274,58 @@ def dynamic_int_proxytype(handler, cls, bind):
     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__', '__dict__']
+#     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 unproxy_type(cls):
+        return cls.__dict__.get('__retrace_unproxied__', cls)
 
-def extending_proxytype(cls, thread_state, ext_handler, int_handler, on_subclass_new, is_stub = False):
+    bases = tuple(map(unproxy_type, cls.__bases__))
+    slots = dict(cls.__dict__)
+    del slots['__init_subclass__']
+    return type(cls.__name__, tuple(bases), slots)
 
+def extending_proxytype(cls, base, thread_state, ext_handler, int_handler, on_subclass_new):
+
+    # assert cls is base
     assert not issubclass(cls, BaseException)
+    assert not issubclass(cls, ExtendingProxy)
 
     def init_subclass(subclass, **kwargs):
         print(f'In init_subclass: {subclass} {kwargs}')
-        # subclass.__retrace_unproxied__ = create_unproxied_type(subclass)
+        unproxied = create_unproxied_type(subclass)
+        subclass.__retrace_unproxied__ = unproxied
 
         proxy_method_descriptors(cls = subclass, handler = int_handler)
 
@@ -200,7 +333,12 @@ def extending_proxytype(cls, thread_state, ext_handler, int_handler, on_subclass
             subclass.__new__ = functional.sequence(subclass.__new__, functional.side_effect(on_subclass_new))
             subclass.__bases__ = subclass.__bases__ + (InternalProxy,)
 
-    slots = { "__slots__": (), "__init_subclass__": init_subclass }
+        assert not issubclass(subclass.__retrace_unproxied__, ExtendingProxy)
+
+    slots = { "__slots__": (), 
+              "__retrace_unproxied__": cls,
+              "__module__": cls.__module__,
+              "__init_subclass__": init_subclass }
 
     def wrap(target): return utils.wrapped_function(handler = ext_handler, target = target)
 
@@ -213,79 +351,22 @@ 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__}'
+    slots['__retrace_unproxied__'] = cls
 
-    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 unproxied__new__(subclass, *args, **kwargs):
+        return subclass.__retrace_unproxied__(*args, **kwargs)
+      
+    extended.__new__ = thread_state.dispatch(unproxied__new__, internal = base.__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
+    assert not issubclass(extended.__retrace_unproxied__, ExtendingProxy)
+    assert extended.__dict__['__retrace_unproxied__'] is extended.__retrace_unproxied__
+    print(f'FOO: {extended} {id(extended)} {id(extended.__retrace_unproxied__)}')
+    # breakpoint()
 
     return extended
-
-
-def stubtype(cls, result, thread_state, handler):
-    
-    name = f'retrace.stub.{cls.__module__}.{cls.__name__}'
-
-    slots = {}
-
-    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)
-
-    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.__new__ = thread_state.dispatch(disabled__new__, internal = stub.__new__, external = stub.__new__)
-
-    stub.__retrace_unproxied__ = cls
-
-    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):
-
-    cls.__retrace_unproxied__ = cls.__base__
-
-    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)
-
-        # 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