codesuture 0.5.1__tar.gz → 0.6.0__tar.gz

{codesuture-0.5.1 → codesuture-0.6.0}/.gitignore

@@ -25,6 +25,7 @@ realbugg.py
 real.py
 *.zip
 .livepatch_*/
+v4test/
 
 # IDE / OS
 .vscode/

{codesuture-0.5.1 → codesuture-0.6.0}/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.0] - 2026-05-12
+
+### Fixed
+- PEP 659: Force de-specialization after `__code__` swap via
+  `ctypes.pythonapi.PyFunction_SetCode` — prevents CPython 3.11+
+  adaptive bytecode cache from ignoring injected patches
+- Thread blindness: Install trace hook on all threads via
+  `threading.settrace` at startup, with `_install_trace_on_all_threads`
+  helper covering existing and future threads; added `threading.Lock`
+  for thread-safe patch store writes
+- Exception table corruption: Guard injection now detects try/except
+  scope via `TryBegin`/`TryEnd` markers and redirects to function
+  entry-point injection to avoid corrupting `co_exceptiontable` offsets
+  in CPython 3.11+
+
 ## [0.5.1] - 2026-05-11
 
 ### Fixed

{codesuture-0.5.1 → codesuture-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codesuture
-Version: 0.5.1
+Version: 0.6.0
 Summary: Runtime Python bytecode patcher with guard knowledge base, persistence, and self-healing re-execution
 License-Expression: MIT
 Project-URL: Source, https://github.com/codesuture-py/codesuture
@@ -158,7 +158,7 @@ Beyond basic patching, CodeSuture includes a set of higher-order behaviors that
 
 **Single-process scope.** Patches apply per-process. Multi-process applications need a CodeSuture instance per worker. The `.codesuture_store/` directory is shared on disk, so patches load correctly on restart.
 
-**Async support is experimental.** `async def` functions with standard `CO_COROUTINE` frames are patched. Async generators and deeply nested `await` chains may not be handled correctly in all cases.
+**Web server support requires Python 3.11+ with `threading.settrace` active.** Tested with `socketserver` and `threading.Thread`. ASGI frameworks (FastAPI, Starlette) require the ASGI middleware wrapper.
 
 ---
 

{codesuture-0.5.1 → codesuture-0.6.0}/README.md

@@ -137,7 +137,7 @@ Beyond basic patching, CodeSuture includes a set of higher-order behaviors that
 
 **Single-process scope.** Patches apply per-process. Multi-process applications need a CodeSuture instance per worker. The `.codesuture_store/` directory is shared on disk, so patches load correctly on restart.
 
-**Async support is experimental.** `async def` functions with standard `CO_COROUTINE` frames are patched. Async generators and deeply nested `await` chains may not be handled correctly in all cases.
+**Web server support requires Python 3.11+ with `threading.settrace` active.** Tested with `socketserver` and `threading.Thread`. ASGI frameworks (FastAPI, Starlette) require the ASGI middleware wrapper.
 
 ---
 

codesuture-0.6.0/codesuture/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.6.0"
+

{codesuture-0.5.1 → codesuture-0.6.0}/codesuture/cli.py

@@ -1,11 +1,11 @@
 import sys
 import argparse
-from codesuture.tracer import install, uninstall
+from codesuture.tracer import install, uninstall, _install_trace_on_all_threads
 
 def main():
     parser = argparse.ArgumentParser(prog='codesuture',
                                      description='Runtime Python bytecode patcher with self-healing re-execution')
-    parser.add_argument('--version', action='version', version='codesuture 0.5.1')
+    parser.add_argument('--version', action='version', version='codesuture 0.6.0')
     sub = parser.add_subparsers(dest='command', required=True)
 
     run_parser = sub.add_parser('run', help='Run a script with live patching')
@@ -102,7 +102,7 @@ def main():
                 patched_before = tracer.stats['patched']
                 tracer._handled_exc_ids.clear()
                 try:
-                    sys.settrace(tracer)
+                    _install_trace_on_all_threads(tracer)
                     globs = make_persisted_patch_globals(
                         "__main__",
                         {'__name__': '__main__', '__file__': args.script},

{codesuture-0.5.1 → codesuture-0.6.0}/codesuture/guard_synthesizer.py

@@ -1,9 +1,30 @@
 """
 Synthesises guard + original bytecode for all deterministic strategies.
 """
+import ctypes
 from bytecode import Bytecode, Instr, Label, Compare
 from codesuture.pattern_matcher import PatchSpec
 
+def _force_despecialize(func):
+    """
+    Force CPython 3.11+ to abandon its adaptive
+    instruction cache for this function.
+    After __code__ replacement, the interpreter must
+    re-read the new bytecode from scratch.
+    """
+    try:
+        # PyFunction_SetCode forces de-specialization
+        # by going through the official C API path
+        # rather than the Python attribute setter.
+        ctypes.pythonapi.PyFunction_SetCode(
+            ctypes.py_object(func),
+            ctypes.py_object(func.__code__)
+        )
+    except Exception:
+        pass  # Non-fatal: patch still applied, may not
+              # take effect until next function cold-start
+
+
 class PatchValidationError(Exception):
     pass
 
@@ -51,21 +72,91 @@ def propagate_patch(original_func, patched_code) -> int:
         if hasattr(ref, '__func__') and hasattr(ref.__func__, '__code__'):
             if ref.__func__.__code__ is original_code:
                 ref.__func__.__code__ = patched_code
+                _force_despecialize(ref.__func__)
                 propagated += 1
 
         elif hasattr(ref, '__code__') and ref.__code__ is original_code:
             ref.__code__ = patched_code
+            _force_despecialize(ref)
             propagated += 1
 
     original_func.__code__ = patched_code
+    _force_despecialize(original_func)
 
     if propagated > 0:
         print(f"[CodeSuture] Propagated patch to {propagated} additional "
               f"live reference(s) of {original_func.__qualname__}.")
     return propagated
 
+def _is_inside_try_block(code):
+    """Return True if any BINARY_SUBSCR or crash-relevant opcode
+       falls inside an exception handler range (TryBegin/TryEnd).
+       Uses the bytecode library's TryBegin/TryEnd markers."""
+    import sys
+    if sys.version_info < (3, 11):
+        return False
+    try:
+        from bytecode import TryBegin, TryEnd
+        bc = Bytecode.from_code(code)
+        depth = 0
+        has_subscr_in_try = False
+        for item in bc:
+            if isinstance(item, TryBegin):
+                depth += 1
+            elif isinstance(item, TryEnd):
+                depth = max(0, depth - 1)
+            elif depth > 0 and isinstance(item, Instr):
+                if item.name in ('BINARY_SUBSCR', 'LOAD_ATTR', 'LOAD_METHOD',
+                                 'BINARY_OP', 'BINARY_TRUE_DIVIDE'):
+                    has_subscr_in_try = True
+                    break
+        return has_subscr_in_try
+    except Exception:
+        return False
+
+def _build_entry_point_null_guard(original_code, var_name, default):
+    """Build a guard injected at the function entry point (after RESUME).
+       Checks if var_name is None and replaces it with default.
+       Safe for use when the crash site is inside a try block."""
+    bc = Bytecode.from_code(original_code)
+    skip = Label()
+    patch = [
+        Instr('LOAD_FAST', var_name),
+        Instr('LOAD_CONST', None),
+        Instr('IS_OP', 0),
+        Instr('POP_JUMP_FORWARD_IF_FALSE', skip),
+        Instr('LOAD_CONST', default),
+        Instr('RETURN_VALUE'),
+        skip
+    ]
+    idx = 0
+    for i, instr in enumerate(bc):
+        if isinstance(instr, Instr) and instr.name == 'RESUME':
+            idx = i + 1
+            break
+    for instr in reversed(patch):
+        bc.insert(idx, instr)
+    return bc
+
+# Strategies that inject inline at the crash site (replace BINARY_SUBSCR etc.)
+# These are the ones that can corrupt exception tables when inside try blocks.
+_INLINE_STRATEGIES = frozenset({
+    'subscript_guard', 'key_guard', 'dict_get_guard',
+    'chain_subscript_guard', 'division_guard',
+})
+
 def synthesize_guarded_code(original_code, spec: PatchSpec) -> Bytecode:
-    if spec.strategy in ('subscript_guard', 'key_guard', 'dict_get_guard'):
+    # Bug 3 fix: If the crash site is inside a try/except block and we
+    # would normally inject inline, redirect to an entry-point guard
+    # to avoid corrupting co_exceptiontable offsets on CPython 3.11+.
+    if spec.strategy in _INLINE_STRATEGIES and _is_inside_try_block(original_code):
+        import logging
+        logging.getLogger(__name__).debug(
+            "[CodeSuture] Crash inside try block — redirecting %s to entry-point guard",
+            spec.strategy
+        )
+        res = _build_entry_point_null_guard(original_code, spec.var_name, spec.default_value)
+    elif spec.strategy in ('subscript_guard', 'key_guard', 'dict_get_guard'):
         res = _build_subscript_guarded_code(original_code, spec.var_name, spec.key_name, spec.default_value)
     elif spec.strategy == 'chain_subscript_guard':
         res = _build_chain_subscript_guarded_code(original_code, spec.var_name, spec.key_name, spec.default_value)

{codesuture-0.5.1 → codesuture-0.6.0}/codesuture/tracer.py

@@ -3,7 +3,7 @@ import os
 import json
 from datetime import datetime
 from codesuture.pattern_matcher import analyze_exception
-from codesuture.guard_synthesizer import synthesize_guarded_code
+from codesuture.guard_synthesizer import synthesize_guarded_code, _force_despecialize
 from codesuture.code_replacer import replace_function_code, get_function_from_frame
 from codesuture.rewind import rewind_frame_to_start
 
@@ -27,6 +27,7 @@ def _is_internal_frame(frame):
 
 class CodeSutureTracer:
     def __init__(self, dry_run=False, log_file=None, max_retries=3, autonomous=False, script_path=None, verbose=False, shadow=False, ttl=7):
+        import threading
         self.dry_run = dry_run
         self.log_file = log_file
         self.max_retries = max_retries
@@ -44,6 +45,7 @@ class CodeSutureTracer:
         }
         self.patched_signatures = {}  
         self._handled_exc_ids = set()  
+        self._patch_lock = threading.Lock()
 
     def __call__(self, frame, event, arg):
         if event == 'return' and self.shadow_mode and frame.f_code in self._patched_codes:
@@ -271,22 +273,24 @@ class CodeSutureTracer:
                 if getattr(spec, 'target_func', None):
                     assert spec.target_func.__code__ is new_code, "Property fget code replacement failed"
 
-                from codesuture.persistence import save_patch
-                save_patch(func, new_code, spec, self.ttl)
+                with self._patch_lock:
+                    from codesuture.persistence import save_patch
+                    save_patch(func, new_code, spec, self.ttl)
 
-                if self.shadow_mode:
-                    self._patched_codes[new_code] = spec.strategy
+                    if self.shadow_mode:
+                        self._patched_codes[new_code] = spec.strategy
 
                 if self.verbose:
                     from codesuture.diff_guard import semantic_diff
                     diff = semantic_diff(old_code, new_code, spec.strategy)
                     print(f"[CodeSuture DEBUG] Diff: +{diff.added} -{diff.removed} instructions (allowed <= {diff.allowed})")
 
-                if not is_reuse:
-                    self.patched_signatures[sig] = spec
+                with self._patch_lock:
+                    if not is_reuse:
+                        self.patched_signatures[sig] = spec
 
-                if not cached:
-                    record(fp, spec.strategy, spec.var_name, getattr(func, '__name__', 'unknown'), exc_type.__name__, spec.default_value, spec.key_name)
+                    if not cached:
+                        record(fp, spec.strategy, spec.var_name, getattr(func, '__name__', 'unknown'), exc_type.__name__, spec.default_value, spec.key_name)
 
                 entry["action"] = "applied"
                 self._log(entry)
@@ -347,6 +351,7 @@ class CodeSutureTracer:
             new_bc = synthesize_guarded_code(internal_frame.f_code, spec)
             new_code = new_bc.to_code()
             replace_function_code(func, new_code)
+            _force_despecialize(func)
             self.stats["patched"] += 1
             print(f"[CodeSuture]   Self-healed {func.__name__}().")
 
@@ -369,6 +374,7 @@ class CodeSutureTracer:
             if hasattr(ref, "__code__") and getattr(ref, "__code__", None) is old_code:
                 try:
                     ref.__code__ = new_code
+                    _force_despecialize(ref)
                     replaced = True
                     propagated_count += 1
                 except Exception:
@@ -378,6 +384,7 @@ class CodeSutureTracer:
                 if hasattr(fn, "__code__") and getattr(fn, "__code__", None) is old_code:
                     try:
                         fn.__code__ = new_code
+                        _force_despecialize(fn)
                         replaced = True
                         propagated_count += 1
                     except Exception:
@@ -404,6 +411,7 @@ class CodeSutureTracer:
 
             if func and hasattr(func, "__code__") and getattr(func, "__code__", None) is old_code:
                 func.__code__ = new_code
+                _force_despecialize(func)
                 print(f"[CodeSuture] In-memory propagated patch applied to {func.__name__}().")
             else:
                 print("[CodeSuture] Could not find code object in memory to persist.")
@@ -428,17 +436,40 @@ def _codesuture_excepthook(tracer, exc_type, exc_value, exc_tb):
     if exc_tb:
         tracer._handle_exception(exc_tb.tb_frame, exc_type, exc_value, exc_tb, thread=threading.current_thread())
 
+    # If CodeSuture handled and patched this exception, suppress the
+    # default traceback — the patch was applied and re-execution will
+    # handle the rest.
+    if id(exc_value) in tracer._handled_exc_ids:
+        return
+
     if _original_excepthook:
         _original_excepthook(exc_type, exc_value, exc_tb)
     else:
         sys.__excepthook__(exc_type, exc_value, exc_tb)
 
+def _install_trace_on_all_threads(trace_fn):
+    """Install trace hook on main thread and
+       all currently running threads."""
+    import threading
+    sys.settrace(trace_fn)
+    threading.settrace(trace_fn)
+    # For threads already running:
+    for thread in threading.enumerate():
+        if thread is not threading.current_thread():
+            try:
+                import ctypes
+                ctypes.pythonapi.PyThreadState_SetAsyncExc(
+                    ctypes.c_ulong(thread.ident),
+                    None  # does not raise, just wakes thread
+                )
+            except Exception:
+                pass
+
 def install(dry_run=False, log_file=None, max_retries=3, autonomous=False, script_path=None, verbose=False, shadow=False, ttl=7):
     global _original_excepthook
     import threading
     tracer = CodeSutureTracer(dry_run, log_file, max_retries, autonomous, script_path, verbose, shadow, ttl)
-    sys.settrace(tracer)
-    threading.settrace(tracer)
+    _install_trace_on_all_threads(tracer)
 
     if getattr(threading, 'excepthook', None) is not None:
         if threading.excepthook != getattr(threading, '__excepthook__', None):

{codesuture-0.5.1 → codesuture-0.6.0}/codesuture.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codesuture
-Version: 0.5.1
+Version: 0.6.0
 Summary: Runtime Python bytecode patcher with guard knowledge base, persistence, and self-healing re-execution
 License-Expression: MIT
 Project-URL: Source, https://github.com/codesuture-py/codesuture
@@ -158,7 +158,7 @@ Beyond basic patching, CodeSuture includes a set of higher-order behaviors that
 
 **Single-process scope.** Patches apply per-process. Multi-process applications need a CodeSuture instance per worker. The `.codesuture_store/` directory is shared on disk, so patches load correctly on restart.
 
-**Async support is experimental.** `async def` functions with standard `CO_COROUTINE` frames are patched. Async generators and deeply nested `await` chains may not be handled correctly in all cases.
+**Web server support requires Python 3.11+ with `threading.settrace` active.** Tested with `socketserver` and `threading.Thread`. ASGI frameworks (FastAPI, Starlette) require the ASGI middleware wrapper.
 
 ---
 

{codesuture-0.5.1 → codesuture-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codesuture"
-version = "0.5.1"
+version = "0.6.0"
 description = "Runtime Python bytecode patcher with guard knowledge base, persistence, and self-healing re-execution"
 readme = "README.md"
 license = "MIT"
@@ -35,3 +35,4 @@ codesuture = "codesuture.cli:main"
 [tool.setuptools.packages.find]
 include = ["codesuture*"]
 
+

codesuture-0.5.1/codesuture/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.5.1"