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

retracesoftware/config.json

@@ -182,9 +182,11 @@
     },
     
     "importlib._bootstrap": {
+      "comment": {
       "with_state": {
         "bootstrap": ["_load_unlocked", "_find_spec"]
       }
+      } 
     },
 
     "encodings": {

retracesoftware/install/patcher.py

@@ -275,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()
 
@@ -474,18 +474,19 @@ class Patcher:
 
     def __call__(self, module):
 
-        if not hasattr(module, '__retrace__'):
-            configs = list(self.configs(module))
-
-            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
+        if self.thread_state.value == 'internal' and not hasattr(module, '__retrace__'):
+            with self.thread_state.select('bootstrap'):
+                configs = list(self.configs(module))
+
+                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
     

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
     
@@ -58,6 +59,9 @@ class ProxySystem:
     # 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,9 +126,12 @@ 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):
+        if cls is object:
+            breakpoint()
+
         proxytype = dynamic_int_proxytype(
                 handler = self.int_dispatch,
                 cls = cls,
@@ -128,64 +140,64 @@ class ProxySystem:
         if self.on_proxytype: self.on_proxytype(proxytype)
         return proxytype
 
-
-    def dynamic_ext_proxytype(self, cls):
+    def ext_proxytype(self, cls):
+        if cls is object:
+            breakpoint()
 
         proxytype = dynamic_proxytype(handler = self.ext_dispatch, cls = cls)
         
         if self.on_proxytype: self.on_proxytype(proxytype)
         
         return proxytype
+    
+    def function_target(self, obj): return obj
+
+    def proxy_function(self, obj):
+        return utils.wrapped_function(handler = self.ext_handler, target = obj)
         
-        # 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 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)
 
-    def ext_proxytype(self, cls):
-        assert isinstance(cls, type)
         if utils.is_extendable(cls):
-            proxytype = self.extend_type(cls)
-            if self.on_proxytype: self.on_proxytype(proxytype)
-            return proxytype
-        else:
-            new = functional.droparg(self.proxy_function(cls))
-            return type(cls.__name__, (object,), {'__module__': cls.__module__, '__new__': new})
+            slots = {'__module__': cls.__module__, '__slots__': []}
 
-    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)
-        
-        self.immutable_types.add(extended)
+            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 extended
+            return type(cls.__name__, (cls,), slots)
 
-    def function_target(self, obj): return obj
+        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 proxy_function(self, obj):
-        return utils.wrapped_function(handler = self.ext_handler, target = obj)
-        
     def __call__(self, obj):
         assert not isinstance(obj, BaseException)
         assert not isinstance(obj, Proxy)
         assert not isinstance(obj, utils.wrapped_function)
             
-        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

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,28 +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):
-        breakpoint()
-        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):
@@ -204,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]
 
@@ -219,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

retracesoftware/proxy/record.py

@@ -113,121 +113,38 @@ class RecordProxySystem(ProxySystem):
         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(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.8.dist-info → retracesoftware_proxy-0.1.9.dist-info}/METADATA

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

{retracesoftware_proxy-0.1.8.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=_GTEhl9ba5ed9io_sWAR3nO30T-w66qU6Q-fHKguEHg,8638
+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=aDFSUfR8ZWAkLKm5xMuilTxtQ9-uUrHeFHZmozMkRSU,18756
+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=F0YSsF6BlDjWrjiApfy12GBopD647ML-UXP8Ovn_CL8,6953
-retracesoftware/proxy/proxytype.py,sha256=nwOhAqcVIG4h9uonXWBvQidKSbF4YSuMzrGJFlonk0s,12595
-retracesoftware/proxy/record.py,sha256=Ukjrzsv7WMA-2oC6Ji-JgIr0R8pRLyQGkHc8grzKtpE,8000
-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.8.dist-info/METADATA,sha256=MiCu-FDSk5wmZv30Kz-R-A8UKJxP-0sLHent41c__5o,202
-retracesoftware_proxy-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-retracesoftware_proxy-0.1.8.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
-retracesoftware_proxy-0.1.8.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,,