init

Author: cocolato

.flake8

@@ -0,0 +1,2 @@
+[flake8]
+max-line-length=120

.gitignore

@@ -0,0 +1,6 @@
+/venv
+__pycache__
+*.pyc
+/.pytest_cache
+*.dump
+test.py

poetry.lock

@@ -0,0 +1,7 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from .debug_dumpling import debug_dumpling, load_dumpling
+from .pydumpling import save_dumping, __version__
+
+__version__ == __version__
+__all__ = ["debug_dumpling", "load_dumpling", "save_dumping"]

pydumpling/__init__.py

@@ -0,0 +1,33 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import gzip
+import pdb
+import dill
+import pickle
+from distutils.version import StrictVersion
+import inspect
+import types
+from .fake_types import FakeFrame, FakeTraceback, FakeCode
+
+
+def load_dumpling(filename):
+    with gzip.open(filename, "rb") as f:
+        try:
+            return dill.load(f)
+        except Exception:
+            return pickle.load(f)
+
+
+def debug_dumpling(dump_file, pdb=pdb):
+    inspect.isframe = lambda obj: isinstance(
+        obj, types.FrameType) or obj.__class__ == FakeFrame
+    inspect.istraceback = lambda obj: isinstance(
+        obj, types.TracebackType) or obj.__class__ == FakeTraceback
+    inspect.iscode = lambda obj: isinstance(
+        obj, types.CodeType) or obj.__class__ == FakeCode
+    dumpling = load_dumpling(dump_file)
+    if not StrictVersion("0.0.1") <= StrictVersion(dumpling["version"]) < StrictVersion("1.0.0"):
+        raise ValueError("Unsupported dumpling version: %s" %
+                         dumpling["version"])
+    tb = dumpling["traceback"]
+    pdb.post_mortem(tb)

pydumpling/debug_dumpling.py

@@ -0,0 +1,112 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import os
+import six
+import dill
+
+
+class FakeType(object):
+    @classmethod
+    def _safe_repr(cls, v):
+        try:
+            return repr(v)
+        except Exception as e:
+            return "repr error: %s" % str(e)
+
+    @classmethod
+    def _convert_dict(cls, v):
+        return {cls._convert(k): cls._convert(i) for k, i in v.items()}
+
+    @classmethod
+    def _convert_obj(cls, obj):
+        try:
+            return FakeClass(cls._safe_repr(obj), cls._convert_dict(obj.__dict__))
+        except Exception:
+            return cls._convert(obj)
+
+    @classmethod
+    def _convert_seq(cls, v):
+        return map(cls._convert, v)
+
+    @classmethod
+    def _convert(cls, v):
+
+        if v is None:
+            return v
+
+        if dill is not None:
+            try:
+                dill.dumps(v)
+                return v
+            except Exception:
+                return cls._safe_repr(v)
+        else:
+            from datetime import date, time, datetime, timedelta
+
+            BUILTIN = (str, unicode, int, long, float, date, time, datetime, timedelta) if six.PY2 \
+                else (str, int, float, date, time, datetime, timedelta)  # noqa: F821
+
+            if type(v) in BUILTIN:
+                return v
+
+            if isinstance(v, (tuple, list, set)):
+                return type(v)(cls._convert_seq(v))
+
+            if isinstance(v, dict):
+                return cls._convert_dict(v)
+
+            return cls._safe_repr(v)
+
+
+class FakeTraceback(FakeType):
+
+    def __init__(self, traceback):
+        self.tb_frame = FakeFrame(
+            traceback.tb_frame) if traceback.tb_frame else None
+        self.tb_lineno = traceback.tb_lineno
+        self.tb_next = FakeTraceback(
+            traceback.tb_next) if traceback.tb_next else None
+        self.tb_lasti = 0
+
+
+class FakeFrame(FakeType):
+    def __init__(self, frame):
+        self.f_code = FakeCode(frame.f_code)
+        self.f_locals = self._convert_dict(frame.f_locals)
+        if "self" in frame.f_locals:
+            self.f_locals["self"] = self._convert_obj(frame.f_locals["self"])
+        self.f_globals = self._convert_dict(frame.f_globals)
+        self.f_lineno = frame.f_lineno
+        self.f_back = FakeFrame(frame.f_back) if frame.f_back else None
+
+
+class FakeClass(FakeType):
+
+    def __init__(self, repr, vals):
+        self.__repr = repr
+        self.__dict__.update(vars)
+
+    def __repr__(self):
+        return self.__repr
+
+
+class FakeCode(FakeType):
+
+    def __init__(self, code):
+        self.co_filename = os.path.abspath(code.co_filename)
+        self.co_name = code.co_name
+        self.co_argcount = code.co_argcount
+        self.co_consts = tuple(FakeCode(c) if hasattr(
+            c, "co_filename") else c for c in code.co_consts)
+        self.co_firstlineno = code.co_firstlineno
+        self.co_lnotab = code.co_lnotab
+        self.co_varnames = code.co_varnames
+        self.co_flags = code.co_flags
+        self.co_code = code.co_code
+        self._co_lines = list(code.co_lines()) if hasattr(
+            code, "co_lines") else []
+        if hasattr(code, "co_kwonlyargcount"):
+            self.co_kwonlyargcount = code.co_kwonlyargcount
+
+    def co_lines(self):
+        return iter(self._co_lines)

pydumpling/fake_types.py

@@ -0,0 +1,36 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import gzip
+import sys
+import dill
+import pickle
+import warnings
+from .fake_types import FakeTraceback
+
+__version__ = "0.0.1"
+
+
+def save_dumping(filename=None, tb=None):
+    try:
+        if tb is None:
+            tb = sys.exc_info()[2]
+
+        if filename is None:
+            filename = "%s:%d.dump" % (
+                tb.tb_frame.f_code.co_filename, tb.tb_frame.f_lineno)
+
+        fake_tb = FakeTraceback(tb)
+        dumpling = {
+            "traceback": fake_tb,
+            "version": __version__,
+            "dump_type": "DILL"
+        }
+        with gzip.open(filename, "wb") as f:
+            try:
+                dill.dump(dumpling, f, protocol=dill.HIGHEST_PROTOCOL)
+            except Exception:
+                dumpling["dump_type"] = "PICKLE"
+                pickle.dump(dumpling, f, protocol=dill.HIGHEST_PROTOCOL)
+    except Exception as e:
+        err_msg = "Unexpected error: %s when dumping traceback" % str(e)
+        warnings.warn(err_msg, RuntimeWarning)

pydumpling/pydumpling.py

@@ -7,6 +7,8 @@ readme = "README.md"
 
 [tool.poetry.dependencies]
 python = "^3.10"
+dill = "^0.3.6"
+six = "^1.16.0"
 
 
 [build-system]

pyproject.toml

@@ -0,0 +1,8 @@
+#! /usr/bin/env bash
+
+set -e
+
+pip install pytest pytest-order flake8 six
+
+flake8 ./tests ./pydumpling
+python -m pytest

test.sh

@@ -0,0 +1,10 @@
+from pydumpling import load_dumpling, __version__
+from pydumpling.fake_types import FakeTraceback
+import pytest
+
+
+@pytest.mark.order(2)
+def test_debug():
+    dumpling = load_dumpling("test.dump")
+    assert isinstance(dumpling["traceback"], FakeTraceback)
+    assert dumpling["version"] == __version__