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

retracesoftware/proxy/proxyfactory.py

@@ -108,250 +108,250 @@ class GCHook:
         elif phase == 'stop':
             self.thread_state.value = self.saved_state
 
-class ProxyFactory:
+# class ProxyFactory:
 
-    def ext_proxy_factory(self):
-        return wrapping_proxy_factory(proxytype = self.proxytype, create_reference = compose(type, Reference), handler = self.ext_handler)
+#     def ext_proxy_factory(self):
+#         return wrapping_proxy_factory(proxytype = self.proxytype, create_reference = compose(type, Reference), handler = self.ext_handler)
     
-    def int_proxy_factory(self):
-        return wrapping_proxy_factory(proxytype = self.proxytype, create_reference = Reference, handler = self.int_handler)
+#     def int_proxy_factory(self):
+#         return wrapping_proxy_factory(proxytype = self.proxytype, create_reference = Reference, handler = self.int_handler)
     
-    def ext_call_handler(self):
-        return self.int_handler.call_handler
+#     def ext_call_handler(self):
+#         return self.int_handler.call_handler
     
-    def int_call_handler(self):
-        return self.ext_handler.call_handler
+#     def int_call_handler(self):
+#         return self.ext_handler.call_handler
 
-    def before_fork(self):
-        pass
-        # self.state_before_fork = self.thread_state.value
-        # self.thread_state.value = 'disabled'
+#     def before_fork(self):
+#         pass
+#         # self.state_before_fork = self.thread_state.value
+#         # self.thread_state.value = 'disabled'
 
-    def after_fork_in_child(self):
-        self.fork_counter = 0
+#     def after_fork_in_child(self):
+#         self.fork_counter = 0
 
-    def after_fork_in_parent(self):
-        self.fork_counter += 1
-        # self.thread_state.value = self.state_before_fork
+#     def after_fork_in_parent(self):
+#         self.fork_counter += 1
+#         # self.thread_state.value = self.state_before_fork
 
-    def gc_start(self):
-        self.before_gc = self.thread_state.value
-        self.thread_state.value = 'external'
+#     def gc_start(self):
+#         self.before_gc = self.thread_state.value
+#         self.thread_state.value = 'external'
 
-    def gc_end(self):
-        self.thread_state.value = self.before_gc
-        del self.before_gc
+#     def gc_end(self):
+#         self.thread_state.value = self.before_gc
+#         del self.before_gc
 
-    def gc_hook(self, phase, info):
+#     def gc_hook(self, phase, info):
 
-        if phase == 'start':
-            self.gc_start()
+#         if phase == 'start':
+#             self.gc_start()
 
-        elif phase == 'stop':
-            self.gc_end()
+#         elif phase == 'stop':
+#             self.gc_end()
     
-    def __init__(self, thread_state, on_new_proxytype, sync, 
-                 debug, checkpoint, verbose,
-                 ext_proxy, ext_handler, int_proxy, int_handler):
+#     def __init__(self, thread_state, on_new_proxytype, sync, 
+#                  debug, checkpoint, verbose,
+#                  ext_proxy, ext_handler, int_proxy, int_handler):
         
-        assert ext_proxy
+#         assert ext_proxy
         
-        self.ext_proxy = ext_proxy
-        self.ext_handler = ext_handler
-        self.int_proxy = int_proxy
-        self.int_handler = int_handler
-
-        def normalize(obj):
-            if isinstance(obj, RootProxy):
-                return str(obj)
-            elif isinstance(obj, MethodDescriptor):
-                return f'{obj.__objclass__.__module__}.{obj.__objclass__.__name__}.{obj.__name__}'
-            elif isinstance(obj, Proxy):
-                return 'Proxy'
-            else:
-                return obj
-
-        self.normalize = walker(normalize)
-
-        self.checkpoint_ext_call = mapargs(transform = self.normalize, 
-                                           function = self.checkpoint_ext_call)
+#         self.ext_proxy = ext_proxy
+#         self.ext_handler = ext_handler
+#         self.int_proxy = int_proxy
+#         self.int_handler = int_handler
+
+#         def normalize(obj):
+#             if isinstance(obj, RootProxy):
+#                 return str(obj)
+#             elif isinstance(obj, MethodDescriptor):
+#                 return f'{obj.__objclass__.__module__}.{obj.__objclass__.__name__}.{obj.__name__}'
+#             elif isinstance(obj, Proxy):
+#                 return 'Proxy'
+#             else:
+#                 return obj
+
+#         self.normalize = walker(normalize)
+
+#         self.checkpoint_ext_call = mapargs(transform = self.normalize, 
+#                                            function = self.checkpoint_ext_call)
         
-        # self.checkpoint_ext_call = self.arg_serializer(self.checkpoint_ext_call)
+#         # self.checkpoint_ext_call = self.arg_serializer(self.checkpoint_ext_call)
 
-        self.thread_state = thread_state
-        self.debug = debug
-        self.fork_counter = 0
-        self.verbose = verbose
+#         self.thread_state = thread_state
+#         self.debug = debug
+#         self.fork_counter = 0
+#         self.verbose = verbose
 
-        self.on_new_proxytype = on_new_proxytype
-        self._sync = sync
-        self.thread_counter = self.sync_function(counter(1))
+#         self.on_new_proxytype = on_new_proxytype
+#         self._sync = sync
+#         self.thread_counter = self.sync_function(counter(1))
 
-        # immutable_types = self.disable_for(immutable_types)
+#         # immutable_types = self.disable_for(immutable_types)
 
-        gc.callbacks.append(self.gc_hook)
+#         gc.callbacks.append(self.gc_hook)
 
-        def before():
-            print("In before!!!!")
-            with self.thread_state.select('disabled'):
-                self.before_fork()
+#         def before():
+#             print("In before!!!!")
+#             with self.thread_state.select('disabled'):
+#                 self.before_fork()
 
-        os.register_at_fork(
-            # before = self.thread_state.wrap('disabled', self.before_fork),
-            before = before,
-            after_in_parent = self.thread_state.wrap('disabled', self.after_fork_in_parent),
-            after_in_child = self.thread_state.wrap('disabled', self.after_fork_in_child))
+#         os.register_at_fork(
+#             # before = self.thread_state.wrap('disabled', self.before_fork),
+#             before = before,
+#             after_in_parent = self.thread_state.wrap('disabled', self.after_fork_in_parent),
+#             after_in_child = self.thread_state.wrap('disabled', self.after_fork_in_child))
 
-        self.tracing = None
+#         self.tracing = None
 
-        if debug > 3:
+#         if debug > 3:
 
-            # def checkpoint(obj):
-            #     print(f'in checkpoint: {obj}')
-            #     self.checkpoint(obj)
+#             # def checkpoint(obj):
+#             #     print(f'in checkpoint: {obj}')
+#             #     self.checkpoint(obj)
 
-            FrameTracer.install(self.thread_state.dispatch(_proxy.noop, internal = checkpoint))
+#             FrameTracer.install(self.thread_state.dispatch(_proxy.noop, internal = checkpoint))
 
-            # import threading
-            # tracer = FrameTracer(
-            #     pred = self.thread_state.predicate('internal'), 
-            #     checkpoint = checkpoint)
+#             # import threading
+#             # tracer = FrameTracer(
+#             #     pred = self.thread_state.predicate('internal'), 
+#             #     checkpoint = checkpoint)
             
-            # sys.settrace(tracer)
-            # threading.settrace(tracer)            
-            # self.trace = lambda event, **kwargs: checkpoint({'type': 'trace', 'event': event} | kwargs)
-            # self.enable_tracing()            
+#             # sys.settrace(tracer)
+#             # threading.settrace(tracer)            
+#             # self.trace = lambda event, **kwargs: checkpoint({'type': 'trace', 'event': event} | kwargs)
+#             # self.enable_tracing()            
 
-    def sync_type(self, base):
-        return sync_type(sync = self.sync, base = base)
+#     def sync_type(self, base):
+#         return sync_type(sync = self.sync, base = base)
 
-    def sync_function(self, function):
-        return intercept(on_call = self._sync, function = function)
+#     def sync_function(self, function):
+#         return intercept(on_call = self._sync, function = function)
 
-    def checkpoint(self, obj):
-        pass
+#     def checkpoint(self, obj):
+#         pass
 
-    def log(self, message):
-        if self.verbose:
-            print(message)
+#     def log(self, message):
+#         if self.verbose:
+#             print(message)
 
-        self.checkpoint({'type': 'log', 'message': message})
+#         self.checkpoint({'type': 'log', 'message': message})
 
-    @property
-    def disable(self):
-        return self.thread_state.select('disabled')
+#     @property
+#     def disable(self):
+#         return self.thread_state.select('disabled')
 
-    def with_state(self, state, function):
-        return self.thread_state.wrap(desired_state = state, function = function)
+#     def with_state(self, state, function):
+#         return self.thread_state.wrap(desired_state = state, function = function)
 
-    def disable_for(self, function):
-        return self.thread_state.wrap(desired_state = 'disabled', function = function)
+#     def disable_for(self, function):
+#         return self.thread_state.wrap(desired_state = 'disabled', function = function)
 
-    def __call__(self, module, name, obj):
+#     def __call__(self, module, name, obj):
         
-        if type(obj) == type:
-            try:
-                return self.extend_type(obj)
-            except:
-                pass
+#         if type(obj) == type:
+#             try:
+#                 return self.extend_type(obj)
+#             except:
+#                 pass
         
-        self.checkpoint({'type': 'proxy', 'module': module, 'name': name})
+#         self.checkpoint({'type': 'proxy', 'module': module, 'name': name})
 
-        if is_function_type(type(obj)) or type(obj) == type:
-            proxied = RootProxy(module = module, name = name, handler = self.ext_handler, target = obj)
+#         if is_function_type(type(obj)) or type(obj) == type:
+#             proxied = RootProxy(module = module, name = name, handler = self.ext_handler, target = obj)
             
-            try:
-                # print(f"signature: {inspect.signature(obj)} for {obj}")
-                proxied.__signature__ = inspect.signature(obj)
-            except:
-                pass
-
-            return proxied
-        else:
-            return self.ext_proxy(obj)
+#             try:
+#                 # print(f"signature: {inspect.signature(obj)} for {obj}")
+#                 proxied.__signature__ = inspect.signature(obj)
+#             except:
+#                 pass
+
+#             return proxied
+#         else:
+#             return self.ext_proxy(obj)
         
-        # return self.ext_proxy(obj)
+#         # return self.ext_proxy(obj)
     
-    def start_new_thread(self, start_new_thread, function, *args):
-        # synchronized, replay shoudl yeild correct number
-        thread_id = self.thread_counter()
-
-        def threadrunner(*args, **kwargs):
-            self.set_thread_number(thread_id)
-            with self.thread_state.select('internal'):
-                if self.tracing:
-                    FrameTracer.install(self.thread_state.dispatch(noop, internal = self.checkpoint))
+#     def start_new_thread(self, start_new_thread, function, *args):
+#         # synchronized, replay shoudl yeild correct number
+#         thread_id = self.thread_counter()
+
+#         def threadrunner(*args, **kwargs):
+#             self.set_thread_number(thread_id)
+#             with self.thread_state.select('internal'):
+#                 if self.tracing:
+#                     FrameTracer.install(self.thread_state.dispatch(noop, internal = self.checkpoint))
                 
-                return function(*args, **kwargs)
+#                 return function(*args, **kwargs)
 
-        return start_new_thread(threadrunner, *args)
+#         return start_new_thread(threadrunner, *args)
 
-    def wrap_start_new_thread(self, start_new_thread):
-        wrapped = functools.partial(self.start_new_thread, start_new_thread)
-        return self.thread_state.dispatch(start_new_thread, internal = wrapped)
+#     def wrap_start_new_thread(self, start_new_thread):
+#         wrapped = functools.partial(self.start_new_thread, start_new_thread)
+#         return self.thread_state.dispatch(start_new_thread, internal = wrapped)
     
-    def checkpoint_ext_call(self, func, *args, **kwargs):
-        self.checkpoint({'type': 
-                         'external.call', 
-                         'function': str(func)})
-
-    def extend_type(self, base):
-
-        assert not issubclass(base, BaseException)
-
-        self.checkpoint({'type': 'log', 'message': f'extending type: {base}'})
-
-        def custom_init_subclass(cls, **kwargs):
-            for name, target in cls.__dict__.items():
-                if is_method_descriptor(target):
-                    proxied = cls.method_descriptor(handler = self.int_handler, 
-                                                    call_handler = self.thread_state.predicate('external'),
-                                                    name = name,
-                                                    target = target)
-                    setattr(cls, name, proxied)
-
-        def __new__(cls, *args, **kwargs):
-            instance = base.__new__(cls, *args, **kwargs)
-            self.on_new(instance)
-            return instance
+#     def checkpoint_ext_call(self, func, *args, **kwargs):
+#         self.checkpoint({'type': 
+#                          'external.call', 
+#                          'function': str(func)})
+
+#     def extend_type(self, base):
+
+#         assert not issubclass(base, BaseException)
+
+#         self.checkpoint({'type': 'log', 'message': f'extending type: {base}'})
+
+#         def custom_init_subclass(cls, **kwargs):
+#             for name, target in cls.__dict__.items():
+#                 if is_method_descriptor(target):
+#                     proxied = cls.method_descriptor(handler = self.int_handler, 
+#                                                     call_handler = self.thread_state.predicate('external'),
+#                                                     name = name,
+#                                                     target = target)
+#                     setattr(cls, name, proxied)
+
+#         def __new__(cls, *args, **kwargs):
+#             instance = base.__new__(cls, *args, **kwargs)
+#             self.on_new(instance)
+#             return instance
         
-        slots = {
-            "__slots__": (),
-            '__new__': __new__,
-            "__init_subclass__": classmethod(custom_init_subclass)
-        }
-
-        extended = type(f'retrace.extended.{base.__module__}.{base.__name__}', (base, _proxy.ExtendedProxy), slots)
-
-        blacklist = ['__getattribute__', '__hash__', '__del__']
-
-        for name,value in superdict(base).items():
-            if name not in blacklist:
-                if is_method_descriptor(value):
-                    proxied = extended.method_descriptor(
-                        handler = self.ext_handler,
-                        name = name,
-                        target = getattr(base, name))
-
-                    setattr(extended, name, proxied)
-                elif is_descriptor(value):
-                    setattr(extended, name, self.ext_proxy(value))
+#         slots = {
+#             "__slots__": (),
+#             '__new__': __new__,
+#             "__init_subclass__": classmethod(custom_init_subclass)
+#         }
+
+#         extended = type(f'retrace.extended.{base.__module__}.{base.__name__}', (base, _proxy.ExtendedProxy), slots)
+
+#         blacklist = ['__getattribute__', '__hash__', '__del__']
+
+#         for name,value in superdict(base).items():
+#             if name not in blacklist:
+#                 if is_method_descriptor(value):
+#                     proxied = extended.method_descriptor(
+#                         handler = self.ext_handler,
+#                         name = name,
+#                         target = getattr(base, name))
+
+#                     setattr(extended, name, proxied)
+#                 elif is_descriptor(value):
+#                     setattr(extended, name, self.ext_proxy(value))
                 
-        def __del__(obj):
-            try:
-                self.on_del(Reference(obj))
-                # self.external.handler.on_del(_proxy.Reference(obj))
-            except:
-                pass
+#         def __del__(obj):
+#             try:
+#                 self.on_del(Reference(obj))
+#                 # self.external.handler.on_del(_proxy.Reference(obj))
+#             except:
+#                 pass
 
-            try:
-                base.__del__(obj)
-            except:
-                pass
+#             try:
+#                 base.__del__(obj)
+#             except:
+#                 pass
 
-        extended.__del__ = __del__
+#         extended.__del__ = __del__
 
-        if self.on_new_proxytype:
-            self.on_new_proxytype(base.__module__, base.__name__, extended)
+#         if self.on_new_proxytype:
+#             self.on_new_proxytype(base.__module__, base.__name__, extended)
 
-        return extended
+#         return extended

retracesoftware/proxy/proxysystem.py

@@ -1,20 +1,202 @@
 import retracesoftware.functional as functional
 import retracesoftware_utils as utils
-                                                                 
-from retracesoftware.proxy.proxytype import extending_proxytype, make_extensible
+import types
+from retracesoftware.proxy.gateway import adapter_pair
+from types import SimpleNamespace
+from retracesoftware.proxy.proxytype import *
+from retracesoftware.proxy.stubfactory import Stub
+import sys
+import gc
+
+class RetraceError(Exception):
+    pass
+
+def proxy(proxytype):
+    return functional.spread(
+        utils.create_wrapped,
+        functional.sequence(functional.typeof, proxytype),
+        None)
+
+def maybe_proxy(proxytype):
+    return functional.if_then_else(
+            functional.isinstanceof(utils.Wrapped),
+            utils.unwrap,
+            proxy(functional.memoize_one_arg(proxytype)))
+
+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 __init__(self, thread_state):
+    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):
+        pass
+
+    def on_ext_result(self, result):
+        pass
+
+    def on_ext_error(self, err_type, err_value, err_traceback):
+        pass
+
+    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))
+
+        is_immutable = functional.sequence(functional.typeof, functional.memoize_one_arg(is_immutable_type))
+
+        def proxyfactory(proxytype):
+            return functional.walker(functional.when_not(is_immutable, maybe_proxy(proxytype)))
+
+        int_spec = SimpleNamespace(
+            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'),
+        )
+
+        ext_spec = SimpleNamespace(
+            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,
+        )
+
+        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 =  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
+
+    def before_fork(self):
+        self.saved_thread_state = self.thread_state.value
+        self.thread_state.value = 'disabled'
+
+    def after_fork_in_child(self):
+        self.thread_state.value = self.saved_thread_state
+        self.fork_counter = 0
+
+    def after_fork_in_parent(self):
+        self.thread_state.value = self.saved_thread_state
+        self.fork_counter += 1
+
+    def create_stub(self): return False
+        
+    def int_proxytype(self, cls):
+        return dynamic_int_proxytype(
+                handler = self.int_dispatch,
+                cls = cls,
+                bind = self.bind)
+
+    def dynamic_ext_proxytype(self, cls):
+        print(f'dynamic_ext_proxytype: {cls} {self.thread_state.value}')
+
+        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_dispatch, 
+                    cls = cls,
+                    thread_state = self.thread_state,
+                    create_stub = self.create_stub())
+
+    def extend_type(self, cls):
+
+        extended = extending_proxytype(
+            cls = cls,
+            base = Stub if self.create_stub() else cls,
+            thread_state = self.thread_state, 
+            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)
+            
+        try:
+            print(f'STARTING PROXYING: {obj}')
+            if type(obj) == type:
+                if obj in self.immutable_types or issubclass(obj, tuple):
+                    return obj
+                
+                return self.ext_proxytype(obj)
+                
+            elif type(obj) in self.immutable_types:
+                return obj
+            
+            elif is_function_type(type(obj)):
 
-        if type(obj) == type and utils.is_extendable(obj):
-            return self.extend_type(obj)
-        elif callable(obj):
-            return utils.wrapped_function(handler = self.ext_handler, target = obj)
-        else:
-            raise Exception(f'object {obj} was not proxied as its not a extensible type and is not callable')
-    
+                return self.thread_state.dispatch(
+                    obj, 
+                    internal = self.proxy_function(obj))
+            
+            else:
+                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')
+        finally:
+            print(f'FINISHED PROXYING: {obj}')