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

retracesoftware/proxy/record.py

@@ -1,41 +1,24 @@
 import retracesoftware.functional as functional
-import retracesoftware_utils as utils
+import retracesoftware.utils as utils
 import retracesoftware.stream as stream
 
-from retracesoftware.proxy.proxytype import dynamic_proxytype, superdict, is_descriptor, extending_proxytype, dynamic_int_proxytype, make_extensible, Proxy
+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.install.tracer import Tracer
+from retracesoftware.proxy.stubfactory import StubRef, ExtendedRef
+
 import sys
 import os
 import types
+import gc
 
 class Placeholder:
     __slots__ = ['id', '__weakref__']
 
     def __init__(self, id):
         self.id = id
-
-class ExtendedProxy:
-    __slots__ = []
-
-class ProxyRef:
-    def __init__(self, module, name):
-        self.module = module
-        self.name = name
-
-    def resolve(self):
-        return getattr(sys.modules[self.module], self.name)
-
-class ProxySpec(ProxyRef):
-    def __init__(self, module, name, methods, members):
-        super().__init__(module, name)
-        self.methods = methods
-        self.members = members
-
-    def __str__(self):
-        return f'ProxySpec(module = {self.module}, name = {self.name}, methods = {self.methods}, members = {self.members})'
     
 def keys_where_value(pred, dict):
     for key,value in dict.items():
@@ -101,10 +84,10 @@ class RecordProxySystem(ProxySystem):
 
         self.writer = stream.writer(path)
         
-        w = self.writer.handle('TRACE')
-        def trace_writer(*args):
-            print(f'Trace: {args}')
-            w(*args)
+        # w = self.writer.handle('TRACE')
+        # def trace_writer(*args):
+        #     print(f'Trace: {args}')
+        #     w(*args)
 
         self.extended_types = {}
         self.bindings = utils.id_dict()
@@ -116,17 +99,7 @@ class RecordProxySystem(ProxySystem):
             utils.thread_switch_monitor(
                 functional.repeatedly(functional.sequence(utils.thread_id, self.writer)))
 
-        # self.sync = lambda function: functional.observer(on_call = functional.always(writer.handle('SYNC')), function = function)
         self.sync = lambda function: functional.firstof(thread_switch_monitor, functional.always(self.writer.handle('SYNC')), function)
-
-        # trace_handle = writer.handle('TRACE')
-        # tracer = Tracer(tracing_config, writer = trace_handle)
-
-        # on_ext_result = writer.handle('RESULT')
-        # on_ext_result = functional.if_then_else(
-        #     functional.isinstanceof(str), self.writer.handle('RESULT'), functional.sequence(serialize, self.writer))
- 
-        # on_int_call = functional.mapargs(transform = serialize, function = self.writer.handle('CALL'))
             
         error = self.writer.handle('ERROR')
 
@@ -137,25 +110,7 @@ class RecordProxySystem(ProxySystem):
 
         def watch(f): return functional.either(thread_switch_monitor, f)
 
-        tracer = Tracer(tracing_config, writer = trace_writer)
-
-        # def wrap_int_to_ext(self, obj): return obj
-        # def wrap_ext_to_int(self, obj): return obj
-        
-        # def on_int_call(self, func, *args, **kwargs):
-        #     pass
-
-        # def on_ext_result(self, result):
-        #     pass
-
-        # def on_ext_error(self, err_type, err_value, err_tarceback):
-        #     pass
-
-        # def ext_apply(self, func, *args, **kwargs):
-        #     return func(*args, **kwargs)
-        
-        # def int_apply(self, func, *args, **kwargs):
-        #     return func(*args, **kwargs)
+        tracer = Tracer(tracing_config, writer = self.writer.handle('TRACE'))
 
         self.wrap_int_to_ext = watch
         
@@ -171,22 +126,50 @@ class RecordProxySystem(ProxySystem):
         self.ext_apply = self.int_apply = functional.apply
 
         super().__init__(thread_state = thread_state, tracer = tracer, immutable_types = immutable_types)
-            # wrap_int_to_ext = watch,
-            # on_int_call = on_int_call,
-            # on_ext_result = on_ext_result,
-            # on_ext_error = write_error)
+
+    def dynamic_ext_proxytype(self, cls):
         
-        # self.ext_handler, self.int_handler = gateway_pair(
-        #     thread_state,
-        #     self.tracer,
-        #     immutable_types = immutable_types,
-        #     wrap_int_to_ext = watch,
-        #     int_proxytype = self.int_proxytype,
-        #     ext_proxytype = self.proxytype,
-        #     on_int_call = on_int_call,
-        #     on_ext_result = on_ext_result,
-        #     on_ext_error = write_error)
-            
+        proxytype = super().dynamic_ext_proxytype(cls)
+
+        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}"
 
@@ -194,31 +177,45 @@ class RecordProxySystem(ProxySystem):
 
         proxytype = super().ext_proxytype(cls)
 
-        if resolveable_name(cls):
-            module, name = resolveable_name(cls)
-            ref = self.writer.handle(ProxyRef(name = name, module = module))
-        else:
-            blacklist = ['__getattribute__']
-            descriptors = {k: v for k,v in superdict(cls).items() if k not in blacklist and is_descriptor(v) }
+        assert resolve(cls) is cls
+
+        # ref = self.writer.handle(StubRef(name = cls.__name__,
+        #                                  module = cls.__module__))
 
-            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)]
+        # 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) }
 
-            ref = self.writer.handle(ProxySpec(name = cls.__name__, 
-                                            module = cls.__module__,
-                                            methods = methods,
-                                            members = members))
+        #     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.writer.type_serializer[proxytype] = functional.constantly(ref)
         return proxytype
 
-    def extend_type(self, base):
 
-        if base in self.extended_types:
-            return self.extended_types[base]
+    def extend_type(self, cls):
 
-        extended = super().extend_type(base)
+        if cls in self.extended_types:
+            return self.extended_types[cls]
+
+        extended = super().extend_type(cls)
         
-        self.extended_types[base] = extended 
+        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

@@ -4,34 +4,41 @@ import retracesoftware.stream as stream
 
 from retracesoftware.install.tracer import Tracer
 from retracesoftware.proxy.thread import per_thread_messages
-from retracesoftware.proxy.proxytype import dynamic_proxytype, dynamic_int_proxytype, extending_proxytype, make_extensible, dynamic_stubtype, stubtype_from_spec, Stub
+from retracesoftware.proxy.proxytype import *
 # from retracesoftware.proxy.gateway import gateway_pair
-from retracesoftware.proxy.record import ProxyRef, ProxySpec, Placeholder
-from retracesoftware.proxy.proxysystem import ProxySystem
+from retracesoftware.proxy.record import StubRef, Placeholder
+from retracesoftware.proxy.proxysystem import ProxySystem, RetraceError
+from retracesoftware.proxy.stubfactory import StubFactory, StubFunction
 
 import os
 import weakref
+import traceback
 # we can have a dummy method descriptor, its has a __name__ and when called, returns the next element
 
 # for types, we can patch the __new__ method
 # do it from C and immutable types can be patched too
 # patch the tp_new pointer?
 
+class ReplayError(RetraceError):
+    pass
+
 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)
+    # 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):
@@ -55,7 +62,7 @@ class ReplayProxySystem(ProxySystem):
                 err_value = self.messages()
                 utils.raise_exception(err_type, err_value)
             else:
-                assert not isinstance(next, str)
+                assert type(next) is not str
                 return next
 
     def bind(self, obj):
@@ -78,6 +85,15 @@ class ReplayProxySystem(ProxySystem):
         self.reader.path = self.new_child_path(self.reader.path)
         super().after_fork_in_child()
 
+    # def dynamic_ext_proxytype(self, cls):
+    #     raise Exception('dynamic_ext_proxytype should not be called in replay')
+
+    def proxy_function(self, obj):
+        func = functional.repeatedly(self.next_result)
+        func.__name__ = obj.__name__
+
+        return super().proxy_function(func)
+
     def __init__(self, 
                  thread_state,
                  immutable_types,
@@ -96,15 +112,19 @@ class ReplayProxySystem(ProxySystem):
 
         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():
-            try:
-                return self.messages()
-            except Exception as error:
-                self.thread_state.value = 'disabled'
-                print(f'Error reading stream: {error}')
-                os._exit(1)
+            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
@@ -119,7 +139,7 @@ class ReplayProxySystem(ProxySystem):
         def read_required(required):
             obj = readnext()
             if obj != required:
-                print(f'Expected: {required} but got: {obj}')
+                print(f'Replay: {required} Record: {obj}')
                 for i in range(5):
                     print(readnext())
 
@@ -128,13 +148,14 @@ class ReplayProxySystem(ProxySystem):
                 raise Exception(f'Expected: {required} but got: {obj}')
 
         def trace_writer(name, *args):
-            print(f'Trace: {name} {args}')
-            
-            read_required('TRACE')
-            read_required(name)
+            with thread_state.select('disabled'):
+                print(f'Trace: {name} {args}')
+                
+                read_required('TRACE')
+                read_required(name)
 
-            for arg in args:
-                read_required(arg)
+                for arg in args:
+                    read_required(arg)
 
         # self.tracer = Tracer(tracing_config, writer = trace_writer)
         # self.immutable_types = immutable_types
@@ -147,10 +168,12 @@ class ReplayProxySystem(ProxySystem):
         #     immutable_types.add(cls)
 
         # add_stubtype = functional.side_effect(foo)
-        add_stubtype = functional.side_effect(immutable_types.add)
+        # 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[ProxyRef] = functional.sequence(lambda ref: ref.resolve(), self.stubtype, add_stubtype)
-        reader.type_deserializer[ProxySpec] = functional.sequence(self.stubtype_from_spec, add_stubtype)
+        reader.type_deserializer[StubRef] = self.stub_factory
+        # reader.type_deserializer[ProxySpec] = functional.sequence(self.stubtype_from_spec, add_stubtype)
 
         # on_ext_result = functional.if_then_else(
         #     functional.is_instanceof(str), writer.handle('RESULT'), writer)
@@ -158,12 +181,11 @@ class ReplayProxySystem(ProxySystem):
         # def int_proxytype(gateway):
         #     return lambda cls: dynamic_int_proxytype(handler = gateway, cls = cls, bind = self.bind)
 
-        def is_stub_type(obj):
-            return functional.typeof(obj) is type and issubclass(obj, Stub)
-
-        create_stubs = functional.walker(functional.when(is_stub_type, lambda cls: cls()))
+        # 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.ext_apply = functional.repeatedly(functional.sequence(self.next_result, create_stubs))
+        # 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')
 

retracesoftware/proxy/stubfactory.py

@@ -0,0 +1,140 @@
+import sys
+import os
+
+import retracesoftware.functional as functional
+import retracesoftware.utils as utils
+
+class Stub:
+    __slots__ = []
+
+class ExtendedRef:
+    def __init__(self, module, name):
+        self.type = type
+        self.module = module
+
+class StubRef:
+    def __init__(self, module, name, methods, members):
+        self.name = name
+        self.module = module
+        self.methods = methods
+        self.members = members
+
+    def __str__(self):
+        return f'StubRef(module = {self.module}, name = {self.name}, methods = {self.methods}, members = {self.members})'
+
+def resolve(module, name):
+    try:
+        return getattr(sys.modules[module], name)
+    except:
+        return None
+
+class StubMethodDescriptor(functional.repeatedly):
+    def __init__(self, name, next_result):
+        super().__init__(next_result)
+        self.__name__ = name
+
+    def __str__(self):
+        return f"stub - {__name__}"
+    
+class StubMemberDescriptor:
+    def __init__(self, name, next_result):
+        self.next_result = next_result
+        self.__name__ = name
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self
+        
+        return self.next_result()
+
+    def __set__(self, instance, value):
+        return self.next_result()
+
+    def __delete__(self, instance):
+        return self.next_result()
+
+    def __str__(self):
+        return f"stub member - {__name__}"
+
+class StubFunction(functional.repeatedly):
+    def __init__(self, name, next_result):
+        super().__init__(next_result)
+        self.__name__ = name
+
+    def __str__(self):
+        return f"stub function - {__name__}"
+
+class StubFactory:
+
+    __slots__ = ['next_result', 'thread_state', 'cache']
+
+    def __init__(self, thread_state, next_result):
+        self.next_result = next_result
+        self.thread_state = thread_state
+        self.cache = {}
+
+    def create_member(self, name):
+        def disabled(*args, **kwargs):
+            if self.thread_state.value == 'disabled' and name == '__repr__':
+                return f"stub member - {name}"
+            else:
+                print(f'Error trying to call member descriptor: {name} {args} {kwargs}, retrace mode: {self.thread_state.value}')
+                utils.sigtrap(None)
+                os._exit(1)
+            
+        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):
+            if self.thread_state.value == 'disabled' and name == '__repr__':
+                return f"stub - {name}"
+            else:
+                print(f'Error trying to call descriptor: {name} {args} {kwargs}, retrace mode: {self.thread_state.value}')
+                utils.sigtrap(None)
+                os._exit(1)
+            
+        next_result = self.thread_state.dispatch(disabled, external = self.next_result)
+
+        func = functional.repeatedly(next_result)
+        func.__name__ = name
+
+        return func
+
+    def create_stubtype(self, spec):
+
+        slots = {
+            '__module__': spec.module,
+            '__qualname__': spec.name,
+        }
+
+        for method in spec.methods:
+            slots[method] = self.create_method(method)
+            assert utils.is_method_descriptor(slots[method])
+
+        for member in spec.members:
+            slots[member] = self.create_member(member)
+
+        resolved = resolve(spec.module, spec.name)
+
+        if isinstance(resolved, type):
+            slots['__class__'] = property(functional.repeatedly(resolved))
+
+        stubtype = type(spec.name, (Stub, ), slots)
+
+        for method in spec.methods:
+            slots[method].__objclass__ = stubtype
+
+        return stubtype
+
+    def __call__(self, spec):
+        print(f'In stubFactory.__call__ {spec}')
+        if spec not in self.cache:
+            self.cache[spec] = self.create_stubtype(spec)
+        
+        stubtype = self.cache[spec]
+        stub = stubtype.__new__(stubtype)
+        print(f'In stubFactory created new')
+        return stub

retracesoftware/proxy/thread.py

@@ -24,7 +24,7 @@ def prefix_with_thread_id(f, current):
         nonlocal current, f
         obj = f()
 
-        while isinstance(obj, ThreadSwitch):
+        while issubclass(type(obj), ThreadSwitch):
             current = obj.id
             obj = f()
 

{retracesoftware_proxy-0.1.1.dist-info → retracesoftware_proxy-0.1.3.dist-info}/METADATA

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

retracesoftware_proxy-0.1.3.dist-info/RECORD

@@ -0,0 +1,27 @@
+retracesoftware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+retracesoftware/config.json,sha256=zhi3DZKG0pIT3Mh2EUXlzQai-U6YrknueOjMJLwNKxY,8281
+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=zSDmaVmgwTteF-ysMjHFbum793mt93J0gVHDOnYg2uM,17286
+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=NFilwwtopDrEXjh4ZLkwyIgvPvzApQYC6BA78B11WTQ,4675
+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=eUYinugkA2EZgTkxcXcdDntQmK5HCQp5oOwRzfhosx4,6698
+retracesoftware/proxy/proxytype.py,sha256=iKN57FPRrACgYIFEDsCMvROA_tuhuGtZVguOxGlzVEE,12246
+retracesoftware/proxy/record.py,sha256=YEwfqldpb1MQGi6EngPxdbmjbCIjbz9EQCZuXubLSy4,7503
+retracesoftware/proxy/replay.py,sha256=4DxEuBlQSA6e-vB401JVfJV9Dgfesf5qbuBQBD-ApkA,7847
+retracesoftware/proxy/stubfactory.py,sha256=6dvDnbClDY1tDLIDvPYOPxuCIGsg3TYa1qf2SqrmAvg,4114
+retracesoftware/proxy/thread.py,sha256=-SvnyVbANkmX2lLRpOvFtkpdpAoF6DhnnYdOOs7Q8vo,1379
+retracesoftware_proxy-0.1.3.dist-info/METADATA,sha256=J7wYAHin2b8ikm4VVMN9YfzRDZ9VEg43dpEbvqm0BXw,202
+retracesoftware_proxy-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+retracesoftware_proxy-0.1.3.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
+retracesoftware_proxy-0.1.3.dist-info/RECORD,,

retracesoftware_proxy-0.1.1.dist-info/RECORD

@@ -1,26 +0,0 @@
-retracesoftware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-retracesoftware/config.json,sha256=zhi3DZKG0pIT3Mh2EUXlzQai-U6YrknueOjMJLwNKxY,8281
-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=nHnXjLnZDcY2untKR7BsPJEAcwoHfvXqgCmdHLiwRPE,5104
-retracesoftware/install/patcher.py,sha256=PY4j3aXzu5l5fOGiChT8Y54nzhVpnHkWTGcxPtpe5mo,16773
-retracesoftware/install/predicate.py,sha256=tX7NQc0rGkyyHYO3mduYHcJHbw1wczT53m_Dpkzo6do,2679
-retracesoftware/install/record.py,sha256=Y-vDuUP_ZVzMC8PGhZP2fp8gLkIa5FJPhMKTBUSXi_o,3113
-retracesoftware/install/references.py,sha256=0nUY_9BkeFz2imcw97rcJNq2jqISCB8dysBbCrh1eCo,1623
-retracesoftware/install/replay.py,sha256=SV7-k05xZFiNfBaxrlLrqbB8-i01IPvnJQjRj9zuinI,1828
-retracesoftware/install/tracer.py,sha256=UUVzBD_Nd91VH4iTs7ZDzaIbp_WeiOCSQnSe76dmfjM,4588
-retracesoftware/install/typeutils.py,sha256=_a1PuwdCsYjG1Nkd77V-flqYtwbD4RkJVKn6Z-xABL4,1813
-retracesoftware/proxy/__init__.py,sha256=ZlDZIuUmKFsE9Tvfd2EKGabTepqv8nrbr5pQhCM3IKc,193
-retracesoftware/proxy/gateway.py,sha256=qRaE1xIdbRy6kBWmvvrBh-xKRmywWybO01yi1ppVdu8,6062
-retracesoftware/proxy/proxyfactory.py,sha256=2PgC0NtDbRmhmU--caTiQDsaF8s1h9tavQxvPIow_bM,11912
-retracesoftware/proxy/proxysystem.py,sha256=aX5bYqL2yf7mSgbjtDh1-n8dQ98nHZLT55kSLdVMy_c,6442
-retracesoftware/proxy/proxytype.py,sha256=RuZL0xl48hfSnOFMum74FXdde-UNJ1Urz-ILBNMs4Ts,9398
-retracesoftware/proxy/record.py,sha256=ShQrPSiNvZ9hckW6eaOoHj-w7_-X1o7R6zlaZkV_zdI,7687
-retracesoftware/proxy/replay.py,sha256=jsg0DZTe1TBU5kjRt9weqLpHl8AlDQeqakNddYhBE2E,7111
-retracesoftware/proxy/thread.py,sha256=zAqzLDJuhZxieMPtHzipTbuZ8WSO4nmRBgDBs7kPQy0,1373
-retracesoftware_proxy-0.1.1.dist-info/METADATA,sha256=QuPCODtdgePy3CzNyVoMpLZAVbScOYpeHPfpTOwTIrQ,202
-retracesoftware_proxy-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-retracesoftware_proxy-0.1.1.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
-retracesoftware_proxy-0.1.1.dist-info/RECORD,,