retracesoftware-proxy 0.2.11__py3-none-any.whl → 0.2.14__py3-none-any.whl

retracesoftware/__init__.py

@@ -0,0 +1,17 @@
+from retracesoftware.exceptions import (
+    RetraceError,
+    RecordError,
+    ReplayError,
+    ConfigurationError,
+    VersionMismatchError,
+    RecordingNotFoundError,
+)
+
+__all__ = [
+    'RetraceError',
+    'RecordError',
+    'ReplayError',
+    'ConfigurationError',
+    'VersionMismatchError',
+    'RecordingNotFoundError',
+]

retracesoftware/__main__.py

@@ -20,6 +20,7 @@ import gc
 import hashlib
 
 from retracesoftware.run import install, run_with_retrace, ImmutableTypes, thread_states
+from retracesoftware.exceptions import RecordingNotFoundError, VersionMismatchError, ConfigurationError
 
 def expand_recording_path(path):
     return datetime.datetime.now().strftime(path.format(pid = os.getpid()))
@@ -74,7 +75,7 @@ def checksum(path):
     return file_md5(path) if path.is_file() else {entry.name: checksum(entry) for entry in path.iterdir() if entry.name != '__pycache__'}
 
 def retrace_extension_paths():
-    names = ['retracesoftware_utils', 'retracesoftware_functional', 'retracesoftware_stream']
+    names = ['retracesoftware_utils', '_retracesoftware_functional', 'retracesoftware_stream']
     return {name: Path(sys.modules[name].__file__) for name in names}
 
 def retrace_module_paths():
@@ -97,6 +98,7 @@ def record(options, args):
     # write various recording files to directory
     dump_as_json(path / 'settings.json', {
         'argv': args,
+        'executable': sys.executable,
         'magic_markers': options.magic_markers,
         'trace_inputs': options.trace_inputs,
         'trace_shutdown': options.trace_shutdown,
@@ -174,18 +176,21 @@ def replay(args):
     path = Path(args.recording)
 
     if not path.exists():
-        raise Exception(f"Recording path: {path} does not exist")
+        raise RecordingNotFoundError(f"Recording path: {path} does not exist")
 
     settings = load_json(path / "settings.json")
 
     if settings['md5_checksums'] != checksums():
-        raise Exception("Checksums for Retrace do not match, cannot run replay with different version of retrace to record")
+        raise VersionMismatchError("Checksums for Retrace do not match, cannot run replay with different version of retrace to record")
 
     if settings['python_version'] != sys.version:
-        raise Exception("Python version does not match, cannot run replay with different version of Python to record")
+        raise VersionMismatchError("Python version does not match, cannot run replay with different version of Python to record")
 
     os.environ.update(settings['env'])
 
+    if sys.executable != settings['executable']:
+        raise ConfigurationError(f"Stopping replay as current python executable: {sys.executable} is not what was used for record: {settings['executable']}")
+
     thread_state = utils.ThreadState(*thread_states)
 
     # with stream.reader(path = path / 'trace.bin',

retracesoftware/exceptions.py

@@ -0,0 +1,34 @@
+"""
+Retrace exception hierarchy.
+
+All retrace-specific exceptions inherit from RetraceError.
+"""
+
+class RetraceError(Exception):
+    """Base exception for all retrace errors."""
+    pass
+
+
+class RecordError(RetraceError):
+    """Error during recording phase."""
+    pass
+
+
+class ReplayError(RetraceError):
+    """Error during replay phase."""
+    pass
+
+
+class ConfigurationError(RetraceError):
+    """Error in retrace configuration."""
+    pass
+
+
+class VersionMismatchError(RetraceError):
+    """Recording and replay versions don't match."""
+    pass
+
+
+class RecordingNotFoundError(RetraceError):
+    """Recording path does not exist."""
+    pass

retracesoftware/install/modulepatcher.py

@@ -0,0 +1,506 @@
+import retracesoftware.utils as utils
+import retracesoftware.functional as functional
+from functools import wraps
+import inspect
+import gc
+import importlib
+import types
+import sys
+
+from retracesoftware.proxy.thread import start_new_thread_wrapper, counters
+from retracesoftware.install.typeutils import modify
+
+def find_attr(mro, name):
+    for cls in mro:
+        if name in cls.__dict__:
+            return cls.__dict__[name]
+
+def is_descriptor(obj):
+    return hasattr(obj, '__get__') or hasattr(obj, '__set__') or hasattr(obj, '__delete__')
+
+def resolve(path):
+    module, sep, name = path.rpartition('.')
+    if module == None: module = 'builtins'
+    
+    return getattr(importlib.import_module(module), name)
+
+def phase(func):
+    func.is_phase = True  # add marker attribute
+    return func
+
+def replace(replacements, coll):
+    return map(lambda x: replacements.get(x, x), coll)
+
+def container_replace(container, old, new):
+    if isinstance(container, dict):
+        if old in container:
+            elem = container.pop(old)
+            container[new] = elem
+            container_replace(container, old, new)
+        else:
+            for key,value in container.items():
+                if key != '__retrace_unproxied__' and value is old:
+                    container[key] = new
+        return True
+    elif isinstance(container, list):
+        for i,value in enumerate(container):
+            if value is old:
+                container[i] = new
+        return True
+    elif isinstance(container, set):
+        container.remove(old)
+        container.add(new)
+        return True
+    else:
+        return False
+
+def select_keys(keys, dict):
+    return {key: dict[key] for key in keys if key in dict}
+
+def map_values(f, dict):
+    return {key: f(value) for key,value in dict.items()}
+
+def common_keys(dict, *dicts):
+    common_keys = utils.set(dict)
+    for d in dicts:
+        common_keys &= d.keys()
+
+    assert isinstance(common_keys, utils.set)
+
+    return common_keys
+
+def intersection(*dicts):
+    return { key: tuple(d[key] for d in dicts) for key in common_keys(*dicts) }
+
+def intersection_apply(f, *dicts):
+    return map_values(lambda vals: f(*vals), intersection(*dicts))
+
+def patch(func):
+    @wraps(func)
+    def wrapper(self, spec, mod_dict):
+        if isinstance(spec, str):
+            return wrapper(self, [spec], mod_dict)
+        elif isinstance(spec, list):
+            res = {}
+            for name in spec:
+                if name in mod_dict:
+                    value = func(self, mod_dict[name])
+                    if value is not None:
+                        res[name] = value
+            return res
+        elif isinstance(spec, dict):
+            # return {name: func(self, mod_dict[name], value) for name, value in spec.items() if name in mod_dict}
+            res = {}
+            for name,value in spec.items():
+                if name in mod_dict:
+                    value = func(self, mod_dict[name], value)
+                    if value is not None:
+                        res[name] = value
+            return res
+        else:
+            raise Exception('TODO')
+
+    wrapper.is_phase = True  
+    return wrapper
+
+def is_special(name):
+    return len(name) > 4 and name.startswith('__') and name.endswith('__')
+
+def superdict(cls):
+    result = {}
+    for cls in list(reversed(cls.__mro__))[1:]:
+        result.update(cls.__dict__)
+    
+    return result
+
+def wrap_method_descriptors(wrapper, prefix, base):
+    slots = {"__slots__": () }
+
+    extended = type(f'{prefix}.{base.__module__}.{base.__name__}', (base,), {"__slots__": () })
+
+    blacklist = ['__getattribute__', '__hash__', '__del__']
+
+    for name,value in superdict(base).items():
+        if name not in blacklist:
+            if utils.is_method_descriptor(value):
+                setattr(extended, name, wrapper(value))
+
+    return extended
+
+class ElementPatcher:
+
+    def __init__(self, config, phases):
+        funcs = {}
+
+        for phase in phases:
+            if phase.name in config:
+                for key,func in phase(config[phase.name]).items():
+                    val = funcs.get(key, [])
+                    val.append(func)
+                    funcs[key] = val
+
+        self.funcs = utils.map_values(lambda funcs: functional.sequence(*funcs), funcs)
+        self.fallback = None
+
+        if 'default' in config:
+            default_name = config['default']
+            for phase in phases:
+                if phase.name == default_name:
+                    self.fallback = phase.patch
+            
+    def __call__(self, name, value):
+        if name in self.funcs:
+            return self.funcs[name](value)
+        elif not is_special(name) and self.fallback:
+            return self.fallback(value)
+        else:
+            return value
+
+# class Patcher:
+
+#     def __init__(self, config):
+        
+#         self.config = config
+#         self.phases = []
+#         self.patched = {}
+
+#         # system.set_thread_id(0)
+#         # self.thread_counter = system.sync(utils.counter(1))
+#         # self.module_config = module_config
+
+#         # self.thread_state = thread_state
+#         # self.debug_level = debug_level
+#         # self.on_function_proxy = on_function_proxy
+#         # self.modules = config['modules']
+#         # self.immutable_types_set = immutable_types
+#         # self.predicate = PredicateBuilder()
+#         # self.system = system        
+#         # self.type_attribute_filter = self.predicate(config['type_attribute_filter'])
+#         # self.post_commit = post_commit
+#         # self.exclude_paths = [re.compile(s) for s in config.get('exclude_paths', [])]
+#         # self.typepatcher = {}
+#         # self.originals = {}
+
+#         # def is_phase(name): return getattr(getattr(self, name, None), "is_phase", False)
+        
+#         # self.phases = [(name, getattr(self, name)) for name in Patcher.__dict__.keys() if is_phase(name)]
+
+#     def add_phase(self, phase):
+#         self.phases.append(phase)
+
+#     # def log(self, *args):
+#     #     self.system.tracer.log(*args)
+
+#     def path_predicate(self, path):
+#         for exclude in self.exclude_paths:
+#             if exclude.match(str(path)) is not None:
+#                 # print(f'in path_predicate, excluding {path}')
+#                 return False
+#         return True
+
+#     # def on_proxytype(self, cls):
+
+#     #     def patch(spec):
+#     #         for method, transform in spec.items():                
+#     #             setattr(cls, method, resolve(transform)(getattr(cls, method)))
+
+#     #     if cls.__module__ in self.modules:
+#     #         spec = self.modules[cls.__module__]
+
+#     #         if 'patchtype' in spec:
+#     #             patchtype = spec['patchtype']
+#     #             if cls.__name__ in patchtype:
+#     #                 patch(patchtype[cls.__name__])
+
+#     @property
+#     def disable(self):
+#         return self.thread_state.select('disabled')
+    
+#     def proxyable(self, name, obj):
+#         if name.startswith('__') and name.endswith('__'):
+#             return False
+        
+#         if isinstance(obj, (str, int, dict, list, tuple)):
+#             return False
+        
+#         if isinstance(obj, type):
+#             return not issubclass(obj, BaseException) and obj not in self.immutable_types_set
+
+class Patcher:
+
+    def __init__(self, config):
+        
+        self.config = config
+        self.phases = []
+        self.patched = {}
+
+    def add_phase(self, phase):
+        self.phases.append(phase)
+
+    def path_predicate(self, path):
+        for exclude in self.exclude_paths:
+            if exclude.match(str(path)) is not None:
+                # print(f'in path_predicate, excluding {path}')
+                return False
+        return True
+
+    @property
+    def disable(self):
+        return self.thread_state.select('disabled')
+    
+    def proxyable(self, name, obj):
+        if name.startswith('__') and name.endswith('__'):
+            return False
+        
+        if isinstance(obj, (str, int, dict, list, tuple)):
+            return False
+        
+        if isinstance(obj, type):
+            return not issubclass(obj, BaseException) and obj not in self.immutable_types_set
+        else:
+            return type(obj) not in self.immutable_types_set
+
+    @phase
+    def proxy_type_attributes(self, spec, mod_dict):
+        for classname, attributes in spec.items():
+            if classname in mod_dict:
+                cls = mod_dict[classname]
+                if isinstance(cls, type):
+                    for name in attributes:
+                        attr = find_attr(cls.__mro__, name)
+                        if attr is not None and (callable(attr) or is_descriptor(attr)):
+                            proxied = self.system(attr)
+                            # proxied = self.proxy(attr)
+
+                            with modify(cls):
+                                setattr(cls, name, proxied)
+                else:
+                    raise Exception(f"Cannot patch attributes for {cls.__module__}.{cls.__name__} as object is: {cls} and not a type")
+
+    @phase
+    def replace(self, spec, mod_dict):
+        return {key: resolve(value) for key,value in spec.items()}
+
+    @patch
+    def patch_start_new_thread(self, value):
+        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)
+                
+        #         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 self.thread_state.dispatch(value, internal = start_new_thread)
+
+    @phase
+    def wrappers(self, spec, mod_dict): 
+        return intersection_apply(lambda path, value: resolve(path)(value), spec, mod_dict)
+
+    @patch
+    def patch_exec(self, exec):
+
+        def is_module(source, *args):
+            return isinstance(source, types.CodeType) and source.co_name == '<module>'
+        
+        def after_exec(source, globals = None, locals = None):
+            if isinstance(source, types.CodeType) and source.co_name == '<module>' and '__name__' in globals:
+                self(sys.modules[globals['__name__']])
+        
+        def first(x): return x[0]
+            
+        def disable(func): return self.thread_state.wrap('disabled', func)
+    
+        return self.thread_state.dispatch(
+            exec, 
+            internal = functional.sequence(
+                functional.juxt(exec, functional.when(is_module, disable(after_exec))), first))
+    
+    # self.thread_state.wrap(desired_state = 'disabled', function = exec_wrapper)
+
+    @patch
+    def sync_types(self, value):
+        return wrap_method_descriptors(self.system.sync, "retrace", value)
+
+    @phase
+    def with_state_recursive(self, spec, mod_dict):
+
+        updates = {}
+
+        for state,elems in spec.items():
+
+            def wrap(obj): 
+                return functional.recurive_wrap_function(
+                    functional.partial(self.thread_state.wrap, state),
+                    obj)
+            
+            updates.update(map_values(wrap, select_keys(elems, mod_dict)))
+        
+        return updates
+
+    @phase
+    def methods_with_state(self, spec, mod_dict):
+
+        # updates = {}
+
+        def update(cls, name, f):
+            setattr(cls, name, f(getattr(cls, name)))
+
+        for state,cls_methods in spec.items():
+            def wrap(obj): 
+                assert callable(obj)
+                return self.thread_state.wrap(desired_state = state, function = obj)
+
+            for typename,methodnames in cls_methods.items():
+                cls = mod_dict[typename]
+
+                for methodname in methodnames:
+                    update(cls, methodname, wrap)
+        
+        return {}
+
+    @phase
+    def with_state(self, spec, mod_dict):
+
+        updates = {}
+
+        for state,elems in spec.items():
+
+            def wrap(obj): 
+                return self.thread_state.wrap(desired_state = state, function = obj)
+
+            updates.update(map_values(wrap, select_keys(elems, mod_dict)))
+        
+        return updates
+
+    @patch
+    def patch_extension_exec(self, exec):
+        
+        def first(x): return x[0]
+
+        def disable(func): return self.thread_state.wrap('disabled', func)
+    
+        return self.thread_state.dispatch(exec, 
+                                   internal = functional.sequence(functional.juxt(exec, disable(self)), first))
+        
+        # def wrapper(module):
+        #     with self.thread_state.select('internal'):
+        #         res = exec(module)
+
+        #     self(module)
+        #     return res
+
+        # return wrapper
+
+    @patch
+    def path_predicates(self, func, param):
+        signature = inspect.signature(func).parameters
+
+        try:
+            index = list(signature.keys()).index(param)
+        except ValueError:
+            print(f'parameter {param} not in: {signature.keys()} {type(func)} {func}')
+            raise
+        
+        param = functional.param(name = param, index = index)
+
+        assert callable(param)
+        
+        return functional.if_then_else(
+            test = functional.sequence(param, self.path_predicate),
+            then = func, 
+            otherwise = self.thread_state.wrap('disabled', func)) 
+        
+    @phase
+    def wrap(self, spec, mod_dict):
+        updates = {}
+
+        for path, wrapper_name in spec.items():
+
+            parts = path.split('.')
+            name = parts[0]
+            if name in mod_dict:
+                value = mod_dict[name]
+                assert not isinstance(value, utils.wrapped_function), \
+                    f"value for key: {name} is already wrapped"
+                
+                if len(parts) == 1:
+                    updates[name] = resolve(wrapper_name)(value)
+                elif len(parts) == 2:
+                    member = getattr(value, parts[1], None)
+                    if member:
+                        new_value = resolve(wrapper_name)(member)
+                        setattr(value, parts[1], new_value)
+                else:
+                    raise Exception('TODO')
+                
+        return updates
+
+    def find_phase(self, name):
+        for phase in self.phases:
+            if phase.name == name:
+                return phase
+
+        raise Exception(f'Phase: {name} not found')
+
+    # def run_transforms(self, config, obj):
+    #     if isinstance(config, str):
+    #         return find_phase(config).patch(obj)
+    #     else:
+    #         for name in config
+
+    def element_patcher(self, name):
+        if name in self.config:
+            return ElementPatcher(config = self.config[name], 
+                                  phases = self.phases)
+
+    def wrap_namespace(self, ns):
+        name = ns.get('__name__', None)
+        patcher = self.element_patcher(name)
+        print(f'wrap_namespace {name} {patcher}')
+        return utils.InterceptDict(ns, patcher) if patcher else ns
+
+    def update(self, old, new):
+        if isinstance(new, type) and isinstance(old, type) and issubclass(new, old):
+            for subclass in old.__subclasses__():
+                if subclass is not new:
+                    subclass.__bases__ = tuple(replace({old: new}, subclass.__bases__))
+
+        for ref in gc.get_referrers(old):
+            container_replace(container = ref, old = old, new = new)
+
+    def patch_loaded_module(self, mod_dict):
+        modname = mod_dict.get('__name__', None)
+        
+        print(f'Patching loaded module: {modname}')
+
+        if modname in self.config:
+            
+
+            originals = {}
+            self.patched[modname] = originals
+
+            patcher = self.element_patcher(modname)
+
+            for key in list(mod_dict.keys()):
+                original = mod_dict[key]
+                patched = patcher(key, original)
+
+                if patched is not original:
+                    self.update(old = original, new = patched)
+                    originals[key] = original
+                    assert mod_dict[key] is patched

retracesoftware/install/patcher.py

@@ -94,8 +94,13 @@ def patch_namespace(patcher, config, namespace, update_refs):
                     # print(f"patching: {name}")
 
                     value = namespace[name]
-                    new_value = func(value)
 
+                    try:
+                        new_value = func(value)
+                    except Exception as e:
+                        print(f"Error patching {name}, phase: {phase_name}: {e}")
+                        raise e
+                    
                     if value is not new_value:
                         namespace[name] = new_value
 

retracesoftware/modules.toml

@@ -366,9 +366,8 @@ proxy = ["SemLock", "sem_unlink"]
 #       "map_buffer": "ignore",
 #       "*": "proxy_if_function"
 #     },
-#     "psycopg2._psycopg": {
-#       "proxy_all_except": ["Error"]
-#     },
+["psycopg2._psycopg"]
+proxy = ["connect", "cursor", "connection"]
 
 #     "_weakrefset": {
 #       "WeakSet": "sync_type",

retracesoftware/proxy/proxysystem.py

@@ -16,8 +16,7 @@ import enum
 import functools
 import re
 
-class RetraceError(Exception):
-    pass
+from retracesoftware.exceptions import RetraceError
 
 def proxy(proxytype):
     return functional.spread(
@@ -403,8 +402,9 @@ class ProxySystem:
                 cls.__init_subclass__ = classmethod(init_subclass)
 
                 for subtype in get_all_subtypes(cls):
-                    init_subclass(subtype)
-                    utils.set_on_alloc(subtype, on_alloc)
+                    with WithoutFlags(subtype, "Py_TPFLAGS_IMMUTABLETYPE"):
+                        init_subclass(subtype)
+                        utils.set_on_alloc(subtype, on_alloc)
 
             cls.__retrace__ = self
 

retracesoftware/proxy/record.py

@@ -162,6 +162,21 @@ class RecordProxySystem(ProxySystem):
 
         def write_error(cls, val, traceback):
             assert isinstance(val, BaseException)
+            # if not isinstance(val, BaseException):
+            #     # Debug: something is passing wrong value type
+            #     import sys
+            #     print(f"DEBUG write_error called with:")
+            #     print(f"  cls={cls}, type={type(cls)}")
+            #     print(f"  val={val!r}, type={type(val)}")
+            #     print(f"  traceback={traceback}")
+            #     print(f"  sys.exc_info()={sys.exc_info()}")
+                
+            #     # Some C extensions (e.g. psycopg2) return plain strings as errors
+            #     # Wrap them in the exception class if possible
+            #     if isinstance(val, str) and isinstance(cls, type) and issubclass(cls, BaseException):
+            #         val = cls(val)
+            #     else:
+            #         val = RuntimeError(f"Non-exception error: {val}")
             error(cls, val)
         
         tracer = Tracer(tracing_config, writer = self.writer.handle('TRACE'))

retracesoftware/replay.py

@@ -8,6 +8,7 @@ from retracesoftware.proxy.replay import ReplayProxySystem
 import retracesoftware.utils as utils
 import json
 from retracesoftware.stackdifference import on_stack_difference
+from retracesoftware.exceptions import RecordingNotFoundError
 
 def parse_args():
     parser = argparse.ArgumentParser(
@@ -68,7 +69,7 @@ def main():
     path = Path(args.recording)
 
     if not path.exists():
-        raise Exception(f"Recording path: {path} does not exist")
+        raise RecordingNotFoundError(f"Recording path: {path} does not exist")
 
     settings = load_json(path / "settings.json")
 

retracesoftware/run.py

@@ -145,9 +145,9 @@ def run_python_command(argv):
     except ModuleNotFoundError:
         print(f"Error: No module named '{argv[1]}'", file=sys.stderr)
         return 1
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        return 1
+    # except Exception as e:
+    #     print(f"Error1234: {e}", file=sys.stderr)
+    #     raise e
     finally:
         sys.argv = original_argv
         os.chdir(original_cwd)

{retracesoftware_proxy-0.2.11.dist-info → retracesoftware_proxy-0.2.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: retracesoftware_proxy
-Version: 0.2.11
+Version: 0.2.14
 License: Apache-2.0
 Requires-Python: >=3.11
 Requires-Dist: retracesoftware_utils

{retracesoftware_proxy-0.2.11.dist-info → retracesoftware_proxy-0.2.14.dist-info}/RECORD

@@ -1,19 +1,21 @@
-retracesoftware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-retracesoftware/__main__.py,sha256=UxuQ6HM4HdHT_9Kvj6pZoE7aARoPnd_DITLDq3Ju1rw,9196
+retracesoftware/__init__.py,sha256=6hG8VXyXsdrmZr-txG_TZ1z61YnHtfXr0nLhWihXL9Y,330
+retracesoftware/__main__.py,sha256=DGCvchaF_wW1j_cirC1tu1QM1gBHE3i-69okn3LKEXM,9582
 retracesoftware/autoenable.py,sha256=s7dSykM0y3xVqRzrWouGgoed4-lMNRhdA7Gnm1f04NA,1772
 retracesoftware/config.json,sha256=Cw5YZCfTo8GLmtbTH2LYwST7wNe7925DAwsTtRIGhBE,3817
 retracesoftware/config.yaml,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-retracesoftware/modules.toml,sha256=rQkTbb8eU88JxHdht1sDV3vZvXQAUYBOuyG5xrIaFJw,14623
+retracesoftware/exceptions.py,sha256=8jT4tJrRRRh3nRERrsqaKgIJ3itb-VYumpa9UcoxF9o,647
+retracesoftware/modules.toml,sha256=Xu8B6H9HMM4ZaxiEPy9FGcMHBHsyBD1qR0weUXgau4Y,14613
 retracesoftware/preload.txt,sha256=8Wm8OWnDfEp9X4FN-yNQYLfZk_h36kMgHA_QUw_7Hbs,2370
-retracesoftware/replay.py,sha256=rKuhen_MDDi_5WVDmQgchxJ0ZrCbYL1yZZboZsu_q54,3601
-retracesoftware/run.py,sha256=dQ_yM5f7Mlb0NyZf0CysBX6d_j_IHtIB_NG1W6FGIuY,12207
+retracesoftware/replay.py,sha256=FEEenvRUeULmv-Zzb6g7Ub85oGonmvMT4ATE4q0yWqI,3676
+retracesoftware/run.py,sha256=Gi1TpMF30QLmiziCU7hu3zR_8Hr1R7Qx0TsiQOjLmzA,12216
 retracesoftware/stackdifference.py,sha256=nM9r5YHMCNQcrWozMjUX4ZTrZL5U0rQChSGzpiXy_DU,4466
 retracesoftware/install/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 retracesoftware/install/config.py,sha256=AnSlHI3lWQrPUg0fOS26PqXiq1hJSy56SwrNL8mbAG8,1546
 retracesoftware/install/edgecases.py,sha256=Ry3BETJ4Hmqpw9xXTlNeUgBL9q-sumaazqjmzZBRtD4,7265
 retracesoftware/install/globals.py,sha256=F8XvIoZQQ10gSRalk30dvdKllxlwxkaggYY6FogLDxY,510
 retracesoftware/install/install.py,sha256=HCD_ji8XCr96b5fNzNdL_8qcEp0Jf05Em7T6GA6u8HU,4969
-retracesoftware/install/patcher.py,sha256=sHgsKvdvjMJSVl8lOa3YiCjGf6zYhxgkWp67-ptJvlk,4157
+retracesoftware/install/modulepatcher.py,sha256=yBXrbfr5J9JQXCVbcNpDm8H17bsPbL6DY54bImFjBKM,16715
+retracesoftware/install/patcher.py,sha256=DL8GKQzxCSVdTXeexgRuPaKL51SsymcPpP6lUJ1Ezo8,4364
 retracesoftware/install/patchfindspec.py,sha256=uQkfdOQOY20hFAcwDAqx7m8rbtGM2rBKOfC3Szb1zhw,4942
 retracesoftware/install/phases.py,sha256=OWaw86xzC924tdIA9C-12Qdr3sCx67hEOn-Ih9FM--4,9359
 retracesoftware/install/predicate.py,sha256=tX7NQc0rGkyyHYO3mduYHcJHbw1wczT53m_Dpkzo6do,2679
@@ -28,15 +30,15 @@ retracesoftware/proxy/gateway.py,sha256=xESohWXkiNm4ZutU0RgWUwxjxcBWRQ4rQyxIGQXv
 retracesoftware/proxy/globalref.py,sha256=yXtJsOeBHN9xoEgJWA3MJco-jD2SQUef_fDatA4A6rg,803
 retracesoftware/proxy/messagestream.py,sha256=kjxIugCSr7YSJbIqsqqXeW7dyE2SzWow2E-UJnkAflk,5890
 retracesoftware/proxy/proxyfactory.py,sha256=qhOqDfMJnLDNkQs26JqDB431MwjjRhGQi8xupJ45asg,12272
-retracesoftware/proxy/proxysystem.py,sha256=Pj9sk5FE3Mfyf4-PAtXSz2Pvr_GwXcpfhUSJvkz00dg,15076
+retracesoftware/proxy/proxysystem.py,sha256=-uvTS6-9zyRVxpIhAqOXSAJuZWZfA1xVRLmUZW5M-HY,15172
 retracesoftware/proxy/proxytype.py,sha256=LZ1rNMsxXRUMdI4uTzDvGkUyPOYxCFroT_ZAtOGTbBk,14012
-retracesoftware/proxy/record.py,sha256=JTmeZ13ISbsVal1WOtae425DP0iA-QiAv0C6azPpV8k,6680
+retracesoftware/proxy/record.py,sha256=BfZap06nz2cr6eGgf3baMyyilqWipTXCjMB5_1ZIlSA,7522
 retracesoftware/proxy/replay.py,sha256=Kx4XrsP0T35IvTzf3pwhR24Lotoz43p7E8LBevEQHpE,4948
 retracesoftware/proxy/serializer.py,sha256=S5yhHoP2iYaXBY7Jr8Ei630Z31521x0IO6DeuClOD9s,958
 retracesoftware/proxy/startthread.py,sha256=YKUcOSjA-9_5ZsDHhyP0fXJSP3RWDKV-ajX-I0SI-bU,1270
 retracesoftware/proxy/stubfactory.py,sha256=fyQtCZnkXvLaTlGcxE0Lx8od09ZOgnPWPn0YvNFfVeQ,6219
 retracesoftware/proxy/thread.py,sha256=T1ME6DHB8O0xVnX3Rt1lMl7oCJ2Y0aoFT91D76yNICk,3073
-retracesoftware_proxy-0.2.11.dist-info/METADATA,sha256=qRuCC5mCi51x13S4_TAtxH0BAZQfLPeabyJdkbqALxQ,227
-retracesoftware_proxy-0.2.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-retracesoftware_proxy-0.2.11.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
-retracesoftware_proxy-0.2.11.dist-info/RECORD,,
+retracesoftware_proxy-0.2.14.dist-info/METADATA,sha256=v8BpAX64SHWvNz8A-AzKC74Hax3eSzcuQ_cAMaJd96A,227
+retracesoftware_proxy-0.2.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+retracesoftware_proxy-0.2.14.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
+retracesoftware_proxy-0.2.14.dist-info/RECORD,,