errortools 2.5.0__tar.gz → 3.1.0__tar.gz

errortools-3.1.0/AUTHORS.txt

@@ -0,0 +1,12 @@
+# (Lines starting with # are comments)
+# Tips:
+#   Contributors are not sorted by initials, 
+#   but by contribution time.
+# Here are the real contributors
+aiwonderland
+qorexdev
+vgauraha62
+yangphysics
+# And here are bot contributors
+dependabot[bot]
+AbaAbaAba-bot-like[bot]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: errortools
-Version: 2.5.0
+Version: 3.1.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
@@ -44,6 +46,7 @@ A lightweight Python exception handling utility library.
 ![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)
+![OS support](https://img.shields.io/badge/OS-macOS%20Linux%20Windows-red)
 
 ## Features
 - **Raise Exceptions**: `raises()`, `raises_all()`, `reraise()` — batch raising and exception conversion
@@ -51,7 +54,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
 
@@ -95,7 +97,7 @@ assert err.traceback          # full formatted traceback string
 | `exception` | `Exception \| None` | The original exception instance |
 | `traceback` | `str \| None` | Formatted traceback string for debugging |
 
-## Examples
+## Sorry, but there was more code examples!
 
 ```python
 # ── ignore as a decorator ──

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

@@ -8,6 +8,7 @@ A lightweight Python exception handling utility library.
 ![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)
+![OS support](https://img.shields.io/badge/OS-macOS%20Linux%20Windows-red)
 
 ## Features
 - **Raise Exceptions**: `raises()`, `raises_all()`, `reraise()` — batch raising and exception conversion
@@ -15,7 +16,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
 
@@ -59,7 +59,7 @@ assert err.traceback          # full formatted traceback string
 | `exception` | `Exception \| None` | The original exception instance |
 | `traceback` | `str \| None` | Formatted traceback string for debugging |
 
-## Examples
+## Sorry, but there was more code examples!
 
 ```python
 # ── ignore as a decorator ──

errortools-3.1.0/_errortools/_speedup.c

@@ -0,0 +1,127 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+/* Fast exception type checking
+ * 
+ * Optimized check for exception type hierarchy using PyObject_IsSubclass.
+ * Returns False immediately if typ is None, otherwise checks if typ is a
+ * subclass of excs.
+ * 
+ * Args:
+ *   typ: The type object to check (or None)
+ *   excs: The exception class(es) to check against
+ * 
+ * Returns:
+ *   True if typ is a subclass of excs, False otherwise
+ *   NULL on error with exception set
+ */
+static PyObject* fast_issubclass_check(PyObject* self, PyObject* const* args, Py_ssize_t nargs) {
+    if (nargs != 2) {
+        PyErr_Format(PyExc_TypeError, 
+                     "fast_issubclass_check() takes exactly 2 arguments (%zd given)", 
+                     nargs);
+        return NULL;
+    }
+
+    PyObject *typ = args[0];
+    PyObject *excs = args[1];
+
+    /* Handle None case explicitly */
+    if (typ == Py_None) {
+        Py_RETURN_FALSE;
+    }
+
+    /* Validate that excs is a class or tuple of classes */
+    if (!PyType_Check(excs) && !PyTuple_Check(excs)) {
+        PyErr_SetString(PyExc_TypeError, 
+                        "second argument must be a class or tuple of classes");
+        return NULL;
+    }
+
+    int result = PyObject_IsSubclass(typ, excs);
+    if (result == -1) {
+        return NULL;  /* Exception already set by PyObject_IsSubclass */
+    }
+
+    /* Return bool directly instead of going through PyBool_FromLong */
+    if (result == 1) {
+        Py_RETURN_TRUE;
+    } else {
+        Py_RETURN_FALSE;
+    }
+}
+
+/* Fast exception collector append
+ * 
+ * Optimized append operation for adding exceptions to a list.
+ * 
+ * Args:
+ *   list: The list object to append to
+ *   exc: The exception object to append
+ * 
+ * Returns:
+ *   None on success
+ *   NULL on error with exception set
+ */
+static PyObject* fast_append_exception(PyObject* self, PyObject* const* args, Py_ssize_t nargs) {
+    if (nargs != 2) {
+        PyErr_Format(PyExc_TypeError, 
+                     "fast_append_exception() takes exactly 2 arguments (%zd given)", 
+                     nargs);
+        return NULL;
+    }
+
+    PyObject *list = args[0];
+    PyObject *exc = args[1];
+
+    /* Validate that first argument is actually a list */
+    if (!PyList_Check(list)) {
+        PyErr_SetString(PyExc_TypeError, "first argument must be a list");
+        return NULL;
+    }
+
+    if (PyList_Append(list, exc) == -1) {
+        return NULL;  /* Exception already set by PyList_Append */
+    }
+
+    Py_RETURN_NONE;
+}
+
+/* Method definitions */
+static PyMethodDef SpeedupMethods[] = {
+    {
+        "fast_issubclass_check",
+        (PyCFunction)fast_issubclass_check,
+        METH_FASTCALL,
+        "fast_issubclass_check(typ, excs) -> bool\n\n"
+        "Check if typ is a subclass of excs exception type(s).\n"
+        "Returns False if typ is None, otherwise uses PyObject_IsSubclass.\n"
+        "Optimized for exception handling performance."
+    },
+    {
+        "fast_append_exception",
+        (PyCFunction)fast_append_exception,
+        METH_FASTCALL,
+        "fast_append_exception(list, exc) -> None\n\n"
+        "Append an exception to a list with minimal overhead.\n"
+        "Validates that the first argument is a list."
+    },
+    {NULL, NULL, 0, NULL}  /* Sentinel */
+};
+
+/* Module definition */
+static struct PyModuleDef speedupmodule = {
+    PyModuleDef_HEAD_INIT,
+    "_speedup",                 /* name */
+    "C speedup module for errortools\n\n"
+    "Provides optimized implementations of exception handling operations:\n"
+    "  - fast_issubclass_check: Quick exception type hierarchy checking\n"
+    "  - fast_append_exception: Efficient exception list append operations",
+    -1,                         /* size */
+    SpeedupMethods               /* methods */
+};
+
+/* Module initialization */
+PyMODINIT_FUNC PyInit__speedup(void) {
+    return PyModule_Create(&speedupmodule);
+}

{errortools-2.5.0 → errortools-3.1.0}/_errortools/cli.py

@@ -95,7 +95,7 @@ def main() -> None:
     elif args.url:
         print(f"URL: {__url__}")
     elif args.run_tests:
-        from tests.run_tests import run_tests
+        from testing.run_tests import run_tests
 
         run_tests()
     elif args.info:

{errortools-2.5.0 → errortools-3.1.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.1.0}/_errortools/ignore.py

@@ -107,11 +107,19 @@ class fast_ignore:
         >>> with fast_ignore(KeyError):
         ...     d = {}
         ...     _ = d["missing"]
+
+    .. deprecated:: 3.0.0
+        This class is deprecated as it is functionally redundant.
     """
 
     __slots__ = ("_excs",)
 
     def __init__(self, *excs: ExceptionType) -> None:
+        warnings.warn(
+            "fast_ignore is deprecated as it is functionally redundant.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         for exc in excs:
             if not isinstance(exc, type) or not issubclass(exc, BaseException):
                 raise TypeError(f"Expected Exception subclass, got {exc!r}")

{errortools-2.5.0 → errortools-3.1.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.1.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,
@@ -57,16 +63,28 @@ AnyErrorCode: TypeAlias = Union[
 """Union of all predefined error-code subclasses."""
 
 InputError: TypeAlias = InvalidInputError
-"""Alias for `InvalidInputError` (1001)."""
+"""Alias for `InvalidInputError` (1001).
+
+.. deprecated:: 3.0.0
+    This type alias is deprecated as it is redundant."""
 
 AccessError: TypeAlias = AccessDeniedError
-"""Alias for `AccessDeniedError` (2001)."""
+"""Alias for `AccessDeniedError` (2001).
+
+.. deprecated:: 3.0.0
+    This type alias is deprecated as it is redundant."""
 
 LookupError_: TypeAlias = NotFoundError
-"""Alias for `NotFoundError` (3001). Trailing underscore avoids shadowing builtins."""
+"""Alias for `NotFoundError` (3001). Trailing underscore avoids shadowing builtins.
+
+.. deprecated:: 3.0.0
+    This type alias is deprecated as it is redundant."""
 
 RuntimeError_: TypeAlias = Union[RuntimeFailure, TimeoutFailure]
-"""Union of runtime-related errors: `RuntimeFailure` (4001) and `TimeoutFailure` (4002)."""
+"""Union of runtime-related errors: `RuntimeFailure` (4001) and `TimeoutFailure` (4002).
+
+.. deprecated:: 3.0.0
+    This type alias is deprecated as it is redundant."""
 
 # ---------------------------------------------------------------------------
 # More type aliases

{errortools-2.5.0 → errortools-3.1.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.1.0"
+__version_tuple__: tuple[int, int, int] = (3, 1, 0)
 __commit_id__: str | None = None
 
 version = __version__

{errortools-2.5.0 → errortools-3.1.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",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: errortools
-Version: 2.5.0
+Version: 3.1.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
@@ -44,6 +46,7 @@ A lightweight Python exception handling utility library.
 ![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)
+![OS support](https://img.shields.io/badge/OS-macOS%20Linux%20Windows-red)
 
 ## Features
 - **Raise Exceptions**: `raises()`, `raises_all()`, `reraise()` — batch raising and exception conversion
@@ -51,7 +54,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
 
@@ -95,7 +97,7 @@ assert err.traceback          # full formatted traceback string
 | `exception` | `Exception \| None` | The original exception instance |
 | `traceback` | `str \| None` | Formatted traceback string for debugging |
 
-## Examples
+## Sorry, but there was more code examples!
 
 ```python
 # ── ignore as a decorator ──

errortools-3.1.0/errortools.egg-info/SOURCES.txt

@@ -0,0 +1,47 @@
+AUTHORS.txt
+LICENSE.txt
+README.md
+setup.py
+_errortools/__init__.py
+_errortools/_cli.py
+_errortools/_speedup.c
+_errortools/cli.py
+_errortools/const.py
+_errortools/errno.py
+_errortools/future.py
+_errortools/ignore.py
+_errortools/metadata.py
+_errortools/partial.py
+_errortools/py.typed
+_errortools/raises.py
+_errortools/typing.py
+_errortools/version.py
+errortools/__init__.py
+errortools/__main__.py
+errortools/future.py
+errortools/logging.py
+errortools/partial.py
+errortools.egg-info/PKG-INFO
+errortools.egg-info/SOURCES.txt
+errortools.egg-info/dependency_links.txt
+errortools.egg-info/entry_points.txt
+errortools.egg-info/requires.txt
+errortools.egg-info/top_level.txt
+testing/__init__.py
+testing/__main__.py
+testing/conftest.py
+testing/run_tests.py
+testing/test_abc.py
+testing/test_const.py
+testing/test_decorator.py
+testing/test_descriptor.py
+testing/test_errno.py
+testing/test_errorcodes.py
+testing/test_future.py
+testing/test_groups.py
+testing/test_ignore.py
+testing/test_logging.py
+testing/test_partials.py
+testing/test_raises.py
+testing/test_typing.py
+testing/test_warnings.py

{errortools-2.5.0 → errortools-3.1.0}/errortools.egg-info/entry_points.txt

@@ -1,3 +1,2 @@
 [console_scripts]
 logger = _errortools.cli:main
-python -m errortools = _errortools.cli:main

{errortools-2.5.0 → errortools-3.1.0}/errortools.egg-info/top_level.txt

@@ -1,3 +1,3 @@
 _errortools
 errortools
-tests
+testing

errortools-3.1.0/setup.py

@@ -0,0 +1,58 @@
+import sys
+
+from setuptools import setup, Extension
+
+_VERSION: str = "3.1.0"
+_CLI_INFO: dict[str, list[str]] = {
+    "console_scripts": [
+        # "python -m errortools = _errortools.cli:main",
+        "logger = _errortools.cli:main",
+    ]
+}
+_DESCRIPTION: str = (
+    "errortools - a toolset for working with Python exceptions and warnings and logging."
+)
+_URL: str = "https://github.com/more-abc/errortools"
+_AUTHOR: str = "Evan Yang"
+_AUTHOR_EMAIL: str = "quantbit@126.com"
+_LICENSE: str = "MIT"
+
+# C extension for performance
+_speedup_module = Extension(
+    "_errortools._speedup",
+    sources=["_errortools/_speedup.c"],
+    extra_compile_args=["/O2"] if sys.platform == "win32" else ["-O3", "-march=native"],
+)
+
+setup(
+    name="errortools",
+    version=_VERSION,
+    description=_DESCRIPTION,
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    url=_URL,
+    author=_AUTHOR,
+    author_email=_AUTHOR_EMAIL,
+    license=_LICENSE,
+    classifiers=[
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Programming Language :: Python :: 3.14",
+        "Programming Language :: Python :: 3.15",
+        "Operating System :: OS Independent",
+        "Typing :: Typed",
+    ],
+    packages=["_errortools", "errortools", "testing"],
+    package_data={"errortools": ["py.typed"]},
+    include_package_data=True,
+    python_requires=">=3.8",
+    install_requires=["namebyauthor==1.0.0", "typing_extensions>=4.8.0"],
+    entry_points=_CLI_INFO,
+    ext_modules=[_speedup_module],
+)