retracesoftware-proxy 0.1.14__py3-none-any.whl → 0.1.15__py3-none-any.whl

retracesoftware/config.json

@@ -4,7 +4,6 @@
     "internal", {"comment": "Default state when retrace is disabled for a thread"},
     "external", {"comment": "When target thread is running outside the python system to be recorded"},
     "retrace", {"comment": "When target thread is running outside the retrace system"},
-    "bootstrap", {"comment": "When the target thread is running in the low-level module load machinery"},
     "gc", {"comment": "When the target thread is running inside the pyton garbage collector"}
   ],
 
@@ -175,6 +174,7 @@
         "disabled": ["Bdb.trace_dispatch"]
       }
     },
+
     "sys": {
       "with_state": {
         "disabled": ["excepthook"]
@@ -186,13 +186,21 @@
       }
     },
     
-    "importlib._bootstrap": {
+    "importlib": {
       "with_state": {
-        "bootstrap": [
-          "_load_unlocked",
-          "_find_spec",
-          "_lock_unlock_module",
-          "_get_module_lock"]
+        "disabled": ["import_module"]
+      }
+    },
+
+    "importlib._bootstrap": {
+      "comment": {
+        "with_state": {
+          "internal": [
+            "_load_unlocked",
+            "_find_spec",
+            "_lock_unlock_module",
+            "_get_module_lock"]
+        }
       }
     },
 
@@ -233,6 +241,10 @@
     "builtins": {
       "patch_hash": ["object"],
 
+      "with_state": {
+        "disabled": ["__import__"]
+      },
+
       "comment": {
         "replace": {
           "set": "retracesoftware_utils.set",

retracesoftware/install/patcher.py

@@ -29,6 +29,8 @@ import retracesoftware.utils as utils
 
 from retracesoftware.install import edgecases
 from functools import partial
+from retracesoftware.proxy.thread import start_new_thread_wrapper
+
 # from retrace_utils.intercept import proxy
 
 # from retrace_utils.intercept.typeutils import *
@@ -300,22 +302,29 @@ class Patcher:
 
     @patch
     def patch_start_new_thread(self, value):
-        def start_new_thread(function, *args):
-            # synchronized, replay shoudl yield correct number
-            thread_id = self.thread_counter()
+        return start_new_thread_wrapper(thread_state = self.thread_state, 
+                                        on_exit = self.system.on_thread_exit,
+                                        start_new_thread = value)
+    
+        # def start_new_thread(function, *args):
+        #     # synchronized, replay shoudl yield correct number
+        #     thread_id = self.thread_counter()
 
-            def threadrunner(*args, **kwargs):
-                nonlocal thread_id
-                self.system.set_thread_id(thread_id)
+        #     def threadrunner(*args, **kwargs):
+        #         nonlocal thread_id
+        #         self.system.set_thread_id(thread_id)
                 
-                with self.thread_state.select('internal'):
-                    # if self.tracing:
-                    #     FrameTracer.install(self.thread_state.dispatch(noop, internal = self.checkpoint))    
-                    return function(*args, **kwargs)
+        #         with self.thread_state.select('internal'):
+        #             try:
+        #                 # if self.tracing:
+        #                 #     FrameTracer.install(self.thread_state.dispatch(noop, internal = self.checkpoint))    
+        #                 return function(*args, **kwargs)
+        #             finally:
+        #                 print(f'exiting: {thread_id}')
 
-            return value(threadrunner, *args)
+        #     return value(threadrunner, *args)
 
-        return self.thread_state.dispatch(value, internal = start_new_thread)
+        # return self.thread_state.dispatch(value, internal = start_new_thread)
 
     @phase
     def wrappers(self, spec, mod_dict): 
@@ -323,39 +332,21 @@ class Patcher:
 
     @patch
     def patch_exec(self, exec):
-        def is_module_exec(source):
-            return isinstance(source, types.CodeType) and \
-                    source.co_name == '<module>' and inspect.getmodule(source)
 
-        def exec_wrapper(source, *args,**kwargs):
-            module = None
-
-            with self.thread_state.select('disabled'):
-                if is_module_exec(source):
-                    module = inspect.getmodule(source)
-            
-            if module:
-                result = exec(source, *args, **kwargs)
-                self(module)
-                return result
-            else:
-                return exec(source, *args,**kwargs)
+        def exec_wrapper2(source, *args,**kwargs):
+            if isinstance(source, types.CodeType) and source.co_name == '<module>':
+                self(inspect.getmodule(source))
         
-            # if self.thread_state.value != 'bootstrap':
-
-            #     and is_module_exec(source):
-            #     with self.thread_state.select('disabled'):
-            #         module = inspect.getmodule(source)
-            #     with self.thread_state.select('internal'):
-            #         result = exec(source, *args, **kwargs)
-                
-            #     self(module)
+        def first(x): return x[0]
+            
+        wrapped_exec = functional.sequence(
+            functional.vector(
+                self.thread_state.wrap('internal', exec),
+                exec_wrapper2),
+            first)
 
-            #     return result
-            # else:
-            #     return exec(source, *args,**kwargs)
-        
-        return self.thread_state.dispatch(exec, internal = exec_wrapper)
+        return self.thread_state.dispatch(exec, internal = wrapped_exec)
+    
     # self.thread_state.wrap(desired_state = 'disabled', function = exec_wrapper)
 
     @patch
@@ -415,7 +406,6 @@ class Patcher:
 
     @patch
     def patch_hash(self, cls):
-        print(f'patching hash for: {cls}')
         utils.patch_hash(cls = cls, hashfunc = self.hashfunc)
 
     @patch
@@ -496,6 +486,8 @@ class Patcher:
 
     def patch_module_with_name(self, mod_name, module):
         with self.disable:
+            print(f'Patching: {module}')
+
             self.log('install.module', mod_name)
 
             # self.system.log(f'patching module: {mod_name}')
@@ -520,19 +512,23 @@ class Patcher:
 
     def __call__(self, module):
 
-        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
+        print(f'patcher called with: {module} {self.thread_state.value}')
+
+        if not hasattr(module, '__retrace__'):
+
+            print(f'patcher called with: {module} 1')
+
+            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/proxy/proxysystem.py

@@ -100,8 +100,8 @@ class ProxySystem:
             default = tracer(name, unproxy_execute)
             return thread_state.dispatch(default, internal = internal, external = external)
 
-        self.ext_handler = self.wrap_int_to_ext(int2ext)
-        self.int_handler = self.wrap_ext_to_int(ext2int)
+        self.ext_handler = thread_state.wrap('retrace', self.wrap_int_to_ext(int2ext))
+        self.int_handler = thread_state.wrap('retrace', self.wrap_ext_to_int(ext2int))
 
         self.ext_dispatch = gateway('proxy.int.disabled.event', internal = self.ext_handler)
         self.int_dispatch = gateway('proxy.ext.disabled.event', external = self.int_handler)
@@ -126,6 +126,9 @@ class ProxySystem:
         self.thread_state.value = self.saved_thread_state
         self.fork_counter += 1
 
+    def on_thread_exit(self, thread_id):
+        pass
+
     # def create_stub(self): return False
         
     def int_proxytype(self, cls):
@@ -156,6 +159,8 @@ class ProxySystem:
         return utils.wrapped_function(handler = self.ext_handler, target = obj)
         
     def patchtype(self, cls):
+        print(f'Proxying type: {cls}')
+
         if cls in self.immutable_types or issubclass(cls, tuple):
             return cls
 

retracesoftware/proxy/record.py

@@ -5,7 +5,7 @@ import retracesoftware.stream as stream
 from retracesoftware.proxy.proxytype import *
 # from retracesoftware.proxy.gateway import gateway_pair
 from retracesoftware.proxy.proxysystem import ProxySystem
-from retracesoftware.proxy.thread import write_thread_switch, ThreadSwitch
+from retracesoftware.proxy.thread import write_thread_switch, ThreadSwitch, thread_id
 from retracesoftware.install.tracer import Tracer
 from retracesoftware.proxy.stubfactory import StubRef, ExtendedRef
 from retracesoftware.proxy.globalref import GlobalRef
@@ -87,16 +87,16 @@ class RecordProxySystem(ProxySystem):
         
         self.pid = self.getpid()
 
-        self.writer = stream.writer(path)
+        self.writer = stream.writer(path = path, thread = thread_id)
         
-        def on_switch():
-            print(f"On thread switch!!!")
-            # print(f"On thread switch!!!: {utils.thread_id().id}")
-            # utils.sigtrap(utils.thread_id())
-            self.writer(utils.thread_id())
-            # utils.sigtrap(utils.thread_id())
+        # def on_switch():
+        #     print(f"On thread switch!!!")
+        #     # print(f"On thread switch!!!: {utils.thread_id().id}")
+        #     # utils.sigtrap(utils.thread_id())
+        #     self.writer(utils.thread_id())
+        #     # utils.sigtrap(utils.thread_id())
 
-        write = utils.observer(on_call = utils.thread_switch_monitor(on_switch), function = self.writer)
+        # write = utils.observer(on_call = utils.thread_switch_monitor(on_switch), function = self.writer)
 
         # w = self.writer.handle('TRACE')
         # def trace_writer(*args):
@@ -121,15 +121,15 @@ class RecordProxySystem(ProxySystem):
 
         # self.sync = lambda function: functional.firstof(self.thread_switch_monitor, functional.always(self.writer.handle('SYNC')), function)
 
+        sync_handle = self.writer.handle('SYNC')
+
         self.sync = lambda function: \
-            utils.observer(
-                on_call = functional.lazy(write, self.writer.handle('SYNC')), 
-                function = function)
+            utils.observer(on_call = functional.lazy(sync_handle), function = function)
 
         error = self.writer.handle('ERROR')
 
         def write_error(cls, val, traceback):
-            write(error, cls, val)
+            error(cls, val)
         
         # self.set_thread_id = functional.partial(utils.set_thread_id, self.writer)
 
@@ -139,13 +139,13 @@ class RecordProxySystem(ProxySystem):
         #     w(self.writer.messages_written, name, *args)
 
         # tracer = Tracer(tracing_config, writer = foo)
-        tracer = Tracer(tracing_config, writer = functional.partial(write, self.writer.handle('TRACE')))
+        tracer = Tracer(tracing_config, writer = self.writer.handle('TRACE'))
 
         # self.wrap_int_to_ext = self.sync
         
-        self.on_int_call = functional.mapargs(transform = serialize, function = functional.partial(write, self.writer.handle('CALL')))
+        self.on_int_call = functional.mapargs(transform = serialize, function = self.writer.handle('CALL'))
         
-        self.on_ext_result = functional.sequence(serialize, functional.partial(write, self.writer.handle('RESULT')))
+        self.on_ext_result = functional.sequence(serialize, self.writer.handle('RESULT'))
         
         self.on_ext_error = write_error
 

retracesoftware/proxy/replay.py

@@ -3,7 +3,7 @@ import retracesoftware_utils as utils
 import retracesoftware.stream as stream
 
 from retracesoftware.install.tracer import Tracer
-from retracesoftware.proxy.thread import per_thread_messages
+from retracesoftware.proxy.thread import per_thread_messages, thread_id
 from retracesoftware.proxy.proxytype import *
 # from retracesoftware.proxy.gateway import gateway_pair
 from retracesoftware.proxy.record import StubRef, Placeholder
@@ -15,6 +15,7 @@ import os
 import weakref
 import traceback
 import pprint
+
 from itertools import count, islice
 
 # we can have a dummy method descriptor, its has a __name__ and when called, returns the next element
@@ -61,6 +62,8 @@ def on_stack_mismatch(last_matching, record, replay):
         print('Record stacktrace:')
         for line in islice(record, 0, len(record) - matching):
             print(line)
+        
+        print(f'-----------')
     else:
         matching = count_matching(reversed(record), reversed(replay))
 
@@ -75,36 +78,52 @@ def on_stack_mismatch(last_matching, record, replay):
         print('Record stacktrace:')
         for line in islice(record, 0, len(record) - matching):
             print(line)
+        
 
 
 class ReplayProxySystem(ProxySystem):
     
     @utils.striptraceback
     def next_result(self):
-        while True:
-            next = self.messages()
+        try:
+            while True:
+                next = self.messages()
+
+                if next == 'CALL':
+                    func = self.messages()
+                    args = self.messages()
+                    kwargs = self.messages()
+
+                    try:
+                        func(*args, **kwargs)
+                    except:
+                        pass
+
+                elif next == 'RESULT':
+                    return self.messages()
+                
+                elif next == 'ERROR':
+                    # breakpoint()
+                    err_type = self.messages()
+                    err_value = self.messages()
+                    utils.raise_exception(err_type, err_value)
+                else:
+                    assert type(next) is not str
+                    return next
+        except TimeoutError:
+            print(f'timeout for reader, active thread: {self.reader.active_thread}, next_control: {self.reader.next_control}')
 
-            if next == 'CALL':
-                func = self.messages()
-                args = self.messages()
-                kwargs = self.messages()
+            for thread,stack in self.reader.stacktraces.items():
+                print(f'thread: {thread}')
 
-                try:
-                    func(*args, **kwargs)
-                except:
-                    pass
+                formatted_frames = [
+                    (frame.filename, frame.lineno, frame.function, frame.code_context[0].strip() if frame.code_context else None)
+                    for frame in stack
+                ]
+                formatted_trace = traceback.format_list(formatted_frames)
+                print("Traceback (most recent call last):\n" + "".join(formatted_trace))
 
-            elif next == 'RESULT':
-                return self.messages()
-            
-            elif next == 'ERROR':
-                # breakpoint()
-                err_type = self.messages()
-                err_value = self.messages()
-                utils.raise_exception(err_type, err_value)
-            else:
-                assert type(next) is not str
-                return next
+            utils.sigtrap(None)
 
     def bind(self, obj):
         read = self.messages()
@@ -138,7 +157,6 @@ 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:
@@ -201,6 +219,11 @@ class ReplayProxySystem(ProxySystem):
                 for arg in args:
                     self.read_required(arg)
 
+    def on_thread_exit(self, thread_id):
+        print(f'on_thread_exit!!!!')
+        self.reader.wake_pending()
+
+
     def __init__(self, 
                  thread_state,
                  immutable_types,
@@ -209,8 +232,11 @@ class ReplayProxySystem(ProxySystem):
                  fork_path = []):
         
         # self.messages_read = 0
-        self.reader = stream.reader(path)
 
+        self.reader = stream.reader(path, 
+                                    thread = thread_id,
+                                    timeout_seconds = 5)
+    
         self.bindings = utils.id_dict()
         # self.set_thread_id = utils.set_thread_id
         self.fork_path = fork_path
@@ -235,9 +261,9 @@ class ReplayProxySystem(ProxySystem):
                 print(f'Error reading next result: {error}')
                 raise(error)
         
-        self.messages = functional.sequence(per_thread_messages(foo), deserialize)
+        # self.messages = functional.sequence(per_thread_messages(foo), deserialize)
 
-        # self.messages = functional.sequence(per_thread_messages(self.reader), deserialize)
+        self.messages = functional.sequence(self.reader, deserialize)
 
         self.stub_factory = StubFactory(thread_state = thread_state, next_result = self.next_result)
 

retracesoftware/proxy/thread.py

@@ -1,6 +1,9 @@
 import retracesoftware.functional as functional
 import retracesoftware_utils as utils
 
+import os
+import _thread
+
 # def thread_aware_writer(writer):
 #     on_thread_switch = functional.sequence(utils.thread_id(), writer.handle('THREAD_SWITCH'))
 #     return utils.threadawareproxy(on_thread_switch = on_thread_switch, target = writer)
@@ -39,6 +42,7 @@ def prefix_with_thread_id(f, thread_id):
             current = obj.id
             obj = f()
 
+        # print(f'prefix_with_thread_id: {(current, obj)}')
         return (current, obj)
 
     return next
@@ -47,8 +51,15 @@ def per_thread_messages(messages):
     thread_id = utils.thread_id
     # thread_id = lambda: 'FOOOOO!!!'
 
+    def on_timeout(demux, key):
+        print(f'ON TIMEOUT!!!! {key} pending: {demux.pending} {demux.pending_keys}')
+        utils.sigtrap(demux)
+        os._exit(1)
+
     demux = utils.demux(source = prefix_with_thread_id(messages, thread_id),
-                        key_function = lambda obj: obj[0])
+                        key_function = lambda obj: obj[0],
+                        timeout_seconds = 60,
+                        on_timeout = on_timeout)
 
     # def next():
     #     thread,message = demux(thread_id())
@@ -56,3 +67,40 @@ def per_thread_messages(messages):
     
     # return next
     return functional.repeatedly(lambda: demux(thread_id())[1])
+
+
+# _thread.start_new_thread(function, args[, kwargs])
+counters = _thread._local()
+counters.id = ()
+counters.counter = 0
+
+def with_thread_id(thread_id, on_exit, function):
+    def on_call(*args, **kwargs):
+        counters.id = thread_id
+        counters.counter = 0
+
+    def on_result(res):
+        on_exit(thread_id)
+    
+    def on_error(*args):
+        on_exit(thread_id)
+
+    return utils.observer(on_call = on_call, on_result = on_result, on_error = on_error, function = function)
+
+thread_id = functional.lazy(getattr, counters, 'id')
+
+def start_new_thread_wrapper(thread_state, on_exit, start_new_thread):
+
+    def wrapper(function, *args):
+        
+        next_id = counters.id + (counters.counter,)
+        counters.counter += 1
+
+        wrapped_function = with_thread_id(thread_id = next_id,
+                                          on_exit = on_exit, 
+                                          function = thread_state.wrap('internal', function))
+
+        return start_new_thread(wrapped_function, *args)
+
+    return thread_state.dispatch(start_new_thread, internal = wrapper)
+

{retracesoftware_proxy-0.1.14.dist-info → retracesoftware_proxy-0.1.15.dist-info}/METADATA

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

{retracesoftware_proxy-0.1.14.dist-info → retracesoftware_proxy-0.1.15.dist-info}/RECORD

@@ -1,12 +1,12 @@
 retracesoftware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-retracesoftware/config.json,sha256=JU3LYWZbqBLqiHXDc9fBYVh0owMUcKGw3W-vaVm-roo,9024
+retracesoftware/config.json,sha256=yMAD8410r8VEnBToXNmtfaBz6MClBVEiKsq6vKgSI0c,9121
 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=ryX73_KjdcUCC0oy0Uqel_L3bwfZZldS3CIYQ-XAl_k,20520
+retracesoftware/install/patcher.py,sha256=_J8YTDd0QNLgURRyrUFikNsImgMOBhCv8Nmps5rjkZI,20241
 retracesoftware/install/predicate.py,sha256=tX7NQc0rGkyyHYO3mduYHcJHbw1wczT53m_Dpkzo6do,2679
 retracesoftware/install/record.py,sha256=R2GOIA_WAggrNmVwZJh9r1xp-GVu43iKq-ykQ1VKEHE,3408
 retracesoftware/install/references.py,sha256=A-G651IDOfuo00MkbAdpbIQh_15ChvJ7uAVTSmE6zd4,1721
@@ -17,13 +17,13 @@ retracesoftware/proxy/__init__.py,sha256=ntIyqKhBRkKEkcW_oOPodikh-mxYl8OXRnSaj-9
 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=ZX6eNT8go-YDbLWD2pq5j_V8DZAHteu-iNfkMO8jLWg,7567
+retracesoftware/proxy/proxysystem.py,sha256=ttzHcNH4O2GrlTjy3R386HTwRY7Z5QKWbMt6BOf7Jto,7722
 retracesoftware/proxy/proxytype.py,sha256=hP-1vJmWBa9KgZFB3CnZy0UbC4u8Wr2e76lGI0JM2SA,12992
-retracesoftware/proxy/record.py,sha256=QBx3G8mXjUiB9vCXJZ0tZdt3Mi1WEtRhuZ7HOUroNNQ,5505
-retracesoftware/proxy/replay.py,sha256=vVFkhYOOZSprLD_mjx-p6SpDB8fy81SK3x2A5H0odUs,8614
+retracesoftware/proxy/record.py,sha256=47vhAYIUrR2bWo-rQ9xU_Xyg3kNrA5Lqq4-8Cxg4-zg,5463
+retracesoftware/proxy/replay.py,sha256=RWfmTrbeLFCSvV26ow1iwitf1wWt6XfypMcKIxYXZEg,9669
 retracesoftware/proxy/stubfactory.py,sha256=37UX1r8HCAbASTwPdz8QKCrg72NQmM5PsiCho7N2nzg,5129
-retracesoftware/proxy/thread.py,sha256=idkJwJ8rR1kpRHfo81uCi6Y0LEIChAdfc0GqK_bFqTA,1635
-retracesoftware_proxy-0.1.14.dist-info/METADATA,sha256=Y6QfA5aDmUke1rEvUWSOgRIwbEAk7YbbcpW-7m00kQM,203
-retracesoftware_proxy-0.1.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-retracesoftware_proxy-0.1.14.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
-retracesoftware_proxy-0.1.14.dist-info/RECORD,,
+retracesoftware/proxy/thread.py,sha256=T1ME6DHB8O0xVnX3Rt1lMl7oCJ2Y0aoFT91D76yNICk,3073
+retracesoftware_proxy-0.1.15.dist-info/METADATA,sha256=5EIkVm31Txgu2-FN94NLguxj4YtbZ7pU_VaZLisxhCE,203
+retracesoftware_proxy-0.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+retracesoftware_proxy-0.1.15.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
+retracesoftware_proxy-0.1.15.dist-info/RECORD,,