retracesoftware-proxy 0.2.17__py3-none-any.whl → 0.2.19__py3-none-any.whl

retracesoftware/__main__.py

@@ -33,6 +33,24 @@ def dump_as_json(path, obj):
     with open(path, 'w') as f:
         json.dump(obj, f, indent=2)
 
+def load_env(file):
+    """Load a .env file into a dict."""
+    env = {}
+    with open(file, 'r') as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            if '=' in line:
+                key, value = line.split('=', 1)
+                # Remove surrounding quotes if present
+                if value.startswith('"') and value.endswith('"'):
+                    value = value[1:-1]
+                # Unescape
+                value = value.replace('\\n', '\n').replace('\\"', '"').replace('\\\\', '\\')
+                env[key] = value
+    return env
+
 vscode_workspace = {
     "folders": [{ 'path': '.' }],
     "settings": {
@@ -74,6 +92,28 @@ def file_md5(path):
 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 diff_dicts(recorded, current, path=""):
+    """Recursively diff two dicts, returning list of differences."""
+    diffs = []
+    all_keys = set(recorded.keys()) | set(current.keys())
+    
+    for key in sorted(all_keys):
+        key_path = f"{path}.{key}" if path else key
+        
+        if key not in recorded:
+            diffs.append(f"  + {key_path}: (new in current)")
+        elif key not in current:
+            diffs.append(f"  - {key_path}: (missing in current)")
+        elif recorded[key] != current[key]:
+            if isinstance(recorded[key], dict) and isinstance(current[key], dict):
+                diffs.extend(diff_dicts(recorded[key], current[key], key_path))
+            else:
+                diffs.append(f"  ! {key_path}:")
+                diffs.append(f"      recorded: {recorded[key][:16]}..." if isinstance(recorded[key], str) and len(recorded[key]) > 16 else f"      recorded: {recorded[key]}")
+                diffs.append(f"      current:  {current[key][:16]}..." if isinstance(current[key], str) and len(current[key]) > 16 else f"      current:  {current[key]}")
+    
+    return diffs
+
 def retrace_extension_paths():
     names = ['_retracesoftware_utils_release', '_retracesoftware_utils_debug', 
              '_retracesoftware_functional_release', '_retracesoftware_functional_debug', 
@@ -88,33 +128,55 @@ def retrace_module_paths():
 def checksums():
     return {name: checksum(path) for name, path in retrace_module_paths().items()}
 
+def run_create_tracedir_cmd(create_tracedir_cmd, path):
+    import subprocess
+    result = subprocess.run([create_tracedir_cmd, str(path)], capture_output=True, text=True)
+    if result.returncode != 0:
+        msg = f"create_tracedir_cmd '{create_tracedir_cmd}' failed with exit code {result.returncode}"
+        if result.stdout:
+            msg += f"\nstdout: {result.stdout}"
+        if result.stderr:
+            msg += f"\nstderr: {result.stderr}"
+        raise ConfigurationError(msg)
+    if not path.exists():
+        raise ConfigurationError(f"create_tracedir_cmd '{create_tracedir_cmd}' exited successfully but directory '{path}' does not exist")
+
 def record(options, args):
     
+    if options.verbose:
+        print(f"Retrace enabled, recording to {options.recording}", file=sys.stderr)
+
     path = Path(expand_recording_path(options.recording))
-    # ensure the path exists
-    path.mkdir(parents=True, exist_ok=True) 
+    
+    # Create trace directory via custom command or default mkdir
+    if options.create_tracedir_cmd:
+        run_create_tracedir_cmd(options.create_tracedir_cmd, path)
+    else:
+        path.mkdir(parents=True, exist_ok=True) 
 
     from retracesoftware.install import edgecases
     edgecases.recording_path = path
 
     # write various recording files to directory
+    path_info = stream.get_path_info()
     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,
-        'env': dict(os.environ),
         'python_version': sys.version,
-        'md5_checksums': checksums(),
+        'cwd': path_info['cwd'],
+        'sys_path': path_info['sys_path'],
     })
-
-    rundir = path / 'run'
-    rundir.mkdir(exist_ok=True)
-
-    script = Path(scriptname(args))
-    if script.exists():
-        copy2(script, rundir)
+    dump_as_json(path / 'md5_checksums.json', checksums())
+    
+    # Write env to standard .env file
+    with open(path / '.env', 'w') as f:
+        for key, value in os.environ.items():
+            # Escape newlines and quotes for .env format
+            escaped = value.replace('\\', '\\\\').replace('\n', '\\n').replace('"', '\\"')
+            f.write(f'{key}="{escaped}"\n')
 
     # create a .venv directory in the recording path
     # venv_path = path / '.venv'
@@ -175,24 +237,32 @@ def record(options, args):
         gc.callbacks.remove(system.on_gc_event)
 
 def replay(args):
-    path = Path(args.recording)
+    # Resolve path before any chdir
+    path = Path(args.recording).resolve()
 
     if not path.exists():
         raise RecordingNotFoundError(f"Recording path: {path} does not exist")
 
     settings = load_json(path / "settings.json")
+    recorded_checksums = load_json(path / "md5_checksums.json")
 
-    if settings['md5_checksums'] != checksums():
-        raise VersionMismatchError("Checksums for Retrace do not match, cannot run replay with different version of retrace to record")
+    current_checksums = checksums()
+    if recorded_checksums != current_checksums:
+        diffs = diff_dicts(recorded_checksums, current_checksums)
+        diff_str = "\n".join(diffs) if diffs else "(no differences found in structure)"
+        raise VersionMismatchError(f"Checksums for Retrace do not match:\n{diff_str}")
 
     if settings['python_version'] != sys.version:
         raise VersionMismatchError("Python version does not match, cannot run replay with different version of Python to record")
 
-    os.environ.update(settings['env'])
+    os.environ.update(load_env(path / '.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']}")
 
+    # Change to recorded cwd - replay from same directory as recording
+    os.chdir(settings['cwd'])
+
     thread_state = utils.ThreadState(*thread_states)
 
     # with stream.reader(path = path / 'trace.bin',
@@ -223,6 +293,7 @@ def replay(args):
         gc.collect()
         gc.disable()
 
+        # Use original argv - scripts are now relative to cwd (recording/run)
         run_with_retrace(system, settings['argv'], settings['trace_shutdown'])
 
 def main():
@@ -269,6 +340,13 @@ def main():
             help='Whether to write call parameters, used for debugging'
         )
 
+        parser.add_argument(
+            '--create_tracedir_cmd',
+            type=str,
+            default=None,
+            help='Command to create trace directory (receives directory path as argument)'
+        )
+
         parser.add_argument('rest', nargs = argparse.REMAINDER, help='target application and arguments')
 
         args = parser.parse_args()

retracesoftware/autoenable.py

@@ -51,6 +51,10 @@ else:
             if is_true('RETRACE_TRACE_INPUTS'):
                 new_argv.append('--trace_inputs')
 
+            if 'RETRACE_CREATE_TRACEDIR_CMD' in os.environ:
+                new_argv.append('--create_tracedir_cmd')
+                new_argv.append(os.environ['RETRACE_CREATE_TRACEDIR_CMD'])
+
             new_argv.append('--')
             new_argv.extend(sys.orig_argv[1:])
             

retracesoftware/install/patcher.py

@@ -61,12 +61,39 @@ def create_patcher(system):
 
     per_thread = PerThread()
         
+    # Hash patching for deterministic record/replay
+    # 
+    # Why we patch __hash__:
+    # Python's default object hashes are based on memory addresses, which vary
+    # between runs. Sets iterate in hash order, so iteration order is 
+    # non-deterministic. For record/replay to work correctly, we need identical
+    # set iteration order during both phases, so we replace __hash__ with a
+    # deterministic counter-based hash that returns stable values.
+    # (Note: dicts maintain insertion order since Python 3.7, so they're stable.)
+    #
+    # The hashfunc dispatches based on thread state:
+    # - disabled: returns None (unhashable, triggers fallback)
+    # - internal: counter for when thread is inside the sandbox (proxied code)
+    # - external: counter for when thread is outside the sandbox (user code)
+    #
+    # IMPORTANT - Python 3.12 compatibility:
+    # Python 3.12 changed typing._tp_cache to use a global _caches dict with
+    # functions as keys (see bpo GH-98253). If typing is imported BEFORE we
+    # patch FunctionType.__hash__, those functions won't be in our internal
+    # hash cache, and lookups will fail. utils.patch_hash handles this by
+    # pre-populating the cache with all existing instances of the patched type.
+    #
     hashfunc = system.thread_state.dispatch(
         functional.constantly(None),
         internal = functional.repeatedly(functional.partial(getattr, per_thread, 'internal')),
         external = functional.repeatedly(functional.partial(getattr, per_thread, 'external')))
 
     def patch_hash(obj):
+        """Patch __hash__ on a type to use deterministic counter-based hashing.
+        
+        This ensures stable set iteration order for instances of this type,
+        which is required for record/replay consistency.
+        """
         if not isinstance(obj, type):
             raise Exception("TODO")
 

retracesoftware/install/patchfindspec.py

@@ -1,117 +1,23 @@
-from functools import wraps
 import os
 from pathlib import Path
-import shutil
-import sys
 
-# Set to track copied modules
-copied_modules = set()
-
-def get_relative_path(module_path: Path, sys_path: list) -> Path:
-    """Compute the relative path of module_path relative to sys.path entries."""
-    module_path = module_path.resolve()
-    for base in sys_path:
-        base_path = Path(base).resolve()
-        try:
-            if module_path.is_relative_to(base_path):
-                return module_path.relative_to(base_path)
-        except ValueError:
-            continue
-    return Path(module_path.name)
+# Set to track logged modules (avoid duplicates)
+logged_modules = set()
 
 class patch_find_spec:
-    def __init__(self, cwd, run_path, python_path):
-        self.cwd = cwd
-        self.run_path = run_path
-        self.python_path = python_path
+    """
+    Hook that logs accessed module file paths to a file.
+    One absolute path per line.
+    """
+    def __init__(self, output_file):
+        self.output_file = output_file
 
     def __call__(self, spec):
         if spec is not None and spec.origin and spec.origin != "built-in" and os.path.isfile(spec.origin):
             module_name = spec.name
-            if module_name not in copied_modules:
-                module_path = Path(spec.origin)
-
-                dest_path = None
-
-                if module_path.is_relative_to(self.cwd):
-                    dest_path = self.run_path / module_path.relative_to(self.cwd)
-                elif self.python_path:
-                    relative_path = get_relative_path(module_path, sys.path)
-                    dest_path = self.python_path / relative_path
-
-                if dest_path:
-                    dest_path.parent.mkdir(parents=True, exist_ok=True)
-                    shutil.copy2(module_path, dest_path)
-                    copied_modules.add(module_name)
-
-    # def __call__(self, fullname, path, target=None):
-    #     spec = self.original_find_spec(fullname, path, target)
-
-    #     if spec is not None and spec.origin and spec.origin != "built-in" and os.path.isfile(spec.origin):
-    #         module_name = spec.name
-    #         if module_name not in copied_modules:
-    #             module_path = Path(spec.origin)
-
-    #             dest_path = None
-
-    #             if module_path.is_relative_to(self.cwd):
-    #                 dest_path = self.run_path / module_path.relative_to(self.cwd)
-    #             elif self.python_path:
-    #                 relative_path = get_relative_path(module_path, sys.path)
-    #                 dest_path = self.python_path / relative_path
-
-    #             if dest_path:
-    #                 dest_path.parent.mkdir(parents=True, exist_ok=True)
-    #                 shutil.copy2(module_path, dest_path)
-    #                 copied_modules.add(module_name)
-
-    #     return spec
-
-# def patch_find_spec(cwd, run_path, python_path, original_find_spec):
-#     """Create a patched version of find_spec that copies .py files."""
-#     @wraps(original_find_spec)
-#     def patched_find_spec(fullname, path, target=None):
-#         spec = original_find_spec(fullname, path, target)
-
-#         if spec is not None and spec.origin and spec.origin != "built-in" and os.path.isfile(spec.origin):
-#             module_name = spec.name
-#             if module_name not in copied_modules:
-#                 module_path = Path(spec.origin)
-
-#                 dest_path = None
-
-#                 if module_path.is_relative_to(cwd):
-#                     dest_path = run_path / module_path.relative_to(cwd)
-#                 elif python_path:
-#                     relative_path = get_relative_path(module_path, sys.path)
-#                     dest_path = python_path / relative_path
-
-#                 if dest_path:
-#                     dest_path.parent.mkdir(parents=True, exist_ok=True)
-#                     shutil.copy2(module_path, dest_path)
-#                     copied_modules.add(module_name)
-
-#                 # elif python_path:
-#                 #     relative_path = get_relative_path(module_path, sys.path)
-#                 #     dest_path = python_path / relative_path
-#                 #     dest_path.parent.mkdir(parents=True, exist_ok=True)
-
-#                 #     shutil.copy2(module_path, dest_path)
-#                 #     copied_modules.add(module_name)
-
-#                     # if module_path.suffix == '.py':
-#                 # elif module_path.suffix == '.py':
-#                 #     relative_path = get_relative_path(module_path, sys.path)
-#                 #     dest_path = path / relative_path
-#                 #     dest_path.parent.mkdir(parents=True, exist_ok=True)
-#                 #     try:
-#                 #         shutil.copy2(module_path, dest_path)
-#                 #         print(f"Copied {module_path} to {dest_path} (relative: {relative_path})")
-#                 #         copied_modules.add(module_name)
-#                 #     except Exception as e:
-#                 #         print(f"Failed to copy {module_path}: {e}")
-#                 # else:
-#                 #     print(f"Skipped copying {module_path} (not a .py file)")
-
-#         return spec
-#     return patched_find_spec
+            if module_name not in logged_modules:
+                # Write absolute path to output file
+                abs_path = os.path.realpath(spec.origin)
+                self.output_file.write(abs_path + '\n')
+                self.output_file.flush()
+                logged_modules.add(module_name)

retracesoftware/run.py

@@ -133,13 +133,11 @@ def run_python_command(argv):
                 print(f"Error: Not a Python script: {script_path}", file=sys.stderr)
                 return 1
 
-            full_path = str(path.resolve())
-            sys.argv = [full_path] + script_args
+            # Use the path as given (relative or absolute) to preserve cwd-relative paths
+            # for stack trace normalization during record/replay
+            sys.argv = [script_path] + script_args
 
-            # Change to script's directory
-            os.chdir(path.parent)
-
-            runpy.run_path(full_path, run_name="__main__")
+            runpy.run_path(script_path, run_name="__main__")
             return 0
 
     except ModuleNotFoundError:

{retracesoftware_proxy-0.2.17.dist-info → retracesoftware_proxy-0.2.19.dist-info}/METADATA

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

{retracesoftware_proxy-0.2.17.dist-info → retracesoftware_proxy-0.2.19.dist-info}/RECORD

@@ -1,29 +1,21 @@
 retracesoftware/__init__.py,sha256=jQw15XBREFZX93BHpvREfc-hQmMUHYtO6gO-qZmdW1o,482
-retracesoftware/__main__.py,sha256=tJR_vKz6-WRCXlioto2PP92SC_K-GPAKoT05fsA8Px0,9761
-retracesoftware/autoenable.py,sha256=6KxpaPpeleSN7-qmekA4w2HJQaet_9Flt9WikQvyN04,1808
+retracesoftware/__main__.py,sha256=oTpF0ev2yJrrhROIJroT5UqJPRQWdBYrfUWwctOywrY,13375
+retracesoftware/autoenable.py,sha256=LVt6KfMIIScV5b4dsXP_DHlrRm1i5iIGfVauup61YtE,2001
 retracesoftware/config.json,sha256=Cw5YZCfTo8GLmtbTH2LYwST7wNe7925DAwsTtRIGhBE,3817
 retracesoftware/config.yaml,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=FEEenvRUeULmv-Zzb6g7Ub85oGonmvMT4ATE4q0yWqI,3676
 retracesoftware/retrace.pth,sha256=umCRQITpnqAp1N-svTCi4lJxOo7GihDrLtO3pA2wwgM,35
-retracesoftware/run.py,sha256=Gi1TpMF30QLmiziCU7hu3zR_8Hr1R7Qx0TsiQOjLmzA,12216
+retracesoftware/run.py,sha256=h0t4ZO9-JHXZ4mjgwXNGSGL1UFxh7pKdr_wvokkJ-PY,12253
 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=fP7E9OWiQd1Dgi4jL8rL9T5SXW5AL62BM3NEW61fisw,4969
-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
-retracesoftware/install/record.py,sha256=0iV9zMnO7aMUx8HDkni1eeopC3lWR5J6sDwxY6bgeX0,5861
-retracesoftware/install/references.py,sha256=A-G651IDOfuo00MkbAdpbIQh_15ChvJ7uAVTSmE6zd4,1721
+retracesoftware/install/patcher.py,sha256=Z98ux8SDw53wyRKCevOT-tPOFcwcM3KH1dyR7Tg_TJ4,5859
+retracesoftware/install/patchfindspec.py,sha256=oOjmsVsTSfex3ined3kcZ4iLh0emsx2Q5dB2_YVd62I,792
 retracesoftware/install/replace.py,sha256=FYiSJtNrXEhl-H6M5tJm0kbliBA0sZdxE0306pr-YQg,872
-retracesoftware/install/replay.py,sha256=bB2eMpIP2vXZzeJ98jtlkGSE1DEYWk3olUbiBQcdVj0,3539
 retracesoftware/install/tracer.py,sha256=VfjghYepk2M2DLy1nEYgHcaCXo0616OVMxxx3A3dNhM,9363
 retracesoftware/install/typeutils.py,sha256=GiYDPsKGBtp0_1E71AJm16u03L8eSoR1piz3yvOgAhk,2253
 retracesoftware/proxy/__init__.py,sha256=ntIyqKhBRkKEkcW_oOPodikh-mxYl8OXRnSaj-9-Xwc,178
@@ -39,7 +31,7 @@ retracesoftware/proxy/serializer.py,sha256=S5yhHoP2iYaXBY7Jr8Ei630Z31521x0IO6Deu
 retracesoftware/proxy/startthread.py,sha256=YKUcOSjA-9_5ZsDHhyP0fXJSP3RWDKV-ajX-I0SI-bU,1270
 retracesoftware/proxy/stubfactory.py,sha256=fyQtCZnkXvLaTlGcxE0Lx8od09ZOgnPWPn0YvNFfVeQ,6219
 retracesoftware/proxy/thread.py,sha256=AAj6BL4kw-KMHX4fV66LuePQbTYvPmI3IY8ZwV069nI,3073
-retracesoftware_proxy-0.2.17.dist-info/METADATA,sha256=_t4czKiwu0bwCYVOr24gXZS_QlH4cufaqEIn5f97asM,227
-retracesoftware_proxy-0.2.17.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-retracesoftware_proxy-0.2.17.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
-retracesoftware_proxy-0.2.17.dist-info/RECORD,,
+retracesoftware_proxy-0.2.19.dist-info/METADATA,sha256=sUiA5tyrwKB5INk9509ZpTYDjFSbR_2x60bPC9cIOpY,227
+retracesoftware_proxy-0.2.19.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+retracesoftware_proxy-0.2.19.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
+retracesoftware_proxy-0.2.19.dist-info/RECORD,,

retracesoftware/install/install.py

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-import retracesoftware.functional as functional
-import retracesoftware.utils as utils
-
-# from retracesoftware_functional import mapargs, walker, first_arg, if_then_else, compose, observer, anyargs, memoize_one_arg, side_effect, partial, threadwatcher, firstof, notinstance_test, instance_test,typeof, isinstanceof, always
-# from retracesoftware.proxy.proxy import ProxyFactory, InternalProxy, ProxySpec, WrappingProxySpec, ExtendingProxySpec, ExtendingProxy
-from retracesoftware_proxy import thread_id
-# from retracesoftware_stream import ObjectWriter, ObjectReader
-import retracesoftware.stream as stream
-
-# from retracesoftware_utils import visitor
-from retracesoftware.install.tracer import Tracer
-from retracesoftware.proxy.record import RecordProxySystem
-from retracesoftware.proxy.replay import ReplayProxySystem
-from datetime import datetime
-
-import os
-import sys
-import json
-import enum
-import _thread
-import pickle
-import weakref
-import types
-from pathlib import Path
-import glob, os
-import re
-
-# from retracesoftware_proxy import *
-# from retracesoftware_utils import *
-# from retracesoftware.proxy import references
-from retracesoftware.install import patcher
-from retracesoftware.install.config import load_config
-# from retracesoftware.proxy.immutabletypes import ImmutableTypes
-# from retracesoftware.proxy import edgecases
-from retracesoftware.install import globals
-# from retracesoftware.proxy.record import RecordProxyFactory
-
-
-class DebugWriter:
-    __slot__ = ['checkpoint']
-
-    def __init__(self, checkpoint):
-        self.checkpoint = checkpoint
- 
-    def write_call(self, func, *args, **kwargs):
-        self.checkpoint({'type': 'call', 'func': ...})
-
-    def write_result(self, res):
-        self.checkpoint({'type': 'result', 'result': res})
-
-    def write_error(self, *args):
-        self.checkpoint({'type': 'error', 'error': tuple(args)})
-
-class MethodDescriptor:
-    def __init__(self, descriptor):
-        self.cls = descriptor.__objclass__
-        self.name = descriptor.name
-
-def once(*args): return functional.memoize_one_arg(functional.sequence(*args))
-
-any = functional.firstof
-
-
-def compose(*args):
-    new_args = [item for item in args if item is not None]
-    if len(new_args) == 0:
-        raise Exception('TODO')
-    elif len(new_args) == 1:
-        return new_args[0]
-    else:
-        return functional.compose(*new_args)
-
-class SerializedWrappedFunction:
-    def __init__(self, func):
-        if hasattr(func, '__objclass__'):
-            self.cls = func.__objclass__
-        elif hasattr(func, '__module__'):
-            self.module = func.__module__
-    
-        if hasattr(func, '__name__'):
-            self.name = func.__name__
-
-
-def replaying_proxy_factory(thread_state, is_immutable_type, tracer, next, bind, checkpoint):
-
-    # def on_new_ext_proxytype(proxytype):
-    #     assert not issubclass(proxytype, DynamicProxy)
-    #     bind(proxytype)
-        # writer.add_type_serializer(cls = proxytype, serializer = functional.typeof)
-
-    # bind_new_int_proxy = functional.if_then_else(functional.isinstanceof(InternalProxy), functional.memoize_one_arg(bind), None)
-        
-    # on_ext_call = utils.visitor(from_arg = 1, function = bind_new_int_proxy)
-
-    def wrap_int_call(handler):
-        return functional.observer(
-            on_call = tracer('proxy.int.call'),
-            on_result = tracer('proxy.int.result'),
-            on_error = tracer('proxy.int.error'),
-            function = handler)
-    
-    # def is_stub_type(obj):
-    #     return type(obj) == type and issubclass(obj, (WrappingProxy, ExtendingProxy))
-
-    def is_stub_type(obj):
-        return type(obj) == type
-
-    create_stubs = functional.walker(functional.when(is_stub_type, utils.create_stub_object))
-    # create_stubs = functional.walker(functional.when(is_stub_type, utils.create_stub_object))
-
-    def wrap_ext_call(handler):
-        return functional.observer(
-            on_call = tracer('proxy.ext.call'),
-            on_result = tracer('proxy.ext.result'),
-            on_error = tracer('proxy.ext.error'),
-            function = functional.sequence(functional.always(next), create_stubs))
-
-    return ProxyFactory(thread_state = thread_state,
-                        is_immutable_type = is_immutable_type,
-                        tracer = tracer, 
-                        on_new_int_proxy = bind,
-                        # on_new_ext_proxytype = on_new_ext_proxytype,
-                        wrap_int_call = wrap_int_call,
-                        wrap_ext_call = wrap_ext_call)
-
-
-# class Reader:
-
-#     def __init__(self, objectreader):
-#         self.objectreader = objectreader
-
-#     self.objectreader()
-
-def tracing_config(config):
-    level = os.environ.get('RETRACE_DEBUG', config['default_tracing_level'])
-    return config['tracing_levels'].get(level, {})
-
-
-def install(create_system):
-    return patcher.install(config = load_config('config.json'), create_system = create_system)