errortools 2.5.0__tar.gz → 3.0.0__tar.gz

{errortools-2.5.0/errortools.egg-info → errortools-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: errortools
-Version: 2.5.0
+Version: 3.0.0
 Summary: errortools - a toolset for working with Python exceptions and warnings and logging.
 Home-page: https://github.com/more-abc/errortools
 Author: Evan Yang
@@ -8,6 +8,8 @@ Author-email: quantbit@126.com
 License: MIT
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -16,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Operating System :: OS Independent
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 License-File: AUTHORS.txt
@@ -51,7 +53,6 @@ A lightweight Python exception handling utility library.
 - **Future Utilities**: `super_fast_catch()`, `super_fast_reraise()`, `ExceptionCollector` — lightweight exception handling for high-performance scenarios
 - **Exception Caching**: `error_cache` — cache exceptions raised by functions (similar to `lru_cache`)
 - **Custom Exceptions**: `PureBaseException`, `ContextException`, `BaseErrorCodes`, `BaseWarning` — structured exception classes with error codes, trace IDs, and context
-- **Attribute Error Mixin**: Customize error behavior for attribute access, assignment, and deletion
 - **Type Aliases**: `ExceptionType`, `AnyErrorCode`, `BaseErrorCodesType`, and more
 - **Logging**: `logger` — loguru-inspired structured logger with leveled output, multiple sinks, context binding, and exception capture
 

{errortools-2.5.0 → errortools-3.0.0}/README.md

@@ -15,7 +15,6 @@ A lightweight Python exception handling utility library.
 - **Future Utilities**: `super_fast_catch()`, `super_fast_reraise()`, `ExceptionCollector` — lightweight exception handling for high-performance scenarios
 - **Exception Caching**: `error_cache` — cache exceptions raised by functions (similar to `lru_cache`)
 - **Custom Exceptions**: `PureBaseException`, `ContextException`, `BaseErrorCodes`, `BaseWarning` — structured exception classes with error codes, trace IDs, and context
-- **Attribute Error Mixin**: Customize error behavior for attribute access, assignment, and deletion
 - **Type Aliases**: `ExceptionType`, `AnyErrorCode`, `BaseErrorCodesType`, and more
 - **Logging**: `logger` — loguru-inspired structured logger with leveled output, multiple sinks, context binding, and exception capture
 

errortools-3.0.0/_errortools/_speedup.c

@@ -0,0 +1,58 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+/* Fast exception type checking */
+static PyObject* fast_issubclass_check(PyObject* self, PyObject* args) {
+    PyObject *typ, *excs;
+    if (!PyArg_ParseTuple(args, "OO", &typ, &excs)) {
+        return NULL;
+    }
+
+    if (typ == Py_None) {
+        Py_RETURN_FALSE;
+    }
+
+    int result = PyObject_IsSubclass(typ, excs);
+    if (result == -1) {
+        return NULL;
+    }
+
+    return PyBool_FromLong(result);
+}
+
+/* Fast exception collector append */
+static PyObject* fast_append_exception(PyObject* self, PyObject* args) {
+    PyObject *list, *exc;
+    if (!PyArg_ParseTuple(args, "OO", &list, &exc)) {
+        return NULL;
+    }
+
+    if (PyList_Append(list, exc) == -1) {
+        return NULL;
+    }
+
+    Py_RETURN_NONE;
+}
+
+/* Method definitions */
+static PyMethodDef SpeedupMethods[] = {
+    {"fast_issubclass_check", fast_issubclass_check, METH_VARARGS,
+     "Fast exception type checking"},
+    {"fast_append_exception", fast_append_exception, METH_VARARGS,
+     "Fast exception list append"},
+    {NULL, NULL, 0, NULL}
+};
+
+/* Module definition */
+static struct PyModuleDef speedupmodule = {
+    PyModuleDef_HEAD_INIT,
+    "_speedup",
+    "C speedup for errortools",
+    -1,
+    SpeedupMethods
+};
+
+/* Module initialization */
+PyMODINIT_FUNC PyInit__speedup(void) {
+    return PyModule_Create(&speedupmodule);
+}

{errortools-2.5.0 → errortools-3.0.0}/_errortools/classes/abc.py

@@ -11,13 +11,6 @@ if sys.version_info >= (3, 15):
 else:
     from typing_extensions import disjoint_base
 
-from ..methods import (
-    ErrorAttrMixin,
-    ErrorAttrCheckMixin,
-    ErrorAttrDeletionMixin,
-    ErrorSetAttrMixin,
-)
-
 
 def _check_methods(C: type[Any], *methods: str) -> Union[bool, Literal[NotImplemented]]:  # type: ignore
     """Check methods in `C`. If has, return `True`, else `NotImplemented`."""
@@ -36,147 +29,6 @@ def _check_methods(C: type[Any], *methods: str) -> Union[bool, Literal[NotImplem
     return True
 
 
-@disjoint_base
-class ErrorAttrable(ABC):
-    """
-    Abstract Base Class (ABC) for classes supporting custom attribute error handling.
-
-    This class follows the design pattern of `collections.abc` (e.g., Iterable, Mapping):
-    - Uses `__subclasshook__` + `_check_methods` to validate subclass compliance
-    - Enforces implementation of attribute error handling methods via abstract methods
-    - Implements native attribute magic methods to forward errors to custom handlers
-
-    Core behavior:
-        When attribute operations (get/delete/check/set) fail, the corresponding native
-        magic methods automatically invoke custom error handling methods implemented by subclasses.
-    """
-
-    __slots__ = ()
-
-    @classmethod
-    def __subclasshook__(cls, C: type[Any]) -> Union[bool, Literal[NotImplemented]]:  # type: ignore
-        """
-        Check if a class is a subclass of ErrorAttrable (per `collections.abc` style).
-
-        This method enables `issubclass()` to recognize classes that implement the core
-        __errorattr__ method (base requirement), matching the behavior of standard ABCs.
-
-        Args:
-            C: The class to check for compliance with ErrorAttrable interface
-
-        Returns:
-            True if C implements __errorattr__, NotImplemented otherwise
-        """
-        if cls is ErrorAttrable:
-            return _check_methods(C, "__errorattr__")
-        return NotImplemented
-
-    def __getattr__(self, name: str) -> Any:
-        """
-        Native magic method: Automatically invoked for missing attribute access.
-
-        Forwards the attribute lookup failure to the custom `__errorattr__` method.
-        """
-        return self.__errorattr__(name)
-
-    @abstractmethod
-    def __errorattr__(self, name: str) -> Any:
-        """
-        Abstract method for custom missing attribute handling (MUST be implemented).
-
-        Args:
-            name: Name of the missing attribute being accessed
-
-        Raises:
-            NotImplementedError: If not overridden
-            AttributeError: Recommended error type for missing attributes
-        """
-        raise NotImplementedError(
-            "Subclasses of ErrorAttrable must implement __errorattr__(self, name: str).\n"
-            "See `collections.abc` for similar abstract method requirements (e.g., __iter__ for Iterable)."
-        )
-
-    def __delattr__(self, name: str) -> None:
-        """
-        Native magic method: Automatically invoked for attribute deletion errors.
-
-        Forwards to __errordelattr__ if implemented, else raises standard error.
-        """
-        if hasattr(self, "__errordelattr__"):
-            self.__errordelattr__(name)
-        else:
-            super().__delattr__(name)
-
-    def __errordelattr__(self, name: str) -> None:
-        """
-        Custom handler for attribute deletion errors (OPTIONAL to implement).
-
-        Args:
-            name: Name of the attribute being deleted
-        """
-        raise NotImplementedError(
-            "Subclasses of ErrorAttrable must implement __errordelattr__(self, name: str).\n"
-            "See `collections.abc` for similar abstract method requirements (e.g., __iter__ for Iterable)."
-        )
-
-    def __contains__(self, name: str) -> bool:
-        """
-        Alternative to __hasattr__: Check if attribute exists (customizable).
-
-        Forwards to __errorhasattr__ if implemented, else uses standard check.
-        """
-        if hasattr(self, "__errorhasattr__"):
-            return self.__errorhasattr__(name)
-        else:
-            return hasattr(super(), name)
-
-    def __errorhasattr__(self, name: str) -> bool:
-        """
-        Custom handler for attribute existence checks (OPTIONAL to implement).
-
-        Args:
-            name: Name of the attribute to check
-
-        Returns:
-            bool: True if attribute exists (custom logic), False otherwise
-        """
-        raise NotImplementedError(
-            "Subclasses of ErrorAttrable must implement __errorhasattr__(self, name: str).\n"
-            "See `collections.abc` for similar abstract method requirements (e.g., __iter__ for Iterable)."
-        )
-
-    def __setattr__(self, name: str, value: Any) -> None:
-        """
-        Native magic method: Automatically invoked for attribute setting errors.
-
-        Forwards to __errorsetattr__ if implemented, else uses standard setting.
-        """
-        if hasattr(self, "__errorsetattr__"):
-            self.__errorsetattr__(name, value)
-        else:
-            super().__setattr__(name, value)
-
-    def __errorsetattr__(self, name: str, value: Any) -> None:
-        """
-        Custom handler for attribute setting errors (OPTIONAL to implement).
-
-        Args:
-            name: Name of the attribute to set
-            value: Value to assign to the attribute
-        """
-        raise NotImplementedError(
-            "Subclasses of ErrorAttrable must implement __errorsetattr__(self, name: str, value: Any).\n"
-            "See `collections.abc` for similar abstract method requirements (e.g., __iter__ for Iterable)."
-        )
-
-
-# register four Mixin's
-ErrorAttrable.register(ErrorAttrMixin)
-ErrorAttrable.register(ErrorAttrDeletionMixin)
-ErrorAttrable.register(ErrorAttrCheckMixin)
-ErrorAttrable.register(ErrorSetAttrMixin)
-
-
 # ----------------------------------------------------------------------
 # ErrorCodeable
 # ----------------------------------------------------------------------

{errortools-2.5.0 → errortools-3.0.0}/_errortools/classes/group.py

@@ -1,6 +1,7 @@
 """Base and concrete group classes for collecting and raising exceptions together."""
 
 from abc import abstractmethod, ABC
+import sys
 
 __all__ = [
     "BaseGroup",
@@ -67,52 +68,54 @@ class BaseGroup(Exception, ABC):
         )
 
 
-class GroupErrors(BaseGroup):
-    """A collector that accumulates exceptions and raises them as an ExceptionGroup.
+if sys.version_info >= (3, 11):
 
-    Call `collect` to add exceptions one by one, then `raise_group`
-    to raise them all at once.  Use `errors` to inspect what has been
-    collected without raising.
+    class GroupErrors(BaseGroup):
+        """A collector that accumulates exceptions and raises them as an ExceptionGroup.
 
-    Example:
+        Call `collect` to add exceptions one by one, then `raise_group`
+        to raise them all at once.  Use `errors` to inspect what has been
+        collected without raising.
 
-        >>> g = GroupErrors("validation failed")
-        >>> g.collect(TypeError("expected str"))
-        >>> g.collect(ValueError("value out of range"))
-        >>> g.raise_group()
-        Traceback (most recent call last):
-            ...
-        ExceptionGroup: validation failed (2 sub-exceptions)
-    """
+        Example:
 
-    def __init__(self, group_msg: str = "multiple errors") -> None:
-        super().__init__(group_msg)
-        self._errors: list[Exception] = []
+            >>> g = GroupErrors("validation failed")
+            >>> g.collect(TypeError("expected str"))
+            >>> g.collect(ValueError("value out of range"))
+            >>> g.raise_group()
+            Traceback (most recent call last):
+                ...
+            ExceptionGroup: validation failed (2 sub-exceptions)
+        """
 
-    @property
-    def errors(self) -> list[Exception]:
-        """A copy of the collected exceptions."""
-        return list(self._errors)
+        def __init__(self, group_msg: str = "multiple errors") -> None:
+            super().__init__(group_msg)
+            self._errors: list[Exception] = []
 
-    def collect(self, exc: Exception) -> None:
-        """Add *exc* to the group without raising it.
+        @property
+        def errors(self) -> list[Exception]:
+            """A copy of the collected exceptions."""
+            return list(self._errors)
 
-        Args:
-            exc: The exception instance to collect.
-        """
-        self._errors.append(exc)
+        def collect(self, exc: Exception) -> None:
+            """Add *exc* to the group without raising it.
 
-    def clear(self) -> None:
-        """Remove all collected exceptions."""
-        self._errors.clear()
+            Args:
+                exc: The exception instance to collect.
+            """
+            self._errors.append(exc)
 
-    def raise_group(self) -> None:
-        """Raise all collected exceptions as an `ExceptionGroup`.
+        def clear(self) -> None:
+            """Remove all collected exceptions."""
+            self._errors.clear()
 
-        Does nothing if no exceptions have been collected.
+        def raise_group(self) -> None:
+            """Raise all collected exceptions as an `ExceptionGroup`.
 
-        Raises:
-            ExceptionGroup: Containing every exception added via `collect`.
-        """
-        if self._errors:
-            raise ExceptionGroup(self.group_msg, self._errors)
+            Does nothing if no exceptions have been collected.
+
+            Raises:
+                ExceptionGroup: Containing every exception added via `collect`.
+            """
+            if self._errors:
+                raise ExceptionGroup(self.group_msg, self._errors)

{errortools-2.5.0 → errortools-3.0.0}/_errortools/future.py

@@ -1,8 +1,25 @@
 """Future-focused lightweight exception handling utilities."""
 
 from __future__ import annotations
+import sys
+
+if sys.version_info <= (3, 10):
+    from typing_extensions import TypeAlias
+else:
+    from typing import TypeAlias
+from typing import cast, Literal
+
+# Try to import C speedup
+try:
+    from _errortools._speedup import fast_issubclass_check, fast_append_exception  # type: ignore[import-not-found]
+except ImportError:
+
+    def fast_issubclass_check(typ, excs) -> bool:
+        return typ is not None and issubclass(typ, excs)
+
+    def fast_append_exception(lst, exc) -> None:
+        lst.append(exc)
 
-from typing import TypeAlias, cast, Literal
 
 __all__ = [
     "super_fast_ignore",
@@ -26,10 +43,7 @@ class super_fast_ignore:
         return
 
     def __exit__(self, typ: _ExcType | None, *_) -> bool:
-        if typ is None:
-            return False
-        excs = self.excs
-        return issubclass(typ, excs)
+        return cast(bool, fast_issubclass_check(typ, self.excs))
 
 
 class super_fast_catch:
@@ -50,11 +64,11 @@ class super_fast_catch:
         self.excs = excs if excs else (BaseException,)
         self.exception: BaseException | None = None
 
-    def __enter__(self) -> "super_fast_catch":
+    def __enter__(self) -> super_fast_catch:
         return self
 
     def __exit__(self, typ: _ExcType | None, val, *_) -> bool:
-        if typ is None or not issubclass(typ, self.excs):
+        if not fast_issubclass_check(typ, self.excs):
             return False
         self.exception = val
         return True
@@ -117,7 +131,7 @@ class ExceptionCollector:
 
     def __exit__(self, exc_typ, exc_val, *_) -> bool:
         if exc_typ is not None:
-            self._exceptions.append(exc_val)
+            fast_append_exception(self._exceptions, exc_val)
             if self._stop_on_first:
                 return False
             return True
@@ -129,14 +143,14 @@ class ExceptionCollector:
             func(*args, **kwargs)
             return False
         except BaseException as exc:
-            self._exceptions.append(exc)
+            fast_append_exception(self._exceptions, exc)
             if self._stop_on_first:
                 raise
             return True
 
     def add(self, exc: BaseException) -> None:
         """Manually add an exception."""
-        self._exceptions.append(exc)
+        fast_append_exception(self._exceptions, exc)
         if self._stop_on_first:
             raise exc
 

{errortools-2.5.0 → errortools-3.0.0}/_errortools/logging/record.py

@@ -6,10 +6,17 @@ import sys
 import threading
 import traceback
 from dataclasses import dataclass, field
-from datetime import datetime, UTC
+from datetime import datetime
 from types import TracebackType
 from typing import Any
 
+if sys.version_info >= (3, 9):
+    from datetime import UTC
+else:
+    from datetime import timezone
+
+    UTC = timezone.utc
+
 from .level import Level
 
 

{errortools-2.5.0 → errortools-3.0.0}/_errortools/logging/sink.py

@@ -5,10 +5,17 @@ from __future__ import annotations
 import sys
 import threading
 from abc import ABC, abstractmethod
-from datetime import datetime, UTC
+from datetime import datetime
 from pathlib import Path
 from typing import IO, Any
 
+if sys.version_info >= (3, 9):
+    from datetime import UTC
+else:
+    from datetime import timezone
+
+    UTC = timezone.utc
+
 from .level import Level
 from .record import Record
 

{errortools-2.5.0 → errortools-3.0.0}/_errortools/raises.py

@@ -1,5 +1,6 @@
 """Utilities for raising exceptions."""
 
+import sys
 from contextlib import contextmanager
 from itertools import product
 from typing import Callable, Any
@@ -107,45 +108,47 @@ def assert_raises(
     )
 
 
-def raises_all(
-    errors: Iterable[type[Exception]],
-    msgs: Iterable[str],
-    baseerror: type[Exception] = Exception,
-    group_msg: str = "multiple errors",
-) -> None:
-    """Validate exception types and raise all (error, message) combinations as an ExceptionGroup.
-
-    Args:
-        errors: An iterable of exception types to include in the group.
-        msgs: An iterable of message strings to pair with each exception type.
-        baseerror: The base exception class that every type in *errors* must
-            inherit from.  Defaults to `Exception`.
-        group_msg: The message attached to the `ExceptionGroup` itself.
-            Defaults to ``"multiple errors"``.
-
-    Raises:
-        TypeError: If any type in *errors* is not a subclass of *baseerror*.
-        ExceptionGroup: Containing one ``errors[i](msgs[j])`` instance for
-            every ``(i, j)`` pair in the Cartesian product.
-
-    Example:
-        >>> raises_all([ValueError, TypeError], ["bad input"])
-        Traceback (most recent call last):
-            ...
-        ExceptionGroup: multiple errors (2 sub-exceptions)
-    """
-    # NOTE: Computes the Cartesian product of *errors* x *msgs*, validates that every
-    # error type is a subclass of *baseerror*, then raises a single
-    # `ExceptionGroup` containing one instantiated exception per pair.
-    # If the product is empty (either iterable is empty) the function returns
-    # without raising.
-    pairs = _warp_list_product(errors, msgs)
-    if not pairs:
-        return
-    for error, _ in pairs:
-        if not _is_base_subclass(error=error, baseerror=baseerror):
-            raise TypeError(f"{error!r} is not a subclass of {baseerror.__name__}")
-    raise ExceptionGroup(group_msg, [error(msg) for error, msg in pairs])
+if sys.version_info >= (3, 11):
+
+    def raises_all(
+        errors: Iterable[type[Exception]],
+        msgs: Iterable[str],
+        baseerror: type[Exception] = Exception,
+        group_msg: str = "multiple errors",
+    ) -> None:
+        """Validate exception types and raise all (error, message) combinations as an ExceptionGroup.
+
+        Args:
+            errors: An iterable of exception types to include in the group.
+            msgs: An iterable of message strings to pair with each exception type.
+            baseerror: The base exception class that every type in *errors* must
+                inherit from.  Defaults to `Exception`.
+            group_msg: The message attached to the `ExceptionGroup` itself.
+                Defaults to ``"multiple errors"``.
+
+        Raises:
+            TypeError: If any type in *errors* is not a subclass of *baseerror*.
+            ExceptionGroup: Containing one ``errors[i](msgs[j])`` instance for
+                every ``(i, j)`` pair in the Cartesian product.
+
+        Example:
+            >>> raises_all([ValueError, TypeError], ["bad input"])
+            Traceback (most recent call last):
+                ...
+            ExceptionGroup: multiple errors (2 sub-exceptions)
+        """
+        # NOTE: Computes the Cartesian product of *errors* x *msgs*, validates that every
+        # error type is a subclass of *baseerror*, then raises a single
+        # `ExceptionGroup` containing one instantiated exception per pair.
+        # If the product is empty (either iterable is empty) the function returns
+        # without raising.
+        pairs = _warp_list_product(errors, msgs)
+        if not pairs:
+            return
+        for error, _ in pairs:
+            if not _is_base_subclass(error=error, baseerror=baseerror):
+                raise TypeError(f"{error!r} is not a subclass of {baseerror.__name__}")
+        raise ExceptionGroup(group_msg, [error(msg) for error, msg in pairs])
 
 
 @contextmanager

{errortools-2.5.0 → errortools-3.0.0}/_errortools/typing.py

@@ -1,6 +1,12 @@
 """Public type aliases for errortools exception classes."""
 
-from typing import TypeAlias, Union
+import sys
+
+if sys.version_info <= (3, 10):
+    from typing_extensions import TypeAlias
+else:
+    from typing import TypeAlias
+from typing import Union
 
 from .classes.errorcodes import (
     PureBaseException,

{errortools-2.5.0 → errortools-3.0.0}/_errortools/version.py

@@ -1,5 +1,5 @@
-__version__: str = "2.5.0"
-__version_tuple__: tuple[int, int, int] = (2, 5, 0)
+__version__: str = "3.0.0"
+__version_tuple__: tuple[int, int, int] = (3, 0, 0)
 __commit_id__: str | None = None
 
 version = __version__

{errortools-2.5.0 → errortools-3.0.0}/_errortools/wrappers/cache.py

@@ -1,6 +1,12 @@
 from collections import OrderedDict
 from collections.abc import Hashable, Callable
-from typing import Any, Generic, TypeVar, Optional, TypeAlias, NamedTuple
+import sys
+
+if sys.version_info <= (3, 10):
+    from typing_extensions import TypeAlias
+else:
+    from typing import TypeAlias
+from typing import Any, Generic, NamedTuple, Optional, TypeVar
 
 _T = TypeVar("_T", bound=Callable[..., Any])
 _Key: TypeAlias = tuple[

{errortools-2.5.0 → errortools-3.0.0}/_errortools/wrappers/ignore.py

@@ -1,6 +1,13 @@
 import traceback
 from collections.abc import Callable
-from typing import Any, Generic, TypeVar, Optional, TypeAlias
+import sys
+
+if sys.version_info <= (3, 10):
+    from typing_extensions import TypeAlias
+else:
+    from typing import TypeAlias
+
+from typing import Any, Generic, TypeVar, Optional
 
 _T = TypeVar("_T", bound=Callable[..., Any])
 _ExcType: TypeAlias = type[Exception]

{errortools-2.5.0 → errortools-3.0.0}/errortools/__init__.py

@@ -39,14 +39,7 @@ from _errortools.classes.warn import (
     RuntimeBehaviourWarning,
     ConfigurationWarning,
 )
-from _errortools.methods import (
-    ErrorSetAttrMixin,
-    ErrorAttrCheckMixin,
-    ErrorAttrDeletionMixin,
-    ErrorAttrMixin,
-)
 from _errortools.classes.abc import (
-    ErrorAttrable,
     ErrorCodeable,
     Warnable,
     Raiseable,
@@ -130,11 +123,6 @@ __all__ = [
     "ResourceUsageWarning",
     "RuntimeBehaviourWarning",
     "ConfigurationWarning",
-    "ErrorAttrMixin",
-    "ErrorAttrDeletionMixin",
-    "ErrorAttrCheckMixin",
-    "ErrorSetAttrMixin",
-    "ErrorAttrable",
     "ErrorCodeable",
     "Warnable",
     "Raiseable",