retracesoftware-proxy 0.0.0__py3-none-any.whl

retracesoftware/run.py

@@ -0,0 +1,373 @@
+import sys
+import os
+import runpy
+from pathlib import Path
+# from retracesoftware.install.phases import *
+import pkgutil
+import tomllib
+import retracesoftware.functional as functional
+import builtins
+import importlib
+import _imp
+import importlib._bootstrap_external as _bootstrap_external
+import atexit
+import threading
+import _signal
+import retracesoftware.utils as utils
+from retracesoftware.install.patcher import patch_module, create_patcher, patch_imported_module
+from retracesoftware.proxy.startthread import patch_thread_start
+from retracesoftware.install.replace import update
+
+thread_states = [
+    "disabled", # Default state when retrace is disabled for a thread
+    "internal", # Default state when retrace is disabled for a thread
+    "external", # When target thread is running outside the python system to be recorded
+    "retrace", # When target thread is running outside the retrace system
+    "importing", # When target thread is running outside the retrace system
+    "gc", # When the target thread is running inside the pyton garbage collector
+]
+
+class ImmutableTypes(set):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def __contains__(self, item):
+        assert isinstance(item, type)
+
+        if super().__contains__(item):
+            return True
+
+        for elem in self:
+            if issubclass(item, elem):
+                self.add(item)
+                return True
+
+        return False            
+
+def load_module_config(filename):
+    data = pkgutil.get_data("retracesoftware", filename)
+    assert data is not None
+    return tomllib.loads(data.decode("utf-8"))
+
+def wait_for_non_daemon_threads(timeout=None):
+    """
+    Wait for all non-daemon threads to finish, just like Python does on exit.
+    
+    Args:
+        timeout (float, optional): Max seconds to wait. None = wait forever.
+    
+    Returns:
+        bool: True if all threads finished, False if timeout exceeded.
+    """
+    import threading
+    import time
+
+    start_time = time.time()
+    main_thread = threading.main_thread()
+
+    while True:
+        # Get all active threads
+        active = threading.enumerate()
+
+        # Filter: non-daemon and not the main thread
+        non_daemon_threads = [
+            t for t in active
+            if t is not main_thread and not t.daemon
+        ]
+
+        if not non_daemon_threads:
+            return True  # All done!
+
+        # Check timeout
+        if timeout is not None:
+            elapsed = time.time() - start_time
+            if elapsed >= timeout:
+                print(f"Timeout: {len(non_daemon_threads)} thread(s) still alive")
+                return False
+
+        # Sleep briefly to avoid busy-wait
+        time.sleep(0.1)
+
+def run_python_command(argv):
+    """
+    Run a Python app from a command list using runpy.
+
+    Supports:
+        ['-m', 'module', 'arg1', ...]     → like `python -m module arg1 ...`
+        ['script.py', 'arg1', ...]        → like `python script.py arg1 ...`
+
+    Args:
+        argv: List of command-line arguments (first item is either '-m' or script path)
+
+    Returns:
+        Exit code (0 on success, 1+ on error)
+    """
+    if not argv:
+        print("Error: No command provided", file=sys.stderr)
+        return 1
+
+    original_argv = sys.argv[:]
+    original_cwd = os.getcwd()
+
+    try:
+        if argv[0] == '-m':
+            if len(argv) < 2:
+                print("Error: -m requires a module name", file=sys.stderr)
+                return 1
+            module_name = argv[1]
+            module_args = argv[2:]
+            sys.argv = ['-m', module_name] + module_args
+            runpy.run_module(module_name, run_name="__main__")
+            return 0
+
+        else:
+            script_path = argv[0]
+            script_args = argv[1:]
+            path = Path(script_path)
+
+            if not path.exists():
+                print(f"Error: Script not found: {script_path}", file=sys.stderr)
+                return 1
+
+            if path.suffix != ".py":
+                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
+
+            # Change to script's directory
+            os.chdir(path.parent)
+
+            runpy.run_path(full_path, run_name="__main__")
+            return 0
+
+    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
+    finally:
+        sys.argv = original_argv
+        os.chdir(original_cwd)
+
+def patch_import(thread_state, patcher, sync, checkpoint):
+    # builtins.__import__ = thread_state.dispatch(builtins.__import__, internal = sync(thread_state.wrap('importing', builtins.__import__)))
+    # bi = builtins.__import__
+    # def foo(*args, **kwargs):
+    #     print(f'in patched __import__: {thread_state.value} {args[0]}')
+    #     if thread_state.value == 'internal':
+    #         with thread_state.select('importing'):
+    #             return bi(*args, **kwargs)
+    #     else:
+    #         return bi(*args, **kwargs)
+        
+    # builtins.__import__ = foo
+
+    builtins.__import__ = thread_state.dispatch(builtins.__import__, internal = thread_state.wrap('importing', builtins.__import__))
+
+    def exec(source, globals = None, locals = None):
+        checkpoint(f"exec module: {globals.get('__name__', 'unknown')}")
+        res = builtins.exec(source, globals, locals)
+        patcher(globals, False)
+        return res
+
+    def patch(module):
+        patcher(module.__dict__, False)
+        return module
+
+    _imp.exec_dynamic = thread_state.dispatch(_imp.exec_dynamic, 
+        importing = functional.juxt(
+                        thread_state.wrap('internal', _imp.exec_dynamic), 
+                        patch))
+    # _imp.exec_dynamic = lambda mod: utils.sigtrap(f'{thread_state.value} - {mod}')
+    # _imp.exec_builtin = lambda mod: utils.sigtrap(f'{thread_state.value} - {mod}')
+
+    _imp.exec_builtin = thread_state.dispatch(_imp.exec_builtin, 
+        importing = functional.juxt(
+                        thread_state.wrap('internal', _imp.exec_builtin), 
+                        patch))
+
+    # def runpy_exec(source, globals = None, locals = None):
+    #     print(f'In runpy exec!!!!!')
+    #     return builtins.exec(source, globals, locals)
+    
+    # utils.update(runpy, "_run_code",
+    #              utils.wrap_func_with_overrides,
+    #              exec = runpy_exec)
+
+    utils.update(_bootstrap_external._LoaderBasics, "exec_module", 
+                 utils.wrap_func_with_overrides,
+                 exec = thread_state.dispatch(builtins.exec, importing = thread_state.wrap('internal', sync(exec))))
+
+preload = [
+    "logging",
+    "pathlib",
+    "_signal",
+    "_posixsubprocess",
+    "socket",
+    "select",
+    "ssl",
+    "random",
+    "email",
+    "email.errors",
+    "http.client",
+
+    "json",
+    "typing",
+    "queue",
+    "mimetypes",
+    "tempfile",
+    "zipfile",
+    "importlib.resources",
+    "importlib.metadata",
+    "encodings.idna"
+
+    # "http.client",
+    # "queue",
+    # "mimetypes",
+    # "encodings.idna",
+    # "hmac",
+    # "ipaddress",
+    # "tempfile",
+    # "zipfile",
+    # "importlib.resources",
+    # "importlib.metadata",
+    # "atexit",
+    # "weakref"
+  ]
+
+# def debugger_is_active():
+#     return sys.gettrace() and 'debugpy' in sys.modules
+
+def init_weakref():
+    import weakref
+    def dummy_callback():
+        pass
+
+    class DummyTarget:
+        pass
+
+    f = weakref.finalize(DummyTarget(), dummy_callback)
+    f.detach()
+
+def wrapped_weakref(ref, thread_state, wrap_callback):
+    orig_new = ref.__new__
+
+    def __new__(cls, ob, callback=None, **kwargs):
+        return orig_new(cls, ob, wrap_callback(callback) if callback else None)
+    
+    return type('ref', (ref, ), {'__new__': thread_state.dispatch(orig_new, internal = __new__)})
+
+def patch_weakref(thread_state, wrap_callback):
+    import _weakref
+
+    update(_weakref.ref, wrapped_weakref(_weakref.ref, thread_state, wrap_callback))
+    # _weakref.ref = wrapped_weakref(_weakref.ref)
+
+# def patch_signal(thread_state, wrap_callback):  
+
+#     def wrap_handler(handler):
+#         return utils.observer(on_call = ..., function = handler)
+
+#     _signal.signal = 
+#     update(_signal.signal, thread_state.dispatch(_signal.signal, internal = thread_state.wrap('internal', _signal.signal)))
+
+
+
+def install(system):
+
+    patch_weakref(thread_state = system.thread_state, wrap_callback = system.wrap_weakref_callback)
+
+    init_weakref()
+    
+    for name in preload:
+        importlib.import_module(name)
+
+    # if 'pydevd' in sys.modules:
+    #     utils.update(sys.modules['pydevd'].PyDB, 'enable_tracing', system.disable_for)
+    #     utils.update(sys.modules['pydevd'].PyDB, 'set_suspend', system.disable_for)
+    #     utils.update(sys.modules['pydevd'].PyDB, 'do_wait_suspend', system.disable_for)
+
+    # if '_pydevd_bundle.pydevd_trace_dispatch_regular' in sys.modules:
+    #     mod = sys.modules['_pydevd_bundle.pydevd_trace_dispatch_regular']
+    #     utils.update(mod.ThreadTracer, '__call__', system.disable_for)
+        
+    for function in utils.stack_functions():
+        system.exclude_from_stacktrace(function)
+
+    def recursive_disable(func):
+        if not callable(func):
+            return func
+        
+        def wrapped(*args, **kwargs):
+            with system.thread_state.select('disabled'):
+                return recursive_disable(func(*args, **kwargs))
+        
+        return wrapped
+
+    sys.settrace = functional.sequence(recursive_disable, sys.settrace)
+    sys.setprofile = functional.sequence(recursive_disable, sys.setprofile)
+    threading.settrace = functional.sequence(recursive_disable, threading.settrace)
+
+    sys.settrace(sys.gettrace())
+    sys.setprofile(sys.getprofile())
+
+    system.checkpoint('About to install retrace system')
+
+    module_config = load_module_config('modules.toml')
+
+    patch_loaded = functional.partial(patch_module, create_patcher(system), module_config)
+    patch_imported = functional.partial(patch_imported_module, create_patcher(system), system.checkpoint, module_config)
+    
+    system.checkpoint('Started installing system 1')
+    
+    for modname in module_config.keys():
+        if modname in sys.modules:
+            patch_loaded(sys.modules[modname].__dict__, True)
+
+    system.checkpoint('About to patch threading')
+
+    patch_thread_start(system.thread_state)
+    threading.current_thread().__retrace__ = system
+
+    system.checkpoint('About to patch import')
+    patch_import(thread_state = system.thread_state, 
+                 patcher = patch_imported, 
+                 sync = system.sync, 
+                 checkpoint = system.checkpoint)
+
+    # print(f'MODULES: {list(sys.modules.keys())}')
+
+    importlib.import_module = \
+        system.thread_state.dispatch(system.disable_for(importlib.import_module),
+                              internal = system.thread_state.wrap('importing', importlib.import_module))
+
+
+    system.checkpoint('About to patch preload libraries')
+
+    system.checkpoint('system patched...')
+
+def run_with_retrace(system, argv, trace_shutdown = False):
+
+    def runpy_exec(source, globals = None, locals = None):
+        with system.thread_state.select('internal'):
+            return builtins.exec(source, globals, locals)
+    
+    utils.update(runpy, "_run_code",
+                 utils.wrap_func_with_overrides,
+                 exec = runpy_exec)
+
+    try:
+        run_python_command(argv)
+    finally:
+        wait_for_non_daemon_threads()
+        try:
+            if trace_shutdown:
+                with system.thread_state.select('internal'):
+                    atexit._run_exitfuncs()
+            else:
+                atexit._run_exitfuncs()
+        except Exception as e:
+            print(f"Error in atexit hook: {e}", file=sys.stderr)

retracesoftware/stackdifference.py

@@ -0,0 +1,133 @@
+import itertools
+import inspect
+import ast
+from typing import Optional
+import importlib
+import retracesoftware.utils as utils
+
+def frozen_to_module(name: str):
+    """
+    Given a frozen filename like "<frozen importlib._bootstrap>",
+    return the actual module object (or None if not frozen).
+    """
+    if not name.startswith("<frozen ") or not name.endswith(">"):
+        return None
+
+    # Extract the part between <frozen ...>
+    module_name = name[len("<frozen "):-1]
+
+    # Special case: the stdlib ships some as _frozen_importlib and _frozen_importlib_external
+    if module_name == "importlib._bootstrap":
+        return sys.modules.get("_frozen_importlib") or importlib._bootstrap
+    if module_name == "importlib._bootstrap_external":
+        return sys.modules.get("_frozen_importlib_external") or importlib._bootstrap_external
+
+    # Everything else is directly importable
+    return importlib.import_module(module_name)
+
+def get_function_at_line(filename: str, source: str, lineno: int) -> Optional[str]:
+    """
+    Return the name of the function (or class/method) that contains the given line number.
+    
+    Returns None if:
+      - file not found
+      - syntax error
+      - line is outside any function (module level)
+    """
+    # except FileNotFoundError:
+    #     return None
+    # except UnicodeDecodeError:
+    #     return None
+
+    try:
+        tree = ast.parse(source, filename=filename)
+    except SyntaxError:
+        return None
+
+    class FunctionFinder(ast.NodeVisitor):
+        def __init__(self, target_lineno: int):
+            self.target_lineno = target_lineno
+            self.current: Optional[str] = None
+            self.stack: list[str] = []
+
+        def visit_FunctionDef(self, node):
+            if node.lineno <= self.target_lineno <= node.end_lineno:
+                # breakpoint()
+                self.stack.append(node.name)
+                self.current = node.name
+                self.generic_visit(node)
+                self.stack.pop()
+            elif self.stack:
+                # We're inside a nested function/class, keep traversing
+                self.generic_visit(node)
+
+        def visit_AsyncFunctionDef(self, node):
+            self.visit_FunctionDef(node)  # same logic
+
+        def visit_ClassDef(self, node):
+            if node.lineno <= self.target_lineno <= node.end_lineno:
+                self.stack.append(node.name)
+                # Don't set current here — we prefer method names
+                self.generic_visit(node)
+                self.stack.pop()
+
+        # def get_result(self) -> Optional[str]:
+        #     if not self.stack:
+        #         return None
+        #     # Return the deepest (most specific) function/method name
+        #     return self.current
+        #     # return self.stack[-1]
+
+    finder = FunctionFinder(lineno)
+    finder.visit(tree)
+    # print(f'foind: {finder.current}')
+    return finder.current
+
+def get_source(filename):
+    try:
+        with open(filename, "r", encoding="utf-8") as f:
+            return f.read()
+    except FileNotFoundError:
+        return inspect.getsource(frozen_to_module(filename))
+
+def all_elements_same(t):
+    return len(set(t)) <= 1
+
+def first(coll): return coll[0]
+
+def common_prefix(*colls):
+    return list(map(first, itertools.takewhile(all_elements_same, zip(*colls))))
+
+def render_stack(frames):
+    for filename,lineno in frames:
+        try:
+            source = get_source(filename)
+            print(f'File "{filename}", line {lineno}, in {get_function_at_line(filename, source, lineno)}')
+            print(f'  {source.splitlines()[lineno - 1].lstrip()}')
+        except Exception:
+            print(f'File not found: "{filename}", line {lineno}')
+
+def on_stack_difference(previous, record, replay):
+
+    # previous = [x for x in previous if x not in excludes]
+    # record = [x for x in record if x not in excludes]
+    # replay = [x for x in replay if x not in excludes]
+
+    if record != replay:
+        common = common_prefix(previous, record, replay) if previous else common_prefix(record, replay)
+        
+        if common:
+            print('Common root:')
+            render_stack(common)
+
+        if previous:
+            print('\nlast matching:')
+            render_stack(previous[len(common):])
+
+        print('\nrecord:')
+        render_stack(record[len(common):])
+
+        print('\nreplay:')
+        render_stack(replay[len(common):])
+
+        utils.sigtrap('on_stack_difference!!!!!')

retracesoftware_proxy-0.0.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: retracesoftware_proxy
+Version: 0.0.0
+License: Apache-2.0
+Requires-Python: >=3.11
+Requires-Dist: retracesoftware_utils
+Requires-Dist: retracesoftware_functional
+Requires-Dist: retracesoftware_stream

retracesoftware_proxy-0.0.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+retracesoftware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+retracesoftware/__main__.py,sha256=legPSoOYPrfnB_t2v5NsdGuoBXjFRd8qub98QRXCtFM,8408
+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=C3O4LnHwWInRT9ZSB-crSM8Q98vYCZSFJB3akGJLfVM,14536
+retracesoftware/replay.py,sha256=rKuhen_MDDi_5WVDmQgchxJ0ZrCbYL1yZZboZsu_q54,3601
+retracesoftware/run.py,sha256=ovunjJjDAe23ik-KbYrLUseb9u2bZ26uZNg-QIPENMc,11966
+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=zv6xjUFoiuNWeBhIDIKb7kN6DVv8gxoG797sNV2ak8Y,7099
+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/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=08q7zc9cfyCyhLsh15q1d_5vFIhKbs9ln6VvL6kED5o,5861
+retracesoftware/install/references.py,sha256=A-G651IDOfuo00MkbAdpbIQh_15ChvJ7uAVTSmE6zd4,1721
+retracesoftware/install/replace.py,sha256=FYiSJtNrXEhl-H6M5tJm0kbliBA0sZdxE0306pr-YQg,872
+retracesoftware/install/replay.py,sha256=bB2eMpIP2vXZzeJ98jtlkGSE1DEYWk3olUbiBQcdVj0,3539
+retracesoftware/install/tracer.py,sha256=GO3Nnzd0ylxM7-A7RN0LzLCFdouJIiHtIcJ2zjFx0Q0,9363
+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/messagestream.py,sha256=kjxIugCSr7YSJbIqsqqXeW7dyE2SzWow2E-UJnkAflk,5890
+retracesoftware/proxy/proxyfactory.py,sha256=qhOqDfMJnLDNkQs26JqDB431MwjjRhGQi8xupJ45asg,12272
+retracesoftware/proxy/proxysystem.py,sha256=Pj9sk5FE3Mfyf4-PAtXSz2Pvr_GwXcpfhUSJvkz00dg,15076
+retracesoftware/proxy/proxytype.py,sha256=LZ1rNMsxXRUMdI4uTzDvGkUyPOYxCFroT_ZAtOGTbBk,14012
+retracesoftware/proxy/record.py,sha256=JTmeZ13ISbsVal1WOtae425DP0iA-QiAv0C6azPpV8k,6680
+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.0.0.dist-info/METADATA,sha256=mJIUCRnUE3D2fGhntlAEyiUYTf22UT94U4KleWa9i3s,226
+retracesoftware_proxy-0.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+retracesoftware_proxy-0.0.0.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
+retracesoftware_proxy-0.0.0.dist-info/RECORD,,

retracesoftware_proxy-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

retracesoftware_proxy-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+retracesoftware