retracesoftware-proxy 0.1.0__py3-none-any.whl

retracesoftware/proxy/gateway.py

@@ -0,0 +1,100 @@
+import retracesoftware.functional as functional
+import retracesoftware_utils as utils
+
+# from retracesoftware.proxy.proxytype import ExtendingProxy
+
+unproxy_execute = functional.mapargs(starting = 1, 
+                                     transform = functional.walker(utils.try_unwrap), 
+                                     function = functional.apply)
+
+def adapter(proxy_input,
+            proxy_output,
+            function,
+            on_call = None,
+            on_result = None,
+            on_error = None):
+
+    # function = functional.apply
+
+    if on_call: function = functional.observer(on_call = on_call, function = function)
+
+    function = functional.mapargs(starting = 1, transform = proxy_input, function = function)
+
+    function = functional.compose(function, proxy_output)
+
+    if on_result or on_error:
+        function = functional.observer(on_result = on_result, on_error = on_error, function = function)
+
+    return function
+
+def adapter_pair(proxy_int, 
+                 proxy_ext,
+                 int_apply,
+                 ext_apply,
+                 tracer, 
+                 on_int_call,
+                 on_ext_result,
+                 on_ext_error):
+    return (
+        adapter(
+            function = ext_apply,
+            proxy_input = proxy_int,
+            proxy_output = proxy_ext,
+            on_call = tracer('proxy.ext.call'),
+            on_result = on_ext_result,
+            on_error = on_ext_error),
+            # on_result = tracer('proxy.ext.result', on_ext_result),
+            # on_error = tracer('proxy.ext.error', on_ext_error)),
+        adapter(
+            function = int_apply,
+            proxy_input = proxy_ext,
+            proxy_output = proxy_int,
+            on_call = tracer('proxy.int.call', on_int_call),
+            on_result = tracer('proxy.int.result'),
+            on_error = tracer('proxy.int.error')))
+    
+def proxy(proxytype):
+    return functional.selfapply(functional.compose(functional.typeof, proxytype))
+
+def maybe_proxy(proxytype):
+    return functional.if_then_else(
+            functional.isinstanceof(utils.Wrapped),
+            utils.unwrap,
+            proxy(functional.memoize_one_arg(proxytype)))
+
+def gateway_pair(thread_state,
+                 tracer,
+                 immutable_types,
+                 int_proxytype,
+                 ext_proxytype,
+                 int_apply = functional.apply,
+                 ext_apply = functional.apply,
+                 on_int_call = None,
+                 on_ext_result = None,
+                 on_ext_error = 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 create_proxier(proxytype):
+        return functional.walker(functional.when_not(is_immutable, maybe_proxy(proxytype)))
+    
+    int_to_ext_dispatch = thread_state.dispatch(tracer('proxy.int.disabled.event', unproxy_execute))
+    ext_to_int_dispatch = thread_state.dispatch(tracer('proxy.ext.disabled.event', unproxy_execute))
+
+    int_to_ext, ext_to_int = adapter_pair(
+        proxy_int = create_proxier(int_proxytype(ext_to_int_dispatch)),
+        proxy_ext = create_proxier(ext_proxytype(int_to_ext_dispatch)),
+        int_apply = thread_state.wrap(desired_state = 'internal', function = int_apply),
+        ext_apply = thread_state.wrap(desired_state = 'external', function = ext_apply),
+        tracer = tracer,
+        on_int_call = on_int_call,
+        on_ext_result = on_ext_result,
+        on_ext_error = on_ext_error)
+
+    thread_state.set_dispatch(int_to_ext_dispatch, external = functional.apply, internal = tracer('proxy.int_to_ext.stack', int_to_ext))
+    thread_state.set_dispatch(ext_to_int_dispatch, internal = functional.apply, external = tracer('proxy.ext_to_int.wrap', ext_to_int))
+    
+    return (int_to_ext_dispatch, ext_to_int_dispatch)

retracesoftware/proxy/proxyfactory.py

@@ -0,0 +1,357 @@
+from retracesoftware_utils import counter
+from retracesoftware_functional import *
+
+import types
+import pickle
+import gc
+import os
+import functools
+import inspect
+
+def is_function_type(cls):
+    return issubclass(cls, types.BuiltinFunctionType) or issubclass(cls, types.FunctionType)
+
+def superdict(cls):
+    result = {}
+    for cls in list(reversed(cls.__mro__))[1:]:
+        result.update(cls.__dict__)
+    
+    return result
+
+def is_method_descriptor(obj):
+    return isinstance(obj, types.FunctionType) or \
+           (isinstance(obj, (types.WrapperDescriptorType, types.MethodDescriptorType)) and obj.__objclass__ != object)
+
+def blacklist_for(self, cls):
+    return ['__getattribute__', '__hash__', '__del__', '__init__', '__call__']
+
+def is_descriptor(obj):
+    return hasattr(obj, '__get__') or hasattr(obj, '__set__') or hasattr(obj, '__delete__')
+
+def methods(cls):
+    for name,value in superdict(cls).items():
+        if is_descriptor(value) and is_method_descriptor(value):
+            yield name
+
+def patch_spec(cls, blacklist):
+    return {
+        'name': f'retrace.proxied.{cls.__module__}.{cls.__name__}',
+        'methods': [m for m in methods(cls) if m not in blacklist],
+        'callable': yeilds_callable_instances(cls),
+        'weakrefs': yeilds_weakly_referenceable_instances(cls)
+    }
+
+def proxytype_from_spec(target_for, spec):
+    proxytype = create_wrapping_proxy_type(
+        name = spec['name'],
+        callable = spec['callable'],
+        weakrefs = spec['weakrefs'])
+    
+    def add_method_descriptor(name, target):
+        setattr(proxytype, name, proxytype.method_descriptor(name = name, target = target))
+
+    for method in spec['methods']:
+        add_method_descriptor(name = method, target = target_for(method))
+
+    # add_method_descriptor(name = '__getattr__', target = object.__getattribute__)
+    add_method_descriptor(name = '__getattr__', target = getattr)
+    add_method_descriptor(name = '__setattr__', target = setattr)
+
+    return proxytype
+
+def stubtype_from_spec(spec):
+    proxytype = create_stub_proxy_type(
+        name = spec['name'],
+        callable = spec['callable'],
+        weakrefs = spec['weakrefs'])
+
+    def add_method_descriptor(name):
+        setattr(proxytype, name, proxytype.method_descriptor(name))
+
+    for method in spec['methods']:
+        add_method_descriptor(method)
+
+    add_method_descriptor('__getattr__')
+    add_method_descriptor('__setattr__')
+
+    return proxytype
+    
+def wrap_method_descriptors(wrapper, prefix, base):
+    slots = {"__slots__": () }
+
+    extended = type(f'{prefix}.{base.__module__}.{base.__name__}', (base,), {"__slots__": () })
+
+    blacklist = ['__getattribute__', '__hash__', '__del__']
+
+    for name,value in superdict(base).items():
+        if name not in blacklist:
+            if is_method_descriptor(value):
+                setattr(extended, name, wrapper(value))
+
+    return extended
+
+def sync_type(sync, base):
+    return wrap_method_descriptors(
+        wrapper = lambda desc: intercept(on_call = sync, function = desc),
+        prefix = 'retrace.synced',
+        base = base)
+
+class GCHook:
+    def __init__(self, thread_state):
+        self.thread_state = thread_state
+
+    def __call__(self, phase, info):
+        if phase == 'start':
+            self.saved_state = self.thread_state.value
+            self.thread_state.value = 'disabled'
+
+        elif phase == 'stop':
+            self.thread_state.value = self.saved_state
+
+class ProxyFactory:
+
+    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 ext_call_handler(self):
+        return self.int_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 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 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_hook(self, phase, info):
+
+        if phase == 'start':
+            self.gc_start()
+
+        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):
+        
+        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.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.on_new_proxytype = on_new_proxytype
+        self._sync = sync
+        self.thread_counter = self.sync_function(counter(1))
+
+        # immutable_types = self.disable_for(immutable_types)
+
+        gc.callbacks.append(self.gc_hook)
+
+        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))
+
+        self.tracing = None
+
+        if debug > 3:
+
+            # def checkpoint(obj):
+            #     print(f'in checkpoint: {obj}')
+            #     self.checkpoint(obj)
+
+            FrameTracer.install(self.thread_state.dispatch(_proxy.noop, internal = 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()            
+
+    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 checkpoint(self, obj):
+        pass
+
+    def log(self, message):
+        if self.verbose:
+            print(message)
+
+        self.checkpoint({'type': 'log', 'message': message})
+
+    @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 disable_for(self, function):
+        return self.thread_state.wrap(desired_state = 'disabled', function = function)
+
+    def __call__(self, module, name, obj):
+        
+        if type(obj) == type:
+            try:
+                return self.extend_type(obj)
+            except:
+                pass
+        
+        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)
+            
+            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)
+    
+    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 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 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))
+                
+        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
+
+        extended.__del__ = __del__
+
+        if self.on_new_proxytype:
+            self.on_new_proxytype(base.__module__, base.__name__, extended)
+
+        return extended

retracesoftware/proxy/proxysystem.py

@@ -0,0 +1,20 @@
+import retracesoftware.functional as functional
+import retracesoftware_utils as utils
+                                                                 
+from retracesoftware.proxy.proxytype import extending_proxytype, make_extensible
+
+class ProxySystem:
+    
+    def __init__(self, thread_state):
+        self.thread_state = thread_state
+
+    def __call__(self, obj):
+        assert not isinstance(obj, BaseException)
+
+        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')
+