errortools 2.4.0__tar.gz → 3.0.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: errortools
-Version: 2.4.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,14 +8,17 @@ 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
 Classifier: Programming Language :: Python :: 3.13
 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
@@ -36,13 +39,20 @@ Dynamic: summary
 # errortools
 A lightweight Python exception handling utility library.
 
+[![Code Style: Google](https://img.shields.io/badge/style-google-3666d6.svg)](https://google.github.io/styleguide/pyguide.html#s3.8-comments-and-docstrings)
+[![PyPI Version](https://img.shields.io/pypi/v/errortools)](https://pypi.org/project/errortools/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/errortools)](https://pypi.org/project/errortools/)
+![This week commits](https://img.shields.io/github/commit-activity/w/more-abc/errortools)
+![This month commits](https://img.shields.io/github/commit-activity/m/more-abc/errortools)
+![Past year commits](https://img.shields.io/github/commit-activity/y/more-abc/errortools)
+![Total commits badge](https://img.shields.io/github/commit-activity/t/more-abc/errortools)
+
 ## Features
 - **Raise Exceptions**: `raises()`, `raises_all()`, `reraise()` — batch raising and exception conversion
 - **Catch & Suppress**: `ignore()`, `ignore_subclass()`, `ignore_warns()`, `fast_ignore()`, `super_fast_ignore()`, `timeout()`, `retry()` — graceful suppression of exceptions and warnings, with automatic retry
 - **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
 
@@ -255,9 +265,9 @@ logger.success("All systems operational")
 Output (colourised in a terminal):
 
 ```
-2026-01-01 12:00:00.123 | INFO     | app:main:42 - Server started on port 8080
-2026-01-01 12:00:00.124 | WARNING  | app:main:43 - Disk at 92.5%
-2026-01-01 12:00:00.125 | SUCCESS  | app:main:44 - All systems operational
+2026-04-30 08:34:21.850 | ℹ INFO     | <string>:<module>:3 - Server started on port 8080
+2026-04-30 08:34:21.851 | ⚠ WARNING  | <string>:<module>:4 - Disk at 92.5%
+2026-04-30 08:34:21.851 | ✔ SUCCESS  | <string>:<module>:5 - All systems operational
 ```
 
 ### Log levels

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

@@ -1,13 +1,20 @@
 # errortools
 A lightweight Python exception handling utility library.
 
+[![Code Style: Google](https://img.shields.io/badge/style-google-3666d6.svg)](https://google.github.io/styleguide/pyguide.html#s3.8-comments-and-docstrings)
+[![PyPI Version](https://img.shields.io/pypi/v/errortools)](https://pypi.org/project/errortools/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/errortools)](https://pypi.org/project/errortools/)
+![This week commits](https://img.shields.io/github/commit-activity/w/more-abc/errortools)
+![This month commits](https://img.shields.io/github/commit-activity/m/more-abc/errortools)
+![Past year commits](https://img.shields.io/github/commit-activity/y/more-abc/errortools)
+![Total commits badge](https://img.shields.io/github/commit-activity/t/more-abc/errortools)
+
 ## Features
 - **Raise Exceptions**: `raises()`, `raises_all()`, `reraise()` — batch raising and exception conversion
 - **Catch & Suppress**: `ignore()`, `ignore_subclass()`, `ignore_warns()`, `fast_ignore()`, `super_fast_ignore()`, `timeout()`, `retry()` — graceful suppression of exceptions and warnings, with automatic retry
 - **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
 
@@ -220,9 +227,9 @@ logger.success("All systems operational")
 Output (colourised in a terminal):
 
 ```
-2026-01-01 12:00:00.123 | INFO     | app:main:42 - Server started on port 8080
-2026-01-01 12:00:00.124 | WARNING  | app:main:43 - Disk at 92.5%
-2026-01-01 12:00:00.125 | SUCCESS  | app:main:44 - All systems operational
+2026-04-30 08:34:21.850 | ℹ INFO     | <string>:<module>:3 - Server started on port 8080
+2026-04-30 08:34:21.851 | ⚠ WARNING  | <string>:<module>:4 - Disk at 92.5%
+2026-04-30 08:34:21.851 | ✔ SUCCESS  | <string>:<module>:5 - All systems operational
 ```
 
 ### Log levels

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.4.0 → errortools-3.0.0}/_errortools/classes/abc.py

@@ -4,14 +4,12 @@ import copy
 import shutil
 import csv
 import configparser
+import sys
 
-from typing_extensions import disjoint_base  # I use 3.14.3
-from ..methods import (
-    ErrorAttrMixin,
-    ErrorAttrCheckMixin,
-    ErrorAttrDeletionMixin,
-    ErrorSetAttrMixin,
-)
+if sys.version_info >= (3, 15):
+    from typing import disjoint_base
+else:
+    from typing_extensions import disjoint_base
 
 
 def _check_methods(C: type[Any], *methods: str) -> Union[bool, Literal[NotImplemented]]:  # type: ignore
@@ -31,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.4.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.4.0 → errortools-3.0.0}/_errortools/decorator/deprecated.py

@@ -53,7 +53,7 @@ def experimental(
         @wraps(func)
         def wrapper(*args, **kwargs):
             msg = f"{func.__name__} is experimental. {reason}"
-            warnings.warn(msg, UserWarning, stacklevel=2)
+            warnings.warn(msg, FutureWarning, stacklevel=2)
             return func(*args, **kwargs)
 
         return wrapper