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

retracesoftware/proxy/proxysystem.py

@@ -1,20 +1,181 @@
 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_pair1
+from types import SimpleNamespace
+from retracesoftware.proxy.proxytype import ExtendingProxy
+
+from retracesoftware.proxy.proxytype import extending_proxytype, make_extensible, dynamic_proxytype, dynamic_int_proxytype, instantiable_dynamic_proxytype
+
+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,
+        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)
 
 class ProxySystem:
     
-    def __init__(self, thread_state):
+    def wrap_int_to_ext(self, obj): return 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 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
+        
+        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(
+            proxytype = self.int_proxytype,
+            proxy = proxyfactory(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),
+            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)
+
+        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)
+
+
+    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_handler,
+                cls = cls,
+                bind = self.bind)
+
+    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, 
+                    cls = cls,
+                    thread_state = self.thread_state,
+                    create_stub = self.create_stub())
+
+    def extend_type(self, base):
+
+        extended = extending_proxytype(
+            cls = base,
+            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())
+        
+        self.immutable_types.add(extended)
+
+        return extended
 
     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):
+        assert not isinstance(obj, utils.wrapped_function)
+            
+        if type(obj) == type:
+            return self.ext_proxytype(obj)
+            
+        elif type(obj) == types.BuiltinFunctionType:
             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')
+            proxytype = dynamic_proxytype(handler = self.ext_handler, 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

@@ -112,7 +112,7 @@ def dynamic_proxytype(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]
 
@@ -128,13 +128,32 @@ def dynamic_proxytype(handler, cls):
 
     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 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))
@@ -163,7 +182,7 @@ class DescriptorProxy:
         return self.handler(deleter, self.name)
 
 
-blacklist = ['__getattribute__', '__hash__', '__del__']
+blacklist = ['__getattribute__', '__hash__', '__del__', '__dict__']
 
 # if the type can be patched, thats better, all new instances must be of correct type
 
@@ -178,7 +197,7 @@ def extending_proxytype(cls, thread_state, ext_handler, int_handler, on_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 }
@@ -202,14 +221,6 @@ def extending_proxytype(cls, thread_state, ext_handler, int_handler, on_subclass
         proxy = DescriptorProxy(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)

retracesoftware/proxy/record.py

@@ -1,11 +1,21 @@
 import retracesoftware.functional as functional
 import retracesoftware_utils as utils
+import retracesoftware.stream as stream
 
-from retracesoftware.proxy.proxytype import dynamic_proxytype, superdict, is_descriptor, extending_proxytype, dynamic_int_proxytype, make_extensible
-from retracesoftware.proxy.gateway import gateway_pair
+from retracesoftware.proxy.proxytype import dynamic_proxytype, superdict, is_descriptor, extending_proxytype, dynamic_int_proxytype, make_extensible, Proxy
+# from retracesoftware.proxy.gateway import gateway_pair
 from retracesoftware.proxy.proxysystem import ProxySystem
-
+from retracesoftware.proxy.thread import write_thread_switch
+from retracesoftware.install.tracer import Tracer
 import sys
+import os
+import types
+
+class Placeholder:
+    __slots__ = ['id', '__weakref__']
+
+    def __init__(self, id):
+        self.id = id
 
 class ExtendedProxy:
     __slots__ = []
@@ -31,103 +41,184 @@ def keys_where_value(pred, dict):
     for key,value in dict.items():
         if pred(value): yield key
 
+types_lookup = {v:k for k,v in types.__dict__.items() if isinstance(v, type)}
+
+def resolve(obj):
+    try:
+        return getattr(sys.modules[obj.__module__], obj.__name__)
+    except:
+        return None
+    
 def resolveable(obj):
     try:
         return getattr(sys.modules[obj.__module__], obj.__name__) is obj
     except:
         return False
+
+def resolveable_name(obj):
+    if obj in types_lookup:
+        return ('types', types_lookup[obj])
+    elif resolve(obj) is obj:
+        return (obj.__module__, obj.__name__)
+    else:
+        return None
+
+# when 
+class RecordProxySystem(ProxySystem):
     
-class ExtProxytype:
+    def bind(self, obj):
+        self.bindings[obj] = self.writer.handle(Placeholder(self.next_placeholder_id))
+        self.writer(self.bindings[obj])
+        self.next_placeholder_id += 1
+
+    def before_fork(self):
+        self.writer.close()
+        super().before_fork()
+        # self.writer.path = self.dynamic_path
+
+    def after_fork_in_child(self):
+        new_path = self.new_child_path(self.writer.path)
+        new_path.parent.mkdir()
+        self.writer.path = new_path
+        super().after_fork_in_child()
+
+    def after_fork_in_parent(self):
+        super().after_fork_in_parent()
+        self.thread_state.value = self.saved_thread_state
+        self.writer.reopen()
+
+    def __init__(self, thread_state, 
+                 immutable_types, 
+                 tracing_config,
+                 path):
+        
+        self.fork_counter = 0
 
-    def __init__(self, gateway, extended_types, writer):
-        self.gateway = gateway
-        self.writer = writer
-        self.extended_types = extended_types
+        self.getpid = thread_state.wrap(
+            desired_state = 'disabled', function = os.getpid)
+        
+        self.pid = self.getpid()
 
-    def __call__(self, cls):
-        assert isinstance(cls, type)
+        self.writer = stream.writer(path)
+        
+        w = self.writer.handle('TRACE')
+        def trace_writer(*args):
+            print(f'Trace: {args}')
+            w(*args)
 
-        if cls in self.extended_types:
-            return functional.side_effect(lambda obj: utils.set_type(obj, self.extended_types[cls]))
-        else:
-            if resolveable(cls):
-                ref = self.writer.handle(ProxyRef(name = cls.__name__, module = cls.__module__))
-            else:
-                blacklist = ['__getattribute__']
-                descriptors = {k: v for k,v in superdict(cls).items() if k not in blacklist and is_descriptor(v) }
-
-                methods = [k for k, v in descriptors.items() if utils.is_method_descriptor(v)]
-                members = [k for k, v in descriptors.items() if not utils.is_method_descriptor(v)]
-
-                ref = self.writer.handle(ProxySpec(name = cls.__name__, 
-                                                module = cls.__module__,
-                                                methods = methods,
-                                                members = members))
+        self.extended_types = {}
+        self.bindings = utils.id_dict()
+        self.next_placeholder_id = 0
+
+        serialize = functional.walker(self.bindings.get_else_key)
+        
+        thread_switch_monitor = \
+            utils.thread_switch_monitor(
+                functional.repeatedly(functional.sequence(utils.thread_id, self.writer)))
+
+        # self.sync = lambda function: functional.observer(on_call = functional.always(writer.handle('SYNC')), function = function)
+        self.sync = lambda function: functional.firstof(thread_switch_monitor, functional.always(self.writer.handle('SYNC')), function)
+
+        # trace_handle = writer.handle('TRACE')
+        # tracer = Tracer(tracing_config, writer = trace_handle)
+
+        # on_ext_result = writer.handle('RESULT')
+        # on_ext_result = functional.if_then_else(
+        #     functional.isinstanceof(str), self.writer.handle('RESULT'), functional.sequence(serialize, self.writer))
+ 
+        # on_int_call = functional.mapargs(transform = serialize, function = self.writer.handle('CALL'))
             
-            proxytype = dynamic_proxytype(handler = self.gateway, cls = cls)
+        error = self.writer.handle('ERROR')
 
-            self.writer.type_serializer[proxytype] = functional.constantly(ref)
-            return proxytype
+        def write_error(cls, val, traceback):
+            error(cls, val)
         
+        self.set_thread_id = functional.partial(utils.set_thread_id, self.writer)
 
-# when 
-class RecordProxySystem(ProxySystem):
-    
-    def __init__(self, thread_state, immutable_types, tracer, writer):
-        super().__init__(thread_state = thread_state)
+        def watch(f): return functional.either(thread_switch_monitor, f)
 
-        self.immutable_types = immutable_types
+        tracer = Tracer(tracing_config, writer = trace_writer)
 
-        self.extended_types = {}
-        self.writer = writer
-        self.bind = writer.placeholder
+        # def wrap_int_to_ext(self, obj): return obj
+        # def wrap_ext_to_int(self, obj): return obj
+        
+        # def on_int_call(self, func, *args, **kwargs):
+        #     pass
 
-        # on_ext_result = writer.handle('RESULT')
-        on_ext_result = functional.if_then_else(
-            functional.isinstanceof(str), writer.handle('RESULT'), writer)
+        # def on_ext_result(self, result):
+        #     pass
+
+        # def on_ext_error(self, err_type, err_value, err_tarceback):
+        #     pass
 
-        def int_proxytype(gateway):
-            return lambda cls: dynamic_int_proxytype(handler = gateway, cls = cls, bind = self.bind)
+        # def ext_apply(self, func, *args, **kwargs):
+        #     return func(*args, **kwargs)
         
-        def ext_proxytype(gateway):
-            return ExtProxytype(gateway = gateway, writer = writer, extended_types = self.extended_types)
-    
-        error = writer.handle('ERROR')
+        # def int_apply(self, func, *args, **kwargs):
+        #     return func(*args, **kwargs)
 
-        def write_error(cls, val, traceback):
-            error(cls, val)
+        self.wrap_int_to_ext = watch
+        
+        self.on_int_call = functional.mapargs(transform = serialize, function = self.writer.handle('CALL'))
+        
+        self.on_ext_result = functional.if_then_else(
+                                functional.isinstanceof(str), 
+                                self.writer.handle('RESULT'), 
+                                functional.sequence(serialize, self.writer))
+        
+        self.on_ext_error = write_error
 
-        self.ext_handler, self.int_handler = gateway_pair(
-            thread_state,
-            tracer,
-            immutable_types = immutable_types,
-            int_proxytype = int_proxytype,
-            ext_proxytype = ext_proxytype,
-            on_int_call = writer.handle('CALL'),
-            on_ext_result = functional.side_effect(on_ext_result),
-            on_ext_error = write_error)
+        self.ext_apply = self.int_apply = functional.apply
+
+        super().__init__(thread_state = thread_state, tracer = tracer, immutable_types = immutable_types)
+            # wrap_int_to_ext = watch,
+            # on_int_call = on_int_call,
+            # on_ext_result = on_ext_result,
+            # on_ext_error = write_error)
+        
+        # self.ext_handler, self.int_handler = gateway_pair(
+        #     thread_state,
+        #     self.tracer,
+        #     immutable_types = immutable_types,
+        #     wrap_int_to_ext = watch,
+        #     int_proxytype = self.int_proxytype,
+        #     ext_proxytype = self.proxytype,
+        #     on_int_call = on_int_call,
+        #     on_ext_result = on_ext_result,
+        #     on_ext_error = write_error)
+            
+    def ext_proxytype(self, cls):
+        assert isinstance(cls, type), f"record.proxytype requires a type but was passed: {cls}"
+
+        # resolved = resolve(cls)
+
+        proxytype = super().ext_proxytype(cls)
+
+        if resolveable_name(cls):
+            module, name = resolveable_name(cls)
+            ref = self.writer.handle(ProxyRef(name = name, module = module))
+        else:
+            blacklist = ['__getattribute__']
+            descriptors = {k: v for k,v in superdict(cls).items() if k not in blacklist and is_descriptor(v) }
+
+            methods = [k for k, v in descriptors.items() if utils.is_method_descriptor(v)]
+            members = [k for k, v in descriptors.items() if not utils.is_method_descriptor(v)]
+
+            ref = self.writer.handle(ProxySpec(name = cls.__name__, 
+                                            module = cls.__module__,
+                                            methods = methods,
+                                            members = members))
+  
+        self.writer.type_serializer[proxytype] = functional.constantly(ref)
+        return proxytype
 
     def extend_type(self, base):
 
         if base in self.extended_types:
             return self.extended_types[base]
 
-        # self.tracer.log('proxy.ext.new.extended', f'{base.__module__}.{base.__name__}')
-
-        extended = extending_proxytype(
-            cls = base,
-            thread_state = self.thread_state, 
-            ext_handler = self.ext_handler,
-            int_handler = self.int_handler,
-            on_subclass_new = self.bind,
-            is_stub = False)
-        
-        ref = self.writer.handle(ProxyRef(name = base.__name__, module = base.__module__,))
-        self.writer.type_serializer[extended] = functional.constantly(ref)
+        extended = super().extend_type(base)
         
-        # make_extensible(cls = extended, handler = self.int_handler, on_new = self.writer.placeholder)
-
-        self.immutable_types.add(extended)
         self.extended_types[base] = extended 
 
         return extended