fastapi-error-map 0.9.5__tar.gz → 0.9.7__tar.gz

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/.github/workflows/ci.yaml

@@ -18,13 +18,13 @@ jobs:
         uses: astral-sh/setup-uv@v6
 
       - name: Install dependencies
-        run: uv pip install -e '.[dev,test]' --system
+        run: uv sync --locked --group all
 
       - name: Lint code
-        run: make code.lint
+        run: uv run make code.lint
 
       - name: Run tests for Codecov
-        run: pytest --cov=fastapi_error_map --cov-branch --cov-report=xml
+        run: uv run pytest --cov=fastapi_error_map --cov-branch --cov-report=xml
 
       - name: Upload coverage reports to Codecov
         uses: codecov/codecov-action@v5

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/.github/workflows/test-compatibility.yaml

@@ -20,6 +20,7 @@ jobs:
           - "3.11"
           - "3.12"
           - "3.13"
+          - "3.14"
 
     steps:
       - uses: actions/checkout@v4
@@ -31,8 +32,5 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@v6
 
-      - name: Install nox
-        run: uv pip install nox --system
-
       - name: Run tests
-        run: nox -s compatibility
+        run: uvx nox -s compatibility

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: fastapi-error-map
-Version: 0.9.5
-Summary: Elegant per-endpoint error handling for FastAPI that keeps OpenAPI docs in sync
+Version: 0.9.7
+Summary: Elegant per-endpoint error handling for FastAPI that keeps OpenAPI in sync
 Project-URL: Homepage, https://github.com/ivan-borovets/fastapi-error-map
 Project-URL: Repository, https://github.com/ivan-borovets/fastapi-error-map
 Author-email: Ivan Borovets <ivan.r.borovets@gmail.com>
@@ -17,37 +17,23 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
 Requires-Python: >=3.9
-Requires-Dist: fastapi>=0.100.0
-Requires-Dist: orjson>=3.8.4
-Provides-Extra: dev
-Requires-Dist: mypy==1.8.0; extra == 'dev'
-Requires-Dist: pre-commit==4.2.0; extra == 'dev'
-Requires-Dist: ruff==0.11.2; extra == 'dev'
-Provides-Extra: examples
-Requires-Dist: uvicorn==0.35.0; extra == 'examples'
-Provides-Extra: publish
-Requires-Dist: hatch==1.14.1; extra == 'publish'
-Provides-Extra: test
-Requires-Dist: coverage==7.10.1; extra == 'test'
-Requires-Dist: httpx==0.28.1; extra == 'test'
-Requires-Dist: nox==2025.5.1; extra == 'test'
-Requires-Dist: pytest-asyncio==1.1.0; extra == 'test'
-Requires-Dist: pytest-cov==6.2.1; extra == 'test'
-Requires-Dist: pytest==8.4.1; extra == 'test'
+Requires-Dist: fastapi==0.100.0
+Requires-Dist: orjson==3.11.1
 Description-Content-Type: text/markdown
 
 ## FastAPI Error Map
 
-[![PyPI version](https://badge.fury.io/py/fastapi-error-map.svg?cacheBust=5)](https://badge.fury.io/py/fastapi-error-map)
-![PyPI - Python Version](https://img.shields.io/pypi/pyversions/fastapi-error-map?cacheBust=1)
+[![PyPI version](https://badge.fury.io/py/fastapi-error-map.svg?cacheBust=6)](https://badge.fury.io/py/fastapi-error-map)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/fastapi-error-map?cacheBust=2)
 [![codecov](https://codecov.io/gh/ivan-borovets/fastapi-error-map/branch/master/graph/badge.svg?token=ABTVQLI0RL)](https://codecov.io/gh/ivan-borovets/fastapi-error-map)
 ![GitHub License](https://img.shields.io/github/license/ivan-borovets/fastapi-error-map?cacheBust=1)
 ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/ivan-borovets/fastapi-error-map/ci.yaml?cacheBust=1)
 
-Elegant per-endpoint error handling for FastAPI that keeps OpenAPI docs in sync.
+Elegant per-endpoint error handling for FastAPI that keeps OpenAPI in sync.
 
 ### 📦 Installation
 
@@ -128,6 +114,9 @@ See the [example in the 🚀 Quickstart](#-quickstart).
 Error handling rules are defined directly in the route declaration of an `ErrorAwareRouter`, using the `error_map`
 parameter.
 
+> [!NOTE]
+> `error_map` handles HTTP error responses only — statuses must be 4xx or 5xx.
+
 There are two ways to do it:
 
 #### 🔸 Short Form
@@ -173,10 +162,10 @@ error_map = {
 
 Parameters of `rule(...)`, * — required:
 
-- `status`* — HTTP status code to return (e.g. `404`, `409`, `422`)
-- `translator` — object that converts an exception into JSON response. If not provided, the default one is used (returns
-  `{ "error": "..." }`)
-- `on_error` — function to call when an exception occurs (e.g. logging or alerting)
+- `status`* — HTTP status code to return (must be 4xx or 5xx; e.g. `404`, `409`, `422`)
+- `translator` — object that converts an exception into serializable payload. If not provided, the default one is used
+  (`{ "error": str(err) }` for 4xx; `{ "error": "Internal server error" }` for 5xx).
+- `on_error` — function to call when an exception occurs (e.g. logging or alerting). Can be awaitable
 
 #### 🧩 Matching semantics
 
@@ -228,7 +217,7 @@ If `from_error(...)` fails at runtime, the exception will propagate to FastAPI
 ### 🔄 Side Effects (`on_error`)
 
 The `on_error` parameter in `rule(...)` allows specifying function to run when exception occurs, before response is
-generated.
+generated. The awaitable function will be awaited.
 It doesn’t change the response status/body when it succeeds and is useful for:
 
 - logging
@@ -301,7 +290,8 @@ When an error occurs, `fastapi-error-map` processes it as follows:
     - If the status is `>= 500`, `default_server_error_translator` is used (if given)
     - If none are set, the built-in one is used:
   ```raw
-  { "error": "..." } or { "error": "Internal server error" }
+  { "error": str(err) } for 4xx;
+  { "error": "Internal server error" } for 5xx
   ```
 
 3. `on_error`:

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/README.md

@@ -1,12 +1,12 @@
 ## FastAPI Error Map
 
-[![PyPI version](https://badge.fury.io/py/fastapi-error-map.svg?cacheBust=5)](https://badge.fury.io/py/fastapi-error-map)
-![PyPI - Python Version](https://img.shields.io/pypi/pyversions/fastapi-error-map?cacheBust=1)
+[![PyPI version](https://badge.fury.io/py/fastapi-error-map.svg?cacheBust=6)](https://badge.fury.io/py/fastapi-error-map)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/fastapi-error-map?cacheBust=2)
 [![codecov](https://codecov.io/gh/ivan-borovets/fastapi-error-map/branch/master/graph/badge.svg?token=ABTVQLI0RL)](https://codecov.io/gh/ivan-borovets/fastapi-error-map)
 ![GitHub License](https://img.shields.io/github/license/ivan-borovets/fastapi-error-map?cacheBust=1)
 ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/ivan-borovets/fastapi-error-map/ci.yaml?cacheBust=1)
 
-Elegant per-endpoint error handling for FastAPI that keeps OpenAPI docs in sync.
+Elegant per-endpoint error handling for FastAPI that keeps OpenAPI in sync.
 
 ### 📦 Installation
 
@@ -87,6 +87,9 @@ See the [example in the 🚀 Quickstart](#-quickstart).
 Error handling rules are defined directly in the route declaration of an `ErrorAwareRouter`, using the `error_map`
 parameter.
 
+> [!NOTE]
+> `error_map` handles HTTP error responses only — statuses must be 4xx or 5xx.
+
 There are two ways to do it:
 
 #### 🔸 Short Form
@@ -132,10 +135,10 @@ error_map = {
 
 Parameters of `rule(...)`, * — required:
 
-- `status`* — HTTP status code to return (e.g. `404`, `409`, `422`)
-- `translator` — object that converts an exception into JSON response. If not provided, the default one is used (returns
-  `{ "error": "..." }`)
-- `on_error` — function to call when an exception occurs (e.g. logging or alerting)
+- `status`* — HTTP status code to return (must be 4xx or 5xx; e.g. `404`, `409`, `422`)
+- `translator` — object that converts an exception into serializable payload. If not provided, the default one is used
+  (`{ "error": str(err) }` for 4xx; `{ "error": "Internal server error" }` for 5xx).
+- `on_error` — function to call when an exception occurs (e.g. logging or alerting). Can be awaitable
 
 #### 🧩 Matching semantics
 
@@ -187,7 +190,7 @@ If `from_error(...)` fails at runtime, the exception will propagate to FastAPI
 ### 🔄 Side Effects (`on_error`)
 
 The `on_error` parameter in `rule(...)` allows specifying function to run when exception occurs, before response is
-generated.
+generated. The awaitable function will be awaited.
 It doesn’t change the response status/body when it succeeds and is useful for:
 
 - logging
@@ -260,7 +263,8 @@ When an error occurs, `fastapi-error-map` processes it as follows:
     - If the status is `>= 500`, `default_server_error_translator` is used (if given)
     - If none are set, the built-in one is used:
   ```raw
-  { "error": "..." } or { "error": "Internal server error" }
+  { "error": str(err) } for 4xx;
+  { "error": "Internal server error" } for 5xx
   ```
 
 3. `on_error`:

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/examples/errors.py

@@ -1,3 +1,4 @@
+import asyncio
 from dataclasses import dataclass
 
 from fastapi_error_map.translators import ErrorTranslator
@@ -25,5 +26,6 @@ class OutOfStockTranslator(ErrorTranslator[ErrorResponseModel]):
         return ErrorResponseModel
 
 
-def notify(err: Exception) -> None:
+async def notify(err: Exception) -> None:
+    await asyncio.sleep(0)
     print("Notified admin:", err)

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/fastapi_error_map/error_handling.py

@@ -1,9 +1,11 @@
 import inspect
+from collections.abc import Awaitable
 from functools import wraps
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, Union
 
 from fastapi.encoders import jsonable_encoder
 from fastapi.responses import ORJSONResponse
+from starlette.concurrency import run_in_threadpool
 
 from fastapi_error_map.rules import ErrorMap, resolve_rule_for_error
 from fastapi_error_map.translators import ErrorTranslator
@@ -16,7 +18,7 @@ def wrap_with_error_handling(
     warn_on_unmapped: bool,
     default_client_error_translator: ErrorTranslator[Any],
     default_server_error_translator: ErrorTranslator[Any],
-    default_on_error: Optional[Callable[[Exception], None]],
+    default_on_error: Optional[Callable[[Exception], Union[Awaitable[None], None]]],
 ) -> Callable[..., Any]:
     is_coro = inspect.iscoroutinefunction(func)
 
@@ -27,7 +29,7 @@ def wrap_with_error_handling(
                 return await func(*args, **kwargs)
             return func(*args, **kwargs)
         except Exception as error:
-            return handle_with_error_map(
+            return await handle_with_error_map(
                 error=error,
                 error_map=error_map,
                 warn_on_unmapped=warn_on_unmapped,
@@ -39,14 +41,14 @@ def wrap_with_error_handling(
     return wrapped
 
 
-def handle_with_error_map(
+async def handle_with_error_map(
     *,
     error: Exception,
     error_map: ErrorMap,
     warn_on_unmapped: bool,
     default_client_error_translator: ErrorTranslator[Any],
     default_server_error_translator: ErrorTranslator[Any],
-    default_on_error: Optional[Callable[[Exception], None]],
+    default_on_error: Optional[Callable[[Exception], Union[Awaitable[None], None]]],
 ) -> ORJSONResponse:
     try:
         rule = resolve_rule_for_error(
@@ -63,7 +65,12 @@ def handle_with_error_map(
         raise original.with_traceback(original.__traceback__) from None
 
     if rule.on_error is not None:
-        rule.on_error(error)
+        if inspect.iscoroutinefunction(rule.on_error):
+            await rule.on_error(error)
+        else:
+            result = await run_in_threadpool(rule.on_error, error)
+            if inspect.isawaitable(result):
+                await result
 
     content = rule.translator.from_error(error)
     return ORJSONResponse(

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/fastapi_error_map/openapi.py

@@ -1,7 +1,10 @@
 from typing import Any, Union
 
 from fastapi_error_map.rules import ErrorMap
-from fastapi_error_map.translator_policy import pick_translator_for_status
+from fastapi_error_map.translator_policy import (
+    pick_translator_for_status,
+    validate_error_status,
+)
 from fastapi_error_map.translators import ErrorTranslator
 
 
@@ -21,6 +24,8 @@ def build_openapi_responses(
             status = value.status
             translator = value.translator
 
+        validate_error_status(status)
+
         if translator is None:
             translator = pick_translator_for_status(
                 status=status,

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/fastapi_error_map/rules.py

@@ -1,7 +1,11 @@
+from collections.abc import Awaitable
 from dataclasses import dataclass
 from typing import Any, Callable, Optional, Union
 
-from fastapi_error_map.translator_policy import pick_translator_for_status
+from fastapi_error_map.translator_policy import (
+    pick_translator_for_status,
+    validate_error_status,
+)
 from fastapi_error_map.translators import ErrorTranslator
 
 
@@ -9,14 +13,14 @@ from fastapi_error_map.translators import ErrorTranslator
 class Rule:
     status: int
     translator: Optional[ErrorTranslator[Any]]
-    on_error: Optional[Callable[[Exception], None]]
+    on_error: Optional[Callable[[Exception], Union[Awaitable[None], None]]]
 
 
 def rule(
     *,
     status: int,
     translator: Optional[ErrorTranslator[Any]] = None,
-    on_error: Optional[Callable[[Exception], None]] = None,
+    on_error: Optional[Callable[[Exception], Union[Awaitable[None], None]]] = None,
 ) -> Rule:
     """
     Defines full error handling rule for use in `error_map`.
@@ -46,7 +50,7 @@ ErrorMap = dict[type[Exception], Union[int, Rule]]
 class ResolvedRule:
     status: int
     translator: ErrorTranslator[Any]
-    on_error: Optional[Callable[[Exception], None]]
+    on_error: Optional[Callable[[Exception], Union[Awaitable[None], None]]]
 
 
 def resolve_rule_for_error(
@@ -55,7 +59,9 @@ def resolve_rule_for_error(
     error_map: ErrorMap,
     default_client_error_translator: ErrorTranslator[Any],
     default_server_error_translator: ErrorTranslator[Any],
-    default_on_error: Optional[Callable[[Exception], None]] = None,
+    default_on_error: Optional[
+        Callable[[Exception], Union[Awaitable[None], None]]
+    ] = None,
 ) -> ResolvedRule:
     try:
         status_or_rule = error_map[type(error)]
@@ -71,6 +77,8 @@ def resolve_rule_for_error(
             status_or_rule.on_error or default_on_error,
         )
 
+    validate_error_status(status)
+
     if translator is None:
         translator = pick_translator_for_status(
             status=status,

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/fastapi_error_map/translator_policy.py

@@ -1,12 +1,19 @@
 from typing import Any
 
-from starlette import status as http_status
-
 from fastapi_error_map.translators import ErrorTranslator
 
 
 def is_server_error(status: int) -> bool:
-    return status >= http_status.HTTP_500_INTERNAL_SERVER_ERROR
+    return status // 100 == 5
+
+
+def is_client_error(status: int) -> bool:
+    return status // 100 == 4
+
+
+def validate_error_status(status: int) -> None:
+    if not (is_client_error(status) or is_server_error(status)):
+        raise RuntimeError(f"Unsupported status for error_map: {status}. Use 4xx/5xx.")
 
 
 def pick_translator_for_status(

fastapi_error_map-0.9.7/noxfile.py

@@ -0,0 +1,14 @@
+import nox
+
+
+@nox.session(python=None)
+@nox.parametrize("fastapi", ["0.100.0", "latest"])
+def compatibility(session, fastapi):
+    session.run("uv", "sync", "--locked", "--group", "test", "--active", external=True)
+
+    if fastapi == "latest":
+        session.run("uv", "add", "fastapi", "--active", external=True)
+    else:
+        session.run("uv", "add", f"fastapi=={fastapi}", "--active", external=True)
+
+    session.run("uv", "run", "--active", "make", "code.test", external=True)

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/pyproject.toml

@@ -7,8 +7,8 @@ sources = ["src"]
 
 [project]
 name = "fastapi-error-map"
-version = "0.9.5"
-description = "Elegant per-endpoint error handling for FastAPI that keeps OpenAPI docs in sync"
+version = "0.9.7"
+description = "Elegant per-endpoint error handling for FastAPI that keeps OpenAPI in sync"
 readme = "README.md"
 license = { text = "Apache-2.0" }
 authors = [
@@ -23,6 +23,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Software Development :: Libraries",
     "Typing :: Typed",
     "Intended Audience :: Developers",
@@ -30,19 +31,15 @@ classifiers = [
     "Framework :: FastAPI",
 ]
 dependencies = [
-    "fastapi>=0.100.0",
-    "orjson>=3.8.4",
+    "fastapi==0.100.0",
+    "orjson==3.11.1",
 ]
-
-[project.urls]
-Homepage = "https://github.com/ivan-borovets/fastapi-error-map"
-Repository = "https://github.com/ivan-borovets/fastapi-error-map"
-
-[project.optional-dependencies]
+[dependency-groups]
 dev = [
     "mypy==1.8.0",
     "pre-commit==4.2.0",
     "ruff==0.11.2",
+    { include-group = "test" },
 ]
 test = [
     "coverage==7.10.1",
@@ -58,6 +55,15 @@ publish = [
 examples = [
     "uvicorn==0.35.0",
 ]
+all = [
+    { include-group = "dev" },
+    { include-group = "publish" },
+    { include-group = "examples" },
+]
+
+[project.urls]
+Homepage = "https://github.com/ivan-borovets/fastapi-error-map"
+Repository = "https://github.com/ivan-borovets/fastapi-error-map"
 
 [tool.coverage.report]
 show_missing = true
@@ -179,6 +185,6 @@ split-on-trailing-comma = true
 "src/fastapi_error_map/translators.py" = [
     "ARG002", # unused-method-argument
 ]
-
-[tool.slotscheck]
-strict-imports = true
+"src/fastapi_error_map/translator_policy.py" = [
+    "PLR2004", # magic-value-comparison
+]

fastapi_error_map-0.9.7/tests/integration/conftest.py

@@ -0,0 +1,25 @@
+from collections.abc import AsyncIterator
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
+from typing import Callable
+
+import pytest
+from fastapi import FastAPI
+from httpx import ASGITransport, AsyncClient
+
+AsgiClientFactory = Callable[[FastAPI], AbstractAsyncContextManager[AsyncClient]]
+
+
+@pytest.fixture
+def app() -> FastAPI:
+    return FastAPI()
+
+
+@pytest.fixture
+def asgi_client_factory() -> AsgiClientFactory:
+    @asynccontextmanager
+    async def _make(app: FastAPI) -> AsyncIterator[AsyncClient]:
+        transport = ASGITransport(app=app)
+        async with AsyncClient(transport=transport, base_url="http://test") as client:
+            yield client
+
+    return _make

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/tests/integration/test_example.py

@@ -1,16 +1,22 @@
-import httpx
+from typing import TYPE_CHECKING
+
 import pytest
-from httpx import ASGITransport
 
 from examples.main import create_app
+from tests.integration.conftest import AsgiClientFactory
+
+if TYPE_CHECKING:
+    import httpx
 
 
 @pytest.mark.asyncio
-async def test_check_stock(capsys: pytest.CaptureFixture[str]) -> None:
+async def test_check_stock(
+    asgi_client_factory: AsgiClientFactory,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
     app = create_app()
 
-    transport = ASGITransport(app=app)
-    async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
+    async with asgi_client_factory(app) as client:
         authz_err_response: httpx.Response = await client.get("/stock?user_id=0")
         out_of_stock_err_response: httpx.Response = await client.get("/stock?user_id=1")
         openapi_response: httpx.Response = await client.get("/openapi.json")

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/tests/integration/test_routing.py

@@ -1,12 +1,15 @@
 import asyncio
+from typing import TYPE_CHECKING
 from unittest.mock import Mock
 
-import httpx
 import pytest
 from fastapi import FastAPI
-from httpx import ASGITransport
 
 from fastapi_error_map import ErrorAwareRouter, rule
+from tests.integration.conftest import AsgiClientFactory
+
+if TYPE_CHECKING:
+    import httpx
 
 
 class CustomError(Exception):
@@ -15,8 +18,11 @@ class CustomError(Exception):
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("method", ["get", "post", "put", "patch", "delete"])
-async def test_error_aware_router_routes(method: str) -> None:
-    app = FastAPI()
+async def test_error_aware_router_routes(
+    method: str,
+    app: FastAPI,
+    asgi_client_factory: AsgiClientFactory,
+) -> None:
     router = ErrorAwareRouter()
     router_path = "/fail"
     error_message = "This is a test"
@@ -35,8 +41,7 @@ async def test_error_aware_router_routes(method: str) -> None:
     )(failing_endpoint)
     app.include_router(router)
 
-    transport = ASGITransport(app=app)
-    async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
+    async with asgi_client_factory(app) as client:
         response: httpx.Response = await getattr(client, method)(router_path)
         openapi_response: httpx.Response = await client.get("/openapi.json")
 

fastapi_error_map-0.9.7/tests/integration/test_threadpool.py

@@ -0,0 +1,79 @@
+import asyncio
+from typing import TYPE_CHECKING
+
+import pytest
+from fastapi import FastAPI
+
+from fastapi_error_map import ErrorAwareRouter, rule
+from tests.integration.conftest import AsgiClientFactory
+
+if TYPE_CHECKING:
+    import httpx
+
+
+def has_running_loop_in_this_thread() -> bool:
+    try:
+        asyncio.get_running_loop()
+        return True
+    except RuntimeError:
+        return False
+
+
+@pytest.mark.asyncio
+async def test_fastapi_sync_handler_runs_in_threadpool(
+    app: FastAPI,
+    asgi_client_factory: AsgiClientFactory,
+) -> None:
+    @app.get("/")
+    def index():
+        return {"in_loop": has_running_loop_in_this_thread()}
+
+    async with asgi_client_factory(app) as client:
+        index_response: httpx.Response = await client.get("/")
+
+    assert index_response.status_code == 200
+    assert index_response.json() == {"in_loop": False}
+
+
+@pytest.mark.asyncio
+async def test_error_aware_router_sync_handler_runs_in_threadpool(
+    app: FastAPI,
+    asgi_client_factory: AsgiClientFactory,
+) -> None:
+    router = ErrorAwareRouter()
+
+    @app.get("/")
+    def index():
+        return {"in_loop": has_running_loop_in_this_thread()}
+
+    app.include_router(router)
+
+    async with asgi_client_factory(app) as client:
+        index_response: httpx.Response = await client.get("/")
+
+    assert index_response.status_code == 200
+    assert index_response.json() == {"in_loop": False}
+
+
+@pytest.mark.asyncio
+async def test_error_aware_router_sync_on_error_runs_in_threadpool(
+    app: FastAPI,
+    asgi_client_factory: AsgiClientFactory,
+) -> None:
+    router = ErrorAwareRouter()
+    seen: dict[str, bool] = {}
+
+    def on_error(_: Exception) -> None:
+        seen["in_loop"] = has_running_loop_in_this_thread()
+
+    @router.get("/err", error_map={ValueError: rule(status=400, on_error=on_error)})
+    def index():
+        raise ValueError
+
+    app.include_router(router)
+
+    async with asgi_client_factory(app) as client:
+        index_response: httpx.Response = await client.get("/err")
+
+    assert index_response.status_code == 400
+    assert seen["in_loop"] is False

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/tests/unit/test_error_handling.py

@@ -1,12 +1,17 @@
 import asyncio
-from typing import NoReturn
-from unittest.mock import Mock
+from collections.abc import Awaitable
+from functools import partial
+from typing import NoReturn, cast
+from unittest.mock import AsyncMock, Mock
 
 import pytest
 from starlette.responses import JSONResponse
 
 from fastapi_error_map import rule
-from fastapi_error_map.error_handling import wrap_with_error_handling
+from fastapi_error_map.error_handling import (
+    handle_with_error_map,
+    wrap_with_error_handling,
+)
 from fastapi_error_map.translators import (
     DefaultClientErrorTranslator,
     DefaultServerErrorTranslator,
@@ -126,3 +131,97 @@ async def test_wrap_calls_on_error_with_error_if_defined() -> None:
 
     mock_on_error.assert_called_once()
     assert isinstance(mock_on_error.call_args[0][0], ValidationError)
+
+
+@pytest.mark.asyncio
+async def test_handles_sync_on_error_from_map() -> None:
+    mock_on_error = Mock()
+    error = ValidationError()
+
+    sut = await handle_with_error_map(
+        error=error,
+        error_map={ValidationError: rule(status=422, on_error=mock_on_error)},
+        warn_on_unmapped=True,
+        default_client_error_translator=DefaultClientErrorTranslator(),
+        default_server_error_translator=DefaultServerErrorTranslator(),
+        default_on_error=None,
+    )
+
+    assert sut.status_code == 422
+    mock_on_error.assert_called_once_with(error)
+
+
+@pytest.mark.asyncio
+async def test_handles_default_on_error_from_defaults() -> None:
+    mock_on_error = AsyncMock()
+    error = ValidationError()
+
+    sut = await handle_with_error_map(
+        error=error,
+        error_map={ValidationError: 422},
+        warn_on_unmapped=True,
+        default_client_error_translator=DefaultClientErrorTranslator(),
+        default_server_error_translator=DefaultServerErrorTranslator(),
+        default_on_error=mock_on_error,
+    )
+
+    assert sut.status_code == 422
+    mock_on_error.assert_awaited_once_with(error)
+
+
+@pytest.mark.asyncio
+async def test_handles_async_on_error() -> None:
+    mock_on_error = AsyncMock()
+    error = ValidationError()
+
+    sut = await handle_with_error_map(
+        error=error,
+        error_map={ValidationError: rule(status=422, on_error=mock_on_error)},
+        warn_on_unmapped=True,
+        default_client_error_translator=DefaultClientErrorTranslator(),
+        default_server_error_translator=DefaultServerErrorTranslator(),
+        default_on_error=None,
+    )
+
+    assert sut.status_code == 422
+    mock_on_error.assert_awaited_once_with(error)
+
+
+@pytest.mark.asyncio
+async def test_handles_async_on_error_partial() -> None:
+    wrapped = AsyncMock()
+    mock_on_error = partial(wrapped)
+    error = ValidationError()
+
+    sut = await handle_with_error_map(
+        error=error,
+        error_map={ValidationError: rule(status=422, on_error=mock_on_error)},
+        warn_on_unmapped=True,
+        default_client_error_translator=DefaultClientErrorTranslator(),
+        default_server_error_translator=DefaultServerErrorTranslator(),
+        default_on_error=None,
+    )
+
+    assert sut.status_code == 422
+    wrapped.assert_awaited_once_with(error)
+
+
+@pytest.mark.asyncio
+async def test_handles_sync_on_error_returning_awaitable() -> None:
+    coro = AsyncMock()
+    error = ValidationError()
+
+    def on_error(err: Exception) -> Awaitable[None]:
+        return cast("Awaitable[None]", coro(err))
+
+    sut = await handle_with_error_map(
+        error=error,
+        error_map={ValidationError: rule(status=422, on_error=on_error)},
+        warn_on_unmapped=True,
+        default_client_error_translator=DefaultClientErrorTranslator(),
+        default_server_error_translator=DefaultServerErrorTranslator(),
+        default_on_error=None,
+    )
+
+    assert sut.status_code == 422
+    coro.assert_awaited_once_with(error)

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/tests/unit/test_openapi.py

@@ -1,5 +1,8 @@
 from typing import TYPE_CHECKING
 
+import pytest
+from starlette import status
+
 from fastapi_error_map.openapi import build_openapi_responses
 from fastapi_error_map.rules import rule
 from tests.unit.error_stubs import DatabaseError, ValidationError
@@ -63,3 +66,20 @@ def test_builds_response_with_custom_translator() -> None:
     )
 
     assert responses == {400: {"model": dict}}
+
+
+@pytest.mark.parametrize(
+    "bad_status",
+    [
+        status.HTTP_200_OK,
+        status.HTTP_300_MULTIPLE_CHOICES,
+        status.WS_1000_NORMAL_CLOSURE,
+    ],
+)
+def test_rejects_non_error_status_codes(bad_status: int) -> None:
+    with pytest.raises(RuntimeError):
+        build_openapi_responses(
+            error_map={ValidationError: bad_status},
+            default_client_error_translator=DummyClientErrorTranslator(),
+            default_server_error_translator=DummyServerErrorTranslator(),
+        )

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/tests/unit/test_rules.py

@@ -1,6 +1,7 @@
 from typing import Union
 
 import pytest
+from starlette import status
 
 from fastapi_error_map.rules import Rule, resolve_rule_for_error, rule
 from tests.unit.error_stubs import DatabaseError, UnknownError, ValidationError
@@ -55,6 +56,25 @@ def test_resolves_status_code_with_server_error_translator(
     assert isinstance(sut.translator, DummyServerErrorTranslator)
 
 
+@pytest.mark.parametrize(
+    "bad_status",
+    [
+        status.HTTP_200_OK,
+        status.HTTP_300_MULTIPLE_CHOICES,
+        status.WS_1000_NORMAL_CLOSURE,
+    ],
+)
+def test_resolver_rejects_non_error_status_codes(bad_status: int) -> None:
+    with pytest.raises(RuntimeError):
+        resolve_rule_for_error(
+            error=ValidationError(),
+            error_map={ValidationError: bad_status},
+            default_client_error_translator=DummyClientErrorTranslator(),
+            default_server_error_translator=DummyServerErrorTranslator(),
+            default_on_error=None,
+        )
+
+
 def test_does_not_override_explicit_translator() -> None:
     custom_translator = CustomTranslator()
 

{fastapi_error_map-0.9.5 → fastapi_error_map-0.9.7}/uv.lock

@@ -377,31 +377,50 @@ wheels = [
 
 [[package]]
 name = "fastapi"
-version = "0.116.1"
+version = "0.100.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pydantic" },
     { name = "starlette" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/78/d7/6c8b3bfe33eeffa208183ec037fee0cce9f7f024089ab1c5d12ef04bd27c/fastapi-0.116.1.tar.gz", hash = "sha256:ed52cbf946abfd70c5a0dccb24673f0670deeb517a88b3544d03c2a6bf283143", size = 296485, upload-time = "2025-07-11T16:22:32.057Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/e0/f9d77b3a1569e2217abf260b0b1462401736973d1c5d3d335f6f2009daa2/fastapi-0.100.0.tar.gz", hash = "sha256:acb5f941ea8215663283c10018323ba7ea737c571b67fc7e88e9469c7eb1d12e", size = 10440814, upload-time = "2023-07-07T17:33:19.001Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/47/d63c60f59a59467fda0f93f46335c9d18526d7071f025cb5b89d5353ea42/fastapi-0.116.1-py3-none-any.whl", hash = "sha256:c46ac7c312df840f0c9e220f7964bada936781bc4e2e6eb71f1c4d7553786565", size = 95631, upload-time = "2025-07-11T16:22:30.485Z" },
+    { url = "https://files.pythonhosted.org/packages/49/f5/048206823aae9b3a4a61ba6b7a1dd1de36bd4c0a0283f2efb1f1f2289c8a/fastapi-0.100.0-py3-none-any.whl", hash = "sha256:271662daf986da8fa98dc2b7c7f61c4abdfdccfb4786d79ed8b2878f172c6d5f", size = 65736, upload-time = "2023-07-07T17:33:17.001Z" },
 ]
 
 [[package]]
 name = "fastapi-error-map"
-version = "0.9.0"
+version = "0.9.7"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi" },
     { name = "orjson" },
 ]
 
-[package.optional-dependencies]
+[package.dev-dependencies]
+all = [
+    { name = "coverage" },
+    { name = "hatch" },
+    { name = "httpx" },
+    { name = "mypy" },
+    { name = "nox" },
+    { name = "pre-commit" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+    { name = "ruff" },
+    { name = "uvicorn" },
+]
 dev = [
+    { name = "coverage" },
+    { name = "httpx" },
     { name = "mypy" },
+    { name = "nox" },
     { name = "pre-commit" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
     { name = "ruff" },
 ]
 examples = [
@@ -421,21 +440,45 @@ test = [
 
 [package.metadata]
 requires-dist = [
-    { name = "coverage", marker = "extra == 'test'", specifier = "==7.10.1" },
-    { name = "fastapi", specifier = ">=0.100.0" },
-    { name = "hatch", marker = "extra == 'publish'", specifier = "==1.14.1" },
-    { name = "httpx", marker = "extra == 'test'", specifier = "==0.28.1" },
-    { name = "mypy", marker = "extra == 'dev'", specifier = "==1.8.0" },
-    { name = "nox", marker = "extra == 'test'", specifier = "==2025.5.1" },
-    { name = "orjson", specifier = ">=3.11.1" },
-    { name = "pre-commit", marker = "extra == 'dev'", specifier = "==4.2.0" },
-    { name = "pytest", marker = "extra == 'test'", specifier = "==8.4.1" },
-    { name = "pytest-asyncio", marker = "extra == 'test'", specifier = "==1.1.0" },
-    { name = "pytest-cov", marker = "extra == 'test'", specifier = "==6.2.1" },
-    { name = "ruff", marker = "extra == 'dev'", specifier = "==0.11.2" },
-    { name = "uvicorn", marker = "extra == 'examples'", specifier = "==0.35.0" },
-]
-provides-extras = ["dev", "test", "publish", "examples"]
+    { name = "fastapi", specifier = "==0.100.0" },
+    { name = "orjson", specifier = "==3.11.1" },
+]
+
+[package.metadata.requires-dev]
+all = [
+    { name = "coverage", specifier = "==7.10.1" },
+    { name = "hatch", specifier = "==1.14.1" },
+    { name = "httpx", specifier = "==0.28.1" },
+    { name = "mypy", specifier = "==1.8.0" },
+    { name = "nox", specifier = "==2025.5.1" },
+    { name = "pre-commit", specifier = "==4.2.0" },
+    { name = "pytest", specifier = "==8.4.1" },
+    { name = "pytest-asyncio", specifier = "==1.1.0" },
+    { name = "pytest-cov", specifier = "==6.2.1" },
+    { name = "ruff", specifier = "==0.11.2" },
+    { name = "uvicorn", specifier = "==0.35.0" },
+]
+dev = [
+    { name = "coverage", specifier = "==7.10.1" },
+    { name = "httpx", specifier = "==0.28.1" },
+    { name = "mypy", specifier = "==1.8.0" },
+    { name = "nox", specifier = "==2025.5.1" },
+    { name = "pre-commit", specifier = "==4.2.0" },
+    { name = "pytest", specifier = "==8.4.1" },
+    { name = "pytest-asyncio", specifier = "==1.1.0" },
+    { name = "pytest-cov", specifier = "==6.2.1" },
+    { name = "ruff", specifier = "==0.11.2" },
+]
+examples = [{ name = "uvicorn", specifier = "==0.35.0" }]
+publish = [{ name = "hatch", specifier = "==1.14.1" }]
+test = [
+    { name = "coverage", specifier = "==7.10.1" },
+    { name = "httpx", specifier = "==0.28.1" },
+    { name = "nox", specifier = "==2025.5.1" },
+    { name = "pytest", specifier = "==8.4.1" },
+    { name = "pytest-asyncio", specifier = "==1.1.0" },
+    { name = "pytest-cov", specifier = "==6.2.1" },
+]
 
 [[package]]
 name = "filelock"
@@ -1225,15 +1268,15 @@ wheels = [
 
 [[package]]
 name = "starlette"
-version = "0.47.2"
+version = "0.27.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.10'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/04/57/d062573f391d062710d4088fa1369428c38d51460ab6fedff920efef932e/starlette-0.47.2.tar.gz", hash = "sha256:6ae9aa5db235e4846decc1e7b79c4f346adf41e9777aebeb49dfd09bbd7023d8", size = 2583948, upload-time = "2025-07-20T17:31:58.522Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/68/559bed5484e746f1ab2ebbe22312f2c25ec62e4b534916d41a8c21147bf8/starlette-0.27.0.tar.gz", hash = "sha256:6a6b0d042acb8d469a01eba54e9cda6cbd24ac602c4cd016723117d6a7e73b75", size = 51394, upload-time = "2023-05-16T10:59:56.286Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/1f/b876b1f83aef204198a42dc101613fefccb32258e5428b5f9259677864b4/starlette-0.47.2-py3-none-any.whl", hash = "sha256:c5847e96134e5c5371ee9fac6fdf1a67336d5815e09eb2a01fdb57a351ef915b", size = 72984, upload-time = "2025-07-20T17:31:56.738Z" },
+    { url = "https://files.pythonhosted.org/packages/58/f8/e2cca22387965584a409795913b774235752be4176d276714e15e1a58884/starlette-0.27.0-py3-none-any.whl", hash = "sha256:918416370e846586541235ccd38a474c08b80443ed31c578a418e2209b3eef91", size = 66978, upload-time = "2023-05-16T10:59:53.927Z" },
 ]
 
 [[package]]

fastapi_error_map-0.9.5/noxfile.py

@@ -1,13 +0,0 @@
-import nox
-
-
-@nox.session(python=None)
-@nox.parametrize("fastapi", ["0.100.0", "latest"])
-def compatibility(session, fastapi):
-    if fastapi == "latest":
-        session.run("uv", "pip", "install", "fastapi", external=True)
-    else:
-        session.run("uv", "pip", "install", f"fastapi=={fastapi}", external=True)
-
-    session.run("uv", "pip", "install", "-e", ".[test]", external=True)
-    session.run("make", "code.test", external=True)