python-corekit 0.4.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

corekit/exceptionator/__init__.py

@@ -0,0 +1,68 @@
+"""
+Process-wide exception capture: catch, run one action, rethrow.
+
+Product concerns (Postgres, ntfy, prompts) stay in the installing application.
+This package owns the wrapper, built-in actions, fingerprinting, ASGI middleware,
+and the ``run_task`` hook point.
+"""
+
+from corekit.exceptionator.actions import (
+    ExceptionatorAction,
+    LogTracebackAction,
+    NoOpAction,
+)
+from corekit.exceptionator.asgi import (
+    ExceptionatorMiddleware,
+    get_process_exceptionator,
+    record_http_exception,
+    set_process_exceptionator,
+    should_record_http_exception,
+)
+from corekit.exceptionator.exceptionator import Exceptionator
+from corekit.exceptionator.fingerprint import ExceptionFingerprint, ExceptionText
+from corekit.exceptionator.guard import (
+    begin_handling,
+    end_handling,
+    handling_active,
+    is_captured,
+    mark_captured,
+)
+from corekit.exceptionator.jobs import (
+    clear_run_task_hook,
+    get_run_task_hook,
+    install_run_task_hook,
+)
+from corekit.exceptionator.models import (
+    CapturedException,
+    ExceptionatorActionName,
+    ExceptionContext,
+    ExceptionSource,
+    build_captured,
+)
+
+__all__ = [
+    "CapturedException",
+    "ExceptionContext",
+    "ExceptionFingerprint",
+    "ExceptionSource",
+    "ExceptionText",
+    "Exceptionator",
+    "ExceptionatorAction",
+    "ExceptionatorActionName",
+    "ExceptionatorMiddleware",
+    "LogTracebackAction",
+    "NoOpAction",
+    "begin_handling",
+    "build_captured",
+    "clear_run_task_hook",
+    "end_handling",
+    "get_process_exceptionator",
+    "get_run_task_hook",
+    "handling_active",
+    "install_run_task_hook",
+    "is_captured",
+    "mark_captured",
+    "record_http_exception",
+    "set_process_exceptionator",
+    "should_record_http_exception",
+]

corekit/exceptionator/actions.py

@@ -0,0 +1,46 @@
+"""
+Built-in Exceptionator actions.
+"""
+
+from __future__ import annotations
+
+from corekit.exceptionator.models import CapturedException
+from corekit.observability.loggable import Loggable
+
+__all__ = ["ExceptionatorAction", "LogTracebackAction", "NoOpAction"]
+
+
+class ExceptionatorAction(Loggable):
+    """
+    Work performed after an exception is captured and before it continues.
+    """
+
+    def run(self, captured: CapturedException) -> None:
+        """
+        Perform the action. Must not raise.
+        """
+        raise NotImplementedError
+
+
+class NoOpAction(ExceptionatorAction):
+    """
+    Catch and continue. Records nothing and publishes nothing.
+    """
+
+    def run(self, captured: CapturedException) -> None:
+        """
+        Do nothing with the captured exception.
+        """
+        return None
+
+
+class LogTracebackAction(ExceptionatorAction):
+    """
+    Write the message and traceback. Does not store or notify.
+    """
+
+    def run(self, captured: CapturedException) -> None:
+        """
+        Log the incident text.
+        """
+        self.error(f"{captured.service} {captured.exception_type}: {captured.message}\n{captured.traceback_text}")

corekit/exceptionator/asgi.py

@@ -0,0 +1,115 @@
+"""
+ASGI middleware and HTTP helpers for Exceptionator.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from fastapi import Request
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+from starlette.exceptions import HTTPException
+from starlette.websockets import WebSocketDisconnect
+
+from corekit.exceptionator.exceptionator import Exceptionator
+from corekit.exceptionator.models import ExceptionContext, ExceptionSource
+
+__all__ = [
+    "ExceptionatorMiddleware",
+    "get_process_exceptionator",
+    "record_http_exception",
+    "set_process_exceptionator",
+    "should_record_http_exception",
+]
+
+ASGIApp = Callable[..., Awaitable[None]]
+
+_process_exceptionator: Exceptionator | None = None
+
+
+def set_process_exceptionator(exceptionator: Exceptionator) -> None:
+    """
+    Remember the process Exceptionator for middleware and HTTP handlers.
+    """
+    global _process_exceptionator
+    _process_exceptionator = exceptionator
+
+
+def get_process_exceptionator() -> Exceptionator:
+    """
+    The Exceptionator installed for this process.
+    """
+    if _process_exceptionator is None:
+        raise RuntimeError("No Exceptionator installed; call set_process_exceptionator first")
+    return _process_exceptionator
+
+
+def should_record_http_exception(exc: BaseException) -> bool:
+    """
+    Client errors and validation failures are not incidents. HTTP 500s are.
+    """
+    if isinstance(exc, RequestValidationError):
+        return False
+    if isinstance(exc, WebSocketDisconnect):
+        return False
+    status = getattr(exc, "status_code", None)
+    if isinstance(exc, HTTPException) and isinstance(status, int) and status < 500:
+        return False
+    return True
+
+
+class ExceptionatorMiddleware:
+    """
+    ASGI middleware that records unhandled HTTP failures and rethrows them.
+
+    Not ``BaseHTTPMiddleware``: that wrapper breaks streaming and exception groups.
+    """
+
+    def __init__(self, app: ASGIApp, exceptionator: Exceptionator | None = None) -> None:
+        self.app = app
+        self._exceptionator = exceptionator
+
+    async def __call__(self, scope: dict[str, Any], receive: Any, send: Any) -> None:
+        if scope.get("type") != "http":
+            await self.app(scope, receive, send)
+            return
+        try:
+            await self.app(scope, receive, send)
+        except Exception as exc:
+            if should_record_http_exception(exc):
+                self._resolve().capture(
+                    exc,
+                    context=ExceptionContext(
+                        source=ExceptionSource.HTTP,
+                        http_method=scope.get("method"),
+                        http_path=scope.get("path"),
+                    ),
+                )
+            raise
+
+    def _resolve(self) -> Exceptionator:
+        if self._exceptionator is not None:
+            return self._exceptionator
+        return get_process_exceptionator()
+
+
+def record_http_exception(request: Request, exc: HTTPException) -> JSONResponse:
+    """
+    Store HTTP 500s, then return the same JSON body FastAPI would have sent.
+
+    Starlette answers ``HTTPException`` inside the router, so the ASGI middleware
+    never sees it. 4xx responses are returned unchanged and are not incidents.
+    """
+    if should_record_http_exception(exc):
+        get_process_exceptionator().capture(
+            exc,
+            context=ExceptionContext(
+                source=ExceptionSource.HTTP,
+                http_method=request.method,
+                http_path=request.url.path,
+            ),
+        )
+    headers = getattr(exc, "headers", None)
+    return JSONResponse(status_code=exc.status_code, content={"detail": exc.detail}, headers=headers)

corekit/exceptionator/constants.py

@@ -0,0 +1,7 @@
+"""
+Limits shared by every Exceptionator install.
+"""
+
+MESSAGE_MAX_CHARS = 2_000
+TRACEBACK_MAX_CHARS = 32_000
+FINGERPRINT_FRAMES = 8

corekit/exceptionator/exceptionator.py

@@ -0,0 +1,62 @@
+"""
+Catch an exception, run one action, and let the caller rethrow.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+from corekit.exceptionator.actions import ExceptionatorAction
+from corekit.exceptionator.guard import (
+    begin_handling,
+    end_handling,
+    handling_active,
+    is_captured,
+    mark_captured,
+)
+from corekit.exceptionator.models import CapturedException, ExceptionContext, build_captured
+from corekit.observability.loggable import Loggable
+
+__all__ = ["Exceptionator"]
+
+
+class Exceptionator(Loggable):
+    """
+    Catch an exception, run the configured action, and let the caller rethrow.
+
+    ``guard`` rethrows. ``capture`` runs the same action and returns, for a
+    caller that has already decided to swallow the error.
+    """
+
+    def __init__(self, action: ExceptionatorAction, *, service: str) -> None:
+        super().__init__()
+        self._action = action
+        self.service = service
+
+    @contextmanager
+    def guard(self, context: ExceptionContext | None = None) -> Iterator[None]:
+        """
+        Run the action when the block raises, then rethrow the original exception.
+        """
+        try:
+            yield
+        except Exception as exc:
+            self.capture(exc, context=context)
+            raise
+
+    def capture(self, exc: BaseException, *, context: ExceptionContext | None = None) -> None:
+        """
+        Run the action once for this exception. Later calls on the same object no-op.
+        """
+        if handling_active() or is_captured(exc):
+            return
+        token = begin_handling()
+        try:
+            captured: CapturedException = build_captured(exc, service=self.service, context=context)
+            mark_captured(exc)
+            self._action.run(captured)
+        except Exception:
+            self.exception("Exceptionator failed while recording an exception")
+        finally:
+            end_handling(token)

corekit/exceptionator/fingerprint.py

@@ -0,0 +1,86 @@
+"""
+Identity for an exception based on its type and innermost frames.
+
+The message is left out so ids embedded in the text do not split one bug into
+many fingerprints.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import traceback
+from types import TracebackType
+from typing import ClassVar
+
+from corekit.exceptionator.constants import FINGERPRINT_FRAMES
+from corekit.utils.text import truncate
+
+__all__ = ["ExceptionFingerprint", "ExceptionText"]
+
+
+class ExceptionText:
+    """
+    Backend text extracted from an exception.
+    """
+
+    @staticmethod
+    def message(exc: BaseException) -> str:
+        """
+        Backend message. Public exceptions stringify to user copy, so prefer ``for_log``.
+        """
+        for_log = getattr(exc, "for_log", None)
+        if callable(for_log):
+            try:
+                return str(for_log())
+            except Exception:
+                return str(exc)
+        return str(exc)
+
+    @staticmethod
+    def first_line(text: str, limit: int) -> str:
+        """
+        The first line of ``text``, truncated to ``limit`` characters.
+        """
+        line = text.splitlines()[0] if text else ""
+        return truncate(line, limit)
+
+
+class ExceptionFingerprint:
+    """
+    Stable identity for an exception based on its type and innermost frames.
+    """
+
+    path_markers: ClassVar[tuple[str, ...]] = ()
+
+    def of(self, exc: BaseException) -> str:
+        """
+        Hash the exception type plus the innermost stack frames.
+        """
+        frames = traceback.extract_tb(exc.__traceback__)[-FINGERPRINT_FRAMES:]
+        parts = [type(exc).__qualname__]
+        for frame in frames:
+            parts.append(f"{self.normalize_path(frame.filename)}|{frame.name}|{frame.lineno}")
+        return hashlib.sha256("\n".join(parts).encode()).hexdigest()
+
+    @classmethod
+    def normalize_path(cls, filename: str) -> str:
+        """
+        Drop machine-specific prefixes so a container path and a checkout match.
+        """
+        normalized = filename.replace("\\", "/")
+        for marker in cls.path_markers:
+            index = normalized.find(marker)
+            if index >= 0:
+                return normalized[index:]
+        parts = [part for part in normalized.split("/") if part]
+        if not parts:
+            return normalized
+        return "/".join(parts[-2:])
+
+    @staticmethod
+    def format_traceback(exc: BaseException) -> str:
+        """
+        Render the traceback text for storage.
+        """
+        tb: TracebackType | None = exc.__traceback__
+        return "".join(traceback.format_exception(type(exc), exc, tb))

corekit/exceptionator/guard.py

@@ -0,0 +1,53 @@
+"""
+ContextVar and per-exception marker so one failure is recorded once.
+"""
+
+from __future__ import annotations
+
+from contextvars import ContextVar, Token
+
+__all__ = [
+    "begin_handling",
+    "end_handling",
+    "handling_active",
+    "is_captured",
+    "mark_captured",
+]
+
+CAPTURED_MARKER = "_exceptionator_captured"
+_handling: ContextVar[bool] = ContextVar("exceptionator_handling", default=False)
+
+
+def is_captured(exc: BaseException) -> bool:
+    """
+    Whether this exception object was already handed to an Exceptionator.
+    """
+    return bool(getattr(exc, CAPTURED_MARKER, False))
+
+
+def mark_captured(exc: BaseException) -> None:
+    """
+    Remember that this exception object has been handled.
+    """
+    setattr(exc, CAPTURED_MARKER, True)
+
+
+def handling_active() -> bool:
+    """
+    Whether this task is already inside the Exceptionator.
+    """
+    return _handling.get()
+
+
+def begin_handling() -> Token[bool]:
+    """
+    Mark this task as inside the Exceptionator. Pair with ``end_handling``.
+    """
+    return _handling.set(True)
+
+
+def end_handling(token: Token[bool]) -> None:
+    """
+    Leave the Exceptionator guard.
+    """
+    _handling.reset(token)

corekit/exceptionator/jobs.py

@@ -0,0 +1,52 @@
+"""
+Hook ``run_task`` calls after a task fails and before ``failure()``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from corekit.exceptionator.models import ExceptionContext, ExceptionSource
+
+if TYPE_CHECKING:
+    from corekit.exceptionator.exceptionator import Exceptionator
+
+__all__ = ["clear_run_task_hook", "get_run_task_hook", "install_run_task_hook"]
+
+RunTaskHook = Callable[[str, BaseException], None]
+
+_hook: RunTaskHook | None = None
+
+
+def install_run_task_hook(exceptionator: Exceptionator) -> None:
+    """
+    Register ``exceptionator`` so ``run_task`` captures failures with the task name.
+
+    Passing the same instance again is a no-op. Call ``clear_run_task_hook`` to
+    remove it. With no hook registered, ``run_task`` behaves as it did before.
+    """
+    global _hook
+
+    def hook(task_name: str, exc: BaseException) -> None:
+        exceptionator.capture(
+            exc,
+            context=ExceptionContext(source=ExceptionSource.RQ, job_name=task_name),
+        )
+
+    _hook = hook
+
+
+def clear_run_task_hook() -> None:
+    """
+    Remove any ``run_task`` capture hook.
+    """
+    global _hook
+    _hook = None
+
+
+def get_run_task_hook() -> RunTaskHook | None:
+    """
+    The hook ``run_task`` should call, or ``None``.
+    """
+    return _hook

corekit/exceptionator/models.py

@@ -0,0 +1,98 @@
+"""
+Values every Exceptionator action receives.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from corekit.exceptionator.constants import MESSAGE_MAX_CHARS, TRACEBACK_MAX_CHARS
+from corekit.exceptionator.fingerprint import ExceptionFingerprint, ExceptionText
+from corekit.schemas import StringEnum
+from corekit.utils.text import truncate
+
+__all__ = [
+    "CapturedException",
+    "ExceptionContext",
+    "ExceptionSource",
+    "ExceptionatorActionName",
+    "build_captured",
+]
+
+_fingerprint = ExceptionFingerprint()
+
+
+class ExceptionatorActionName(StringEnum):
+    """
+    Built-in action names. Apps may define additional string names for custom actions.
+    """
+
+    NOOP = "noop"
+    LOG = "log"
+    PERSIST_AND_NOTIFY = "persist_and_notify"
+
+
+class ExceptionSource(StringEnum):
+    """
+    Which process boundary captured the exception.
+    """
+
+    HTTP = "http"
+    RQ = "rq"
+    DISCORD = "discord"
+    TASK = "task"
+
+
+class ExceptionContext(BaseModel):
+    """
+    Where an exception was caught, plus whatever the boundary already knows.
+    """
+
+    source: ExceptionSource = ExceptionSource.TASK
+    http_method: str | None = None
+    http_path: str | None = None
+    job_name: str | None = None
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+
+@dataclass
+class CapturedException:
+    """
+    One incident, ready for an action. Not a database row.
+    """
+
+    service: str
+    exception_type: str
+    message: str
+    traceback_text: str
+    fingerprint: str
+    context: ExceptionContext
+    exc: BaseException = field(repr=False)
+
+
+def build_captured(
+    exc: BaseException,
+    *,
+    service: str,
+    context: ExceptionContext | None = None,
+) -> CapturedException:
+    """
+    Truncate an exception into the object actions receive.
+
+    Product code that stores the text should redact secrets before writing.
+    """
+    resolved = context or ExceptionContext()
+    message = ExceptionText.message(exc)
+    traceback_text = ExceptionFingerprint.format_traceback(exc)
+    return CapturedException(
+        service=service,
+        exception_type=type(exc).__qualname__,
+        message=truncate(message, MESSAGE_MAX_CHARS),
+        traceback_text=truncate(traceback_text, TRACEBACK_MAX_CHARS, suffix="\n… truncated"),
+        fingerprint=_fingerprint.of(exc),
+        context=resolved,
+        exc=exc,
+    )

corekit/jobs/runner.py

@@ -18,6 +18,7 @@ import inspect
 import logging
 from typing import Any
 
+from corekit.exceptionator.jobs import get_run_task_hook
 from corekit.jobs.registry import task_registry
 from corekit.utils.payload import decode_payload
 
@@ -34,8 +35,10 @@ def run_task(task_name: str, payload: str | bytes | None = None) -> Any:
     raises, and the original exception is re-raised so the queue records the
     job as failed. A hook that raises does not mask the original error.
     ``last_result`` and ``last_error`` are set on the task before the hook
-    runs. A coroutine ``task_function`` is awaited. ``timeout`` is not applied
-    here; the scheduling adapter owns that.
+    runs. When an Exceptionator ``run_task`` hook is installed it runs after
+    ``last_error`` is set and before ``failure()``. A coroutine
+    ``task_function`` is awaited. ``timeout`` is not applied here; the
+    scheduling adapter owns that.
 
     Args:
         task_name: The registered name of the task to run.
@@ -58,6 +61,7 @@ def run_task(task_name: str, payload: str | bytes | None = None) -> Any:
     except Exception as exc:
         task.last_result = None
         task.last_error = exc
+        _run_exceptionator_hook(task_name, exc)
         _run_hook(task, "failure", args, kwargs)
         raise
 
@@ -67,6 +71,22 @@ def run_task(task_name: str, payload: str | bytes | None = None) -> Any:
     return result
 
 
+def _run_exceptionator_hook(task_name: str, exc: BaseException) -> None:
+    """
+    Run the optional Exceptionator hook without replacing the original error.
+    """
+    hook = get_run_task_hook()
+    if hook is None:
+        return
+    try:
+        hook(task_name, exc)
+    except Exception:
+        logger.exception(
+            "Exceptionator run_task hook raised for %s; the task's own outcome stands",
+            task_name,
+        )
+
+
 def _run_hook(task: Any, hook_name: str, args: list[Any], kwargs: dict[str, Any]) -> None:
     """
     Run a success or failure hook without letting it replace the real outcome.

corekit/utils/__init__.py

@@ -19,7 +19,7 @@ from corekit.utils.ids import (
 )
 from corekit.utils.payload import Payload, decode_payload, encode_payload
 from corekit.utils.raise_exc import raise_exc
-from corekit.utils.text import join_lines, list_to_english, sanitize_filename
+from corekit.utils.text import join_lines, list_to_english, sanitize_filename, truncate
 from corekit.utils.time import isoformat_now, parse_docker_timestamp, time_now, timedelta_now, timestamp_now
 from corekit.utils.validators import false_validator, true_validator
 from corekit.utils.void import void
@@ -56,5 +56,6 @@ __all__ = [
     "timedelta_now",
     "timestamp_now",
     "true_validator",
+    "truncate",
     "void",
 ]

corekit/utils/text.py

@@ -2,13 +2,14 @@
 String assembly helpers.
 
 Small formatters for turning collections into text a human will read -- log
-lines, notification bodies, error messages -- plus filename sanitization.
+lines, notification bodies, error messages -- plus filename sanitization and
+length limits.
 """
 
 import re
 from typing import Any, Literal
 
-__all__ = ["join_lines", "list_to_english", "sanitize_filename"]
+__all__ = ["join_lines", "list_to_english", "sanitize_filename", "truncate"]
 
 FALLBACK_FILENAME = "unnamed"
 _UNSAFE_CHARS = re.compile(r"[^a-z0-9\-]")
@@ -43,6 +44,24 @@ def list_to_english(items: list[str], ending: Literal["and", "or"] | None = None
     return f"{buffer}, {ending} {last}"
 
 
+def truncate(text: str, limit: int, *, suffix: str = "") -> str:
+    """
+    Cut ``text`` to at most ``limit`` characters, appending ``suffix`` when cut.
+
+    ``suffix`` counts toward ``limit``, so the returned string is never longer
+    than ``limit`` (unless ``suffix`` itself is longer than ``limit``, in which
+    case ``suffix`` is returned truncated to ``limit``).
+    """
+    if limit <= 0:
+        return ""
+    if len(text) <= limit:
+        return text
+    if len(suffix) >= limit:
+        return suffix[:limit]
+    keep = limit - len(suffix)
+    return text[:keep] + suffix
+
+
 def sanitize_filename(raw: str, fallback: str = FALLBACK_FILENAME) -> str:
     """
     Reduce a string to lowercase kebab-case safe for use as a filename stem.

{python_corekit-0.4.0.dist-info → python_corekit-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-corekit
-Version: 0.4.0
+Version: 0.4.1
 Summary: Shared foundations for Python projects: logging, benchmarking, registries, FastAPI application and routers, SQL statements and migrations, background tasks, ETL, and LLM chat/tool primitives
 Author: Steven Jacobsen
 License-Expression: MIT
@@ -90,6 +90,29 @@ class Report(Benchmarkable):
         self.timing("queried")   # logs the time since the previous split
 ```
 
+## Exceptionator
+
+Catch an exception, run one action, then rethrow so the existing failure path
+still happens. Built-in actions are no-op and log-traceback; apps supply their
+own (persist, notify, …).
+
+```python
+from corekit.exceptionator import (
+    Exceptionator,
+    ExceptionatorMiddleware,
+    LogTracebackAction,
+    install_run_task_hook,
+    set_process_exceptionator,
+)
+
+exceptionator = Exceptionator(LogTracebackAction(), service="api")
+set_process_exceptionator(exceptionator)
+install_run_task_hook(exceptionator)  # optional; run_task captures with task name
+```
+
+`ExceptionatorMiddleware` is raw ASGI (not `BaseHTTPMiddleware`). With no
+`run_task` hook installed, jobs behave as in 0.4.0.
+
 ## Assembling an application
 
 `Application` is a plain `FastAPI` subclass — every constructor argument,

{python_corekit-0.4.0.dist-info → python_corekit-0.4.1.dist-info}/RECORD

@@ -74,6 +74,15 @@ corekit/events/publisher.py,sha256=70lHyEIEg0eXUWJ9k9eUNVBBmckm4rYBgvTZgRfbcl8,2
 corekit/events/reader.py,sha256=HoJs6zb9N3VDD-nJV2fpks7ny2OI8UaAKQMBaXcK7_k,4994
 corekit/events/sse.py,sha256=lhF4KUQ_XrdExGLWbKYJghti2t6ExNzXYoA6dOZi9mA,4090
 corekit/events/websocket.py,sha256=S6CUh9duI5xHVrKqbHpss8FrnKKqnFHBFJpSkmgInN4,3858
+corekit/exceptionator/__init__.py,sha256=-JjKXBPgevTZsd0MeJdyknae3SfJ2Etsqk6WIzrpSS8,1764
+corekit/exceptionator/actions.py,sha256=ji2qEabM-xQRv6Wiu5mkyCQJvDKJmSbfOwcnEvmx5fo,1172
+corekit/exceptionator/asgi.py,sha256=P7LPf_rsHas-2Rywe6lYhzG-C-yzI-cuCub2mn7hguQ,3780
+corekit/exceptionator/constants.py,sha256=pCNrGF_pH-__qMjWzTB1PK2lhTCIzCTRsgI0xkHYBCE,133
+corekit/exceptionator/exceptionator.py,sha256=z5dbvvpEgxRAYrsXQR8tDuo3wNjKsygonQy_4C3FWvs,1974
+corekit/exceptionator/fingerprint.py,sha256=Fjf02FFOq3pm4o88F0I7QDy7Nq9EwgA01jjpb8oWuMM,2609
+corekit/exceptionator/guard.py,sha256=SU95rYpadfqgAUogmXSQyHvHCP7xATADlQyOTwLO_Qk,1180
+corekit/exceptionator/jobs.py,sha256=ufQZNc5bbEsl3IYyCuTtaShXh0-lSbCReTouZHqpv9k,1340
+corekit/exceptionator/models.py,sha256=CQxKKzBBerkEqdUnuPVyXflzx2r9cjFzUpG8K8VizhE,2437
 corekit/exceptions/__init__.py,sha256=8q9EX-0bzOiJI1FOzCbViQFwx53Ugs8NH482Cvpci6k,995
 corekit/exceptions/base.py,sha256=k0AfTfPrLWR6x-l2qvvjqD_sup0fiWhqu1OoNaNM-Lk,5596
 corekit/exceptions/enum.py,sha256=D-YL-cZXs-F2jS1GgRBhPWmuqBfX33B1QP61vAXdAes,324
@@ -95,7 +104,7 @@ corekit/http/status.py,sha256=rZ-cdliG9EAvWMTzvxjqjipRkZRc6RgSzcBY4Kewdg0,2377
 corekit/http/stream.py,sha256=lkERyCXz5amOWzoE-b12iftf3l_G-ghwSvN1lL5lUio,3257
 corekit/jobs/__init__.py,sha256=vsv8o23ApT6MlOwOq-AFYeQW2NT1kjyvu89A5CL2PsY,880
 corekit/jobs/registry.py,sha256=cco6884eVuIYHEtSv6P62MICFjX-QhuSZIFkEJcQi_M,2557
-corekit/jobs/runner.py,sha256=KRzUIaeXVqLFekoIi2C5cnZ8F-5V5Oy_91xOPHjhjmY,2650
+corekit/jobs/runner.py,sha256=VyiTrQJT-E8-XuNBh8s1QgLJkKhkpBq_398Fs_03Kow,3321
 corekit/jobs/task.py,sha256=tqr-QaQSHyfPjbyZscM5i-YgT-fl58cpd2FVxevtG_E,6112
 corekit/llm/__init__.py,sha256=Qa-5V2cG4aH98b0nLY2tMx0G7uhoWhcaaZ7JY1dJjcA,3217
 corekit/llm/client.py,sha256=bO2o21ntKdGNjcWOoEv4ew2QQD7-HQ6Hsn01Zf_5a1I,6441
@@ -148,18 +157,18 @@ corekit/serialization/enum.py,sha256=pzHuAIXeonEF7-jyN1uYddJk-xvmQGuymDf1U6RWR5w
 corekit/serialization/pickle_file.py,sha256=dudKIxR8ueT3wx_IBxHJeoqnFeP1rT7dlTb_PXlSkd8,2251
 corekit/serialization/serializable.py,sha256=viF3ZCKRJ90hk6m4lbqIfo6ifsY2c4sXr4xZrn1Yz-Q,1999
 corekit/serialization/serializer.py,sha256=XlGE1Rq8M55Jl2a4F5MkvDcba2VI7lrh0v9kwL0DWG8,6617
-corekit/utils/__init__.py,sha256=2_YU0DK_guZntR5yooQ1rblLj5BMJSSA-6HMoFCjapk,1801
+corekit/utils/__init__.py,sha256=xOHqpsAipQbkCLurKOYBSQ8RJyHULfoeEKPXqudNWH4,1827
 corekit/utils/coercion.py,sha256=Aq63jrxQYg1ooWUFXHff2uepB_LoHm1izao8_3xkzEU,3650
 corekit/utils/collections.py,sha256=cn7Bzh67utzBi7UO4FfjWrjDun05ye5_rTscwfWcmwo,4475
 corekit/utils/ids.py,sha256=BVniaYqewM-EosDxcJAT_S_7T9C1c5X8nsaVGs5up34,1731
 corekit/utils/payload.py,sha256=T7EgdVU0S5h8MAzvQsmkfRPMatWqUbxjHL9hmZdM9ho,3882
 corekit/utils/raise_exc.py,sha256=cz7ljc6ZW90AGQussKuANN8PLsDLUhl-E8FZ0Ipsw-0,175
-corekit/utils/text.py,sha256=54maLM4jsS8cjVXRQCNVFzVszGimuzgaNzudhZzZeio,1694
+corekit/utils/text.py,sha256=0322DdZGuDGEagTyejuda6QT1jbbxNIO6loC-_AGml0,2311
 corekit/utils/time.py,sha256=-iPaETXcgDu7J39Kwe938JyZKhPVjl6a572BBqsqcDQ,2215
 corekit/utils/validators.py,sha256=_HVKo3y264KGNaZ-1RyM1x46VPvu7XKcQkrHWDC9uxs,340
 corekit/utils/void.py,sha256=eXDb2QynuguiSgHGJLdgE08MuRnxBdYebRdMD7s1m9o,178
-python_corekit-0.4.0.dist-info/licenses/LICENSE,sha256=357LYxbxAQZ95q5cV-8JK6j-KNgiE6AteRodjEsm-kE,1072
-python_corekit-0.4.0.dist-info/METADATA,sha256=N1r_kyXsO1GSGd92YDkDs3HzV6bYkhal5Rnmnl-8QCY,14378
-python_corekit-0.4.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_corekit-0.4.0.dist-info/top_level.txt,sha256=SDK4o8BoaI47E9tPbiNCbbWoc2y6N_wCjwnIEfr-GWI,8
-python_corekit-0.4.0.dist-info/RECORD,,
+python_corekit-0.4.1.dist-info/licenses/LICENSE,sha256=357LYxbxAQZ95q5cV-8JK6j-KNgiE6AteRodjEsm-kE,1072
+python_corekit-0.4.1.dist-info/METADATA,sha256=M24uRb1as-03LHKgbGhDIFJeQ30Z3mEO84EfCj_GNIE,15084
+python_corekit-0.4.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_corekit-0.4.1.dist-info/top_level.txt,sha256=SDK4o8BoaI47E9tPbiNCbbWoc2y6N_wCjwnIEfr-GWI,8
+python_corekit-0.4.1.dist-info/RECORD,,