errortools 2.2.0__tar.gz → 2.3.0__tar.gz

{errortools-2.2.0/errortools.egg-info → errortools-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: errortools
-Version: 2.2.0
+Version: 2.3.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
@@ -20,6 +20,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 License-File: AUTHORS.txt
 Requires-Dist: namebyauthor==1.0.0
+Requires-Dist: typing_extensions>=4.8.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{errortools-2.2.0 → errortools-2.3.0}/_errortools/_cli.py

@@ -1,32 +1,33 @@
-import sys
-
-from _errortools.metadata import (
-    __author__,
-    __author_email__,
-    __copyright__,
-    __description__,
-    __license__,
-    __url__,
-)
-from _errortools.version import __version__
-
-
-def _cmd_log(message: str, level: str, output: str) -> None:
-    """Emit a single log message via the errortools logger."""
-    from .logging import BaseLogger
-    from .logging.level import get_level
-
-    stream = sys.stdout if output == "stdout" else sys.stderr
-    log = BaseLogger(name="errortools-cli")
-    log.add(stream, level="TRACE", colorize=None)
-    log.log(get_level(level), message)
-
-
-def _print_info() -> None:
-    """Print a summary of all package metadata."""
-    print(f"errortools v{__version__}")
-    print(f"  {__description__}")
-    print(f"  Author:    {__author__} <{__author_email__}>")
-    print(f"  License:   {__license__}")
-    print(f"  URL:       {__url__}")
-    print(f"  Copyright: {__copyright__}")
+import sys
+
+from _errortools.metadata import (
+    __author__,
+    __author_email__,
+    __copyright__,
+    __description__,
+    __license__,
+    __url__,
+)
+from _errortools.version import __version__
+
+
+def _cmd_log(message: str, level: str, output: str) -> None:
+    """Emit a single log message via the errortools logger."""
+    from .logging import BaseLogger
+    from .logging.level import get_level
+
+    stream = sys.stdout if output == "stdout" else sys.stderr
+    log = BaseLogger(name="errortools-cli")
+    log.set_level("TRACE")
+    log.add(stream, level=level, colorize=None)
+    log.log(get_level(level), message)
+
+
+def _print_info() -> None:
+    """Print a summary of all package metadata."""
+    print(f"errortools v{__version__}")
+    print(f"  {__description__}")
+    print(f"  Author:    {__author__} <{__author_email__}>")
+    print(f"  License:   {__license__}")
+    print(f"  URL:       {__url__}")
+    print(f"  Copyright: {__copyright__}")

{errortools-2.2.0 → errortools-2.3.0}/_errortools/classes/abc.py

@@ -5,6 +5,7 @@ import shutil
 import csv
 import configparser
 
+from typing_extensions import disjoint_base  # I use 3.14.3
 from ..methods import (
     ErrorAttrMixin,
     ErrorAttrCheckMixin,
@@ -30,6 +31,7 @@ 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.
@@ -175,6 +177,7 @@ ErrorAttrable.register(ErrorSetAttrMixin)
 # ----------------------------------------------------------------------
 
 
+@disjoint_base
 class ErrorCodeable(ABC):
     """Abstract Base Class for exceptions that carry a machine-readable error code.
 

{errortools-2.2.0 → errortools-2.3.0}/_errortools/cli.py

@@ -14,107 +14,95 @@ from .metadata import (
     __url__,
 )
 from .version import __version__
-from tests.run_tests import run_tests
 
 
 def parse_args(args: list[str] | None = None) -> argparse.Namespace:
     """Parse command line arguments."""
+    is_logger = "logger" in sys.argv[0]
+
+    if is_logger:
+        parser = argparse.ArgumentParser(
+            prog="logger",
+            description="Logger CLI - Emit log messages from command line",
+        )
+        parser.add_argument("message", help="Log message")
+        parser.add_argument(
+            "--level",
+            "-l",
+            default="info",
+            choices=[
+                "trace",
+                "debug",
+                "info",
+                "success",
+                "warning",
+                "error",
+                "critical",
+            ],
+        )
+        parser.add_argument(
+            "--output", "-o", choices=["stderr", "stdout"], default="stderr"
+        )
+        return parser.parse_args(args)
+
+    prog = "errortools"
+    desc = __description__
+
     if sys.version_info >= (3, 14):
-        parser = argparse.ArgumentParser(description=__description__, color=True)
+        parser = argparse.ArgumentParser(description=desc, prog=prog, color=True)
     else:
-        parser = argparse.ArgumentParser(description=__description__)
+        parser = argparse.ArgumentParser(description=desc, prog=prog)
 
     parser.add_argument(
         "-v", "--version", action="store_true", help="Show version and exit"
     )
-
     parser.add_argument(
         "-c", "--copyrights", action="store_true", help="Show copyright information"
     )
-
     parser.add_argument("-a", "--author", action="store_true", help="Show author name")
-
     parser.add_argument("-e", "--email", action="store_true", help="Show author email")
-
     parser.add_argument(
         "-l", "--license", action="store_true", help="Show license type"
     )
-
     parser.add_argument("-u", "--url", action="store_true", help="Show project URL")
-
     parser.add_argument(
         "-i", "--info", action="store_true", help="Show all package information"
     )
-
     parser.add_argument(
-        "--run-tests",
-        action="store_true",
-        help="Run tests for errortools module. (Using pytest)",
-    )
-
-    subparsers = parser.add_subparsers(dest="subcommand")
-
-    log_parser = subparsers.add_parser(
-        "log",
-        help="Emit a log message from the command line",
-    )
-    log_parser.add_argument(
-        "message",
-        help="The message to log",
-    )
-    log_parser.add_argument(
-        "--level",
-        "-l",
-        default="info",
-        choices=["trace", "debug", "info", "success", "warning", "error", "critical"],
-        help="Log level (default: info)",
-    )
-    log_parser.add_argument(
-        "--output",
-        "-o",
-        choices=["stderr", "stdout"],
-        default="stderr",
-        help="Output stream (default: stderr)",
+        "--run-tests", action="store_true", help="Run tests using pytest"
     )
 
     return parser.parse_args(args)
 
 
-def log_main() -> None:
-    """Logging main CLI entry point."""
+def main() -> None:
     args = parse_args(sys.argv[1:])
 
-    if args.subcommand == "log":
+    if "logger" in sys.argv[0]:
         _cmd_log(args.message, args.level, args.output)
-
-
-def main() -> None:
-    """Main CLI entry point."""
-    args = parse_args(sys.argv[1:])
+        return
 
     if args.version:
         print(f"v{__version__}")
-
     elif args.copyrights:
         print(__copyright__)
-
     elif args.author:
         print(f"Author: {__author__}")
-
     elif args.email:
         print(f"Email: {__author_email__}")
-
     elif args.license:
         print(f"License: {__license__}")
-
     elif args.url:
         print(f"URL: {__url__}")
-
     elif args.run_tests:
-        run_tests()
+        from tests.run_tests import run_tests
 
+        run_tests()
     elif args.info:
         _print_info()
-
     else:
         parse_args(["--help"])
+
+
+if __name__ == "__main__":
+    main()

{errortools-2.2.0 → errortools-2.3.0}/_errortools/decorator/deprecated.py

@@ -31,3 +31,31 @@ def deprecated(
         return wrapper
 
     return decorator
+
+
+def experimental(
+    reason: str = "This function is experimental and may change in future versions.",
+) -> Callable:
+    """Decorator that marks a function as experimental.
+
+    Emits a UserWarning when the decorated function is called.
+
+    Args:
+        reason: Optional message explaining the experimental status and any caveats.
+
+    Example:
+        >>> @experimental(reason="API may change without notice.")
+        ... def new_feature():
+        ...     pass
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            msg = f"{func.__name__} is experimental. {reason}"
+            warnings.warn(msg, UserWarning, stacklevel=2)
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

errortools-2.3.0/_errortools/errno.py

@@ -0,0 +1,78 @@
+import errno
+
+
+def get_errno_name(code: int) -> str | None:
+    """Get the symbolic name for an errno code.
+
+    Args:
+        code: The errno code (e.g., 2 for ENOENT)
+
+    Returns:
+        The errno name (e.g., "ENOENT") or None if not found
+    """
+    for name in dir(errno):
+        if name.isupper() and getattr(errno, name) == code:
+            return name
+    return None
+
+
+def get_errno_message(code: int) -> str:
+    """Get the error message for an errno code.
+
+    Args:
+        code: The errno code
+
+    Returns:
+        The error message string
+    """
+    try:
+        return errno.errorcode.get(code, f"Unknown error {code}")
+    except (AttributeError, KeyError):
+        return f"Unknown error {code}"
+
+
+def get_all_errno_codes() -> dict[str, int]:
+    """Get a mapping of all errno names to their numeric codes.
+
+    Returns:
+        Dictionary mapping errno names to their numeric values
+    """
+    codes = {}
+    for name in dir(errno):
+        if name.isupper():
+            try:
+                value = getattr(errno, name)
+                if isinstance(value, int):
+                    codes[name] = value
+            except (AttributeError, TypeError):
+                pass
+    return codes
+
+
+def is_valid_errno(code: int) -> bool:
+    """Check if a code is a valid errno constant.
+
+    Args:
+        code: The code to check
+
+    Returns:
+        True if the code is a valid errno, False otherwise
+    """
+    return get_errno_name(code) is not None
+
+
+def strerror(code: int) -> str:
+    """Get human-readable error message for errno code.
+
+    Args:
+        code: The errno code
+
+    Returns:
+        Error message string
+    """
+    import os
+
+    try:
+        return os.strerror(code)
+    except (ValueError, OSError):
+        return f"Unknown error {code}"

{errortools-2.2.0 → errortools-2.3.0}/_errortools/ignore.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from collections.abc import Iterator, Callable
 from contextlib import contextmanager
 from functools import wraps
+from typing import Any, TypeVar
 import asyncio
 import inspect
 import time
@@ -21,6 +22,9 @@ __all__ = [
     "retry",
 ]
 
+Func = TypeVar("Func", bound=Callable[..., Any])
+ExceptionType = type[BaseException]
+ExceptionTypes = tuple[ExceptionType, ...]
 
 # A Context Manager? Maybe it is...
 
@@ -107,7 +111,7 @@ class fast_ignore:
 
     __slots__ = ("_excs",)
 
-    def __init__(self, *excs: type[BaseException]) -> None:
+    def __init__(self, *excs: ExceptionType) -> None:
         for exc in excs:
             if not isinstance(exc, type) or not issubclass(exc, BaseException):
                 raise TypeError(f"Expected Exception subclass, got {exc!r}")
@@ -116,14 +120,14 @@ class fast_ignore:
     def __enter__(self) -> None:
         return
 
-    def __exit__(self, typ: type[BaseException] | None, _, __) -> bool:
+    def __exit__(self, typ: ExceptionType | None, _, __) -> bool:
         if typ is None:
             return False
         return typ in self._excs
 
 
 @contextmanager
-def ignore_subclass(base: type[BaseException]) -> Iterator[None]:
+def ignore_subclass(base: ExceptionType) -> Iterator[None]:
     """Context manager that suppresses any exception whose type is a subclass of *base*.
 
     Args:
@@ -227,13 +231,13 @@ class retry:
         >>> unstable()
         Traceback (most recent call last):
             ...
-        ValueError: oops
+            ValueError: oops
     """
 
     def __init__(
         self,
         times: int,
-        on: type[Exception] | tuple[type[Exception], ...] = Exception,
+        on: ExceptionType | ExceptionTypes = Exception,
         delay: float = 0,
     ) -> None:
         if times < 0:
@@ -241,23 +245,19 @@ class retry:
 
         exc_types = on if isinstance(on, tuple) else (on,)
         for t in exc_types:
-            if not isinstance(t, type) or not issubclass(t, Exception):
+            if not isinstance(t, type) or not issubclass(t, BaseException):
                 raise TypeError(f"Expected Exception subclass, got {t!r}")
 
         self._times = times
         self._on = exc_types
         self._delay = delay
 
-    # ------------------------------------------------------------------
-    # Decorator protocol
-    # ------------------------------------------------------------------
-
-    def __call__(self, func: Callable) -> Callable:
+    def __call__(self, func: Func) -> Func:
         if inspect.iscoroutinefunction(func):
 
             @wraps(func)
-            async def async_wrapper(*args, **kwargs):
-                last_exc: Exception | None = None
+            async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+                last_exc: BaseException | None = None
                 for attempt in range(self._times + 1):
                     try:
                         return await func(*args, **kwargs)
@@ -265,13 +265,15 @@ class retry:
                         last_exc = exc
                         if attempt < self._times and self._delay:
                             await asyncio.sleep(self._delay)
-                raise last_exc
+                if last_exc is not None:
+                    raise last_exc
+                raise RuntimeError("No exception to raise")
 
-            return async_wrapper
+            return async_wrapper  # type: ignore
 
         @wraps(func)
-        def wrapper(*args, **kwargs):
-            last_exc: Exception | None = None
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            last_exc: BaseException | None = None
             for attempt in range(self._times + 1):
                 try:
                     return func(*args, **kwargs)
@@ -279,6 +281,8 @@ class retry:
                     last_exc = exc
                     if attempt < self._times and self._delay:
                         time.sleep(self._delay)
-            raise last_exc
+            if last_exc is not None:
+                raise last_exc
+            raise RuntimeError("No exception to raise")
 
-        return wrapper
+        return wrapper  # type: ignore

{errortools-2.2.0 → errortools-2.3.0}/_errortools/typing.py

@@ -24,6 +24,7 @@ __all__ = [
     "LookupError_",
     "RuntimeError_",
     "ExceptionType",
+    "WarningType",
     "TracebackType",
     "FrameType",
 ]
@@ -74,6 +75,9 @@ RuntimeError_: TypeAlias = Union[RuntimeFailure, TimeoutFailure]
 ExceptionType: TypeAlias = type[Exception]
 """Type alias for an exception *class* (not an instance)."""
 
+WarningType: TypeAlias = type[Warning]
+"""Type alias for an warning *class* like `ExceptionType` (not an instance)."""
+
 # ---------------------------------------------------------------------------
 # Types from ``types`` module
 # ---------------------------------------------------------------------------

{errortools-2.2.0 → errortools-2.3.0}/_errortools/version.py

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

{errortools-2.2.0 → errortools-2.3.0}/errortools/__init__.py

@@ -11,9 +11,15 @@ from _errortools.ignore import (
     timeout,
     retry,
 )
+from _errortools.errno import (
+    get_errno_message,
+    get_errno_name,
+    get_all_errno_codes,
+    is_valid_errno,
+)
 from _errortools.classes.group import BaseGroup, GroupErrors
 from _errortools.decorator.cache import error_cache
-from _errortools.decorator.deprecated import deprecated
+from _errortools.decorator.deprecated import deprecated, experimental
 from _errortools.classes.errorcodes import (
     PureBaseException,
     ContextException,
@@ -56,6 +62,7 @@ from _errortools.typing import (
     InputError,
     AccessError,
     ExceptionType,
+    WarningType,
     TracebackType,
     FrameType,
 )
@@ -98,7 +105,12 @@ __all__ = [
     "ignore_warns",
     "timeout",
     "retry",
+    "get_errno_message",
+    "get_errno_name",
+    "get_all_errno_codes",
+    "is_valid_errno",
     "deprecated",
+    "experimental",
     "error_cache",
     "TracebackType",
     "FrameType",
@@ -141,6 +153,7 @@ __all__ = [
     "LookupError_",
     "RuntimeError_",
     "ExceptionType",
+    "WarningType",
     # metadata
     "__version__",
     "__version_tuple__",

{errortools-2.2.0 → errortools-2.3.0/errortools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: errortools
-Version: 2.2.0
+Version: 2.3.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
@@ -20,6 +20,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 License-File: AUTHORS.txt
 Requires-Dist: namebyauthor==1.0.0
+Requires-Dist: typing_extensions>=4.8.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{errortools-2.2.0 → errortools-2.3.0}/errortools.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ _errortools/__init__.py
 _errortools/_cli.py
 _errortools/cli.py
 _errortools/const.py
+_errortools/errno.py
 _errortools/future.py
 _errortools/ignore.py
 _errortools/metadata.py
@@ -51,10 +52,10 @@ tests/__init__.py
 tests/conftest.py
 tests/run_tests.py
 tests/test_abc.py
-tests/test_cache.py
 tests/test_const.py
 tests/test_decorator.py
 tests/test_descriptor.py
+tests/test_errno.py
 tests/test_errorcodes.py
 tests/test_groups.py
 tests/test_ignore.py

{errortools-2.2.0 → errortools-2.3.0}/errortools.egg-info/entry_points.txt

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

errortools-2.3.0/errortools.egg-info/requires.txt

@@ -0,0 +1,2 @@
+namebyauthor==1.0.0
+typing_extensions>=4.8.0

{errortools-2.2.0 → errortools-2.3.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="errortools",
-    version="2.2.0",
+    version="2.3.0",
     description="errortools - a toolset for working with Python exceptions and warnings and logging.",
     long_description=open("README.md", encoding="utf-8").read(),
     long_description_content_type="text/markdown",
@@ -25,11 +25,11 @@ setup(
     package_data={"errortools": ["py.typed"]},
     include_package_data=True,
     python_requires=">=3.10",
-    install_requires=["namebyauthor==1.0.0"],
+    install_requires=["namebyauthor==1.0.0", "typing_extensions>=4.8.0"],
     entry_points={
         "console_scripts": [
             "python -m errortools = _errortools.cli:main",
-            "logger = _errortools.cli:log_main",
+            "logger = _errortools.cli:main",
         ]
     },
 )

{errortools-2.2.0 → errortools-2.3.0}/tests/__init__.py

@@ -1,6 +1,6 @@
 """Tests for `errortools` module. Using pytest."""
 
-__version__ = "1.5"
+__version__ = "1.9"
 
 try:
     import pytest

errortools-2.2.0/tests/test_cache.py → errortools-2.3.0/tests/test_decorator.py

@@ -1,14 +1,165 @@
-"""Tests for _errortools/cached — error_cache decorator and ErrorCacheWrapper."""
+"""Tests for _errortools/decorator — decorators."""
+
+import warnings
 
 import pytest
 
 from _errortools.decorator.cache import error_cache
+from _errortools.decorator.deprecated import deprecated, experimental
 from . import HAS_PYTEST
 
 if not HAS_PYTEST:
-    print("pytest is required to run these tests, skip run test_cache.py")
+    print("pytest is required to run these tests, skip run test_decorator.py")
     exit(0)
 
+# =============================================================================
+# deprecated decorator
+# =============================================================================
+
+
+class TestDeprecatedDecorator:
+    def test_bare_decorator_with_version(self):
+        @deprecated(version="2.0")
+        def f(x):
+            return x
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            assert f(3) == 3
+
+    def test_decorator_with_reason(self):
+        @deprecated(version="2.0", reason="Use new_func instead")
+        def f(x):
+            return x * 2
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            assert f(5) == 10
+
+    def test_wrapper_has_correct_name(self):
+        @deprecated(version="2.0")
+        def my_func(x):
+            return x
+
+        assert my_func.__name__ == "my_func"
+
+    def test_wrapped_attribute(self):
+        def inner(x):
+            return x
+
+        wrapped = deprecated(version="2.0")(inner)
+        assert wrapped.__wrapped__ is inner
+
+
+class TestDeprecatedWarning:
+    def test_emits_deprecation_warning_on_call(self):
+        @deprecated(version="2.0")
+        def f():
+            pass
+
+        with pytest.warns(DeprecationWarning) as record:
+            f()
+
+        assert len(record) == 1
+        warn = record[0]
+        assert "deprecated since version 2.0" in str(warn.message)
+
+    def test_warning_contains_reason(self):
+        @deprecated(version="2.0", reason="Please upgrade API")
+        def f():
+            pass
+
+        with pytest.warns(DeprecationWarning) as record:
+            f()
+
+        assert "Please upgrade API" in str(record[0].message)
+
+    def test_warning_stacklevel_correct(self):
+        @deprecated(version="2.0")
+        def f():
+            pass
+
+        with pytest.warns(DeprecationWarning) as record:
+            f()
+
+        # Ensure warning points to caller, not wrapper
+        assert record[0].lineno is not None
+
+
+# =============================================================================
+# experimental decorator
+# =============================================================================
+
+
+class TestExperimentalDecorator:
+    def test_bare_decorator(self):
+        @experimental()
+        def f(x):
+            return x
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            assert f(3) == 3
+
+    def test_decorator_with_reason(self):
+        @experimental(reason="API may change without notice")
+        def f(x):
+            return x * 2
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            assert f(5) == 10
+
+    def test_wrapper_has_correct_name(self):
+        @experimental()
+        def my_func(x):
+            return x
+
+        assert my_func.__name__ == "my_func"
+
+    def test_wrapped_attribute(self):
+        def inner(x):
+            return x
+
+        wrapped = experimental()(inner)
+        assert wrapped.__wrapped__ is inner
+
+
+class TestExperimentalWarning:
+    def test_emits_user_warning_on_call(self):
+        @experimental()
+        def f():
+            pass
+
+        with pytest.warns(UserWarning) as record:
+            f()
+
+        assert len(record) == 1
+        warn = record[0]
+        assert "experimental" in str(warn.message)
+
+    def test_warning_contains_reason(self):
+        @experimental(reason="Subject to change")
+        def f():
+            pass
+
+        with pytest.warns(UserWarning) as record:
+            f()
+
+        assert "Subject to change" in str(record[0].message)
+
+    def test_warning_stacklevel_correct(self):
+        @experimental()
+        def f():
+            pass
+
+        with pytest.warns(UserWarning) as record:
+            f()
+
+        # Ensure warning points to caller, not wrapper
+        assert record[0].lineno is not None
+
+
 # =============================================================================
 # error_cache — basic decoration patterns
 # =============================================================================

errortools-2.3.0/tests/test_errno.py

@@ -0,0 +1,112 @@
+"""Tests for _errortools/errno.py — errno tools."""
+
+import errno
+
+from _errortools.errno import (
+    get_errno_name,
+    get_errno_message,
+    get_all_errno_codes,
+    is_valid_errno,
+    strerror,
+)
+from . import HAS_PYTEST
+
+if not HAS_PYTEST:
+    print("pytest is required to run these tests, skip run test_errno.py")
+    exit(0)
+
+
+class TestGetErrnoName:
+    def test_valid_errno_enoent(self):
+        assert get_errno_name(errno.ENOENT) == "ENOENT"
+
+    def test_valid_errno_eacces(self):
+        assert get_errno_name(errno.EACCES) == "EACCES"
+
+    def test_invalid_errno_code(self):
+        assert get_errno_name(9999) is None
+
+    def test_errno_zero(self):
+        assert get_errno_name(0) is None
+
+
+class TestGetErrnoMessage:
+    def test_valid_errno_message(self):
+        message = get_errno_message(errno.ENOENT)
+        assert isinstance(message, str)
+        assert len(message) > 0
+
+    def test_invalid_errno_message(self):
+        message = get_errno_message(9999)
+        assert "Unknown error" in message or len(message) > 0
+
+    def test_errno_two_message(self):
+        message = get_errno_message(2)
+        assert isinstance(message, str)
+
+
+class TestGetAllErrnocodes:
+    def test_returns_dict(self):
+        codes = get_all_errno_codes()
+        assert isinstance(codes, dict)
+
+    def test_contains_enoent(self):
+        codes = get_all_errno_codes()
+        assert "ENOENT" in codes
+        assert codes["ENOENT"] == errno.ENOENT
+
+    def test_contains_eacces(self):
+        codes = get_all_errno_codes()
+        assert "EACCES" in codes
+        assert codes["EACCES"] == errno.EACCES
+
+    def test_all_values_are_integers(self):
+        codes = get_all_errno_codes()
+        for _, code in codes.items():
+            assert isinstance(code, int)
+
+    def test_all_keys_are_uppercase(self):
+        codes = get_all_errno_codes()
+        for name in codes.keys():
+            assert name.isupper()
+
+
+class TestIsValidErrno:
+    def test_valid_errno_enoent(self):
+        assert is_valid_errno(errno.ENOENT) is True
+
+    def test_valid_errno_eacces(self):
+        assert is_valid_errno(errno.EACCES) is True
+
+    def test_invalid_errno(self):
+        assert is_valid_errno(9999) is False
+
+    def test_errno_zero(self):
+        assert is_valid_errno(0) is False
+
+
+class TestStrerror:
+    def test_enoent_message(self):
+        message = strerror(errno.ENOENT)
+        assert isinstance(message, str)
+        assert len(message) > 0
+
+    def test_eacces_message(self):
+        message = strerror(errno.EACCES)
+        assert isinstance(message, str)
+        assert len(message) > 0
+
+    def test_invalid_errno_fallback(self):
+        message = strerror(9999)
+        assert isinstance(message, str)
+        assert "Unknown error" in message or len(message) > 0
+
+    def test_consistency_with_os_strerror(self):
+        import os
+
+        code = errno.ENOENT
+        try:
+            expected = os.strerror(code)
+            assert strerror(code) == expected
+        except (ValueError, OSError):
+            pass

{errortools-2.2.0 → errortools-2.3.0}/tests/test_typing.py

@@ -13,6 +13,7 @@ from _errortools.typing import (
     LookupError_,
     RuntimeError_,
     ExceptionType,
+    WarningType,
     TracebackType,
     FrameType,
 )
@@ -89,6 +90,13 @@ class TestExceptionTypeAlias:
         assert get_args(ExceptionType) == (Exception,)
 
 
+class TestWarningTypeAlias:
+
+    def test_warning_type(self):
+        assert get_origin(WarningType) is type
+        assert get_args(WarningType) == (Warning,)
+
+
 class TestTracebackAndFrameTypes:
 
     def test_traceback_type_matches_real_traceback(self):
@@ -136,6 +144,7 @@ class TestModuleExports:
             "LookupError_",
             "RuntimeError_",
             "ExceptionType",
+            "WarningType",
             "TracebackType",
             "FrameType",
         }

errortools-2.2.0/errortools.egg-info/requires.txt

@@ -1 +0,0 @@
-namebyauthor==1.0.0

errortools-2.2.0/tests/test_decorator.py

@@ -1,85 +0,0 @@
-"""Tests for _errortools/decorator — decorators."""
-
-import warnings
-
-import pytest
-
-from _errortools.decorator.deprecated import deprecated
-from . import HAS_PYTEST
-
-if not HAS_PYTEST:
-    print("pytest is required to run these tests, skip run test_decorator.py")
-    exit(0)
-
-# =============================================================================
-# deprecated decorator
-# =============================================================================
-
-
-class TestDeprecatedDecorator:
-    def test_bare_decorator_with_version(self):
-        @deprecated(version="2.0")
-        def f(x):
-            return x
-
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            assert f(3) == 3
-
-    def test_decorator_with_reason(self):
-        @deprecated(version="2.0", reason="Use new_func instead")
-        def f(x):
-            return x * 2
-
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            assert f(5) == 10
-
-    def test_wrapper_has_correct_name(self):
-        @deprecated(version="2.0")
-        def my_func(x):
-            return x
-
-        assert my_func.__name__ == "my_func"
-
-    def test_wrapped_attribute(self):
-        def inner(x):
-            return x
-
-        wrapped = deprecated(version="2.0")(inner)
-        assert wrapped.__wrapped__ is inner
-
-
-class TestDeprecatedWarning:
-    def test_emits_deprecation_warning_on_call(self):
-        @deprecated(version="2.0")
-        def f():
-            pass
-
-        with pytest.warns(DeprecationWarning) as record:
-            f()
-
-        assert len(record) == 1
-        warn = record[0]
-        assert "deprecated since version 2.0" in str(warn.message)
-
-    def test_warning_contains_reason(self):
-        @deprecated(version="2.0", reason="Please upgrade API")
-        def f():
-            pass
-
-        with pytest.warns(DeprecationWarning) as record:
-            f()
-
-        assert "Please upgrade API" in str(record[0].message)
-
-    def test_warning_stacklevel_correct(self):
-        @deprecated(version="2.0")
-        def f():
-            pass
-
-        with pytest.warns(DeprecationWarning) as record:
-            f()
-
-        # Ensure warning points to caller, not wrapper
-        assert record[0].lineno is not None