retracesoftware-proxy 0.1.5__py3-none-any.whl → 0.2.4__py3-none-any.whl

retracesoftware/proxy/proxytype.py

@@ -3,14 +3,11 @@ import retracesoftware.functional as functional
 
 import types
 
-from retracesoftware.proxy.stubfactory import StubMethodDescriptor
+from retracesoftware.proxy.stubfactory import StubMethodDescriptor, Stub
 
 class Proxy:
     __slots__ = []
 
-class Stub(Proxy):
-    __slots__ = []
-
 class DynamicProxy(Proxy):
     __slots__ = []
 
@@ -163,7 +160,11 @@ class DescriptorProxy:
         self.target = target
 
     def __get__(self, obj, cls):
-        return self.handler(self.target.__get__, obj, cls)
+        try:
+            return self.handler(self.target.__get__, obj, cls)
+        except:
+            print(f'error calling __get__')
+            raise
 
     def __set__(self, obj, value):
         return self.handler(self.target.__set__, obj, value)
@@ -171,46 +172,75 @@ class DescriptorProxy:
     def __delete__(self, obj):
         return self.handler(self.target.__delete__, obj)
 
-class ExtendingDescriptorProxy:
+# class ExtendingDescriptorProxy:
 
-    __slots__ = ['handler', 'proxytype', 'name']
+#     __slots__ = ['handler', 'proxytype', 'name']
 
-    def __init__(self, proxytype, handler, name):
-        self.proxytype = proxytype
-        self.handler = handler
-        self.name = 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 __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 __set__(self, instance, value):
+#         breakpoint()
+#         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)
+#     def __delete__(self, instance):
+#         deleter = functional.partial(delattr, super(self.proxytype, instance))
+#         return self.handler(deleter, self.name)
 
 
 def dynamic_proxytype(handler, cls):
 
+    if cls.__module__.startswith('retracesoftware'):
+        print(cls)
+        utils.sigtrap('HERE5')
+        
+    assert not cls.__module__.startswith('retracesoftware')
+
+    # print(f'In dynamic_proxytype: {cls}')
+
     assert not issubclass(cls, Proxy)
     assert not issubclass(cls, BaseException)
 
-    blacklist = ['__getattribute__', '__hash__', '__del__', '__call__']
+    blacklist = ['__getattribute__', '__hash__', '__del__', '__call__', '__new__']
 
     spec = {}
 
+    def wrap(func): return utils.wrapped_function(handler = handler, target = func)
+    
     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)
+
+            if issubclass(type(value), utils.dispatch):
+                value = utils.dispatch.table(value)['disabled']
+            
+            # if is_descriptor(value):
+            if utils.is_method_descriptor(value):
+                spec[name] = wrap(value) 
+
+            # try:
+            #     value = getattr(cls, name)
+
+            #     assert type(value) is not utils.dispatch
+
+            #     if is_descriptor(value):
+            #         if utils.is_method_descriptor(value):
+            #             spec[name] = wrap(value)
+            # except Exception as error:
+            #     print(f'FOO! {cls} {name} {error}')
+            #     breakpoint()
+            #     raise
+    
+                # else:
+                #     spec[name] = DescriptorProxy(handler = handler, target = value)
 
     # to_proxy = [m for m in methods(cls) if m not in blacklist]
 
@@ -218,26 +248,39 @@ def dynamic_proxytype(handler, cls):
     
     # spec = { name: wrap(getattr(cls, name)) for name in to_proxy }
 
-    # spec['__getattr__'] = wrap(getattr)
-    # spec['__setattr__'] = wrap(setattr)
+    # def foo(obj, name, default = None):        
+    #     print(f'dynamic_proxytype.__getattr__: {type(obj).__mro__} {name}')
+    #     utils.sigtrap(obj)
+    #     return getattr(obj, name, default)
+
+    # spec['__getattr__'] = wrap(foo)    
+    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.sequence(utils.unwrap, functional.typeof)
-    spec['__class__'] = property(target_type)
-    
-    name = f'retrace.proxied.{cls.__module__}.{cls.__name__}'
+    # target_type = functional.sequence(utils.unwrap, functional.typeof)
 
-    return type(name, (utils.Wrapped, DynamicProxy), spec)
+    target_type = cls.__retrace_target_type__ if issubclass(cls, Stub) else cls
+    # functional.repeatedly(resolved)
+
+    # spec['__class__'] = property(target_type)
+    spec['__class__'] = property(functional.constantly(target_type))
+
+    spec['__name__'] = cls.__name__
+    spec['__module__'] = cls.__module__
+    # name = f'retrace.proxied.{cls.__module__}.{cls.__name__}'
+
+    return type(cls.__name__, (utils.Wrapped, DynamicProxy), spec)
 
 def dynamic_from_extended(cls):
     
     base = cls.__base__
 
-    name = f'retrace.proxied.{base.__module__}.{base.__name__}'
+    name = f'retrace.proxied1.{base.__module__}.{base.__name__}'
 
     spec = dict(cls.__dict__)
 
@@ -272,6 +315,7 @@ def instantiable_dynamic_proxytype(handler, cls, thread_state, create_stub = Fal
 def dynamic_int_proxytype(handler, cls, bind):
     proxytype = dynamic_proxytype(handler = handler, cls = cls)
     proxytype.__new__ = functional.sequence(proxytype.__new__, functional.side_effect(bind))
+    proxytype.__retrace_source__ = 'internal'
     return proxytype
                                     
 
@@ -313,6 +357,11 @@ def create_unproxied_type(cls):
 
     bases = tuple(map(unproxy_type, cls.__bases__))
     slots = dict(cls.__dict__)
+
+    if '__slots__' in slots:
+        for slot in slots['__slots__']:
+            slots.pop(slot)
+
     # del slots['__init_subclass__']
     return type(cls.__name__, tuple(bases), slots)
 
@@ -323,7 +372,7 @@ def extending_proxytype(cls, base, thread_state, ext_handler, int_handler, on_su
     assert not issubclass(cls, ExtendingProxy)
 
     def init_subclass(subclass, **kwargs):
-        print(f'In init_subclass: {subclass} {kwargs}')
+        # print(f'In init_subclass: {subclass} {subclass.__mro__} {kwargs}')
         unproxied = create_unproxied_type(subclass)
         subclass.__retrace_unproxied__ = unproxied
 
@@ -347,7 +396,7 @@ def extending_proxytype(cls, base, thread_state, ext_handler, int_handler, on_su
     for name,value in superdict(cls).items():
         if name not in blacklist:
             if is_method_descriptor(value):
-                slots[name] = wrap(getattr(cls, name))
+                slots[name] = wrap(getattr(base, name))
             elif is_descriptor(value):
                 descriptors.append(name)
 
@@ -356,12 +405,15 @@ def extending_proxytype(cls, base, thread_state, ext_handler, int_handler, on_su
     extended = type(cls.__name__, (base, ExtendingProxy), slots)
 
     for name in descriptors:
-        proxy = ExtendingDescriptorProxy(handler = ext_handler, name = name, proxytype = extended)
+        # proxy = ExtendingDescriptorProxy(handler = ext_handler, name = name, proxytype = extended)
+        proxy = DescriptorProxy(handler = ext_handler, target = getattr(cls, name))
         setattr(extended, name, proxy)
                     
     def unproxied__new__(subclass, *args, **kwargs):
         return subclass.__retrace_unproxied__(*args, **kwargs)
       
+    assert callable(base.__new__)
+
     extended.__new__ = thread_state.dispatch(unproxied__new__, internal = base.__new__)
 
     assert not issubclass(extended.__retrace_unproxied__, ExtendingProxy)

retracesoftware/proxy/record.py

@@ -5,20 +5,22 @@ import retracesoftware.stream as stream
 from retracesoftware.proxy.proxytype import *
 # from retracesoftware.proxy.gateway import gateway_pair
 from retracesoftware.proxy.proxysystem import ProxySystem
-from retracesoftware.proxy.thread import write_thread_switch
+from retracesoftware.proxy.thread import write_thread_switch, ThreadSwitch, thread_id
 from retracesoftware.install.tracer import Tracer
+from retracesoftware.install.patchfindspec import patch_find_spec
 from retracesoftware.proxy.stubfactory import StubRef, ExtendedRef
+from retracesoftware.proxy.globalref import GlobalRef
 
 import sys
 import os
 import types
 import gc
 
-class Placeholder:
-    __slots__ = ['id', '__weakref__']
+# class Placeholder:
+#     __slots__ = ['id', '__weakref__']
 
-    def __init__(self, id):
-        self.id = id
+#     def __init__(self, id):
+#         self.id = id
     
 def keys_where_value(pred, dict):
     for key,value in dict.items():
@@ -49,13 +51,14 @@ def resolveable_name(obj):
 # when 
 class RecordProxySystem(ProxySystem):
     
-    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 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()
+        self.writer.keep_open = False
+        # self.writer.close()
         super().before_fork()
         # self.writer.path = self.dynamic_path
 
@@ -63,159 +66,146 @@ class RecordProxySystem(ProxySystem):
         new_path = self.new_child_path(self.writer.path)
         new_path.parent.mkdir()
         self.writer.path = new_path
+        self.writer.keep_open = True
         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()
+        self.writer.keep_open = True
+        # self.writer.reopen()
+    
+    def set_thread_id(self, id):
+        utils.set_thread_id(self.writer.handle(ThreadSwitch(id)))
+        # utils.set_thread_id(id)
+
+    # def is_entry_frame(self, frame):
+    #     if super().is_entry_frame(frame):
+    #         self.write_main_path(frame.function.__code__.co_filename)
+    #         return True
+    #     return False
+
+    def create_from_external(self, obj):
+        # class of obj is bound
+        # can now write type(obj)
+
+        self.bind(obj)
+
+        breakpoint()
+
+    def patch_type(self, cls):
 
-    def __init__(self, thread_state, 
+        patched = super().patch_type(cls)
+
+        self.writer.type_serializer[patched] = functional.side_effect(self.writer.ext_bind)
+
+        return patched
+
+    def exclude_from_stacktrace(self, func):
+        self.writer.exclude_from_stacktrace(func)
+
+    def on_gc_event(self, phase, info):
+        if phase == 'start':
+            self.writer.stacktraces = False
+            self.on_start_collect(info['generation'])
+            
+        elif phase == 'stop':
+            self.on_end_collect()
+            self.writer.stacktraces = self.stacktraces
+
+    def __init__(self, thread_state,
+                 writer,
                  immutable_types, 
                  tracing_config,
-                 path):
+                 maybe_collect,
+                 traceargs):
         
         self.fork_counter = 0
-
+        # self.write_main_path = write_main_path
+    
         self.getpid = thread_state.wrap(
             desired_state = 'disabled', function = os.getpid)
         
         self.pid = self.getpid()
 
-        self.writer = stream.writer(path)
-        
-        # w = self.writer.handle('TRACE')
-        # def trace_writer(*args):
-        #     print(f'Trace: {args}')
-        #     w(*args)
+        self.writer = writer
+
+        self.stacktraces = self.writer.stacktraces
+
+        if self.stacktraces:
+            def set(status):
+                self.writer.stacktraces = status
+
+            self.wrap_weakref_callback = functional.sequence(
+                self.wrap_weakref_callback,
+                lambda callback:           
+                    utils.observer(
+                        on_call = functional.lazy(set, False),
+                        on_result = functional.lazy(set, True),
+                        on_error = functional.lazy(set, True),
+                        function = callback))
+                
+        self.exclude_from_stacktrace(RecordProxySystem.patch_type)
+        self.exclude_from_stacktrace(patch_find_spec.__call__)
 
         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)))
+        sync_handle = self.writer.handle('SYNC')
 
-        self.sync = lambda function: functional.firstof(thread_switch_monitor, functional.always(self.writer.handle('SYNC')), function)
-            
+        self.on_ext_call = functional.lazy(utils.runall(maybe_collect, sync_handle) if maybe_collect else sync_handle) 
+
+        write_sync = thread_state.dispatch(utils.noop, internal = functional.lazy(sync_handle))
+
+        self.sync = lambda function: \
+            utils.observer(on_call = write_sync, function = function)
         error = self.writer.handle('ERROR')
 
         def write_error(cls, val, traceback):
+            assert isinstance(val, BaseException)
             error(cls, val)
         
-        self.set_thread_id = functional.partial(utils.set_thread_id, self.writer)
-
-        def watch(f): return functional.either(thread_switch_monitor, f)
-
         tracer = Tracer(tracing_config, writer = self.writer.handle('TRACE'))
 
-        self.wrap_int_to_ext = watch
+        self.writer.exclude_from_stacktrace(write_error)
+        # self.writer.exclude_from_stacktrace(Tracer.write_call)
         
-        self.on_int_call = functional.mapargs(transform = serialize, function = self.writer.handle('CALL'))
+        self.on_int_call = self.writer.handle('CALL')
         
-        self.on_ext_result = functional.if_then_else(
-                                functional.isinstanceof(str), 
-                                self.writer.handle('RESULT'), 
-                                functional.sequence(serialize, self.writer))
+        # write_new_ref = self.writer.handle('RESULT')
+
+        self.on_ext_result = self.writer.handle('RESULT')
         
         self.on_ext_error = write_error
 
-        self.ext_apply = self.int_apply = functional.apply
+        self.writer.type_serializer[types.ModuleType] = GlobalRef
 
-        super().__init__(thread_state = thread_state, tracer = tracer, immutable_types = immutable_types)
+        self.bind = self.writer.bind
 
-    def dynamic_ext_proxytype(self, cls):
-        
-        proxytype = super().dynamic_ext_proxytype(cls)
+        self.create_from_external = self.writer.ext_bind
 
-        blacklist = ['__class__', '__dict__', '__module__', '__doc__']
+        self.write_trace = self.writer.handle('TRACER')
 
-        methods = []
-        members = []
+        self.checkpoint = self.writer.handle('CHECKPOINT')
 
-        for key,value in proxytype.__dict__.items():
-            if key not in blacklist:
-                if utils.is_method_descriptor(value):
-                    methods.append(key)
-                elif not key.startswith("__retrace"):
-                    members.append(key)
+        self.on_weakref_callback_start = functional.lazy(self.writer.handle('ON_WEAKREF_CALLBACK_START'))
+        self.on_weakref_callback_end = functional.lazy(self.writer.handle('ON_WEAKREF_CALLBACK_END'))
 
-        ref = self.writer.handle(StubRef(
-            name = cls.__name__,
-            module = cls.__module__,
-            methods = methods,
-            members = members))
-        
-        # list(proxytype.__dict__.keys())
-
-        # if resolveable_name(cls):
-        #     module, name = resolveable_name(cls)
-        #     ref = self.writer.handle(StubRef(type = 'dynamic', 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)
+        self.on_start_collect = self.writer.handle('ON_START_COLLECT')
+        self.on_end_collect = self.writer.handle('ON_END_COLLECT')
 
-        return proxytype
+        super().__init__(thread_state = thread_state, 
+                         tracer = tracer, 
+                         traceargs = traceargs,
+                         immutable_types = immutable_types)
 
     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)
 
-        assert resolve(cls) is cls
+        ref = self.writer.handle(StubRef(proxytype))
 
-        # ref = self.writer.handle(StubRef(name = cls.__name__,
-        #                                  module = cls.__module__))
-
-        # if resolveable_name(cls):
-        #     module, name = resolveable_name(cls)
-        #     ref = self.writer.handle(StubRef(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)]
+        self.writer.type_serializer[proxytype] = functional.constantly(ref)
 
-        #     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, cls):
-
-        if cls in self.extended_types:
-            return self.extended_types[cls]
-
-        extended = super().extend_type(cls)
-        
-        self.extended_types[cls] = extended 
-
-        ref = self.writer.handle(ExtendedRef(name = cls.__name__,
-                                             module = cls.__module__))
-
-        # for binding?
-        # self.writer(ref)
-
-        self.writer.type_serializer[extended] = functional.constantly(ref)
-
-        return extended