retracesoftware-proxy 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

retracesoftware/config.json

@@ -160,19 +160,33 @@
     "_imp": {
       "patch_extension_exec": ["exec_dynamic", "exec_builtin"]
     },
+    "bdb": {
+      "methods_with_state": {
+        "disabled": {
+          "Bdb": ["trace_dispatch"]
+        }
+      },
+      "with_state": {
+        "disabled": ["Bdb.trace_dispatch"]
+      }
+    },
     "sys": {
       "with_state": {
         "disabled": ["excepthook"]
       },
-      "with_state_recursive0": {
-        "disabled": ["settrace", "setprofile"]
+      "comment": {
+        "with_state_recursive": {
+          "disabled": ["settrace", "setprofile"]
+        }
       }
     },
     
     "importlib._bootstrap": {
+      "comment": {
       "with_state": {
         "bootstrap": ["_load_unlocked", "_find_spec"]
       }
+      } 
     },
 
     "encodings": {
@@ -264,10 +278,16 @@
         "open_code": "path",
         "open": "file"
       },
-      "wrap": {
-        "FileIO.readinfo": "retracesoftware.install.edgecases.readinto",
-        "BufferedReader.readinfo": "retracesoftware.install.edgecases.readinto",
-        "BufferedRandom.readinfo": "retracesoftware.install.edgecases.readinto"
+      "patchtype": {
+        "FileIO": {
+          "readinfo": "retracesoftware.install.edgecases.readinto"
+        },
+        "BufferedReader": {
+          "readinfo": "retracesoftware.install.edgecases.readinto"
+        },
+        "BufferedRandom": {
+          "readinfo": "retracesoftware.install.edgecases.readinto"
+        }
       }
     },
     "pathlib": {
@@ -323,10 +343,12 @@
         "gaierror",
         "timeout"
       ],
-      "wrap": {
-        "socket.recvfrom_into": "retracesoftware.install.edgecases.recvfrom_into",
-        "socket.recv_into": "retracesoftware.install.edgecases.recv_into",
-        "socket.recvmsg_into": "retracesoftware.install.edgecases.recvmsg_into"
+      "patchtype": {
+        "socket": {
+          "recvfrom_into": "retracesoftware.install.edgecases.recvfrom_into",
+          "recv_into": "retracesoftware.install.edgecases.recv_into",
+          "recvmsg_into": "retracesoftware.install.edgecases.recvmsg_into"
+        }
       }
     },
     "select": {
@@ -349,8 +371,10 @@
             "_SSLSocket.write": "write"
           }
         },
-      "wrap": {
-        "_SSLSocket.read": "retracesoftware.install.edgecases.read"
+      "patchtype": {
+        "_SSLSocket": {
+          "read": "retracesoftware.install.edgecases.read"
+        }
       }
     },
     "_random": {

retracesoftware/install/patcher.py

@@ -25,7 +25,7 @@ from retracesoftware.install.config import load_config
 from functools import wraps
 
 import retracesoftware.functional as functional
-import retracesoftware_utils as utils
+import retracesoftware.utils as utils
 
 from retracesoftware.install import edgecases
 from functools import partial
@@ -137,9 +137,9 @@ def superdict(cls):
     
     return result
 
-def is_method_descriptor(obj):
-    return isinstance(obj, types.FunctionType) or \
-           (isinstance(obj, (types.WrapperDescriptorType, types.MethodDescriptorType)) and obj.__objclass__ != object)
+# def is_method_descriptor(obj):
+#     return isinstance(obj, types.FunctionType) or \
+#            (isinstance(obj, (types.WrapperDescriptorType, types.MethodDescriptorType)) and obj.__objclass__ != object)
 
 def wrap_method_descriptors(wrapper, prefix, base):
     slots = {"__slots__": () }
@@ -150,7 +150,7 @@ def wrap_method_descriptors(wrapper, prefix, base):
 
     for name,value in superdict(base).items():
         if name not in blacklist:
-            if is_method_descriptor(value):
+            if utils.is_method_descriptor(value):
                 setattr(extended, name, wrapper(value))
 
     return extended
@@ -179,6 +179,7 @@ class Patcher:
         self.type_attribute_filter = self.predicate(config['type_attribute_filter'])
         self.post_commit = post_commit
         self.exclude_paths = [re.compile(s) for s in config.get('exclude_paths', [])]
+        self.typepatcher = {}
 
         def is_phase(name): return getattr(getattr(self, name, None), "is_phase", False)
         
@@ -193,7 +194,21 @@ class Patcher:
                 # print(f'in path_predicate, excluding {path}')
                 return False
         return True
-                        
+
+    def on_proxytype(self, cls):
+
+        def patch(spec):
+            for method, transform in spec.items():                
+                setattr(cls, method, resolve(transform)(getattr(cls, method)))
+
+        if cls.__module__ in self.modules:
+            spec = self.modules[cls.__module__]
+
+            if 'patchtype' in spec:
+                patchtype = spec['patchtype']
+                if cls.__name__ in patchtype:
+                    patch(patchtype[cls.__name__])
+
     @property
     def disable(self):
         return self.thread_state.select('disabled')
@@ -260,7 +275,7 @@ class Patcher:
 
     @patch
     def patch_start_new_thread(self, value):
-        def start_new_thread(self, function, *args):
+        def start_new_thread(function, *args):
             # synchronized, replay shoudl yield correct number
             thread_id = self.thread_counter()
 
@@ -314,15 +329,35 @@ class Patcher:
         for state,elems in spec.items():
 
             def wrap(obj): 
-                return functional.recursive_wrap(
-                    callable, 
-                    lambda f: self.thread_state.wrap(state, f),
+                return functional.recurive_wrap_function(
+                    functional.partial(self.thread_state.wrap, state),
                     obj)
             
             updates.update(map_values(wrap, select_keys(elems, mod_dict)))
         
         return updates
 
+    @phase
+    def methods_with_state(self, spec, mod_dict):
+
+        # updates = {}
+
+        def update(cls, name, f):
+            setattr(cls, name, f(getattr(cls, name)))
+
+        for state,cls_methods in spec.items():
+            def wrap(obj): 
+                assert callable(obj)
+                return self.thread_state.wrap(desired_state = state, function = obj)
+
+            for typename,methodnames in cls_methods.items():
+                cls = mod_dict[typename]
+
+                for methodname in methodnames:
+                    update(cls, methodname, wrap)
+        
+        return {}
+
     @phase
     def with_state(self, spec, mod_dict):
 
@@ -330,7 +365,8 @@ class Patcher:
 
         for state,elems in spec.items():
 
-            def wrap(obj): return self.thread_state.wrap(desired_state = state, function = obj)
+            def wrap(obj): 
+                return self.thread_state.wrap(desired_state = state, function = obj)
 
             updates.update(map_values(wrap, select_keys(elems, mod_dict)))
         
@@ -377,7 +413,9 @@ class Patcher:
             name = parts[0]
             if name in mod_dict:
                 value = mod_dict[name]
-                assert not isinstance(value, utils.wrapped_function), f"value for key: {name} is already wrapped"
+                assert not isinstance(value, utils.wrapped_function), \
+                    f"value for key: {name} is already wrapped"
+                
                 if len(parts) == 1:
                     updates[name] = resolve(wrapper_name)(value)
                 elif len(parts) == 2:
@@ -436,20 +474,19 @@ class Patcher:
 
     def __call__(self, module):
 
-        # if module.__name__ == 'locale':
-        #     utils.sigtrap(None)
+        if self.thread_state.value == 'internal' and not hasattr(module, '__retrace__'):
+            with self.thread_state.select('bootstrap'):
+                configs = list(self.configs(module))
 
-        if not hasattr(module, '__retrace__'):
-            configs = list(self.configs(module))
-
-            if len(configs) > 0:
-                if len(configs) > 1:
-                    raise Exception(f'TODO')
-                else:
-                    try:
-                        self.patch_module_with_name(configs[0], module)
-                    except Exception as error:
-                        raise Exception(f'Error patching module: {configs[0]}') from error
+                if len(configs) > 0:
+                    if len(configs) > 1:
+                        raise Exception(f'TODO')
+                    else:
+                        module.__retrace__ = None
+                        try:
+                            self.patch_module_with_name(configs[0], module)
+                        except Exception as error:
+                            raise Exception(f'Error patching module: {configs[0]}') from error
 
         return module
     
@@ -518,6 +555,8 @@ def install(mode):
                       system = system,
                       post_commit = getattr(system, 'on_patched', None),
                       immutable_types = immutable_types)
+    
+    system.on_proxytype = patcher.on_proxytype
 
     def at_exit(): thread_state.value = 'disabled'
 

retracesoftware/install/tracer.py

@@ -13,11 +13,34 @@ def format_kwargs(kwargs):
     return tuple(result)
 
 class Tracer:
+
     def __init__(self, config, writer):
         self.config = config
         serialize = functional.walker(self.serialize)
         self.writer = functional.mapargs(transform = serialize, function = writer)
 
+    def systrace(self, frame, event, arg):
+        try:
+            if event in ['line', 'call']:
+                print(f'In systrace: {event} {frame.f_code.co_filename}:{frame.f_lineno}')
+                self.writer(event, frame.f_code.co_filename, frame.f_code.co_name, frame.f_lineno)
+
+            elif event == 'return':
+                print(f'In systrace: {event}')
+                self.writer(event)
+                # self.writer(event, self.serialize(arg))
+
+            elif event == 'exception':
+                print(f'In systrace: {event}')
+                self.writer(event)
+            else:
+                print(f'In systrace: {event}')
+
+            return self.systrace
+        except:
+            print(f'systrace RAISED ERROR!')
+            raise
+
     def serialize(self, obj):
         try:
             if obj is None: return None
@@ -56,6 +79,9 @@ class Tracer:
         if name in self.config:
             self.writer(name, message)
          
+    def checkpoint(self, obj):
+        self.writer(obj)
+
     def stacktrace(self):
         self.writer('stacktrace', utils.stacktrace())
 
@@ -63,8 +89,11 @@ class Tracer:
         if name in self.config:
             if name.endswith('.call'):
                 def write_call(*args, **kwargs):
-                    # self.stacktrace()
-                    self.writer(name, args[0].__name__, args[1:], kwargs)
+                    self.stacktrace()
+                    if len(args) > 0:
+                        self.writer(name, args[0].__name__, args[1:], kwargs)
+                    else:
+                        breakpoint()
             
                 return functional.firstof(write_call, func) if func else write_call
             

retracesoftware/proxy/proxysystem.py

@@ -36,13 +36,14 @@ def resolve(obj):
 def is_function_type(cls):
     return cls in [types.BuiltinFunctionType, types.FunctionType]
 
+def is_instance_method(obj):
+    return isinstance(obj, types.MethodDescriptorType) or isinstance(obj, types.FunctionType)
+
 class ProxySystem:
     
     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_int_to_ext(self, obj): return obj
     
     def wrap_ext_to_int(self, obj): return obj
     
@@ -54,10 +55,13 @@ class ProxySystem:
 
     def on_ext_error(self, err_type, err_value, err_traceback):
         pass
-
+        
     # def stacktrace(self):
     #     self.tracer.stacktrace()
 
+    def set_thread_id(self, id):
+        utils.set_thread_id(id)
+
     def __init__(self, thread_state, immutable_types, tracer):
         
         self.thread_state = thread_state
@@ -67,7 +71,7 @@ class ProxySystem:
         self.on_proxytype = None
         
         def is_immutable_type(cls):
-            return issubclass(cls, tuple(immutable_types))
+            return cls is object or issubclass(cls, tuple(immutable_types))
 
         is_immutable = functional.sequence(functional.typeof, functional.memoize_one_arg(is_immutable_type))
 
@@ -84,7 +88,7 @@ class ProxySystem:
         
         ext_spec = SimpleNamespace(
             apply = thread_state.wrap('external', functional.apply),
-            proxy = proxyfactory(thread_state.wrap('disabled', self.dynamic_ext_proxytype)),
+            proxy = proxyfactory(thread_state.wrap('disabled', self.ext_proxytype)),
             on_call = tracer('proxy.ext.call'),
             on_result = self.on_ext_result,
             on_error = self.on_ext_error,
@@ -102,6 +106,11 @@ class ProxySystem:
         self.ext_dispatch = gateway('proxy.int.disabled.event', internal = self.ext_handler)
         self.int_dispatch = gateway('proxy.ext.disabled.event', external = self.int_handler)
 
+        if 'systrace' in tracer.config:
+            func = thread_state.wrap(desired_state = 'disabled', function = tracer.systrace)
+            func = self.thread_state.dispatch(lambda *args: None, internal = func)
+            sys.settrace(func)
+
     def new_child_path(self, path):
         return path.parent / f'fork-{self.fork_counter}' / path.name
 
@@ -117,76 +126,78 @@ class ProxySystem:
         self.thread_state.value = self.saved_thread_state
         self.fork_counter += 1
 
-    def create_stub(self): return False
+    # def create_stub(self): return False
         
     def int_proxytype(self, cls):
-        return dynamic_int_proxytype(
+        if cls is object:
+            breakpoint()
+
+        proxytype = dynamic_int_proxytype(
                 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)
         
+        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 self.proxy_function(cls)
+        if cls is object:
+            breakpoint()
+
+        proxytype = dynamic_proxytype(handler = self.ext_dispatch, cls = cls)
         
-            # return instantiable_dynamic_proxytype(
-            #         handler = self.ext_dispatch, 
-            #         cls = cls,
-            #         thread_state = self.thread_state,
-            #         create_stub = self.create_stub())
-
-    def basetype(self, cls):
-        return cls
-    
-    def extend_type(self, cls):
-        extended = extending_proxytype(
-            cls = cls,
-            base = self.basetype(cls),
-            thread_state = self.thread_state, 
-            ext_handler = self.ext_dispatch,
-            int_handler = self.int_dispatch,
-            on_subclass_new = self.bind)
+        if self.on_proxytype: self.on_proxytype(proxytype)
         
-        self.immutable_types.add(extended)
-
-        return extended
-
+        return proxytype
+    
     def function_target(self, obj): return obj
 
     def proxy_function(self, obj):
         return utils.wrapped_function(handler = self.ext_handler, target = obj)
         
+    def patchtype(self, cls):
+        if cls in self.immutable_types or issubclass(cls, tuple):
+            return cls
+
+        def wrap(func):
+            return self.thread_state.dispatch(func, internal = self.proxy_function(func))
+
+        def wrap_new(func):
+            proxied = self.proxy_function(func)
+
+            def new(cls, *args, **kwargs):
+                instance = proxied(cls, *args, **kwargs)
+                instance.__init__(*args, **kwargs)
+                return instance
+            
+            return self.thread_state.dispatch(func, internal = new)
+
+        if utils.is_extendable(cls):
+            slots = {'__module__': cls.__module__, '__slots__': []}
+
+            for name, value in superdict(cls).items():
+                if callable(value) and not is_instance_method(value):
+                    slots[name] = wrap_new(value) if name == '__new__' else wrap(value)
+
+            return type(cls.__name__, (cls,), slots)
+
+        elif not utils.is_immutable(cls):
+            def update(name, f):
+                setattr(cls, name, f(getattr(cls, name)))
+
+            for name, value in superdict(cls).items():
+                if callable(value) and not is_instance_method(value):
+                    update(name, wrap_new if name == '__new__' else wrap)
+        else:
+            return wrap(cls)
+
     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)
+        if type(obj) == type:          
+            return self.patchtype(obj)
             
         elif type(obj) in self.immutable_types:
             return obj
@@ -199,6 +210,7 @@ class ProxySystem:
         
         else:
             proxytype = dynamic_proxytype(handler = self.ext_dispatch, cls = type(obj))
+            if self.on_proxytype: self.on_proxytype(proxytype)
 
             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

@@ -163,7 +163,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,27 +175,28 @@ 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):
@@ -203,14 +208,16 @@ def dynamic_proxytype(handler, cls):
 
     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)
+                    spec[name] = wrap(value)
+                # else:
+                #     spec[name] = DescriptorProxy(handler = handler, target = value)
 
     # to_proxy = [m for m in methods(cls) if m not in blacklist]
 
@@ -218,8 +225,8 @@ def dynamic_proxytype(handler, cls):
     
     # 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
@@ -362,7 +369,8 @@ 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):

retracesoftware/proxy/record.py

@@ -70,6 +70,13 @@ class RecordProxySystem(ProxySystem):
         self.thread_state.value = self.saved_thread_state
         self.writer.reopen()
 
+    def sync(self, function):
+        write_sync = functional.always(self.writer.handle('SYNC'))
+
+        return utils.observer(
+            on_call = functional.firstof(self.thread_switch_monitor, write_sync),
+            function = function)
+    
     def __init__(self, thread_state, 
                  immutable_types, 
                  tracing_config,
@@ -95,132 +102,49 @@ class RecordProxySystem(ProxySystem):
 
         serialize = functional.walker(self.bindings.get_else_key)
         
-        thread_switch_monitor = \
+        self.thread_switch_monitor = \
             utils.thread_switch_monitor(
                 functional.repeatedly(functional.sequence(utils.thread_id, self.writer)))
 
-        self.sync = lambda function: functional.firstof(thread_switch_monitor, functional.always(self.writer.handle('SYNC')), function)
+        # self.sync = lambda function: functional.firstof(self.thread_switch_monitor, functional.always(self.writer.handle('SYNC')), function)
             
         error = self.writer.handle('ERROR')
 
         def write_error(cls, val, traceback):
             error(cls, val)
         
-        self.set_thread_id = functional.partial(utils.set_thread_id, self.writer)
+        # self.set_thread_id = functional.partial(utils.set_thread_id, self.writer)
 
-        def watch(f): return functional.either(thread_switch_monitor, f)
+        def watch(f): return functional.either(self.thread_switch_monitor, f)
 
+        # w = self.writer.handle('TRACE')
+        # def foo(name, *args):
+        #     print(f'writing: {self.writer.messages_written} {name} {args}')
+        #     w(self.writer.messages_written, name, *args)
+
+        # tracer = Tracer(tracing_config, writer = foo)
         tracer = Tracer(tracing_config, writer = self.writer.handle('TRACE'))
 
         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_result = functional.sequence(serialize, 
-                                                 self.writer.handle('RESULT'))
+        self.on_ext_result = functional.sequence(serialize, self.writer.handle('RESULT'))
         
         self.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)
+        super().__init__(thread_state = thread_state, 
+                         tracer = tracer, 
+                         immutable_types = immutable_types)
 
-    def dynamic_ext_proxytype(self, cls):
+    def ext_proxytype(self, cls):
         
-        proxytype = super().dynamic_ext_proxytype(cls)
+        proxytype = super().ext_proxytype(cls)
 
         ref = self.writer.handle(StubRef(proxytype))
-
-        # blacklist = ['__class__', '__dict__', '__module__', '__doc__']
-
-        # methods = []
-        # members = []
-
-        # 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)
-
-        # 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)
 
         return proxytype
-
-    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(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)]
-
-        #     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

retracesoftware/proxy/replay.py

@@ -78,22 +78,6 @@ def on_stack_mismatch(last_matching, record, replay):
 
 class ReplayProxySystem(ProxySystem):
     
-    # def stubtype(self, cls):
-    #     assert not issubclass(cls, Proxy)
-
-    #     return dynamic_proxytype(handler = self.ext_handler, cls = cls)
-
-    def create_stub(self): return True
-
-    # def stubtype_from_spec(self, spec):
-    #     print (f'FOOO!!! {spec}')
-    #     return stubtype_from_spec(
-    #         handler = self.ext_handler,
-    #         module = spec.module, 
-    #         name = spec.name,
-    #         methods = spec.methods,
-    #         members = spec.members)
-
     @utils.striptraceback
     def next_result(self):
         while True:
@@ -113,6 +97,7 @@ class ReplayProxySystem(ProxySystem):
                 return self.messages()
             
             elif next == 'ERROR':
+                # breakpoint()
                 err_type = self.messages()
                 err_value = self.messages()
                 utils.raise_exception(err_type, err_value)
@@ -152,6 +137,66 @@ class ReplayProxySystem(ProxySystem):
     def basetype(self, cls):
         return self.stub_factory.create_stubtype(StubRef(cls))
 
+
+    def readnext(self):
+        with self.thread_state.select('disabled'):
+            try:
+                # obj = self.messages()
+                # print(f'read {obj}')
+                # return obj
+                return self.messages()
+            except Exception as error:
+                # print(f'Error reading stream: {error}')
+                traceback.print_exc()
+                os._exit(1)
+
+    def read_required(self, required):
+        obj = self.readnext()
+        if obj != required:
+            if self.last_matching_stack:
+                for line in self.last_matching_stack:
+                    print(line)
+
+            print('---------------------------------')
+            print(f'Replay: {required}')
+            print('---------------------------------')
+            print(f'Record: {obj}')
+            print('---------------------------------')
+            for i in range(15):
+                print(self.readnext())
+
+            breakpoint()
+            os._exit(1)
+            raise Exception(f'Expected: {required} but got: {obj}')
+        
+        self.last_matching_stack = utils.stacktrace()
+
+    def trace_writer(self, name, *args):
+        with self.thread_state.select('disabled'):
+            # read = self.messages_read
+
+            self.read_required('TRACE')
+            # self.read_required(read)
+            self.read_required(name)
+
+            if name == 'stacktrace':
+                record = self.readnext()
+                if args[0] == record:
+                    self.last_matching_stack = args[0]
+                else:
+                    on_stack_mismatch(
+                        last_matching = self.last_matching_stack,
+                        record = record,
+                        replay = args[0])                        
+                    os._exit(1)
+            else:
+                # print(f'Trace: {self.reader.messages_read} {name} {args}')
+                for arg in args:
+                    self.read_required(arg)
+
+    def sync(self, function):
+        return utils.observer(on_call = functional.always(self.read_sync), function = function)
+
     def __init__(self, 
                  thread_state,
                  immutable_types,
@@ -159,152 +204,29 @@ class ReplayProxySystem(ProxySystem):
                  path,
                  fork_path = []):
         
-        # self.writer = writer
-        # super().__init__(thread_state = thread_state)
-        reader = stream.reader(path)
+        # self.messages_read = 0
+        self.reader = stream.reader(path)
 
         self.bindings = utils.id_dict()
         self.set_thread_id = utils.set_thread_id
         self.fork_path = fork_path
         deserialize = functional.walker(self.bindings.get_else_key)
 
-        self.messages = functional.sequence(per_thread_messages(reader), deserialize)
-
-        self.stub_factory = StubFactory(thread_state = thread_state, next_result = self.next_result)
-
-        # messages = reader
-
-        def readnext():
-            with thread_state.select('disabled'):
-                try:
-                    return self.messages()
-                except Exception as error:
-                    # print(f'Error reading stream: {error}')
-                    traceback.print_exc()
-
-                    os._exit(1)
-
-            # print(f'read: {obj}')
-            # return obj
-
-
-        # lookup = weakref.WeakKeyDictionary()
+        # def count(res):
+        #     self.messages_read += 1
+        #     return res
         
-        # debug = debug_level(config)
-
-        # int_refs = {}
-        last_matching_stack = None
-
-        def read_required(required):
-            obj = readnext()
-            if obj != required:
-                if last_matching_stack:
-                    for line in last_matching_stack:
-                        print(line)
-
-                print('---------------------------------')
-                print(f'Replay: {required}')
-                print('---------------------------------')
-                print(f'Record: {obj}')
-                print('---------------------------------')
-                for i in range(5):
-                    print(readnext())
-
-                utils.sigtrap(None)
-                os._exit(1)
-                raise Exception(f'Expected: {required} but got: {obj}')
-
-        def trace_writer(name, *args):
-            with thread_state.select('disabled'):
-                read_required('TRACE')
-                read_required(name)
-
-                if name == 'stacktrace':
-                    record = readnext()
-                    if args[0] == record:
-                        nonlocal last_matching_stack
-                        last_matching_stack = args[0]
-                    else:
-                        on_stack_mismatch(
-                            last_matching= last_matching_stack,
-                            record = record,
-                            replay = args[0])                        
-                        os._exit(1)
-                else:
-                    print(f'Trace: {name} {args}')
-                    for arg in args:
-                        read_required(arg)
-
-        # self.tracer = Tracer(tracing_config, writer = trace_writer)
-        # self.immutable_types = immutable_types
-
-        self.reader = reader
-
-        # def foo(cls):
-        #     print(cls)
-        #     assert isinstance(cls, type)
-        #     immutable_types.add(cls)
-
-        # add_stubtype = functional.side_effect(foo)
-        # add_stubtype = functional.side_effect(immutable_types.add)
-
-        # reader.type_deserializer[ProxyRef] = functional.sequence(lambda ref: ref.resolve(), self.stubtype, add_stubtype)
-
-        reader.type_deserializer[StubRef] = self.stub_factory
-        # reader.type_deserializer[ProxySpec] = functional.sequence(self.stubtype_from_spec, add_stubtype)
+        self.messages = functional.sequence(per_thread_messages(self.reader), 
+                                            deserialize)                                        
 
-        # on_ext_result = functional.if_then_else(
-        #     functional.is_instanceof(str), writer.handle('RESULT'), writer)
-
-        # def int_proxytype(gateway):
-        #     return lambda cls: dynamic_int_proxytype(handler = gateway, cls = cls, bind = self.bind)
-
-        # create_stubs = functional.walker(functional.when(is_stub_ref, lambda stub: stub.create()))
-        # create_stubs = functional.walker(functional.when(is_stub_type, lambda cls: cls()))
+        self.stub_factory = StubFactory(thread_state = thread_state, next_result = self.next_result)
 
-        # self.ext_apply = functional.repeatedly(functional.sequence(self.next_result, create_stubs))
-        # self.ext_apply = functional.repeatedly(self.next_result)
-        
-        def read_sync(): read_required('SYNC')
+        self.last_matching_stack = None
 
-        self.sync = lambda function: utils.observer(on_call = functional.always(read_sync), function = function)
+        self.reader.type_deserializer[StubRef] = self.stub_factory
+                
+        self.read_sync = functional.always(lambda: self.read_required('SYNC'))
     
         super().__init__(thread_state = thread_state, 
-                         tracer = Tracer(tracing_config, writer = trace_writer), 
+                         tracer = Tracer(tracing_config, writer = self.trace_writer),
                          immutable_types = immutable_types)
-
-        # super().__init__(
-        #     thread_state=thread_state, 
-        #     immutable_types= immutable_types,
-        #     tracer=self.tracer,
-        #     ext_apply = ext_apply)
-        
-        # self.ext_handler, self.int_handler = gateway_pair(
-        #     thread_state,
-        #     self.tracer,
-        #     immutable_types = immutable_types,
-        #     ext_apply = ext_apply,
-        #     int_proxytype = int_proxytype,
-        #     ext_proxytype = functional.identity)
-
-    # def extend_type(self, base):
-        
-    #     # ok, how to provide __getattr__ style access, 
-
-    #     extended = extending_proxytype(
-    #         cls = base,
-    #         thread_state = self.thread_state, 
-    #         int_handler = self.int_handler,
-    #         ext_handler = self.ext_handler,
-    #         on_subclass_new = self.bind,
-    #         is_stub = True)
-
-    #     self.immutable_types.add(extended)
-    #     # proxytype = extending_proxytype(base)
-
-    #     # make_extensible(cls = extended, 
-    #     #                 int_handler = self.int_handler, 
-    #     #                 ext_handler = self.ext_handler,
-    #     #                 on_new = self.reader.supply)
-
-    #     return extended

retracesoftware/proxy/stubfactory.py

@@ -17,19 +17,15 @@ class StubRef:
         blacklist = ['__class__', '__dict__', '__module__', '__doc__', '__new__']
 
         methods = []
-        members = []
 
         for key,value in cls.__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.name = cls.__name__ 
         self.module = cls.__module__
         self.methods = methods
-        self.members = members
 
     # def __init__(self, module, name, methods, members):
     #     self.name = name
@@ -38,7 +34,7 @@ class StubRef:
     #     self.members = members
 
     def __str__(self):
-        return f'StubRef(module = {self.module}, name = {self.name}, methods = {self.methods}, members = {self.members})'
+        return f'StubRef(module = {self.module}, name = {self.name}, methods = {self.methods})'
 
 def resolve(module, name):
     try:
@@ -103,7 +99,7 @@ class StubFactory:
         next_result = self.thread_state.dispatch(disabled, external = self.next_result)
 
         return StubMemberDescriptor(name = name, next_result = next_result)
-
+ 
     def create_method(self, name):
 
         def disabled(*args, **kwargs):
@@ -133,8 +129,24 @@ class StubFactory:
             slots[method] = self.create_method(method)
             assert utils.is_method_descriptor(slots[method])
 
-        for member in spec.members:
-            slots[member] = self.create_member(member)
+        def getattr(instance, name):
+            if self.thread_state.value == 'external':
+                return self.next_result()
+            else:
+                print(f'Error trying to get attribute: {name}, when retrace mode: {self.thread_state.value} was not external')
+                utils.sigtrap(None)
+                os._exit(1)
+
+        def setattr(instance, name, value):
+            if self.thread_state.value == 'external':
+                return self.next_result()
+            else:
+                print(f'Error trying to set attribute: {name}, to: {value} when retrace mode: {self.thread_state.value} was not external')
+                utils.sigtrap(None)
+                os._exit(1)
+
+        slots['__getattr__'] = getattr
+        slots['__setattr__'] = setattr
 
         resolved = resolve(spec.module, spec.name)
 

{retracesoftware_proxy-0.1.7.dist-info → retracesoftware_proxy-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: retracesoftware_proxy
-Version: 0.1.7
+Version: 0.1.9
 License: Apache-2.0
 Requires-Dist: retracesoftware_utils
 Requires-Dist: retracesoftware_functional

{retracesoftware_proxy-0.1.7.dist-info → retracesoftware_proxy-0.1.9.dist-info}/RECORD

@@ -1,27 +1,27 @@
 retracesoftware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-retracesoftware/config.json,sha256=fzfxZF6ES2NuPO9u9fNX8xMZ5rKZStxAHovsVTSJYzs,8276
+retracesoftware/config.json,sha256=c-bqr6SAuIGpnNRqZLPKW-0-VtG8VyGnqpQPhyc5CFY,8666
 retracesoftware/install/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 retracesoftware/install/config.py,sha256=EzE5ifQF2lo--hu2njI4T0FJ-zlnWDJV6i7x0DMkVTw,1364
 retracesoftware/install/edgecases.py,sha256=NR3lyvad9sRsyeDv_Ya8V4xMgPsMPOi9rMcnFOJGOEA,6330
 retracesoftware/install/globals.py,sha256=F8XvIoZQQ10gSRalk30dvdKllxlwxkaggYY6FogLDxY,510
 retracesoftware/install/install.py,sha256=HCD_ji8XCr96b5fNzNdL_8qcEp0Jf05Em7T6GA6u8HU,4969
-retracesoftware/install/patcher.py,sha256=5tRC8XmJW0_loqX1Nqad1rkG--LlX46YwgbbMTbgASc,17598
+retracesoftware/install/patcher.py,sha256=VXYzE01SyDDw3wQ-spZRb5HEcH3MOlod56039zhpJIE,18888
 retracesoftware/install/predicate.py,sha256=tX7NQc0rGkyyHYO3mduYHcJHbw1wczT53m_Dpkzo6do,2679
 retracesoftware/install/record.py,sha256=tseF_jV4k4HLPTgBPJdjcahl4EQqagoiisMAdGNC52Q,3257
 retracesoftware/install/references.py,sha256=A-G651IDOfuo00MkbAdpbIQh_15ChvJ7uAVTSmE6zd4,1721
 retracesoftware/install/replay.py,sha256=VUiHvQK3mgAJEGmtE2TFs9kXzxdWtsjibEcGkhZVCVE,1830
-retracesoftware/install/tracer.py,sha256=Oqh8BhZVQVo1COfSGkFCipZGPB2Dv1b4DK3xBvloRew,4796
+retracesoftware/install/tracer.py,sha256=cHEjiVxIp2iVTJEWndwSbMuiXVyGJQxJYZSGrfpSbCw,5723
 retracesoftware/install/typeutils.py,sha256=_a1PuwdCsYjG1Nkd77V-flqYtwbD4RkJVKn6Z-xABL4,1813
 retracesoftware/proxy/__init__.py,sha256=ZlDZIuUmKFsE9Tvfd2EKGabTepqv8nrbr5pQhCM3IKc,193
 retracesoftware/proxy/gateway.py,sha256=xESohWXkiNm4ZutU0RgWUwxjxcBWRQ4rQyxIGQXv_F4,1590
 retracesoftware/proxy/proxyfactory.py,sha256=qhOqDfMJnLDNkQs26JqDB431MwjjRhGQi8xupJ45asg,12272
-retracesoftware/proxy/proxysystem.py,sha256=W2v0Tj0tJeAt_bg9LljQm2iwWpjNIbqUTQ92WK22TF8,6861
-retracesoftware/proxy/proxytype.py,sha256=mcg3hBG0auYXv7Dez8SwrrG5dNlDl7nH_mdQUd9Iaj4,12488
-retracesoftware/proxy/record.py,sha256=ZsJV0o-Qy874VFObtsfkSF8u9gvyUSee0UPpf9Jq6Es,7734
-retracesoftware/proxy/replay.py,sha256=RVsezEZcy4bFdPQAAztfEHz6adm8t5lBDMhpnNAqeok,10510
-retracesoftware/proxy/stubfactory.py,sha256=UnRDQHgWv2xTYaMPZPXvsa7WBh10CyItc_hsQdtOhcM,4607
+retracesoftware/proxy/proxysystem.py,sha256=Nf_yKa4gMvKA2RWEUBmyH9m46lbsAdyPzj5jVDh4cs8,7427
+retracesoftware/proxy/proxytype.py,sha256=crq7idJP77Magtv58l_uJCAlTnD2aDTT-Uz14raTSIo,12767
+retracesoftware/proxy/record.py,sha256=vtNsoTHP5gsBVJ6dTGHR7QXHGbKm0eONfGcXOb9fhFk,4696
+retracesoftware/proxy/replay.py,sha256=m4Buxlix09aUJX9JYWG1z4jW8Yvbo2zBV353hsZE5qY,7670
+retracesoftware/proxy/stubfactory.py,sha256=CnP0Sm0tZNwyFIQIPkk7w_soNBDcflNKwICsAoZxSD0,5128
 retracesoftware/proxy/thread.py,sha256=-SvnyVbANkmX2lLRpOvFtkpdpAoF6DhnnYdOOs7Q8vo,1379
-retracesoftware_proxy-0.1.7.dist-info/METADATA,sha256=Ug25Z8ULRbcvl7o9RQgSjcQzKC8HDqJhLQ3Z69wLHZc,202
-retracesoftware_proxy-0.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-retracesoftware_proxy-0.1.7.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
-retracesoftware_proxy-0.1.7.dist-info/RECORD,,
+retracesoftware_proxy-0.1.9.dist-info/METADATA,sha256=yiJDDJYQ4XQhjSaQq4PPZaW1dH7SHtn7m-Dfbk_CrUs,202
+retracesoftware_proxy-0.1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+retracesoftware_proxy-0.1.9.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
+retracesoftware_proxy-0.1.9.dist-info/RECORD,,