Add python venv
This commit is contained in:
Isaac Shoebottom
@ -0,0 +1,40 @@
|
||||
__all__ = [
|
||||
"BaseExceptionGroup",
|
||||
"ExceptionGroup",
|
||||
"catch",
|
||||
"format_exception",
|
||||
"format_exception_only",
|
||||
"print_exception",
|
||||
"print_exc",
|
||||
]
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
from ._catch import catch
|
||||
from ._version import version as __version__ # noqa: F401
|
||||
|
||||
if sys.version_info < (3, 11):
|
||||
from ._exceptions import BaseExceptionGroup, ExceptionGroup
|
||||
from ._formatting import (
|
||||
format_exception,
|
||||
format_exception_only,
|
||||
print_exc,
|
||||
print_exception,
|
||||
)
|
||||
|
||||
if os.getenv("EXCEPTIONGROUP_NO_PATCH") != "1":
|
||||
from . import _formatting # noqa: F401
|
||||
|
||||
BaseExceptionGroup.__module__ = __name__
|
||||
ExceptionGroup.__module__ = __name__
|
||||
else:
|
||||
from traceback import (
|
||||
format_exception,
|
||||
format_exception_only,
|
||||
print_exc,
|
||||
print_exception,
|
||||
)
|
||||
|
||||
BaseExceptionGroup = BaseExceptionGroup
|
||||
ExceptionGroup = ExceptionGroup
|
||||
114
utils/python-venv/Lib/site-packages/exceptiongroup/_catch.py
Normal file
114
utils/python-venv/Lib/site-packages/exceptiongroup/_catch.py
Normal file
@ -0,0 +1,114 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
from collections.abc import Callable, Iterable, Mapping
|
||||
from contextlib import AbstractContextManager
|
||||
from types import TracebackType
|
||||
from typing import TYPE_CHECKING, Any
|
||||
|
||||
if sys.version_info < (3, 11):
|
||||
from ._exceptions import BaseExceptionGroup
|
||||
|
||||
if TYPE_CHECKING:
|
||||
_Handler = Callable[[BaseException], Any]
|
||||
|
||||
|
||||
class _Catcher:
|
||||
def __init__(self, handler_map: Mapping[tuple[type[BaseException], ...], _Handler]):
|
||||
self._handler_map = handler_map
|
||||
|
||||
def __enter__(self) -> None:
|
||||
pass
|
||||
|
||||
def __exit__(
|
||||
self,
|
||||
etype: type[BaseException] | None,
|
||||
exc: BaseException | None,
|
||||
tb: TracebackType | None,
|
||||
) -> bool:
|
||||
if exc is not None:
|
||||
unhandled = self.handle_exception(exc)
|
||||
if unhandled is exc:
|
||||
return False
|
||||
elif unhandled is None:
|
||||
return True
|
||||
else:
|
||||
raise unhandled from None
|
||||
|
||||
return False
|
||||
|
||||
def handle_exception(self, exc: BaseException) -> BaseExceptionGroup | None:
|
||||
excgroup: BaseExceptionGroup | None
|
||||
if isinstance(exc, BaseExceptionGroup):
|
||||
excgroup = exc
|
||||
else:
|
||||
excgroup = BaseExceptionGroup("", [exc])
|
||||
|
||||
new_exceptions: list[BaseException] = []
|
||||
for exc_types, handler in self._handler_map.items():
|
||||
matched, excgroup = excgroup.split(exc_types)
|
||||
if matched:
|
||||
try:
|
||||
handler(matched)
|
||||
except BaseException as new_exc:
|
||||
new_exceptions.append(new_exc)
|
||||
|
||||
if not excgroup:
|
||||
break
|
||||
|
||||
if new_exceptions:
|
||||
if excgroup:
|
||||
new_exceptions.append(excgroup)
|
||||
|
||||
return BaseExceptionGroup("", new_exceptions)
|
||||
elif (
|
||||
excgroup and len(excgroup.exceptions) == 1 and excgroup.exceptions[0] is exc
|
||||
):
|
||||
return exc
|
||||
else:
|
||||
return excgroup
|
||||
|
||||
|
||||
def catch(
|
||||
__handlers: Mapping[type[BaseException] | Iterable[type[BaseException]], _Handler]
|
||||
) -> AbstractContextManager[None]:
|
||||
if not isinstance(__handlers, Mapping):
|
||||
raise TypeError("the argument must be a mapping")
|
||||
|
||||
handler_map: dict[
|
||||
tuple[type[BaseException], ...], Callable[[BaseExceptionGroup]]
|
||||
] = {}
|
||||
for type_or_iterable, handler in __handlers.items():
|
||||
iterable: tuple[type[BaseException]]
|
||||
if isinstance(type_or_iterable, type) and issubclass(
|
||||
type_or_iterable, BaseException
|
||||
):
|
||||
iterable = (type_or_iterable,)
|
||||
elif isinstance(type_or_iterable, Iterable):
|
||||
iterable = tuple(type_or_iterable)
|
||||
else:
|
||||
raise TypeError(
|
||||
"each key must be either an exception classes or an iterable thereof"
|
||||
)
|
||||
|
||||
if not callable(handler):
|
||||
raise TypeError("handlers must be callable")
|
||||
|
||||
for exc_type in iterable:
|
||||
if not isinstance(exc_type, type) or not issubclass(
|
||||
exc_type, BaseException
|
||||
):
|
||||
raise TypeError(
|
||||
"each key must be either an exception classes or an iterable "
|
||||
"thereof"
|
||||
)
|
||||
|
||||
if issubclass(exc_type, BaseExceptionGroup):
|
||||
raise TypeError(
|
||||
"catching ExceptionGroup with catch() is not allowed. "
|
||||
"Use except instead."
|
||||
)
|
||||
|
||||
handler_map[iterable] = handler
|
||||
|
||||
return _Catcher(handler_map)
|
||||
@ -0,0 +1,185 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from collections.abc import Sequence
|
||||
from functools import partial
|
||||
from inspect import getmro, isclass
|
||||
from typing import Any, Callable, Generic, Tuple, Type, TypeVar, Union, cast
|
||||
|
||||
T = TypeVar("T", bound="BaseExceptionGroup")
|
||||
EBase = TypeVar("EBase", bound=BaseException)
|
||||
E = TypeVar("E", bound=Exception)
|
||||
_SplitCondition = Union[
|
||||
Type[EBase],
|
||||
Tuple[Type[EBase], ...],
|
||||
Callable[[EBase], bool],
|
||||
]
|
||||
|
||||
|
||||
def check_direct_subclass(
|
||||
exc: BaseException, parents: tuple[type[BaseException]]
|
||||
) -> bool:
|
||||
for cls in getmro(exc.__class__)[:-1]:
|
||||
if cls in parents:
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
|
||||
def get_condition_filter(condition: _SplitCondition) -> Callable[[BaseException], bool]:
|
||||
if isclass(condition) and issubclass(
|
||||
cast(Type[BaseException], condition), BaseException
|
||||
):
|
||||
return partial(check_direct_subclass, parents=(condition,))
|
||||
elif isinstance(condition, tuple):
|
||||
if all(isclass(x) and issubclass(x, BaseException) for x in condition):
|
||||
return partial(check_direct_subclass, parents=condition)
|
||||
elif callable(condition):
|
||||
return cast(Callable[[BaseException], bool], condition)
|
||||
|
||||
raise TypeError("expected a function, exception type or tuple of exception types")
|
||||
|
||||
|
||||
class BaseExceptionGroup(BaseException, Generic[EBase]):
|
||||
"""A combination of multiple unrelated exceptions."""
|
||||
|
||||
def __new__(
|
||||
cls, __message: str, __exceptions: Sequence[EBase]
|
||||
) -> BaseExceptionGroup[EBase] | ExceptionGroup[E]:
|
||||
if not isinstance(__message, str):
|
||||
raise TypeError(f"argument 1 must be str, not {type(__message)}")
|
||||
if not isinstance(__exceptions, Sequence):
|
||||
raise TypeError("second argument (exceptions) must be a sequence")
|
||||
if not __exceptions:
|
||||
raise ValueError(
|
||||
"second argument (exceptions) must be a non-empty sequence"
|
||||
)
|
||||
|
||||
for i, exc in enumerate(__exceptions):
|
||||
if not isinstance(exc, BaseException):
|
||||
raise ValueError(
|
||||
f"Item {i} of second argument (exceptions) is not an " f"exception"
|
||||
)
|
||||
|
||||
if cls is BaseExceptionGroup:
|
||||
if all(isinstance(exc, Exception) for exc in __exceptions):
|
||||
cls = ExceptionGroup
|
||||
|
||||
return super().__new__(cls, __message, __exceptions)
|
||||
|
||||
def __init__(self, __message: str, __exceptions: Sequence[EBase], *args: Any):
|
||||
super().__init__(__message, __exceptions, *args)
|
||||
self._message = __message
|
||||
self._exceptions = __exceptions
|
||||
|
||||
def add_note(self, note: str) -> None:
|
||||
if not isinstance(note, str):
|
||||
raise TypeError(
|
||||
f"Expected a string, got note={note!r} (type {type(note).__name__})"
|
||||
)
|
||||
|
||||
if not hasattr(self, "__notes__"):
|
||||
self.__notes__: list[str] = []
|
||||
|
||||
self.__notes__.append(note)
|
||||
|
||||
@property
|
||||
def message(self) -> str:
|
||||
return self._message
|
||||
|
||||
@property
|
||||
def exceptions(self) -> tuple[EBase, ...]:
|
||||
return tuple(self._exceptions)
|
||||
|
||||
def subgroup(self: T, __condition: _SplitCondition[EBase]) -> T | None:
|
||||
condition = get_condition_filter(__condition)
|
||||
modified = False
|
||||
if condition(self):
|
||||
return self
|
||||
|
||||
exceptions: list[BaseException] = []
|
||||
for exc in self.exceptions:
|
||||
if isinstance(exc, BaseExceptionGroup):
|
||||
subgroup = exc.subgroup(condition)
|
||||
if subgroup is not None:
|
||||
exceptions.append(subgroup)
|
||||
|
||||
if subgroup is not exc:
|
||||
modified = True
|
||||
elif condition(exc):
|
||||
exceptions.append(exc)
|
||||
else:
|
||||
modified = True
|
||||
|
||||
if not modified:
|
||||
return self
|
||||
elif exceptions:
|
||||
group = self.derive(exceptions)
|
||||
group.__cause__ = self.__cause__
|
||||
group.__context__ = self.__context__
|
||||
group.__traceback__ = self.__traceback__
|
||||
return group
|
||||
else:
|
||||
return None
|
||||
|
||||
def split(
|
||||
self: T, __condition: _SplitCondition[EBase]
|
||||
) -> tuple[T | None, T | None]:
|
||||
condition = get_condition_filter(__condition)
|
||||
if condition(self):
|
||||
return self, None
|
||||
|
||||
matching_exceptions: list[BaseException] = []
|
||||
nonmatching_exceptions: list[BaseException] = []
|
||||
for exc in self.exceptions:
|
||||
if isinstance(exc, BaseExceptionGroup):
|
||||
matching, nonmatching = exc.split(condition)
|
||||
if matching is not None:
|
||||
matching_exceptions.append(matching)
|
||||
|
||||
if nonmatching is not None:
|
||||
nonmatching_exceptions.append(nonmatching)
|
||||
elif condition(exc):
|
||||
matching_exceptions.append(exc)
|
||||
else:
|
||||
nonmatching_exceptions.append(exc)
|
||||
|
||||
matching_group: T | None = None
|
||||
if matching_exceptions:
|
||||
matching_group = self.derive(matching_exceptions)
|
||||
matching_group.__cause__ = self.__cause__
|
||||
matching_group.__context__ = self.__context__
|
||||
matching_group.__traceback__ = self.__traceback__
|
||||
|
||||
nonmatching_group: T | None = None
|
||||
if nonmatching_exceptions:
|
||||
nonmatching_group = self.derive(nonmatching_exceptions)
|
||||
nonmatching_group.__cause__ = self.__cause__
|
||||
nonmatching_group.__context__ = self.__context__
|
||||
nonmatching_group.__traceback__ = self.__traceback__
|
||||
|
||||
return matching_group, nonmatching_group
|
||||
|
||||
def derive(self: T, __excs: Sequence[EBase]) -> T:
|
||||
eg = BaseExceptionGroup(self.message, __excs)
|
||||
if hasattr(self, "__notes__"):
|
||||
# Create a new list so that add_note() only affects one exceptiongroup
|
||||
eg.__notes__ = list(self.__notes__)
|
||||
return eg
|
||||
|
||||
def __str__(self) -> str:
|
||||
suffix = "" if len(self._exceptions) == 1 else "s"
|
||||
return f"{self.message} ({len(self._exceptions)} sub-exception{suffix})"
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f"{self.__class__.__name__}({self.message!r}, {self._exceptions!r})"
|
||||
|
||||
|
||||
class ExceptionGroup(BaseExceptionGroup[E], Exception, Generic[E]):
|
||||
def __new__(cls, __message: str, __exceptions: Sequence[E]) -> ExceptionGroup[E]:
|
||||
instance: ExceptionGroup[E] = super().__new__(cls, __message, __exceptions)
|
||||
if cls is ExceptionGroup:
|
||||
for exc in __exceptions:
|
||||
if not isinstance(exc, Exception):
|
||||
raise TypeError("Cannot nest BaseExceptions in an ExceptionGroup")
|
||||
|
||||
return instance
|
||||
@ -0,0 +1,399 @@
|
||||
# traceback_exception_init() adapted from trio
|
||||
#
|
||||
# _ExceptionPrintContext and traceback_exception_format() copied from the standard
|
||||
# library
|
||||
from __future__ import annotations
|
||||
|
||||
import collections.abc
|
||||
import sys
|
||||
import textwrap
|
||||
import traceback
|
||||
from functools import singledispatch
|
||||
from types import TracebackType
|
||||
from typing import Any, List, Optional
|
||||
|
||||
from ._exceptions import BaseExceptionGroup
|
||||
|
||||
max_group_width = 15
|
||||
max_group_depth = 10
|
||||
_cause_message = (
|
||||
"\nThe above exception was the direct cause of the following exception:\n\n"
|
||||
)
|
||||
|
||||
_context_message = (
|
||||
"\nDuring handling of the above exception, another exception occurred:\n\n"
|
||||
)
|
||||
|
||||
|
||||
def _format_final_exc_line(etype, value):
|
||||
valuestr = _safe_string(value, "exception")
|
||||
if value is None or not valuestr:
|
||||
line = f"{etype}\n"
|
||||
else:
|
||||
line = f"{etype}: {valuestr}\n"
|
||||
|
||||
return line
|
||||
|
||||
|
||||
def _safe_string(value, what, func=str):
|
||||
try:
|
||||
return func(value)
|
||||
except BaseException:
|
||||
return f"<{what} {func.__name__}() failed>"
|
||||
|
||||
|
||||
class _ExceptionPrintContext:
|
||||
def __init__(self):
|
||||
self.seen = set()
|
||||
self.exception_group_depth = 0
|
||||
self.need_close = False
|
||||
|
||||
def indent(self):
|
||||
return " " * (2 * self.exception_group_depth)
|
||||
|
||||
def emit(self, text_gen, margin_char=None):
|
||||
if margin_char is None:
|
||||
margin_char = "|"
|
||||
indent_str = self.indent()
|
||||
if self.exception_group_depth:
|
||||
indent_str += margin_char + " "
|
||||
|
||||
if isinstance(text_gen, str):
|
||||
yield textwrap.indent(text_gen, indent_str, lambda line: True)
|
||||
else:
|
||||
for text in text_gen:
|
||||
yield textwrap.indent(text, indent_str, lambda line: True)
|
||||
|
||||
|
||||
def exceptiongroup_excepthook(
|
||||
etype: type[BaseException], value: BaseException, tb: TracebackType | None
|
||||
) -> None:
|
||||
sys.stderr.write("".join(traceback.format_exception(etype, value, tb)))
|
||||
|
||||
|
||||
class PatchedTracebackException(traceback.TracebackException):
|
||||
def __init__(
|
||||
self,
|
||||
exc_type: type[BaseException],
|
||||
exc_value: BaseException,
|
||||
exc_traceback: TracebackType | None,
|
||||
*,
|
||||
limit: int | None = None,
|
||||
lookup_lines: bool = True,
|
||||
capture_locals: bool = False,
|
||||
compact: bool = False,
|
||||
_seen: set[int] | None = None,
|
||||
) -> None:
|
||||
kwargs: dict[str, Any] = {}
|
||||
if sys.version_info >= (3, 10):
|
||||
kwargs["compact"] = compact
|
||||
|
||||
traceback_exception_original_init(
|
||||
self,
|
||||
exc_type,
|
||||
exc_value,
|
||||
exc_traceback,
|
||||
limit=limit,
|
||||
lookup_lines=lookup_lines,
|
||||
capture_locals=capture_locals,
|
||||
_seen=_seen,
|
||||
**kwargs,
|
||||
)
|
||||
|
||||
is_recursive_call = _seen is not None
|
||||
if _seen is None:
|
||||
_seen = set()
|
||||
_seen.add(id(exc_value))
|
||||
|
||||
# Convert __cause__ and __context__ to `TracebackExceptions`s, use a
|
||||
# queue to avoid recursion (only the top-level call gets _seen == None)
|
||||
if not is_recursive_call:
|
||||
queue = [(self, exc_value)]
|
||||
while queue:
|
||||
te, e = queue.pop()
|
||||
|
||||
if e and e.__cause__ is not None and id(e.__cause__) not in _seen:
|
||||
cause = PatchedTracebackException(
|
||||
type(e.__cause__),
|
||||
e.__cause__,
|
||||
e.__cause__.__traceback__,
|
||||
limit=limit,
|
||||
lookup_lines=lookup_lines,
|
||||
capture_locals=capture_locals,
|
||||
_seen=_seen,
|
||||
)
|
||||
else:
|
||||
cause = None
|
||||
|
||||
if compact:
|
||||
need_context = (
|
||||
cause is None and e is not None and not e.__suppress_context__
|
||||
)
|
||||
else:
|
||||
need_context = True
|
||||
if (
|
||||
e
|
||||
and e.__context__ is not None
|
||||
and need_context
|
||||
and id(e.__context__) not in _seen
|
||||
):
|
||||
context = PatchedTracebackException(
|
||||
type(e.__context__),
|
||||
e.__context__,
|
||||
e.__context__.__traceback__,
|
||||
limit=limit,
|
||||
lookup_lines=lookup_lines,
|
||||
capture_locals=capture_locals,
|
||||
_seen=_seen,
|
||||
)
|
||||
else:
|
||||
context = None
|
||||
|
||||
# Capture each of the exceptions in the ExceptionGroup along with each
|
||||
# of their causes and contexts
|
||||
if e and isinstance(e, BaseExceptionGroup):
|
||||
exceptions = []
|
||||
for exc in e.exceptions:
|
||||
texc = PatchedTracebackException(
|
||||
type(exc),
|
||||
exc,
|
||||
exc.__traceback__,
|
||||
lookup_lines=lookup_lines,
|
||||
capture_locals=capture_locals,
|
||||
_seen=_seen,
|
||||
)
|
||||
exceptions.append(texc)
|
||||
else:
|
||||
exceptions = None
|
||||
|
||||
te.__cause__ = cause
|
||||
te.__context__ = context
|
||||
te.exceptions = exceptions
|
||||
if cause:
|
||||
queue.append((te.__cause__, e.__cause__))
|
||||
if context:
|
||||
queue.append((te.__context__, e.__context__))
|
||||
if exceptions:
|
||||
queue.extend(zip(te.exceptions, e.exceptions))
|
||||
|
||||
self.__notes__ = getattr(exc_value, "__notes__", ())
|
||||
|
||||
def format(self, *, chain=True, _ctx=None):
|
||||
if _ctx is None:
|
||||
_ctx = _ExceptionPrintContext()
|
||||
|
||||
output = []
|
||||
exc = self
|
||||
if chain:
|
||||
while exc:
|
||||
if exc.__cause__ is not None:
|
||||
chained_msg = _cause_message
|
||||
chained_exc = exc.__cause__
|
||||
elif exc.__context__ is not None and not exc.__suppress_context__:
|
||||
chained_msg = _context_message
|
||||
chained_exc = exc.__context__
|
||||
else:
|
||||
chained_msg = None
|
||||
chained_exc = None
|
||||
|
||||
output.append((chained_msg, exc))
|
||||
exc = chained_exc
|
||||
else:
|
||||
output.append((None, exc))
|
||||
|
||||
for msg, exc in reversed(output):
|
||||
if msg is not None:
|
||||
yield from _ctx.emit(msg)
|
||||
if exc.exceptions is None:
|
||||
if exc.stack:
|
||||
yield from _ctx.emit("Traceback (most recent call last):\n")
|
||||
yield from _ctx.emit(exc.stack.format())
|
||||
yield from _ctx.emit(exc.format_exception_only())
|
||||
elif _ctx.exception_group_depth > max_group_depth:
|
||||
# exception group, but depth exceeds limit
|
||||
yield from _ctx.emit(f"... (max_group_depth is {max_group_depth})\n")
|
||||
else:
|
||||
# format exception group
|
||||
is_toplevel = _ctx.exception_group_depth == 0
|
||||
if is_toplevel:
|
||||
_ctx.exception_group_depth += 1
|
||||
|
||||
if exc.stack:
|
||||
yield from _ctx.emit(
|
||||
"Exception Group Traceback (most recent call last):\n",
|
||||
margin_char="+" if is_toplevel else None,
|
||||
)
|
||||
yield from _ctx.emit(exc.stack.format())
|
||||
|
||||
yield from _ctx.emit(exc.format_exception_only())
|
||||
num_excs = len(exc.exceptions)
|
||||
if num_excs <= max_group_width:
|
||||
n = num_excs
|
||||
else:
|
||||
n = max_group_width + 1
|
||||
_ctx.need_close = False
|
||||
for i in range(n):
|
||||
last_exc = i == n - 1
|
||||
if last_exc:
|
||||
# The closing frame may be added by a recursive call
|
||||
_ctx.need_close = True
|
||||
|
||||
if max_group_width is not None:
|
||||
truncated = i >= max_group_width
|
||||
else:
|
||||
truncated = False
|
||||
title = f"{i + 1}" if not truncated else "..."
|
||||
yield (
|
||||
_ctx.indent()
|
||||
+ ("+-" if i == 0 else " ")
|
||||
+ f"+---------------- {title} ----------------\n"
|
||||
)
|
||||
_ctx.exception_group_depth += 1
|
||||
if not truncated:
|
||||
yield from exc.exceptions[i].format(chain=chain, _ctx=_ctx)
|
||||
else:
|
||||
remaining = num_excs - max_group_width
|
||||
plural = "s" if remaining > 1 else ""
|
||||
yield from _ctx.emit(
|
||||
f"and {remaining} more exception{plural}\n"
|
||||
)
|
||||
|
||||
if last_exc and _ctx.need_close:
|
||||
yield _ctx.indent() + "+------------------------------------\n"
|
||||
_ctx.need_close = False
|
||||
_ctx.exception_group_depth -= 1
|
||||
|
||||
if is_toplevel:
|
||||
assert _ctx.exception_group_depth == 1
|
||||
_ctx.exception_group_depth = 0
|
||||
|
||||
def format_exception_only(self):
|
||||
"""Format the exception part of the traceback.
|
||||
The return value is a generator of strings, each ending in a newline.
|
||||
Normally, the generator emits a single string; however, for
|
||||
SyntaxError exceptions, it emits several lines that (when
|
||||
printed) display detailed information about where the syntax
|
||||
error occurred.
|
||||
The message indicating which exception occurred is always the last
|
||||
string in the output.
|
||||
"""
|
||||
if self.exc_type is None:
|
||||
yield traceback._format_final_exc_line(None, self._str)
|
||||
return
|
||||
|
||||
stype = self.exc_type.__qualname__
|
||||
smod = self.exc_type.__module__
|
||||
if smod not in ("__main__", "builtins"):
|
||||
if not isinstance(smod, str):
|
||||
smod = "<unknown>"
|
||||
stype = smod + "." + stype
|
||||
|
||||
if not issubclass(self.exc_type, SyntaxError):
|
||||
yield _format_final_exc_line(stype, self._str)
|
||||
elif traceback_exception_format_syntax_error is not None:
|
||||
yield from traceback_exception_format_syntax_error(self, stype)
|
||||
else:
|
||||
yield from traceback_exception_original_format_exception_only(self)
|
||||
|
||||
if isinstance(self.__notes__, collections.abc.Sequence):
|
||||
for note in self.__notes__:
|
||||
note = _safe_string(note, "note")
|
||||
yield from [line + "\n" for line in note.split("\n")]
|
||||
elif self.__notes__ is not None:
|
||||
yield _safe_string(self.__notes__, "__notes__", func=repr)
|
||||
|
||||
|
||||
traceback_exception_original_init = traceback.TracebackException.__init__
|
||||
traceback_exception_original_format = traceback.TracebackException.format
|
||||
traceback_exception_original_format_exception_only = (
|
||||
traceback.TracebackException.format_exception_only
|
||||
)
|
||||
traceback_exception_format_syntax_error = getattr(
|
||||
traceback.TracebackException, "_format_syntax_error", None
|
||||
)
|
||||
if sys.excepthook is sys.__excepthook__:
|
||||
traceback.TracebackException.__init__ = ( # type: ignore[assignment]
|
||||
PatchedTracebackException.__init__
|
||||
)
|
||||
traceback.TracebackException.format = ( # type: ignore[assignment]
|
||||
PatchedTracebackException.format
|
||||
)
|
||||
traceback.TracebackException.format_exception_only = ( # type: ignore[assignment]
|
||||
PatchedTracebackException.format_exception_only
|
||||
)
|
||||
sys.excepthook = exceptiongroup_excepthook
|
||||
|
||||
|
||||
@singledispatch
|
||||
def format_exception_only(__exc: BaseException) -> List[str]:
|
||||
return list(
|
||||
PatchedTracebackException(
|
||||
type(__exc), __exc, None, compact=True
|
||||
).format_exception_only()
|
||||
)
|
||||
|
||||
|
||||
@format_exception_only.register
|
||||
def _(__exc: type, value: BaseException) -> List[str]:
|
||||
return format_exception_only(value)
|
||||
|
||||
|
||||
@singledispatch
|
||||
def format_exception(
|
||||
__exc: BaseException,
|
||||
limit: Optional[int] = None,
|
||||
chain: bool = True,
|
||||
) -> List[str]:
|
||||
return list(
|
||||
PatchedTracebackException(
|
||||
type(__exc), __exc, __exc.__traceback__, limit=limit, compact=True
|
||||
).format(chain=chain)
|
||||
)
|
||||
|
||||
|
||||
@format_exception.register
|
||||
def _(
|
||||
__exc: type,
|
||||
value: BaseException,
|
||||
tb: TracebackType,
|
||||
limit: Optional[int] = None,
|
||||
chain: bool = True,
|
||||
) -> List[str]:
|
||||
return format_exception(value, limit, chain)
|
||||
|
||||
|
||||
@singledispatch
|
||||
def print_exception(
|
||||
__exc: BaseException,
|
||||
limit: Optional[int] = None,
|
||||
file: Any = None,
|
||||
chain: bool = True,
|
||||
) -> None:
|
||||
if file is None:
|
||||
file = sys.stderr
|
||||
|
||||
for line in PatchedTracebackException(
|
||||
type(__exc), __exc, __exc.__traceback__, limit=limit
|
||||
).format(chain=chain):
|
||||
print(line, file=file, end="")
|
||||
|
||||
|
||||
@print_exception.register
|
||||
def _(
|
||||
__exc: type,
|
||||
value: BaseException,
|
||||
tb: TracebackType,
|
||||
limit: Optional[int] = None,
|
||||
file: Any = None,
|
||||
chain: bool = True,
|
||||
) -> None:
|
||||
print_exception(value, limit, file, chain)
|
||||
|
||||
|
||||
def print_exc(
|
||||
limit: Optional[int] = None,
|
||||
file: Any | None = None,
|
||||
chain: bool = True,
|
||||
) -> None:
|
||||
value = sys.exc_info()[1]
|
||||
print_exception(value, limit, file, chain)
|
||||
@ -0,0 +1,5 @@
|
||||
# coding: utf-8
|
||||
# file generated by setuptools_scm
|
||||
# don't change, don't track in version control
|
||||
__version__ = version = '1.0.0'
|
||||
__version_tuple__ = version_tuple = (1, 0, 0)
|
||||
Reference in New Issue
Block a user