actionable-errors 0.1.0__py3-none-any.whl

actionable_errors/__init__.py

@@ -0,0 +1,28 @@
+"""actionable-errors: Three-audience error framework.
+
+Every ActionableError speaks to three audiences simultaneously:
+- Calling code: typed ErrorType for routing (retry? escalate? ignore?)
+- Human operator: suggestion + Troubleshooting steps
+- AI agent: AIGuidance with concrete next tool calls
+"""
+
+from __future__ import annotations
+
+from actionable_errors.classifier import from_exception
+from actionable_errors.error import ActionableError
+from actionable_errors.guidance import AIGuidance, Troubleshooting
+from actionable_errors.result import ToolResult
+from actionable_errors.sanitizer import CredentialSanitizer, register_pattern, sanitize
+from actionable_errors.types import ErrorType
+
+__all__ = [
+    "AIGuidance",
+    "ActionableError",
+    "CredentialSanitizer",
+    "ErrorType",
+    "ToolResult",
+    "Troubleshooting",
+    "from_exception",
+    "register_pattern",
+    "sanitize",
+]

actionable_errors/classifier.py

@@ -0,0 +1,61 @@
+"""from_exception() keyword-based auto-classifier."""
+
+from __future__ import annotations
+
+from actionable_errors.error import ActionableError
+from actionable_errors.types import ErrorType
+
+# Keyword → ErrorType mapping.  First match wins, so order matters.
+# Each tuple is (keywords, target_type).
+_KEYWORD_RULES: list[tuple[list[str], ErrorType]] = [
+    (["unauthorized", "unauthenticated", "credential", "login", "auth", "401"],
+     ErrorType.AUTHENTICATION),
+    (["forbidden", "permission", "denied", "access", "403"],
+     ErrorType.PERMISSION),
+    (["timeout", "timed out", "deadline"],
+     ErrorType.TIMEOUT),
+    (["connection refused", "connection error", "unreachable", "dns", "connect"],
+     ErrorType.CONNECTION),
+    (["not found", "no such", "missing", "does not exist", "404"],
+     ErrorType.NOT_FOUND),
+    (["invalid", "validation", "malformed", "schema", "constraint"],
+     ErrorType.VALIDATION),
+    (["config", "configuration", "setting", "environment variable"],
+     ErrorType.CONFIGURATION),
+]
+
+
+def from_exception(
+    exc: Exception,
+    service: str,
+    operation: str,
+    *,
+    suggestion: str | None = None,
+) -> ActionableError:
+    """Classify an arbitrary exception into an ActionableError.
+
+    Scans ``str(exc)`` against keyword rules (case-insensitive) and assigns
+    the matching :class:`ErrorType`.  Falls back to ``INTERNAL`` when no
+    rule matches.
+
+    If *suggestion* is provided it is passed through to the resulting error.
+    """
+    text = str(exc).lower()
+
+    for keywords, error_type in _KEYWORD_RULES:
+        for kw in keywords:
+            if kw in text:
+                return ActionableError(
+                    error=str(exc),
+                    error_type=error_type,
+                    service=service,
+                    suggestion=suggestion,
+                )
+
+    # Fallback: unrecognised → INTERNAL
+    return ActionableError(
+        error=str(exc),
+        error_type=ErrorType.INTERNAL,
+        service=service,
+        suggestion=suggestion,
+    )

actionable_errors/error.py

@@ -0,0 +1,227 @@
+"""ActionableError dataclass with factory classmethods."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, fields
+from datetime import UTC, datetime
+from typing import Any
+
+from actionable_errors.guidance import AIGuidance, Troubleshooting
+from actionable_errors.types import ErrorType
+
+
+@dataclass
+class ActionableError(Exception):
+    """Three-audience error — code routing, human suggestion, AI guidance.
+
+    Always carries ``success = False`` and a UTC ``timestamp``.
+    Construct via factory classmethods for consistency.
+    """
+
+    error: str
+    error_type: ErrorType | str
+    service: str
+    suggestion: str | None = None
+    ai_guidance: AIGuidance | None = None
+    troubleshooting: Troubleshooting | None = None
+    context: dict[str, Any] | None = None
+    success: bool = field(default=False, init=False)
+    timestamp: str = field(default="", init=False)
+
+    def __post_init__(self) -> None:
+        super().__init__(self.error)
+        self.success = False
+        self.timestamp = datetime.now(tz=UTC).isoformat()
+
+    # ------------------------------------------------------------------
+    # Serialization
+    # ------------------------------------------------------------------
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to dict, excluding None-valued optional fields."""
+        result: dict[str, Any] = {}
+        for f in fields(self):
+            value = getattr(self, f.name)
+            if value is None:
+                continue
+            if f.name == "error_type":
+                result["error_type"] = str(value)
+            elif isinstance(value, (AIGuidance, Troubleshooting)):
+                result[f.name] = value.to_dict()
+            else:
+                result[f.name] = value
+        return result
+
+    # ------------------------------------------------------------------
+    # Factory classmethods
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def authentication(
+        cls,
+        service: str,
+        raw_error: str,
+        *,
+        suggestion: str | None = None,
+        ai_guidance: AIGuidance | None = None,
+        troubleshooting: Troubleshooting | None = None,
+    ) -> ActionableError:
+        """Create an AUTHENTICATION error."""
+        return cls(
+            error=f"{service} authentication failed: {raw_error}",
+            error_type=ErrorType.AUTHENTICATION,
+            service=service,
+            suggestion=suggestion or "Check your credentials and try again.",
+            ai_guidance=ai_guidance or AIGuidance(
+                action_required="Re-authenticate",
+                command="az login",
+            ),
+            troubleshooting=troubleshooting,
+        )
+
+    @classmethod
+    def configuration(
+        cls,
+        field_name: str,
+        reason: str,
+        *,
+        suggestion: str | None = None,
+        ai_guidance: AIGuidance | None = None,
+        troubleshooting: Troubleshooting | None = None,
+    ) -> ActionableError:
+        """Create a CONFIGURATION error."""
+        return cls(
+            error=f"Configuration error — {field_name}: {reason}",
+            error_type=ErrorType.CONFIGURATION,
+            service="configuration",
+            suggestion=suggestion or f"Check the '{field_name}' setting.",
+            ai_guidance=ai_guidance,
+            troubleshooting=troubleshooting,
+        )
+
+    @classmethod
+    def connection(
+        cls,
+        service: str,
+        url: str,
+        raw_error: str,
+        *,
+        suggestion: str | None = None,
+        ai_guidance: AIGuidance | None = None,
+        troubleshooting: Troubleshooting | None = None,
+    ) -> ActionableError:
+        """Create a CONNECTION error."""
+        return cls(
+            error=f"{service} connection to {url} failed: {raw_error}",
+            error_type=ErrorType.CONNECTION,
+            service=service,
+            suggestion=suggestion or f"Verify {service} is running at {url}.",
+            ai_guidance=ai_guidance,
+            troubleshooting=troubleshooting,
+        )
+
+    @classmethod
+    def timeout(
+        cls,
+        service: str,
+        operation: str,
+        timeout_seconds: int | float,
+        *,
+        suggestion: str | None = None,
+        ai_guidance: AIGuidance | None = None,
+        troubleshooting: Troubleshooting | None = None,
+    ) -> ActionableError:
+        """Create a TIMEOUT error."""
+        return cls(
+            error=f"{service} {operation} timed out after {timeout_seconds}s",
+            error_type=ErrorType.TIMEOUT,
+            service=service,
+            suggestion=suggestion or f"Increase the timeout or optimize the {operation}.",
+            ai_guidance=ai_guidance,
+            troubleshooting=troubleshooting,
+        )
+
+    @classmethod
+    def permission(
+        cls,
+        service: str,
+        resource: str,
+        raw_error: str,
+        *,
+        suggestion: str | None = None,
+        ai_guidance: AIGuidance | None = None,
+        troubleshooting: Troubleshooting | None = None,
+    ) -> ActionableError:
+        """Create a PERMISSION error."""
+        return cls(
+            error=f"{service} permission denied on {resource}: {raw_error}",
+            error_type=ErrorType.PERMISSION,
+            service=service,
+            suggestion=suggestion or f"Request access to {resource}.",
+            ai_guidance=ai_guidance,
+            troubleshooting=troubleshooting,
+        )
+
+    @classmethod
+    def validation(
+        cls,
+        service: str,
+        field_name: str,
+        reason: str,
+        *,
+        suggestion: str | None = None,
+        ai_guidance: AIGuidance | None = None,
+        troubleshooting: Troubleshooting | None = None,
+    ) -> ActionableError:
+        """Create a VALIDATION error."""
+        return cls(
+            error=f"{service} validation failed — {field_name}: {reason}",
+            error_type=ErrorType.VALIDATION,
+            service=service,
+            suggestion=suggestion or f"Fix the '{field_name}' value: {reason}.",
+            ai_guidance=ai_guidance,
+            troubleshooting=troubleshooting,
+        )
+
+    @classmethod
+    def not_found(
+        cls,
+        service: str,
+        resource_type: str,
+        resource_id: str,
+        raw_error: str,
+        *,
+        suggestion: str | None = None,
+        ai_guidance: AIGuidance | None = None,
+        troubleshooting: Troubleshooting | None = None,
+    ) -> ActionableError:
+        """Create a NOT_FOUND error."""
+        return cls(
+            error=f"{service} {resource_type} '{resource_id}' not found: {raw_error}",
+            error_type=ErrorType.NOT_FOUND,
+            service=service,
+            suggestion=suggestion or f"Verify the {resource_type} identifier.",
+            ai_guidance=ai_guidance,
+            troubleshooting=troubleshooting,
+        )
+
+    @classmethod
+    def internal(
+        cls,
+        service: str,
+        operation: str,
+        raw_error: str,
+        *,
+        suggestion: str | None = None,
+        ai_guidance: AIGuidance | None = None,
+        troubleshooting: Troubleshooting | None = None,
+    ) -> ActionableError:
+        """Create an INTERNAL error."""
+        return cls(
+            error=f"{service} unexpected error in {operation}: {raw_error}",
+            error_type=ErrorType.INTERNAL,
+            service=service,
+            suggestion=suggestion or "Check logs for details.",
+            ai_guidance=ai_guidance,
+            troubleshooting=troubleshooting,
+        )

actionable_errors/guidance.py

@@ -0,0 +1,49 @@
+"""AIGuidance and Troubleshooting frozen dataclasses."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, fields
+from typing import Any
+
+
+@dataclass(frozen=True)
+class AIGuidance:
+    """Structured guidance for AI agents consuming error responses.
+
+    Only ``action_required`` is mandatory.  Optional fields let producers
+    provide richer context without burdening simple callers.
+    """
+
+    action_required: str
+    command: str | None = None
+    discovery_tool: str | None = None
+    checks: list[str] | None = None
+    steps: list[str] | None = None
+    optimization_tips: list[str] | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to dict, excluding None-valued optional fields."""
+        return {
+            f.name: getattr(self, f.name)
+            for f in fields(self)
+            if getattr(self, f.name) is not None
+        }
+
+
+@dataclass(frozen=True)
+class Troubleshooting:
+    """Ordered human-readable troubleshooting steps.
+
+    ``steps`` must contain at least one entry.
+    """
+
+    steps: list[str]
+
+    def __post_init__(self) -> None:
+        if not self.steps:
+            msg = "Troubleshooting requires at least one step."
+            raise ValueError(msg)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to dict."""
+        return {"steps": list(self.steps)}

actionable_errors/result.py

@@ -0,0 +1,92 @@
+"""ToolResult typed envelope — success/failure with data/error fields."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from actionable_errors.error import ActionableError
+
+
+@dataclass
+class ToolResult:
+    """Structured envelope for MCP tool responses.
+
+    Use the ``.ok()`` and ``.fail()`` factory classmethods instead of
+    constructing directly.
+    """
+
+    success: bool
+    data: Any | None = None
+    error: str | None = None
+    error_type: str | None = None
+    suggestion: str | None = None
+    ai_guidance: dict[str, Any] | None = None
+
+    # ------------------------------------------------------------------
+    # Factories
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def ok(
+        cls,
+        data: Any | None = None,
+        *,
+        suggestion: str | None = None,
+        ai_guidance: dict[str, Any] | None = None,
+    ) -> ToolResult:
+        """Create a success result."""
+        return cls(
+            success=True,
+            data=data,
+            suggestion=suggestion,
+            ai_guidance=ai_guidance,
+        )
+
+    @classmethod
+    def fail(
+        cls,
+        error: str | ActionableError,
+        *,
+        suggestion: str | None = None,
+        ai_guidance: dict[str, Any] | None = None,
+    ) -> ToolResult:
+        """Create a failure result from a string or :class:`ActionableError`.
+
+        When *error* is an ``ActionableError``, ``error_type`` and
+        ``suggestion`` are extracted automatically.  An explicit
+        *suggestion* kwarg overrides the one carried by the error.
+        """
+        if isinstance(error, ActionableError):
+            return cls(
+                success=False,
+                error=error.error,
+                error_type=str(error.error_type),
+                suggestion=suggestion if suggestion is not None else error.suggestion,
+                ai_guidance=ai_guidance,
+            )
+        return cls(
+            success=False,
+            error=error,
+            suggestion=suggestion,
+            ai_guidance=ai_guidance,
+        )
+
+    # ------------------------------------------------------------------
+    # Serialization
+    # ------------------------------------------------------------------
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to dict, excluding None-valued optional fields."""
+        d: dict[str, Any] = {"success": self.success}
+        if self.data is not None:
+            d["data"] = self.data
+        if self.error is not None:
+            d["error"] = self.error
+        if self.error_type is not None:
+            d["error_type"] = self.error_type
+        if self.suggestion is not None:
+            d["suggestion"] = self.suggestion
+        if self.ai_guidance is not None:
+            d["ai_guidance"] = self.ai_guidance
+        return d

actionable_errors/sanitizer.py

@@ -0,0 +1,149 @@
+"""Credential redaction — regex-based, 8+ patterns, configurable."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+
+@dataclass
+class _Pattern:
+    """Internal representation of a registered redaction pattern."""
+
+    name: str
+    regex: re.Pattern[str]
+    replacement: str
+
+
+# ------------------------------------------------------------------ #
+# Built-in patterns                                                   #
+# ------------------------------------------------------------------ #
+
+_BUILTIN_PATTERNS: list[_Pattern] = [
+    # password="...", password=..., Password=...
+    _Pattern(
+        name="password_assignment",
+        regex=re.compile(
+            r'((?:password|passwd|pwd)\s*[=:]\s*)"?([^";,\s]+)"?',
+            re.IGNORECASE,
+        ),
+        replacement=r"\1***",
+    ),
+    # api_key="...", apikey=...
+    _Pattern(
+        name="api_key_assignment",
+        regex=re.compile(
+            r'((?:api[_-]?key)\s*[=:]\s*)"?([^";,\s]+)"?',
+            re.IGNORECASE,
+        ),
+        replacement=r"\1***",
+    ),
+    # token="...", access_token=...
+    _Pattern(
+        name="token_assignment",
+        regex=re.compile(
+            r'((?:token|access_token)\s*[=:]\s*)"?([^";,\s]+)"?',
+            re.IGNORECASE,
+        ),
+        replacement=r"\1***",
+    ),
+    # client_secret="...", secret=...
+    _Pattern(
+        name="secret_assignment",
+        regex=re.compile(
+            r'((?:(?:client_)?secret)\s*[=:]\s*)"?([^";,\s]+)"?',
+            re.IGNORECASE,
+        ),
+        replacement=r"\1***",
+    ),
+    # Authorization: Bearer <token>
+    _Pattern(
+        name="bearer_token",
+        regex=re.compile(
+            r"(Bearer\s+)\S+",
+            re.IGNORECASE,
+        ),
+        replacement=r"\1***",
+    ),
+    # SAS token sig= parameter
+    _Pattern(
+        name="sas_signature",
+        regex=re.compile(
+            r"(sig=)[^&\s]+",
+            re.IGNORECASE,
+        ),
+        replacement=r"\1***",
+    ),
+    # Connection string Password=...;
+    _Pattern(
+        name="connection_string_password",
+        regex=re.compile(
+            r"(Password\s*=\s*)([^;]+)",
+            re.IGNORECASE,
+        ),
+        replacement=r"\1***",
+    ),
+    # AccountKey=...;
+    _Pattern(
+        name="account_key",
+        regex=re.compile(
+            r"(AccountKey\s*=\s*)([^;]+)",
+            re.IGNORECASE,
+        ),
+        replacement=r"\1***",
+    ),
+]
+
+
+@dataclass
+class CredentialSanitizer:
+    """Regex-based credential sanitizer with built-in + custom patterns."""
+
+    _patterns: list[_Pattern] = field(default_factory=lambda: list(_BUILTIN_PATTERNS))
+
+    def register_pattern(
+        self,
+        name: str,
+        pattern: str | re.Pattern[str],
+        replacement: str = "***",
+    ) -> None:
+        """Register an additional redaction pattern.
+
+        Parameters
+        ----------
+        name:
+            Human-readable label for logging/debugging.
+        pattern:
+            Raw string or compiled ``re.Pattern``.
+        replacement:
+            Replacement text (may use back-references).
+        """
+        compiled = re.compile(pattern) if isinstance(pattern, str) else pattern
+        self._patterns.append(_Pattern(name=name, regex=compiled, replacement=replacement))
+
+    def sanitize(self, text: str) -> str:
+        """Apply all registered patterns to *text* and return the redacted result."""
+        for p in self._patterns:
+            text = p.regex.sub(p.replacement, text)
+        return text
+
+
+# ------------------------------------------------------------------ #
+# Module-level convenience API (uses a shared default instance)       #
+# ------------------------------------------------------------------ #
+
+_default = CredentialSanitizer()
+
+
+def sanitize(text: str) -> str:
+    """Redact credentials from *text* using built-in patterns."""
+    return _default.sanitize(text)
+
+
+def register_pattern(
+    name: str,
+    pattern: str | re.Pattern[str],
+    replacement: str = "***",
+) -> None:
+    """Register an additional redaction pattern on the default sanitizer."""
+    _default.register_pattern(name=name, pattern=pattern, replacement=replacement)

actionable_errors/types.py

@@ -0,0 +1,25 @@
+"""ErrorType base categories — extensible by consumers via standard Python enum extension."""
+
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class ErrorType(StrEnum):
+    """Broad error categories for routing decisions.
+
+    Consumers extend this via standard Python enum inheritance::
+
+        class MyErrorType(ErrorType):
+            EMBEDDING = "embedding"
+            RATE_LIMIT = "rate_limit"
+    """
+
+    AUTHENTICATION = "authentication"
+    CONFIGURATION = "configuration"
+    CONNECTION = "connection"
+    TIMEOUT = "timeout"
+    PERMISSION = "permission"
+    VALIDATION = "validation"
+    NOT_FOUND = "not_found"
+    INTERNAL = "internal"

actionable_errors-0.1.0.dist-info/METADATA

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: actionable-errors
+Version: 0.1.0
+Summary: Three-audience error framework: typed errors for code, actionable suggestions for humans, tool guidance for AI agents
+Project-URL: Repository, https://github.com/grimlor/actionable-errors
+Author: grimlor
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Provides-Extra: dev
+Requires-Dist: mypy<2,>=1.13; extra == 'dev'
+Requires-Dist: pre-commit<5,>=4; extra == 'dev'
+Requires-Dist: pytest-asyncio<1,>=0.24; extra == 'dev'
+Requires-Dist: pytest-cov<7,>=6; extra == 'dev'
+Requires-Dist: pytest<9,>=8; extra == 'dev'
+Requires-Dist: ruff<1,>=0.8; extra == 'dev'
+Requires-Dist: taskipy<2,>=1.14; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# actionable-errors
+
+Three-audience error framework for Python.
+
+Every `ActionableError` speaks to three audiences simultaneously:
+
+| Audience | Uses | Provided by |
+|----------|------|-------------|
+| **Calling code** | Typed `ErrorType` for routing (retry? escalate? ignore?) | `ErrorType(StrEnum)` — 8 base categories |
+| **Human operator** | `suggestion` + `Troubleshooting` steps | Frozen dataclasses with actionable text |
+| **AI agent** | `AIGuidance` with concrete next tool calls | Frozen dataclass with tool suggestions |
+
+## Install
+
+```bash
+pip install actionable-errors
+```
+
+**Zero runtime dependencies** — stdlib only. Sits at the bottom of every dependency tree.
+
+## Quick Start
+
+```python
+from actionable_errors import (
+    ActionableError,
+    AIGuidance,
+    ToolResult,
+    from_exception,
+    sanitize,
+)
+
+# Domain-specific factory with built-in defaults
+error = ActionableError.authentication(
+    service="Azure DevOps",
+    raw_error="401 Unauthorized",
+)
+print(error.suggestion)    # "Check your credentials and try again."
+print(error.ai_guidance)   # AIGuidance(action_required="Re-authenticate", command="az login")
+
+# Auto-classify any exception
+try:
+    raise ConnectionError("Connection refused")
+except Exception as exc:
+    ae = from_exception(exc, service="Kusto", operation="query")
+    print(ae.error_type)   # "connection"
+
+# Typed result envelope for MCP tool responses
+result = ToolResult.ok(data={"items": 42})
+result = ToolResult.fail(error=error)     # extracts error_type + suggestion
+
+# Credential sanitization
+clean = sanitize('password="hunter2" token=abc123')
+# → 'password="***" token=***'
+```
+
+## Extending ErrorType
+
+Python `StrEnum` can't be subclassed once it has members, so extend via composition:
+
+```python
+from enum import StrEnum
+from actionable_errors import ActionableError
+
+class RAGErrorType(StrEnum):
+    EMBEDDING = "embedding"
+    INDEX = "index"
+
+error = ActionableError(
+    error="Vector store unavailable",
+    error_type=RAGErrorType.INDEX,
+    service="pinecone",
+    suggestion="Check Pinecone cluster status.",
+)
+```
+
+## Factories
+
+Eight domain-specific factories with sensible defaults:
+
+| Factory | Key Parameters |
+|---------|---------------|
+| `.authentication(service, raw_error)` | Default suggestion + AI guidance |
+| `.configuration(field_name, reason)` | — |
+| `.connection(service, url, raw_error)` | — |
+| `.timeout(service, operation, timeout_seconds)` | — |
+| `.permission(service, resource, raw_error)` | — |
+| `.validation(service, field_name, reason)` | — |
+| `.not_found(service, resource_type, resource_id, raw_error)` | — |
+| `.internal(service, operation, raw_error)` | — |
+
+All factories accept optional `suggestion`, `ai_guidance`, and `troubleshooting` kwargs.
+
+## Development
+
+```bash
+# Install dev dependencies
+uv sync --extra dev
+
+# Run all checks
+task check  # lint → type → test (90 tests, 100% coverage)
+```
+
+## License
+
+MIT

actionable_errors-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+actionable_errors/__init__.py,sha256=YmKO5TqKSjn4wZNYOXVhS85coSLeGovLlYiqRIzfb8M,897
+actionable_errors/classifier.py,sha256=hAogr_MsCK2L_rt8LzuBIe8YPexkerN3-cFoVKhF2u8,2034
+actionable_errors/error.py,sha256=NcN472xNNCIwVT2lmRfR8l4ShKfRxojUnE8YQwhfLFE,7529
+actionable_errors/guidance.py,sha256=3jjbZB5xoqYpSLn7T3xX98f2eBur7pMUh9G1DdmisP0,1355
+actionable_errors/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+actionable_errors/result.py,sha256=yvw1z-juXj9mI9-y27QkG0j2AiLxGTpoXe-x3C-1xYk,2882
+actionable_errors/sanitizer.py,sha256=fj8MUJ60nGpjbrDNVE7laTRnc6thAJMhN9wNJhVj6gw,4189
+actionable_errors/types.py,sha256=SiQHzlibjpBAdLXVJPLrP-h7zPg58Drv5fyNgjqXREM,669
+actionable_errors-0.1.0.dist-info/METADATA,sha256=tqjeRDYiMEpWCffBZdV77TMW-wLNV-6lCI0h1WkVla0,3994
+actionable_errors-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+actionable_errors-0.1.0.dist-info/licenses/LICENSE,sha256=PdpS05B102voqmZt6nyk_9xpy4CGoToVhf4mkqe0yIs,1064
+actionable_errors-0.1.0.dist-info/RECORD,,

actionable_errors-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

actionable_errors-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 grimlor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.