offline-debug 0.1.0b1__py3-none-any.whl

offline_debug/__init__.py

@@ -0,0 +1,3 @@
+from .serializer import save_traceback, load_traceback
+
+__all__ = ["save_traceback", "load_traceback"]

offline_debug/serializer.py

@@ -0,0 +1,167 @@
+import pickle
+import marshal
+import types
+import typing
+import ctypes
+import sys
+
+# Define C API for frame creation
+_py_frame_new = ctypes.pythonapi.PyFrame_New
+_py_frame_new.argtypes = (
+    ctypes.c_void_p,  # PyThreadState *tstate
+    ctypes.py_object,  # PyCodeObject *code
+    ctypes.py_object,  # PyObject *globals
+    ctypes.py_object,  # PyObject *locals
+)
+_py_frame_new.restype = ctypes.py_object
+
+_py_thread_state_get = ctypes.pythonapi.PyThreadState_Get
+_py_thread_state_get.restype = ctypes.c_void_p
+
+
+# Define ctypes structure to access f_back in PyFrameObject
+class _PyObject(ctypes.Structure):
+    _fields_ = [("ob_refcnt", ctypes.c_ssize_t), ("ob_type", ctypes.c_void_p)]
+
+
+class _PyFrameObject(ctypes.Structure):
+    _fields_ = [
+        ("ob_base", _PyObject),
+        ("f_back", ctypes.c_void_p),  # Pointer to previous frame
+    ]
+
+
+def _get_stack_depth(frame):
+    depth = 0
+    while frame:
+        depth += 1
+        frame = frame.f_back
+    return depth
+
+
+def _filter_dict(d: dict) -> dict:
+    """Filter dictionary to include only picklable items."""
+    result = {}
+    for k, v in d.items():
+        if k in ("__builtins__", "__doc__", "__loader__", "__package__", "__spec__"):
+            continue
+        try:
+            pickle.dumps(v)
+            result[k] = v
+        except Exception:
+            result[k] = f"<unpicklable {type(v).__name__}: {repr(v)}>"
+    return result
+
+
+def _serialize_exc_data(exc: BaseException) -> dict:
+    tb_frames = []
+    curr_tb = exc.__traceback__
+    while curr_tb:
+        f = curr_tb.tb_frame
+        tb_frames.append(
+            {
+                "code": marshal.dumps(f.f_code),
+                "globals": _filter_dict(f.f_globals),
+                "locals": _filter_dict(f.f_locals),
+                "lasti": curr_tb.tb_lasti,
+                "lineno": curr_tb.tb_lineno,
+                "stack_depth": _get_stack_depth(f),
+            }
+        )
+        curr_tb = curr_tb.tb_next
+
+    try:
+        exc_pickle = pickle.dumps(exc)
+    except Exception:
+        exc_pickle = pickle.dumps(
+            RuntimeError(f"Unpicklable exception {type(exc).__name__}: {str(exc)}")
+        )
+
+    return {
+        "exc_pickle": exc_pickle,
+        "tb_frames": tb_frames,
+        "cause": _serialize_exc_data(exc.__cause__) if exc.__cause__ else None,
+        "context": _serialize_exc_data(exc.__context__) if exc.__context__ else None,
+    }
+
+
+def save_traceback(exc: Exception, file_path: str):
+    """Serialize an exception and its traceback to a file."""
+    data = _serialize_exc_data(exc)
+    with open(file_path, "wb") as f:
+        pickle.dump(data, f)
+
+
+def _reconstruct_exc_data(data: dict) -> Exception:
+    exc = pickle.loads(data["exc_pickle"])
+
+    tstate = _py_thread_state_get()
+
+    reconstructed_frames = []
+    prev_frame = None
+    for f_data in data["tb_frames"]:
+        code = marshal.loads(f_data["code"])
+
+        frame = _py_frame_new(tstate, code, f_data["globals"], {})
+
+        if f_data["locals"]:
+            frame.f_locals.update(f_data["locals"])
+
+        if prev_frame:
+            frame_ptr = _PyFrameObject.from_address(id(frame))
+            frame_ptr.f_back = id(prev_frame)
+
+        reconstructed_frames.append((frame, f_data))
+        prev_frame = frame
+
+    tb_next = None
+    for frame, f_data in reversed(reconstructed_frames):
+        tb = types.TracebackType(
+            tb_next=tb_next,
+            tb_frame=frame,
+            tb_lasti=f_data["lasti"],
+            tb_lineno=f_data["lineno"],
+        )
+        tb_next = tb
+
+    exc = exc.with_traceback(tb_next)
+
+    if data["cause"]:
+        exc.__cause__ = _reconstruct_exc_data(data["cause"])
+    if data["context"]:
+        exc.__context__ = _reconstruct_exc_data(data["context"])
+
+    return exc
+
+
+def load_traceback(file_path: str) -> typing.Never:
+    """Load an exception and its traceback from a file and raise it."""
+    with open(file_path, "rb") as f:
+        data = pickle.load(f)
+
+    exc = _reconstruct_exc_data(data)
+
+    current_frames = []
+    curr = sys._getframe(1)
+    while curr:
+        current_frames.append(curr)
+        curr = curr.f_back
+
+    if exc.__traceback__ and current_frames:
+        reconstructed_outer = exc.__traceback__.tb_frame
+        caller_frame = current_frames[0]
+
+        frame_ptr = _PyFrameObject.from_address(id(reconstructed_outer))
+        frame_ptr.f_back = id(caller_frame)
+
+    tb_chain = exc.__traceback__
+    for frame in current_frames:
+        tb_chain = types.TracebackType(
+            tb_next=tb_chain,
+            tb_frame=frame,
+            tb_lasti=frame.f_lasti,
+            tb_lineno=frame.f_lineno,
+        )
+
+    exc = exc.with_traceback(tb_chain)
+    raise exc

offline_debug-0.1.0b1.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.3
+Name: offline-debug
+Version: 0.1.0b1
+Summary: Debug exceptions offline by saving them to a dump and raising them at a later point.
+Author: Itai Elidan
+Author-email: Itai Elidan <itaielidan@gmail.com>
+Requires-Dist: typing-extensions>=4.15.0
+Requires-Python: >=3.13

offline_debug-0.1.0b1.dist-info/RECORD

@@ -0,0 +1,5 @@
+offline_debug/__init__.py,sha256=i87K1VHFearUSjk_OxfHW8zaQJYQt6hFF0T7gQOWogQ,103
+offline_debug/serializer.py,sha256=zLaw3UBtPIJ_MI9E3T6JlMnbqwwSf1S1U7FQjRKyH9c,4692
+offline_debug-0.1.0b1.dist-info/WHEEL,sha256=bEhYrD-rjlF0iRRHiAnfJ0mEjMsRwm29hhDD7yRgWCY,80
+offline_debug-0.1.0b1.dist-info/METADATA,sha256=vj6wIXqV6U8GmkFfr2__INmQ_KNKZiphvmEV65J8bpE,287
+offline_debug-0.1.0b1.dist-info/RECORD,,

offline_debug-0.1.0b1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.3
+Root-Is-Purelib: true
+Tag: py3-none-any