retracesoftware-proxy 0.1.18__py3-none-any.whl → 0.1.20__py3-none-any.whl

retracesoftware/config.json

@@ -434,6 +434,9 @@
       "proxy_all_except": ["Error"]
     },
 
+    "_weakrefset": {
+      "sync_types": ["WeakSet", "_IterationGuard"]
+    },
     "_collections": {
       "sync_types": [
         "deque"

retracesoftware/install/patcher.py

@@ -15,6 +15,7 @@ import gc
 import os
 import atexit
 import threading
+from types import SimpleNamespace, MethodType
 
 from retracesoftware.install.typeutils import modify
 # from retracesoftware.proxy.immutabletypes import ImmutableTypes
@@ -336,20 +337,20 @@ class Patcher:
     @patch
     def patch_exec(self, exec):
 
-        def exec_wrapper2(source, globals = None, locals = None):
-            if isinstance(source, types.CodeType) and source.co_name == '<module>':
-                module = sys.modules[globals['__name__']]
-                self(module)
+        def is_module(source, *args):
+            return isinstance(source, types.CodeType) and source.co_name == '<module>'
+        
+        def after_exec(source, globals = None, locals = None):
+            self(sys.modules[globals['__name__']])
         
         def first(x): return x[0]
             
-        wrapped_exec = functional.sequence(
-            functional.vector(
-                self.thread_state.wrap('internal', exec),
-                exec_wrapper2),
-            first)
-
-        return self.thread_state.dispatch(exec, internal = wrapped_exec)
+        def disable(func): return self.thread_state.wrap('disabled', func)
+    
+        return self.thread_state.dispatch(
+            exec, 
+            internal = functional.sequence(
+                functional.vector(exec, functional.when(is_module, disable(after_exec))), first))
     
     # self.thread_state.wrap(desired_state = 'disabled', function = exec_wrapper)
 
@@ -415,14 +416,21 @@ class Patcher:
     @patch
     def patch_extension_exec(self, exec):
         
-        def wrapper(module):
-            with self.thread_state.select('internal'):
-                res = exec(module)
+        def first(x): return x[0]
 
-            self(module)
-            return res
+        def disable(func): return self.thread_state.wrap('disabled', func)
+    
+        return self.thread_state.dispatch(exec, 
+                                   internal = functional.sequence(functional.vector(exec, disable(self)), first))
+        
+        # def wrapper(module):
+        #     with self.thread_state.select('internal'):
+        #         res = exec(module)
+
+        #     self(module)
+        #     return res
 
-        return wrapper
+        # return wrapper
 
     @patch
     def path_predicates(self, func, param):
@@ -494,9 +502,7 @@ class Patcher:
     def patch_module_with_name(self, mod_name, module):
         with self.disable:
 
-            if mod_name == 'selectors':
-                print('DWFEWFW!!!!!!!!!')
-
+            assert self.thread_state.value == 'disabled'
 
             self.log('install.module', mod_name)
 
@@ -525,7 +531,7 @@ class Patcher:
                 self.post_commit(mod_name, updates)
 
     def __call__(self, module):
-        
+                
         if not hasattr(module, '__retrace__'):
 
             configs = list(self.configs(module))
@@ -616,28 +622,57 @@ def install(mode):
 
     importlib.invalidate_caches()
 
-    with thread_state.select('internal'):
+    # with thread_state.select('internal'):
 
-        atexit.register(lambda: at_exit)
-        
-        for key, module in list(sys.modules.items()):
-            if not key.startswith('retracesoftware'):
-                patcher(module)
+    atexit.register(lambda: at_exit)
+    
+    for key, module in list(sys.modules.items()):
+        if not key.startswith('retracesoftware'):
+            patcher(module)
 
-        for library in config.get('preload', []):
+    for library in config.get('preload', []):
+        with thread_state.select('internal'):
             importlib.import_module(library)
 
     importlib.invalidate_caches()
     # # if env_truthy('RETRACE_TRACE_CALLS'):
     # #     trace_calls(system = retracesystem)
 
-    thread_state.value = 'internal'
+    # thread_state.value = 'internal'
 
     # import threading
     # threading.current_thread().retrace = system
 
     threading.current_thread().__retrace__ = system
 
-    # utils.sigtrap(None)
+    # original = atexit.register
+
+    # def atexit_register(function):
+    #     return original(thread_state.wrap('internal', function))
+
+    def wrap_internal(func): return thread_state.wrap('internal', func)
+
+    atexit.register = \
+        thread_state.dispatch(atexit.register, internal = functional.sequence(wrap_internal, atexit.register))
+
+    def disable_after_main(frame):
+        if system.is_entry_frame(frame):
+            print('enabling retrace!!!!')
+            # utils.intercept_frame_eval(None)
+            thread_state.value = 'internal'
+            
+            def on_return(): 
+                thread_state.value = 'disabled'
+
+            obj = SimpleNamespace()
+            obj.on_return = on_return
+
+            return obj
+        else:
+            return disable_after_main
+
+    utils.intercept_frame_eval(disable_after_main)
 
+    # utils.sigtrap(None)
+    print(f'retrace installed: {thread_state}')
     return system

retracesoftware/install/record.py

@@ -70,6 +70,10 @@ def record_system(thread_state, immutable_types, config):
     with open(recording_path / 'tracing_config.json', 'w') as f:
         json.dump(tracing_config, f, indent=2)
 
+    def write_main_path(path):
+        with open(recording_path / 'mainscript', 'w') as f:
+            f.write(path)
+
     # writer = stream.writer(path = recording_path / 'trace.bin')
     
     # os.register_at_fork(
@@ -106,4 +110,5 @@ def record_system(thread_state, immutable_types, config):
     return RecordProxySystem(thread_state = thread_state,
                              immutable_types = immutable_types, 
                              tracing_config = tracing_config,
+                             write_main_path = write_main_path,
                              path = recording_path / 'trace.bin')

retracesoftware/install/replay.py

@@ -48,7 +48,11 @@ def replay_system(thread_state, immutable_types, config):
     with open(recording_path / "tracing_config.json", "r", encoding="utf-8") as f:
         tracing_config = json.load(f)
 
+    with open(recording_path / "mainscript", "r", encoding="utf-8") as f:
+        mainscript = f.read()
+
     return ReplayProxySystem(thread_state = thread_state, 
                                 immutable_types = immutable_types,
                                 tracing_config = tracing_config,
+                                mainscript = mainscript,
                                 path = recording_path / 'trace.bin')

retracesoftware/install/tracer.py

@@ -13,6 +13,38 @@ def format_kwargs(kwargs):
 
     return tuple(result)
 
+class CallTracer:
+
+    ignore = set([('abc', '__subclasscheck__'),
+                  ('threading', '_shutdown'),
+                  ('typing', 'inner')])
+    
+    def __init__(self, writer, thread_state):
+        self.writer = writer
+        self.thread_state = thread_state
+
+    def on_result(self, result):
+        if type(result) in [str]:
+            self.writer(result)
+        else:
+            self.writer(str(type(result)))
+
+    def on_error(self, exc_type, exc_value, exc_traceback):
+        pass
+
+    def __call__(self, frame):
+        if self.thread_state.value == 'internal':
+            with self.thread_state.select('disabled'):
+                func = frame.function
+                        
+                key = (func.__module__, func.__name__)
+
+                if key not in CallTracer.ignore and func.__name__ != '__hash__':
+                    self.writer(f'{func.__module__}.{func.__name__}')
+                    return self
+        else:
+            return lambda *args, **kwargs: self(*args, **kwargs)
+    
 class Tracer:
 
     def __init__(self, config, writer):
@@ -44,65 +76,66 @@ class Tracer:
 
     def trace_calls(self, thread_state):
         if 'tracecalls' in self.config:
-            def on_call(frame):
-                func = frame.function
+            # def on_call(frame):
+
+            #     func = frame.function
                 
-                key = (func.__module__, func.__name__)
+            #     key = (func.__module__, func.__name__)
 
-                ignore = set(('abc', '__subclasscheck__'),
-                             ('threading', '_shutdown'))
+            #     ignore = set([('abc', '__subclasscheck__'),
+            #                   ('threading', '_shutdown')])
 
-                if key in ignore:
-                    print('About to throw!!!')
-                    raise Exception()
+            #     if key in ignore:
+            #         print('About to throw!!!')
+            #         raise Exception()
 
-                objtype = None
+            #     objtype = None
 
-                if 'self' in frame.locals:
-                    this = frame.locals['self']
-                    objtype = type(this)
+            #     if 'self' in frame.locals:
+            #         this = frame.locals['self']
+            #         objtype = type(this)
 
-                # if objtype:
-                #     print(f'Called!!!!: {func.__module__}.{objtype.__name__}.{func.__name__}')
-                # else:
-                #     print(f'Called!!!!: {func.__module__}.{func.__name__}')
+            #     # if objtype:
+            #     #     print(f'Called!!!!: {func.__module__}.{objtype.__name__}.{func.__name__}')
+            #     # else:
+            #     #     print(f'Called!!!!: {func.__module__}.{func.__name__}')
 
-                qualname = (func.__module__, objtype, func.__name__)
+            #     qualname = (func.__module__, objtype, func.__name__)
 
-                self.writer(f'{func.__module__}.{func.__name__}')
+            #     self.writer(f'{func.__module__}.{func.__name__}')
 
-                # if func.__name__ == '_path_stat':
-                #     utils.sigtrap('_path_stat start')
+            #     # if func.__name__ == '_path_stat':
+            #     #     utils.sigtrap('_path_stat start')
 
-                return qualname
+            #     return qualname
 
-            def on_result(qualname, res):
-                mod, obj, func = qualname
+            # def on_result(qualname, res):
+            #     mod, obj, func = qualname
 
-                # if obj:
-                #     print(f'Returning!!!!: {mod}.{obj}.{func}')
-                # else:
-                #     print(f'Returning!!!!: {mod}.{func}')
+            #     # if obj:
+            #     #     print(f'Returning!!!!: {mod}.{obj}.{func}')
+            #     # else:
+            #     #     print(f'Returning!!!!: {mod}.{func}')
 
-                # if func == '_path_stat':
-                #     utils.sigtrap('_path_stat res')
+            #     # if func == '_path_stat':
+            #     #     utils.sigtrap('_path_stat res')
 
-                if func != '__hash__':
-                    ignore = set(('typing', 'inner'))
+            #     if func != '__hash__':
+            #         ignore = set(('typing', 'inner'))
 
-                    if qualname not in ignore:
-                        if type(res) in [str, int]:
-                            self.writer(res)
-                        else:
-                            self.writer(str(type(res)))
-
-            def on_call_disabled(frame):
-                func = frame.function
-                print(f'disabled: {func.__module__}.{func.__name__}')
-                
-            utils.intercept_frame_eval(on_call = thread_state.dispatch(utils.noop, internal = thread_state.wrap('disabled', on_call)),
-                                       on_result = thread_state.dispatch(utils.noop, internal = thread_state.wrap('disabled', on_result)))
+            #         if qualname not in ignore:
+            #             if type(res) in [str, int]:
+            #                 self.writer(res)
+            #             else:
+            #                 self.writer(str(type(res)))
 
+            # def on_call_disabled(frame):
+            #     func = frame.function
+            #     print(f'disabled: {func.__module__}.{func.__name__}')
+            
+            callback = CallTracer(writer = self.writer, thread_state = thread_state)
+            utils.intercept_frame_eval(callback)
+                                       
     def serialize(self, obj):
         try:
             if obj is None: return None

retracesoftware/install/typeutils.py

@@ -35,6 +35,25 @@ class WithoutFlags:
     def __exit__(self, *args):
         utils.set_type_flags(self.cls, self.saved)
 
+class WithFlags:
+
+    def __init__(self, cls  , *flags):
+        self.cls = cls
+        self.flags = flags
+
+    def __enter__(self):
+        self.saved = utils.type_flags(self.cls)
+        flags = self.saved
+
+        for flag in self.flags:
+            flags |= utils.TypeFlags[flag]
+
+        utils.set_type_flags(self.cls, flags)
+        return self.cls
+
+    def __exit__(self, *args):
+        utils.set_type_flags(self.cls, self.saved)
+
 def add_flag(cls : type, flag):
     if isinstance(flag, str):
         flag = utils.TypeFlags[flag]
@@ -45,6 +64,7 @@ def add_flag(cls : type, flag):
 def modify(cls):
     return WithoutFlags(cls, "Py_TPFLAGS_IMMUTABLETYPE")
 
+
 def type_has_feature(cls, flag):
     if isinstance(flag, str):
         flag = utils.TypeFlags[flag]

retracesoftware/proxy/proxysystem.py

@@ -5,7 +5,7 @@ from retracesoftware.proxy.gateway import adapter_pair
 from types import SimpleNamespace
 from retracesoftware.proxy.proxytype import *
 from retracesoftware.proxy.stubfactory import Stub
-from retracesoftware.install.typeutils import modify
+from retracesoftware.install.typeutils import modify, WithFlags
 
 import sys
 import gc
@@ -166,8 +166,16 @@ class ProxySystem:
 
     def proxy_function(self, obj):
         return utils.wrapped_function(handler = self.ext_handler, target = obj)
-        
+    
+    def proxy__new__(self, *args, **kwargs):
+        return self.ext_handler(*args, **kwargs)
+
     def patchtype(self, cls):
+        if not utils.is_extendable(cls):
+            with WithFlags(cls, "Py_TPFLAGS_BASETYPE"):
+                assert utils.is_extendable(cls)
+                return self.patchtype(cls)
+
         if cls in self.immutable_types or issubclass(cls, tuple):
             return cls
 
@@ -184,45 +192,21 @@ class ProxySystem:
             
             return self.thread_state.dispatch(func, internal = new)
 
-        # with modify(cls):
-        #     def update(name, f):
-        #         setattr(cls, name, f(getattr(cls, name)))
+        # slots = {'__module__': cls.__module__, '__slots__': []}
 
-        #     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)
-        
-        # return cls
-        if utils.is_extendable(cls):
-            slots = {'__module__': cls.__module__, '__slots__': []}
+        extended = utils.extend_type(cls)
 
-            extended = utils.extend_type(cls)
+        for name, value in superdict(cls).items():
+            if callable(value) and not is_instance_method(value):
+                setattr(extended, name, wrap_new(value) if name == '__new__' else wrap(value))
 
-            for name, value in superdict(cls).items():
-                if callable(value) and not is_instance_method(value):
-                    setattr(extended, name, wrap_new(value) if name == '__new__' else wrap(value))
+                # slots[name] = wrap_new(value) if name == '__new__' else wrap(value)
+        extended.__module__ = cls.__module__
 
-                    # slots[name] = wrap_new(value) if name == '__new__' else wrap(value)
-            extended.__module__ = cls.__module__
+        return extended
 
-            return extended
-            # 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):
-                    if name == '__new__':
-                        handler = self.thread_state.dispatch(functional.apply, internal = self.ext_handler)
-
-                        utils.intercept__new__(type = cls, handler = handler)
-                    else:
-                        update(name, wrap)                        
-                    # update(name, wrap_new if name == '__new__' else wrap)
-        else:
-            return wrap(cls)
+    def is_entry_frame(self, frame):
+        return frame.globals.get("__name__", None) == "__main__"
 
     def __call__(self, obj):
         assert not isinstance(obj, BaseException)

retracesoftware/proxy/record.py

@@ -75,12 +75,20 @@ class RecordProxySystem(ProxySystem):
         utils.set_thread_id(self.writer.handle(ThreadSwitch(id)))
         # utils.set_thread_id(id)
 
+    def is_entry_frame(self, frame):
+        if super().is_entry_frame(frame):
+            self.write_main_path(frame.function.__code__.co_filename)
+            return True
+        return False
+
     def __init__(self, thread_state, 
                  immutable_types, 
                  tracing_config,
+                 write_main_path,
                  path):
         
         self.fork_counter = 0
+        self.write_main_path = write_main_path
 
         self.getpid = thread_state.wrap(
             desired_state = 'disabled', function = os.getpid)
@@ -123,8 +131,10 @@ class RecordProxySystem(ProxySystem):
 
         sync_handle = self.writer.handle('SYNC')
 
+        write_sync = thread_state.dispatch(utils.noop, internal = functional.lazy(sync_handle))
+
         self.sync = lambda function: \
-            utils.observer(on_call = functional.lazy(sync_handle), function = function)
+            utils.observer(on_call = write_sync, function = function)
 
         error = self.writer.handle('ERROR')
 

retracesoftware/proxy/replay.py

@@ -154,12 +154,20 @@ class ReplayProxySystem(ProxySystem):
 
         return super().proxy_function(func)
 
+    def proxy__new__(self, __new__, *args, **kwargs):
+        func = functional.repeatedly(self.next_result)
+        func.__name__ = '__new__'
+        return super().proxy__new__(func, *args, **kwargs)
+
     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}')
@@ -222,19 +230,26 @@ class ReplayProxySystem(ProxySystem):
         print(f'on_thread_exit!!!!')
         self.reader.wake_pending()
 
+    def is_entry_frame(self, frame):
+        if super().is_entry_frame(frame) and frame.function.__code__.co_filename == self.mainscript:
+            return True
+        return False
 
     def __init__(self, 
                  thread_state,
                  immutable_types,
                  tracing_config,
+                 mainscript,
                  path,
                  fork_path = []):
         
         # self.messages_read = 0
 
+        self.mainscript = mainscript
+
         self.reader = stream.reader(path, 
                                     thread = thread_id,
-                                    timeout_seconds = 5)
+                                    timeout_seconds = 60)
     
         self.bindings = utils.id_dict()
         # self.set_thread_id = utils.set_thread_id
@@ -271,7 +286,7 @@ class ReplayProxySystem(ProxySystem):
         self.reader.type_deserializer[StubRef] = self.stub_factory
         self.reader.type_deserializer[GlobalRef] = lambda ref: ref()
                 
-        read_sync = functional.lazy(thread_state.wrap('disabled', self.read_required), 'SYNC')
+        read_sync = thread_state.dispatch(utils.noop, internal = functional.lazy(thread_state.wrap('disabled', self.read_required), 'SYNC'))
 
         self.sync = lambda function: utils.observer(on_call = read_sync, function = function)
 

{retracesoftware_proxy-0.1.18.dist-info → retracesoftware_proxy-0.1.20.dist-info}/METADATA

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

{retracesoftware_proxy-0.1.18.dist-info → retracesoftware_proxy-0.1.20.dist-info}/RECORD

@@ -1,29 +1,29 @@
 retracesoftware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-retracesoftware/config.json,sha256=Nyk1Wt67_BJR-mVLoxk5Qwcf0X4z83vQ80rCBxUP03s,9182
+retracesoftware/config.json,sha256=iy5d3441PtihMT2QH-ikTYdzlf8zfIcSyvtpsJK5tUQ,9261
 retracesoftware/config.yaml,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=hLOowGOKKcMTtCxQthvdC-4Cx4PCNPuBzgHy-UOBbpE,20906
+retracesoftware/install/patcher.py,sha256=XwpySyqaop3bnLc8ewtowxLchAC0mOtXWDfmk5zTE_s,22195
 retracesoftware/install/predicate.py,sha256=tX7NQc0rGkyyHYO3mduYHcJHbw1wczT53m_Dpkzo6do,2679
-retracesoftware/install/record.py,sha256=R2GOIA_WAggrNmVwZJh9r1xp-GVu43iKq-ykQ1VKEHE,3408
+retracesoftware/install/record.py,sha256=mjk4bien8uWp8c-vWNw3Y4BRR5xO4AWsZi1aodkW5yc,3590
 retracesoftware/install/references.py,sha256=A-G651IDOfuo00MkbAdpbIQh_15ChvJ7uAVTSmE6zd4,1721
-retracesoftware/install/replay.py,sha256=VUiHvQK3mgAJEGmtE2TFs9kXzxdWtsjibEcGkhZVCVE,1830
-retracesoftware/install/tracer.py,sha256=Z1HTI74iczOjVI7sLOg8iEJ_-kMMUzC4ju_UMDyLipw,8009
-retracesoftware/install/typeutils.py,sha256=_a1PuwdCsYjG1Nkd77V-flqYtwbD4RkJVKn6Z-xABL4,1813
+retracesoftware/install/replay.py,sha256=36x40dk8pCmVjHz8zKd2OLY3B7UkP0NEb-1V1X8o3Rg,1992
+retracesoftware/install/tracer.py,sha256=MiaTPlUwcRbgL4CTNhvC4Y5mUhkb--Y7_icTPhscSmY,9014
+retracesoftware/install/typeutils.py,sha256=-oFzgUfq_nHeOkj3YKZiMLlMzQhCedg3qymLiEJNkVE,2253
 retracesoftware/proxy/__init__.py,sha256=ntIyqKhBRkKEkcW_oOPodikh-mxYl8OXRnSaj-9-Xwc,178
 retracesoftware/proxy/gateway.py,sha256=xESohWXkiNm4ZutU0RgWUwxjxcBWRQ4rQyxIGQXv_F4,1590
 retracesoftware/proxy/globalref.py,sha256=yXtJsOeBHN9xoEgJWA3MJco-jD2SQUef_fDatA4A6rg,803
 retracesoftware/proxy/proxyfactory.py,sha256=qhOqDfMJnLDNkQs26JqDB431MwjjRhGQi8xupJ45asg,12272
-retracesoftware/proxy/proxysystem.py,sha256=APigIjw6S7pQHTya2YWhXwsObHDcejCWfra3OMyiLvk,8859
+retracesoftware/proxy/proxysystem.py,sha256=zXrK4eMBJHZlmRJ2pQMltzYHF5CjnAZV6Z_teGH6DO8,8071
 retracesoftware/proxy/proxytype.py,sha256=83y5rQRSts-5rLZu_k3tT90mwX2M-Ny6RZ91l-LTJ6k,13199
-retracesoftware/proxy/record.py,sha256=47vhAYIUrR2bWo-rQ9xU_Xyg3kNrA5Lqq4-8Cxg4-zg,5463
-retracesoftware/proxy/replay.py,sha256=bU657DOuvC4m2oWgTHbsQQPtruQzbvMXCKSyp6if9kI,9655
+retracesoftware/proxy/record.py,sha256=AsoVhuTX0pVVAqOih9-Mgh54psyggqfAXwAYYwy7umM,5818
+retracesoftware/proxy/replay.py,sha256=mMb3jiCPS8W-Nev1JMaBIQSxRjV1sKTJYRPWAurw4i0,10264
 retracesoftware/proxy/stubfactory.py,sha256=eHlbzWR1LoQVkIRX1HoLPPQSOpYhOO_5R_p3buD4o7s,5256
 retracesoftware/proxy/thread.py,sha256=T1ME6DHB8O0xVnX3Rt1lMl7oCJ2Y0aoFT91D76yNICk,3073
-retracesoftware_proxy-0.1.18.dist-info/METADATA,sha256=RMIcM6zELH7mx-kFXHOCxtAu55602_u0NgJOUSJVwzc,203
-retracesoftware_proxy-0.1.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-retracesoftware_proxy-0.1.18.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
-retracesoftware_proxy-0.1.18.dist-info/RECORD,,
+retracesoftware_proxy-0.1.20.dist-info/METADATA,sha256=rTN6xgpmhR225Wnal7A_PNhHmi_Xj98A_Xej4IUscoc,203
+retracesoftware_proxy-0.1.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+retracesoftware_proxy-0.1.20.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
+retracesoftware_proxy-0.1.20.dist-info/RECORD,,