maxframe 0.1.0b5__cp39-cp39-macosx_11_0_arm64.whl

maxframe/lib/tblib/__init__.py

@@ -0,0 +1,327 @@
+import re
+import sys
+from types import CodeType, FrameType, TracebackType
+
+try:
+    from __pypy__ import tproxy
+except ImportError:
+    tproxy = None
+try:
+    from .cpython import tb_set_next
+except ImportError:
+    tb_set_next = None
+
+if not tb_set_next and not tproxy:
+    raise ImportError("Cannot use tblib. Runtime not supported.")
+
+__version__ = "1.7.0"
+__all__ = "Traceback", "TracebackParseError", "Frame", "Code"
+
+PY3 = sys.version_info[0] == 3
+FRAME_RE = re.compile(
+    r'^\s*File "(?P<co_filename>.+)", line (?P<tb_lineno>\d+)(, in (?P<co_name>.+))?$'
+)
+
+
+class _AttrDict(dict):
+    __slots__ = ()
+
+    def __getattr__(self, name):
+        try:
+            return self[name]
+        except KeyError:
+            raise AttributeError(name)
+
+
+# noinspection PyPep8Naming
+class __traceback_maker(Exception):
+    pass
+
+
+class TracebackParseError(Exception):
+    pass
+
+
+class Code(object):
+    """
+    Class that replicates just enough of the builtin Code object to enable serialization and traceback rendering.
+    """
+
+    co_code = None
+
+    def __init__(self, code):
+        self.co_filename = code.co_filename
+        self.co_name = code.co_name
+        self.co_argcount = 0
+        self.co_kwonlyargcount = 0
+        self.co_varnames = ()
+        self.co_nlocals = 0
+        self.co_stacksize = 0
+        self.co_flags = 64
+        self.co_firstlineno = 0
+
+    # noinspection SpellCheckingInspection
+    def __tproxy__(self, operation, *args, **kwargs):
+        """
+        Necessary for PyPy's tproxy.
+        """
+        if operation in ("__getattribute__", "__getattr__"):
+            return getattr(self, args[0])
+        else:
+            return getattr(self, operation)(*args, **kwargs)
+
+
+class Frame(object):
+    """
+    Class that replicates just enough of the builtin Frame object to enable serialization and traceback rendering.
+    """
+
+    def __init__(self, frame):
+        self.f_locals = {}
+        self.f_globals = {
+            k: v for k, v in frame.f_globals.items() if k in ("__file__", "__name__")
+        }
+        self.f_code = Code(frame.f_code)
+        self.f_lineno = frame.f_lineno
+
+    def clear(self):
+        """
+        For compatibility with PyPy 3.5;
+        clear() was added to frame in Python 3.4
+        and is called by traceback.clear_frames(), which
+        in turn is called by unittest.TestCase.assertRaises
+        """
+
+    # noinspection SpellCheckingInspection
+    def __tproxy__(self, operation, *args, **kwargs):
+        """
+        Necessary for PyPy's tproxy.
+        """
+        if operation in ("__getattribute__", "__getattr__"):
+            if args[0] == "f_code":
+                return tproxy(CodeType, self.f_code.__tproxy__)
+            else:
+                return getattr(self, args[0])
+        else:
+            return getattr(self, operation)(*args, **kwargs)
+
+
+class Traceback(object):
+    """
+    Class that wraps builtin Traceback objects.
+    """
+
+    tb_next = None
+
+    def __init__(self, tb):
+        self.tb_frame = Frame(tb.tb_frame)
+        # noinspection SpellCheckingInspection
+        self.tb_lineno = int(tb.tb_lineno)
+
+        # Build in place to avoid exceeding the recursion limit
+        tb = tb.tb_next
+        prev_traceback = self
+        cls = type(self)
+        while tb is not None:
+            traceback = object.__new__(cls)
+            traceback.tb_frame = Frame(tb.tb_frame)
+            traceback.tb_lineno = int(tb.tb_lineno)
+            prev_traceback.tb_next = traceback
+            prev_traceback = traceback
+            tb = tb.tb_next
+
+    def as_traceback(self):
+        """
+        Convert to a builtin Traceback object that is usable for raising or rendering a stacktrace.
+        """
+        if tproxy:
+            return tproxy(TracebackType, self.__tproxy__)
+        if not tb_set_next:
+            raise RuntimeError("Unsupported Python interpreter!")
+
+        current = self
+        top_tb = None
+        tb = None
+        while current:
+            f_code = current.tb_frame.f_code
+            code = compile(
+                "\n" * (current.tb_lineno - 1) + "raise __traceback_maker",
+                current.tb_frame.f_code.co_filename,
+                "exec",
+            )
+            if hasattr(code, "replace"):
+                # Python 3.8 and newer
+                code = code.replace(
+                    co_argcount=0,
+                    co_filename=f_code.co_filename,
+                    co_name=f_code.co_name,
+                    co_freevars=(),
+                    co_cellvars=(),
+                )
+            elif PY3:
+                code = CodeType(
+                    0,
+                    code.co_kwonlyargcount,
+                    code.co_nlocals,
+                    code.co_stacksize,
+                    code.co_flags,
+                    code.co_code,
+                    code.co_consts,
+                    code.co_names,
+                    code.co_varnames,
+                    f_code.co_filename,
+                    f_code.co_name,
+                    code.co_firstlineno,
+                    code.co_lnotab,
+                    (),
+                    (),
+                )
+            else:
+                code = CodeType(
+                    0,
+                    code.co_nlocals,
+                    code.co_stacksize,
+                    code.co_flags,
+                    code.co_code,
+                    code.co_consts,
+                    code.co_names,
+                    code.co_varnames,
+                    f_code.co_filename.encode(),
+                    f_code.co_name.encode(),
+                    code.co_firstlineno,
+                    code.co_lnotab,
+                    (),
+                    (),
+                )
+
+            # noinspection PyBroadException
+            try:
+                exec(code, dict(current.tb_frame.f_globals), {})
+            except Exception:
+                next_tb = sys.exc_info()[2].tb_next
+                if top_tb is None:
+                    top_tb = next_tb
+                if tb is not None:
+                    tb_set_next(tb, next_tb)
+                tb = next_tb
+                del next_tb
+
+            current = current.tb_next
+        try:
+            return top_tb
+        finally:
+            del top_tb
+            del tb
+
+    to_traceback = as_traceback
+
+    # noinspection SpellCheckingInspection
+    def __tproxy__(self, operation, *args, **kwargs):
+        """
+        Necessary for PyPy's tproxy.
+        """
+        if operation in ("__getattribute__", "__getattr__"):
+            if args[0] == "tb_next":
+                return self.tb_next and self.tb_next.as_traceback()
+            elif args[0] == "tb_frame":
+                return tproxy(FrameType, self.tb_frame.__tproxy__)
+            else:
+                return getattr(self, args[0])
+        else:
+            return getattr(self, operation)(*args, **kwargs)
+
+    def as_dict(self):
+        """
+        Converts to a dictionary representation. You can serialize the result to JSON as it only has
+        builtin objects like dicts, lists, ints or strings.
+        """
+        if self.tb_next is None:
+            tb_next = None
+        else:
+            tb_next = self.tb_next.to_dict()
+
+        code = {
+            "co_filename": self.tb_frame.f_code.co_filename,
+            "co_name": self.tb_frame.f_code.co_name,
+        }
+        frame = {
+            "f_globals": self.tb_frame.f_globals,
+            "f_code": code,
+            "f_lineno": self.tb_frame.f_lineno,
+        }
+        return {
+            "tb_frame": frame,
+            "tb_lineno": self.tb_lineno,
+            "tb_next": tb_next,
+        }
+
+    to_dict = as_dict
+
+    @classmethod
+    def from_dict(cls, dct):
+        """
+        Creates an instance from a dictionary with the same structure as ``.as_dict()`` returns.
+        """
+        if dct["tb_next"]:
+            tb_next = cls.from_dict(dct["tb_next"])
+        else:
+            tb_next = None
+
+        code = _AttrDict(
+            co_filename=dct["tb_frame"]["f_code"]["co_filename"],
+            co_name=dct["tb_frame"]["f_code"]["co_name"],
+        )
+        frame = _AttrDict(
+            f_globals=dct["tb_frame"]["f_globals"],
+            f_code=code,
+            f_lineno=dct["tb_frame"]["f_lineno"],
+        )
+        tb = _AttrDict(
+            tb_frame=frame,
+            tb_lineno=dct["tb_lineno"],
+            tb_next=tb_next,
+        )
+        return cls(tb)
+
+    @classmethod
+    def from_string(cls, string, strict=True):
+        """
+        Creates an instance by parsing a stacktrace. Strict means that parsing stops when lines are not indented by at least two spaces
+        anymore.
+        """
+        frames = []
+        header = strict
+
+        for line in string.splitlines():
+            line = line.rstrip()
+            if header:
+                if line == "Traceback (most recent call last):":
+                    header = False
+                continue
+            frame_match = FRAME_RE.match(line)
+            if frame_match:
+                frames.append(frame_match.groupdict())
+            elif line.startswith("  "):
+                pass
+            elif strict:
+                break  # traceback ended
+
+        if frames:
+            previous = None
+            for frame in reversed(frames):
+                previous = _AttrDict(
+                    frame,
+                    tb_frame=_AttrDict(
+                        frame,
+                        f_globals=_AttrDict(
+                            __file__=frame["co_filename"],
+                            __name__="?",
+                        ),
+                        f_code=_AttrDict(frame),
+                        f_lineno=int(frame["tb_lineno"]),
+                    ),
+                    tb_next=previous,
+                )
+            return cls(previous)
+        else:
+            raise TracebackParseError("Could not find any frames in %r." % string)

maxframe/lib/tblib/cpython.py

@@ -0,0 +1,83 @@
+"""
+Taken verbatim from Jinja2.
+https://github.com/mitsuhiko/jinja2/blob/master/jinja2/debug.py#L267
+"""
+import platform
+import sys
+
+
+def _init_ugly_crap():
+    """This function implements a few ugly things so that we can patch the
+    traceback objects.  The function returned allows resetting `tb_next` on
+    any python traceback object.  Do not attempt to use this on non cpython
+    interpreters
+    """
+    import ctypes
+    from types import TracebackType
+
+    # figure out side of _Py_ssize_t
+    if hasattr(ctypes.pythonapi, "Py_InitModule4_64"):
+        _Py_ssize_t = ctypes.c_int64
+    else:
+        _Py_ssize_t = ctypes.c_int
+
+    # regular python
+    class _PyObject(ctypes.Structure):
+        pass
+
+    _PyObject._fields_ = [
+        ("ob_refcnt", _Py_ssize_t),
+        ("ob_type", ctypes.POINTER(_PyObject)),
+    ]
+
+    # python with trace
+    if hasattr(sys, "getobjects"):
+
+        class _PyObject(ctypes.Structure):
+            pass
+
+        _PyObject._fields_ = [
+            ("_ob_next", ctypes.POINTER(_PyObject)),
+            ("_ob_prev", ctypes.POINTER(_PyObject)),
+            ("ob_refcnt", _Py_ssize_t),
+            ("ob_type", ctypes.POINTER(_PyObject)),
+        ]
+
+    class _Traceback(_PyObject):
+        pass
+
+    _Traceback._fields_ = [
+        ("tb_next", ctypes.POINTER(_Traceback)),
+        ("tb_frame", ctypes.POINTER(_PyObject)),
+        ("tb_lasti", ctypes.c_int),
+        ("tb_lineno", ctypes.c_int),
+    ]
+
+    def tb_set_next(tb, next):
+        """Set the tb_next attribute of a traceback object."""
+        if not (
+            isinstance(tb, TracebackType)
+            and (next is None or isinstance(next, TracebackType))
+        ):
+            raise TypeError("tb_set_next arguments must be traceback objects")
+        obj = _Traceback.from_address(id(tb))
+        if tb.tb_next is not None:
+            old = _Traceback.from_address(id(tb.tb_next))
+            old.ob_refcnt -= 1
+        if next is None:
+            obj.tb_next = ctypes.POINTER(_Traceback)()
+        else:
+            next = _Traceback.from_address(id(next))
+            next.ob_refcnt += 1
+            obj.tb_next = ctypes.pointer(next)
+
+    return tb_set_next
+
+
+tb_set_next = None
+try:
+    if platform.python_implementation() == "CPython":
+        tb_set_next = _init_ugly_crap()
+except Exception as exc:
+    sys.stderr.write("Failed to initialize cpython support: {!r}".format(exc))
+del _init_ugly_crap

maxframe/lib/tblib/decorators.py

@@ -0,0 +1,44 @@
+import sys
+from functools import wraps
+
+from . import Traceback
+
+
+class Error(object):
+    def __init__(self, exc_type, exc_value, traceback):
+        self.exc_type = exc_type
+        self.exc_value = exc_value
+        self.__traceback = Traceback(traceback)
+
+    @property
+    def traceback(self):
+        return self.__traceback.as_traceback()
+
+    def reraise(self):
+        raise self.exc_value.with_traceback(self.traceback) from None
+
+
+def return_error(func, exc_type=Exception):
+    @wraps(func)
+    def return_exceptions_wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except exc_type:
+            return Error(*sys.exc_info())
+
+    return return_exceptions_wrapper
+
+
+returns_error = (
+    return_errors
+) = returns_errors = return_error  # cause I make too many typos
+
+
+@return_error
+def apply_with_return_error(args):
+    """
+    args is a tuple where the first argument is a callable.
+    eg::
+        apply_with_return_error((func, 1, 2, 3)) - this will call func(1, 2, 3)
+    """
+    return args[0](*args[1:])

maxframe/lib/tblib/pickling_support.py

@@ -0,0 +1,90 @@
+import sys
+from types import TracebackType
+
+from . import Frame, Traceback
+
+if sys.version_info.major >= 3:
+    import copyreg
+else:
+    import copy_reg as copyreg
+
+
+def unpickle_traceback(tb_frame, tb_lineno, tb_next):
+    ret = object.__new__(Traceback)
+    ret.tb_frame = tb_frame
+    ret.tb_lineno = tb_lineno
+    ret.tb_next = tb_next
+    return ret.as_traceback()
+
+
+def pickle_traceback(tb):
+    return unpickle_traceback, (
+        Frame(tb.tb_frame),
+        tb.tb_lineno,
+        tb.tb_next and Traceback(tb.tb_next),
+    )
+
+
+def unpickle_exception(func, args, cause, tb):
+    inst = func(*args)
+    inst.__cause__ = cause
+    inst.__traceback__ = tb
+    return inst
+
+
+def pickle_exception(obj):
+    # All exceptions, unlike generic Python objects, define __reduce_ex__
+    # __reduce_ex__(4) should be no different from __reduce_ex__(3).
+    # __reduce_ex__(5) could bring benefits in the unlikely case the exception
+    # directly contains buffers, but PickleBuffer objects will cause a crash when
+    # running on protocol=4, and there's no clean way to figure out the current
+    # protocol from here. Note that any object returned by __reduce_ex__(3) will
+    # still be pickled with protocol 5 if pickle.dump() is running with it.
+    rv = obj.__reduce_ex__(3)
+    if isinstance(rv, str):
+        raise TypeError("str __reduce__ output is not supported")
+    assert isinstance(rv, tuple) and len(rv) >= 2
+
+    return (unpickle_exception, rv[:2] + (obj.__cause__, obj.__traceback__)) + rv[2:]
+
+
+def _get_subclasses(cls):
+    # Depth-first traversal of all direct and indirect subclasses of cls
+    to_visit = [cls]
+    while to_visit:
+        this = to_visit.pop()
+        yield this
+        to_visit += list(this.__subclasses__())
+
+
+def install(*exc_classes_or_instances):
+    copyreg.pickle(TracebackType, pickle_traceback)
+
+    if sys.version_info.major < 3:
+        # Dummy decorator?
+        if len(exc_classes_or_instances) == 1:
+            exc = exc_classes_or_instances[0]
+            if isinstance(exc, type) and issubclass(exc, BaseException):
+                return exc
+        return
+
+    if not exc_classes_or_instances:
+        for exception_cls in _get_subclasses(BaseException):
+            copyreg.pickle(exception_cls, pickle_exception)
+        return
+
+    for exc in exc_classes_or_instances:
+        if isinstance(exc, BaseException):
+            while exc is not None:
+                copyreg.pickle(type(exc), pickle_exception)
+                exc = exc.__cause__
+        elif isinstance(exc, type) and issubclass(exc, BaseException):
+            copyreg.pickle(exc, pickle_exception)
+            # Allow using @install as a decorator for Exception classes
+            if len(exc_classes_or_instances) == 1:
+                return exc
+        else:
+            raise TypeError(
+                "Expected subclasses or instances of BaseException, got %s"
+                % (type(exc))
+            )

maxframe/lib/tests/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

maxframe/lib/tests/test_wrapped_pickle.py

@@ -0,0 +1,51 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import io
+import pickle
+
+import pytest
+
+from ..wrapped_pickle import switch_unpickle
+
+
+@pytest.mark.asyncio
+async def test_wrapped_pickle():
+    data = ["abcd", ["efgh"], {"ijk": "lm"}]
+    pickled = pickle.dumps(data)
+    assert pickle.loads(pickled) == data
+
+    # patched pickle can be used normally
+    assert pickle.load(io.BytesIO(pickled)) == data
+
+    # when pickle prohibition is enabled, errors will be raised
+    with pytest.raises(ValueError), switch_unpickle():
+        pickle.loads(pickled)
+
+    @switch_unpickle
+    def limited_func():
+        pickle.loads(pickled)
+
+    with pytest.raises(ValueError):
+        limited_func()
+
+    @switch_unpickle
+    async def limited_async_func():
+        pickle.loads(pickled)
+
+    with pytest.raises(ValueError):
+        await limited_async_func()
+
+    # patched pickle can be used normally when prohibition is eliminated
+    assert pickle.load(io.BytesIO(pickled)) == data