errortools 2.3.0__tar.gz → 2.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: errortools
-Version: 2.3.0
+Version: 2.4.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
@@ -39,6 +39,7 @@ A lightweight Python exception handling utility library.
 ## 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
@@ -62,7 +63,7 @@ from errortools import (
     error_cache,
     PureBaseException, ContextException, BaseErrorCodes, BaseWarning,
 )
-from errortools.future import super_fast_ignore
+from errortools.future import super_fast_ignore, super_fast_catch, super_fast_reraise, ExceptionCollector
 
 # ── 1. ignore ── context manager with full metadata ──────────────────────────
 with ignore(KeyError) as err:
@@ -154,7 +155,27 @@ raises_all(
 exc = assert_raises(int, [ValueError], "not-a-number")
 print(exc)   # invalid literal for int() with base 10: 'not-a-number'
 
-# ── 10. error_cache ── cache exceptions by call arguments ─────────────────────
+# ── 10. super_fast_catch ── lightweight exception capture ──────────────────────
+with super_fast_catch(ValueError) as ctx:
+    raise ValueError("oops")
+    
+assert ctx.exception is not None
+print(ctx.exception)  # ValueError('oops')
+
+# ── 11. super_fast_reraise ── lightweight exception type conversion ────────────
+with super_fast_reraise(KeyError, ValueError):
+    raise KeyError("missing")           # → ValueError: 'missing'
+
+# ── 12. ExceptionCollector ── batch collect exceptions ───────────────────────────
+collector = ExceptionCollector()
+collector.catch(int, "bad1")
+collector.catch(int, "bad2")
+
+if collector.has_errors:
+    print(f"Collected {collector.count} errors")
+    collector.raise_all("batch operation failed")  # → ExceptionGroup (2 sub-exceptions)
+
+# ── 13. error_cache ── cache exceptions by call arguments ─────────────────────
 @error_cache(maxsize=64)
 def load(user_id: int) -> dict:
     if user_id < 0:
@@ -167,7 +188,7 @@ with ignore(ValueError):
 print(load.cache_info())  # CacheInfo(hits=0, misses=1, maxsize=64, currsize=1)
 load.clear_cache()
 
-# ── 11. Custom exceptions — three layers ──────────────────────────────────────
+# ── 14. Custom exceptions — three layers ──────────────────────────────────────
 
 # Layer 1: PureBaseException — code + detail only
 class AppError(PureBaseException):
@@ -203,7 +224,7 @@ raise BaseErrorCodes.runtime_failure("crash")             # RuntimeFailure     [
 raise BaseErrorCodes.timeout_failure()                    # TimeoutFailure     [4002]
 raise BaseErrorCodes.configuration_error("missing key")   # ConfigurationError [5001]
 
-# ── 12. BaseWarning ── structured warnings with factory methods ───────────────
+# ── 15. BaseWarning ── structured warnings with factory methods ───────────────
 class ExperimentalWarning(BaseWarning):
     default_detail = "This feature is experimental."
 

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

@@ -4,6 +4,7 @@ A lightweight Python exception handling utility library.
 ## 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
@@ -27,7 +28,7 @@ from errortools import (
     error_cache,
     PureBaseException, ContextException, BaseErrorCodes, BaseWarning,
 )
-from errortools.future import super_fast_ignore
+from errortools.future import super_fast_ignore, super_fast_catch, super_fast_reraise, ExceptionCollector
 
 # ── 1. ignore ── context manager with full metadata ──────────────────────────
 with ignore(KeyError) as err:
@@ -119,7 +120,27 @@ raises_all(
 exc = assert_raises(int, [ValueError], "not-a-number")
 print(exc)   # invalid literal for int() with base 10: 'not-a-number'
 
-# ── 10. error_cache ── cache exceptions by call arguments ─────────────────────
+# ── 10. super_fast_catch ── lightweight exception capture ──────────────────────
+with super_fast_catch(ValueError) as ctx:
+    raise ValueError("oops")
+    
+assert ctx.exception is not None
+print(ctx.exception)  # ValueError('oops')
+
+# ── 11. super_fast_reraise ── lightweight exception type conversion ────────────
+with super_fast_reraise(KeyError, ValueError):
+    raise KeyError("missing")           # → ValueError: 'missing'
+
+# ── 12. ExceptionCollector ── batch collect exceptions ───────────────────────────
+collector = ExceptionCollector()
+collector.catch(int, "bad1")
+collector.catch(int, "bad2")
+
+if collector.has_errors:
+    print(f"Collected {collector.count} errors")
+    collector.raise_all("batch operation failed")  # → ExceptionGroup (2 sub-exceptions)
+
+# ── 13. error_cache ── cache exceptions by call arguments ─────────────────────
 @error_cache(maxsize=64)
 def load(user_id: int) -> dict:
     if user_id < 0:
@@ -132,7 +153,7 @@ with ignore(ValueError):
 print(load.cache_info())  # CacheInfo(hits=0, misses=1, maxsize=64, currsize=1)
 load.clear_cache()
 
-# ── 11. Custom exceptions — three layers ──────────────────────────────────────
+# ── 14. Custom exceptions — three layers ──────────────────────────────────────
 
 # Layer 1: PureBaseException — code + detail only
 class AppError(PureBaseException):
@@ -168,7 +189,7 @@ raise BaseErrorCodes.runtime_failure("crash")             # RuntimeFailure     [
 raise BaseErrorCodes.timeout_failure()                    # TimeoutFailure     [4002]
 raise BaseErrorCodes.configuration_error("missing key")   # ConfigurationError [5001]
 
-# ── 12. BaseWarning ── structured warnings with factory methods ───────────────
+# ── 15. BaseWarning ── structured warnings with factory methods ───────────────
 class ExperimentalWarning(BaseWarning):
     default_detail = "This feature is experimental."
 

{errortools-2.3.0 → errortools-2.4.0}/_errortools/const.py

@@ -1,10 +1,12 @@
 """Constants for errortools module."""
 
+from typing import Final
+
 # ------------------------------------------------------------------
 # error_cache constants
 # ------------------------------------------------------------------
 
-DEFAULT_ERROR_CACHE_SIZE: int = 128
-SMALL_ERROR_CACHE_SIZE: int = 64
-LARGE_ERROR_CACHE_SIZE: int = 1024
-UNLIMITED_ERROR_CACHE: None = None
+DEFAULT_ERROR_CACHE_SIZE: Final[int] = 128
+SMALL_ERROR_CACHE_SIZE: Final[int] = 64
+LARGE_ERROR_CACHE_SIZE: Final[int] = 1024
+UNLIMITED_ERROR_CACHE: Final[None] = None

errortools-2.4.0/_errortools/errno.py

@@ -0,0 +1,86 @@
+"""Lightweight utilities for errno error code inspection and handling."""
+
+import errno
+
+
+def get_errno_name(code: int) -> str | None:
+    """Get the symbolic name for an errno code.
+
+    Args:
+        code: The numeric errno code (e.g., 2 for ENOENT)
+
+    Returns:
+        The symbolic 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 corresponding message description for an errno code.
+
+    Args:
+        code: The numeric errno code
+
+    Returns:
+        The message string corresponding to the errno code
+
+    Raises:
+        ValueError: If the given errno code is invalid
+    """
+    if not is_valid_errno(code):
+        raise ValueError(f"Unknown error code: {code}")
+
+    return errno.errorcode.get(code, f"Unknown error {code}")
+
+
+def get_all_errno_codes() -> dict[str, int]:
+    """Get a dictionary of all errno constant names and their numeric codes.
+
+    Returns:
+        Dictionary mapping uppercase errno names to their integer 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 whether a given integer is a valid system errno code.
+
+    Args:
+        code: The numeric code to validate
+
+    Returns:
+        True if the code corresponds to a known errno constant, False otherwise
+    """
+    return get_errno_name(code) is not None
+
+
+def strerror(code: int) -> str:
+    """Get the human-readable system error message for an errno code.
+
+    Args:
+        code: The numeric errno code
+
+    Returns:
+        Human-readable error message string
+
+    Raises:
+        ValueError: If the error code is not recognized by the system
+    """
+    import os
+
+    try:
+        return os.strerror(code)
+    except (ValueError, OSError):
+        raise ValueError(f"Unknown error code: {code}")

errortools-2.4.0/_errortools/future.py

@@ -0,0 +1,165 @@
+"""Future-focused lightweight exception handling utilities."""
+
+from __future__ import annotations
+
+from typing import TypeAlias, cast, Literal
+
+__all__ = [
+    "super_fast_ignore",
+    "super_fast_catch",
+    "super_fast_reraise",
+    "ExceptionCollector",
+]
+
+_ExcType: TypeAlias = type[BaseException]
+
+
+class super_fast_ignore:
+    """Ultra-lightweight context manager to suppress exceptions."""
+
+    __slots__ = ("excs",)
+
+    def __init__(self, *excs: _ExcType) -> None:
+        self.excs = excs
+
+    def __enter__(self) -> None:
+        return
+
+    def __exit__(self, typ: _ExcType | None, *_) -> bool:
+        if typ is None:
+            return False
+        excs = self.excs
+        return issubclass(typ, excs)
+
+
+class super_fast_catch:
+    """Ultra-lightweight context manager to catch and store exceptions.
+
+    Args:
+        *excs: Exception types to catch. Empty means catch all.
+
+    Example:
+        >>> with super_fast_catch(ValueError) as ctx:
+        ...     raise ValueError("oops")
+        >>> print(ctx.exception)
+    """
+
+    __slots__ = ("excs", "exception")
+
+    def __init__(self, *excs: _ExcType) -> None:
+        self.excs = excs if excs else (BaseException,)
+        self.exception: BaseException | None = None
+
+    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):
+            return False
+        self.exception = val
+        return True
+
+
+class super_fast_reraise:
+    """Ultra-lightweight context manager to convert exception types.
+
+    Args:
+        catch: Exception type(s) to intercept.
+        raise_as: Exception type to raise instead.
+
+    Example:
+        >>> with super_fast_reraise(KeyError, ValueError):
+        ...     raise KeyError("missing")
+        >>> # Raises ValueError: missing
+    """
+
+    __slots__ = ("catch", "raise_as")
+
+    def __init__(
+        self,
+        catch: _ExcType | tuple[_ExcType, ...],
+        raise_as: _ExcType,
+    ) -> None:
+        self.catch = catch if isinstance(catch, tuple) else (catch,)
+        self.raise_as = raise_as
+
+    def __enter__(self) -> None:
+        return
+
+    def __exit__(self, typ: _ExcType | None, val, *_) -> Literal[False]:
+        if typ is None or not issubclass(typ, self.catch):
+            return False
+        raise self.raise_as(str(val)) from val
+
+
+class ExceptionCollector:
+    """Collect multiple exceptions and raise together at the end.
+
+    Useful for batch operations where you want all errors, not just the first.
+
+    Example:
+        >>> collector = ExceptionCollector()
+        >>> with collector:
+        ...     collector.catch(int, "bad1")
+        ...     collector.catch(int, "bad2")
+        >>> if collector.has_errors:
+        ...     collector.raise_all()
+    """
+
+    __slots__ = ("_exceptions", "_stop_on_first")
+
+    def __init__(self, stop_on_first: bool = False) -> None:
+        self._exceptions: list[BaseException] = []
+        self._stop_on_first = stop_on_first
+
+    def __enter__(self) -> ExceptionCollector:
+        return self
+
+    def __exit__(self, exc_typ, exc_val, *_) -> bool:
+        if exc_typ is not None:
+            self._exceptions.append(exc_val)
+            if self._stop_on_first:
+                return False
+            return True
+        return False
+
+    def catch(self, func, *args, **kwargs) -> bool:
+        """Try to call func and catch any exception. Returns True if exception caught."""
+        try:
+            func(*args, **kwargs)
+            return False
+        except BaseException as exc:
+            self._exceptions.append(exc)
+            if self._stop_on_first:
+                raise
+            return True
+
+    def add(self, exc: BaseException) -> None:
+        """Manually add an exception."""
+        self._exceptions.append(exc)
+        if self._stop_on_first:
+            raise exc
+
+    @property
+    def has_errors(self) -> bool:
+        """Check if any exceptions were collected."""
+        return len(self._exceptions) > 0
+
+    @property
+    def count(self) -> int:
+        """Get number of collected exceptions."""
+        return len(self._exceptions)
+
+    @property
+    def exceptions(self) -> list[BaseException]:
+        """Get the list of exceptions."""
+        return self._exceptions
+
+    def raise_all(self, message: str = "collected errors") -> None:
+        """Raise all collected exceptions as ExceptionGroup."""
+        if self._exceptions:
+            raise ExceptionGroup(message, cast(list[Exception], self._exceptions))
+
+    def clear(self) -> None:
+        """Clear all exceptions."""
+        self._exceptions.clear()

{errortools-2.3.0 → errortools-2.4.0}/_errortools/logging/level.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import ClassVar
+from typing import ClassVar, Final
 
 
 @dataclass(frozen=True)
@@ -55,7 +55,7 @@ Level.CRITICAL = Level("CRITICAL", 50, "\033[1;31m", "☠")  # bold red
 
 
 # Ordered list for iteration / lookup
-LEVELS: tuple[Level, ...] = (
+LEVELS: Final[tuple[Level, ...]] = (
     Level.TRACE,
     Level.DEBUG,
     Level.INFO,
@@ -65,8 +65,8 @@ LEVELS: tuple[Level, ...] = (
     Level.CRITICAL,
 )
 
-_NAME_MAP: dict[str, Level] = {lv.name: lv for lv in LEVELS}
-_NO_MAP: dict[int, Level] = {lv.no: lv for lv in LEVELS}
+_NAME_MAP: Final[dict[str, Level]] = {lv.name: lv for lv in LEVELS}
+_NO_MAP: Final[dict[int, Level]] = {lv.no: lv for lv in LEVELS}
 
 
 def get_level(name_or_no: str | int) -> Level:

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: errortools
-Version: 2.3.0
+Version: 2.4.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
@@ -39,6 +39,7 @@ A lightweight Python exception handling utility library.
 ## 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
@@ -62,7 +63,7 @@ from errortools import (
     error_cache,
     PureBaseException, ContextException, BaseErrorCodes, BaseWarning,
 )
-from errortools.future import super_fast_ignore
+from errortools.future import super_fast_ignore, super_fast_catch, super_fast_reraise, ExceptionCollector
 
 # ── 1. ignore ── context manager with full metadata ──────────────────────────
 with ignore(KeyError) as err:
@@ -154,7 +155,27 @@ raises_all(
 exc = assert_raises(int, [ValueError], "not-a-number")
 print(exc)   # invalid literal for int() with base 10: 'not-a-number'
 
-# ── 10. error_cache ── cache exceptions by call arguments ─────────────────────
+# ── 10. super_fast_catch ── lightweight exception capture ──────────────────────
+with super_fast_catch(ValueError) as ctx:
+    raise ValueError("oops")
+    
+assert ctx.exception is not None
+print(ctx.exception)  # ValueError('oops')
+
+# ── 11. super_fast_reraise ── lightweight exception type conversion ────────────
+with super_fast_reraise(KeyError, ValueError):
+    raise KeyError("missing")           # → ValueError: 'missing'
+
+# ── 12. ExceptionCollector ── batch collect exceptions ───────────────────────────
+collector = ExceptionCollector()
+collector.catch(int, "bad1")
+collector.catch(int, "bad2")
+
+if collector.has_errors:
+    print(f"Collected {collector.count} errors")
+    collector.raise_all("batch operation failed")  # → ExceptionGroup (2 sub-exceptions)
+
+# ── 13. error_cache ── cache exceptions by call arguments ─────────────────────
 @error_cache(maxsize=64)
 def load(user_id: int) -> dict:
     if user_id < 0:
@@ -167,7 +188,7 @@ with ignore(ValueError):
 print(load.cache_info())  # CacheInfo(hits=0, misses=1, maxsize=64, currsize=1)
 load.clear_cache()
 
-# ── 11. Custom exceptions — three layers ──────────────────────────────────────
+# ── 14. Custom exceptions — three layers ──────────────────────────────────────
 
 # Layer 1: PureBaseException — code + detail only
 class AppError(PureBaseException):
@@ -203,7 +224,7 @@ raise BaseErrorCodes.runtime_failure("crash")             # RuntimeFailure     [
 raise BaseErrorCodes.timeout_failure()                    # TimeoutFailure     [4002]
 raise BaseErrorCodes.configuration_error("missing key")   # ConfigurationError [5001]
 
-# ── 12. BaseWarning ── structured warnings with factory methods ───────────────
+# ── 15. BaseWarning ── structured warnings with factory methods ───────────────
 class ExperimentalWarning(BaseWarning):
     default_detail = "This feature is experimental."
 

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

@@ -57,6 +57,7 @@ tests/test_decorator.py
 tests/test_descriptor.py
 tests/test_errno.py
 tests/test_errorcodes.py
+tests/test_future.py
 tests/test_groups.py
 tests/test_ignore.py
 tests/test_logging.py

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

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="errortools",
-    version="2.3.0",
+    version="2.4.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",

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

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

{errortools-2.3.0 → errortools-2.4.0}/tests/test_errno.py

@@ -2,6 +2,8 @@
 
 import errno
 
+import pytest
+
 from _errortools.errno import (
     get_errno_name,
     get_errno_message,
@@ -37,8 +39,9 @@ class TestGetErrnoMessage:
         assert len(message) > 0
 
     def test_invalid_errno_message(self):
-        message = get_errno_message(9999)
-        assert "Unknown error" in message or len(message) > 0
+        with pytest.raises(ValueError):
+            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)

errortools-2.4.0/tests/test_future.py

@@ -0,0 +1,302 @@
+"""Tests for _errortools/future.py — super_fast_ignore, super_fast_catch, super_fast_reraise, ExceptionCollector."""
+
+import pytest
+
+from _errortools.future import (
+    super_fast_ignore,
+    super_fast_catch,
+    super_fast_reraise,
+    ExceptionCollector,
+)
+from . import HAS_PYTEST
+
+if not HAS_PYTEST:
+    print("pytest is required to run these tests, skip run test_future.py")
+    exit(0)
+
+
+# =============================================================================
+# super_fast_ignore
+# =============================================================================
+
+
+class TestSuperFastIgnore:
+    """Tests for super_fast_ignore context manager."""
+
+    def test_suppresses_single_exception(self):
+        """Test that super_fast_ignore suppresses a single exception type."""
+        with super_fast_ignore(ValueError):
+            raise ValueError("ignored")
+
+    def test_suppresses_multiple_exception_types(self):
+        """Test that super_fast_ignore suppresses multiple exception types."""
+        with super_fast_ignore(ValueError, KeyError):
+            raise KeyError("ignored")
+
+    def test_unrelated_exception_propagates(self):
+        """Test that unrelated exceptions are not suppressed."""
+        with pytest.raises(RuntimeError):
+            with super_fast_ignore(ValueError):
+                raise RuntimeError("not suppressed")
+
+    def test_no_exception_in_block(self):
+        """Test that block with no exception executes normally."""
+        result = []
+        with super_fast_ignore(ValueError):
+            result.append(1)
+        assert result == [1]
+
+    def test_execution_continues_after_suppression(self):
+        """Test that execution continues after exception is suppressed."""
+        items = []
+        with super_fast_ignore(ValueError):
+            raise ValueError("ignored")
+        items.append("after")
+        assert items == ["after"]
+
+    def test_suppresses_exception_subclass(self):
+        """Test that subclasses of specified exceptions are suppressed."""
+        with super_fast_ignore(LookupError):
+            raise KeyError("subclass of LookupError")
+
+    def test_nested_suppress(self):
+        """Test nested super_fast_ignore context managers."""
+        with super_fast_ignore(ValueError):
+            with super_fast_ignore(KeyError):
+                raise KeyError("inner")
+
+
+# =============================================================================
+# super_fast_catch
+# =============================================================================
+
+
+class TestSuperFastCatch:
+    """Tests for super_fast_catch context manager."""
+
+    def test_catches_single_exception_type(self):
+        """Test that super_fast_catch catches a specified exception type."""
+        with super_fast_catch(ValueError) as ctx:
+            raise ValueError("caught")
+        assert ctx.exception is not None
+        assert isinstance(ctx.exception, ValueError)
+        assert str(ctx.exception) == "caught"
+
+    def test_catches_multiple_exception_types(self):
+        """Test that super_fast_catch can catch multiple exception types."""
+        with super_fast_catch(ValueError, KeyError) as ctx:
+            raise KeyError("caught")
+        assert isinstance(ctx.exception, KeyError)
+
+    def test_catches_exception_subclass(self):
+        """Test that subclasses of specified exceptions are caught."""
+        with super_fast_catch(LookupError) as ctx:
+            raise KeyError("subclass")
+        assert isinstance(ctx.exception, KeyError)
+
+    def test_no_exception_stored_when_none_raised(self):
+        """Test that exception is None when no exception is raised."""
+        with super_fast_catch(ValueError) as ctx:
+            pass
+        assert ctx.exception is None
+
+    def test_unrelated_exception_propagates(self):
+        """Test that unrelated exceptions propagate."""
+        with pytest.raises(RuntimeError):
+            with super_fast_catch(ValueError) as ctx:
+                raise RuntimeError("not caught")
+
+    def test_catch_all_when_no_args(self):
+        """Test that super_fast_catch catches all exceptions when given no args."""
+        with super_fast_catch() as ctx:
+            raise RuntimeError("caught all")
+        assert ctx.exception is not None
+        assert isinstance(ctx.exception, RuntimeError)
+
+    def test_returns_self(self):
+        """Test that super_fast_catch returns itself."""
+        with super_fast_catch(ValueError) as ctx:
+            assert isinstance(ctx, super_fast_catch)
+
+
+# =============================================================================
+# super_fast_reraise
+# =============================================================================
+
+
+class TestSuperFastReraise:
+    """Tests for super_fast_reraise context manager."""
+
+    def test_converts_exception_type(self):
+        """Test that super_fast_reraise converts exception types."""
+        with pytest.raises(ValueError) as exc_info:
+            with super_fast_reraise(KeyError, ValueError):
+                raise KeyError("original")
+        assert "'original'" in str(exc_info.value)
+        assert exc_info.value.__cause__.__class__ == KeyError
+
+    def test_preserves_exception_message(self):
+        """Test that reraise preserves the original exception message."""
+        msg = "test message"
+        with pytest.raises(ValueError) as exc_info:
+            with super_fast_reraise(KeyError, ValueError):
+                raise KeyError(msg)
+        assert msg in str(exc_info.value)
+
+    def test_catches_multiple_types(self):
+        """Test that super_fast_reraise can catch multiple exception types."""
+        with pytest.raises(RuntimeError):
+            with super_fast_reraise((KeyError, ValueError), RuntimeError):
+                raise ValueError("caught")
+
+    def test_unrelated_exception_propagates(self):
+        """Test that unrelated exceptions propagate unchanged."""
+        with pytest.raises(TypeError):
+            with super_fast_reraise(ValueError, KeyError):
+                raise TypeError("not caught")
+
+    def test_chains_exceptions(self):
+        """Test that original exception is chained with __cause__."""
+        with pytest.raises(ValueError) as exc_info:
+            with super_fast_reraise(KeyError, ValueError):
+                raise KeyError("original")
+        assert exc_info.value.__cause__ is not None
+        assert isinstance(exc_info.value.__cause__, KeyError)
+
+    def test_no_exception_in_block(self):
+        """Test that block with no exception executes normally."""
+        with super_fast_reraise(ValueError, KeyError):
+            pass
+
+
+# =============================================================================
+# ExceptionCollector
+# =============================================================================
+
+
+class TestExceptionCollector:
+    """Tests for ExceptionCollector context manager."""
+
+    def test_collects_single_exception(self):
+        """Test that ExceptionCollector collects a single exception."""
+        collector = ExceptionCollector()
+        collector.catch(int, "not-a-number")
+        assert collector.has_errors
+        assert collector.count == 1
+        assert len(collector.exceptions) == 1
+
+    def test_collects_multiple_exceptions(self):
+        """Test that ExceptionCollector collects multiple exceptions."""
+        collector = ExceptionCollector()
+        collector.catch(int, "bad1")
+        collector.catch(int, "bad2")
+        collector.catch(int, "bad3")
+        assert collector.count == 3
+
+    def test_catch_returns_false_on_success(self):
+        """Test that catch returns False when no exception is raised."""
+        collector = ExceptionCollector()
+        result = collector.catch(int, "123")
+        assert result is False
+
+    def test_catch_returns_true_on_exception(self):
+        """Test that catch returns True when exception is raised."""
+        collector = ExceptionCollector()
+        result = collector.catch(int, "not-a-number")
+        assert result is True
+
+    def test_add_method(self):
+        """Test that add method adds exceptions manually."""
+        collector = ExceptionCollector()
+        exc = ValueError("test")
+        collector.add(exc)
+        assert collector.count == 1
+        assert collector.exceptions[0] is exc
+
+    def test_has_errors_property(self):
+        """Test has_errors property."""
+        collector = ExceptionCollector()
+        assert not collector.has_errors
+        collector.catch(int, "bad")
+        assert collector.has_errors
+
+    def test_clear_method(self):
+        """Test that clear removes all exceptions."""
+        collector = ExceptionCollector()
+        collector.catch(int, "bad1")
+        collector.catch(int, "bad2")
+        assert collector.count == 2
+        collector.clear()
+        assert collector.count == 0
+        assert not collector.has_errors
+
+    def test_raise_all_with_errors(self):
+        """Test that raise_all raises ExceptionGroup when errors collected."""
+        collector = ExceptionCollector()
+        collector.catch(int, "bad1")
+        collector.catch(int, "bad2")
+        with pytest.raises(ExceptionGroup) as exc_info:
+            collector.raise_all()
+        assert exc_info.value.message == "collected errors"
+        assert len(exc_info.value.exceptions) == 2
+
+    def test_raise_all_with_custom_message(self):
+        """Test that raise_all uses custom message."""
+        collector = ExceptionCollector()
+        collector.catch(int, "bad")
+        with pytest.raises(ExceptionGroup) as exc_info:
+            collector.raise_all("custom error message")
+        assert exc_info.value.message == "custom error message"
+
+    def test_raise_all_without_errors(self):
+        """Test that raise_all does nothing when no errors collected."""
+        collector = ExceptionCollector()
+        collector.raise_all()
+
+    def test_context_manager_usage(self):
+        """Test ExceptionCollector as context manager."""
+        with ExceptionCollector() as collector:
+            collector.catch(int, "bad1")
+            collector.catch(int, "bad2")
+        assert collector.count == 2
+
+    def test_context_manager_with_exception_in_block(self):
+        """Test context manager when exception raised in block."""
+        with ExceptionCollector() as collector:
+            raise ValueError("in block")
+        assert collector.count == 1
+        assert isinstance(collector.exceptions[0], ValueError)
+
+    def test_stop_on_first_mode(self):
+        """Test that stop_on_first=True raises immediately."""
+        collector = ExceptionCollector(stop_on_first=True)
+        with pytest.raises(ValueError):
+            collector.catch(int, "bad")
+        assert collector.count == 1
+
+    def test_stop_on_first_add_method(self):
+        """Test that add method respects stop_on_first."""
+        collector = ExceptionCollector(stop_on_first=True)
+        with pytest.raises(RuntimeError):
+            collector.add(RuntimeError("test"))
+
+    def test_exceptions_property(self):
+        """Test that exceptions property returns list of exceptions."""
+        collector = ExceptionCollector()
+        exc1 = ValueError("test1")
+        exc2 = TypeError("test2")
+        collector.add(exc1)
+        collector.add(exc2)
+        exceptions = collector.exceptions
+        assert len(exceptions) == 2
+        assert exceptions[0] is exc1
+        assert exceptions[1] is exc2
+
+    def test_count_property(self):
+        """Test that count property returns correct number."""
+        collector = ExceptionCollector()
+        assert collector.count == 0
+        collector.catch(int, "bad1")
+        assert collector.count == 1
+        collector.catch(int, "bad2")
+        assert collector.count == 2

errortools-2.3.0/_errortools/errno.py

@@ -1,78 +0,0 @@
-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.3.0/_errortools/future.py

@@ -1,23 +0,0 @@
-"""Futures classes and functions."""
-
-from typing import TypeAlias
-
-_ExcType: TypeAlias = type[BaseException]
-
-
-class super_fast_ignore:
-    """Ultra-lightweight context manager to suppress exceptions."""
-
-    __slots__ = ("excs",)
-
-    def __init__(self, *excs: _ExcType) -> None:
-        self.excs = excs
-
-    def __enter__(self) -> None:
-        return
-
-    def __exit__(self, typ: _ExcType | None, *_) -> bool:
-        if typ is None:
-            return False
-        excs = self.excs
-        return issubclass(typ, excs)