dirigent-server 0.16.6__tar.gz → 0.17.0__tar.gz

{dirigent_server-0.16.6 → dirigent_server-0.17.0}/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.4
 Name: dirigent-server
-Version: 0.16.6
+Version: 0.17.0
 Summary: Dirigent FastAPI server: the REST API, its authentication, and the health probes.
 License-Expression: LicenseRef-Proprietary
 License-File: LICENSE
 License-File: THIRD_PARTY_NOTICES.md
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: dirigent-client==0.16.6
-Requires-Dist: dirigent-common==0.16.6
-Requires-Dist: dirigent-core==0.16.6
-Requires-Dist: dirigent-examples==0.16.6
+Requires-Dist: dirigent-client==0.17.0
+Requires-Dist: dirigent-common==0.17.0
+Requires-Dist: dirigent-core==0.17.0
+Requires-Dist: dirigent-examples==0.17.0
 Requires-Dist: fastapi>=0.141.1
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

{dirigent_server-0.16.6 → dirigent_server-0.17.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-server"
-version = "0.16.6"
+version = "0.17.0"
 description = "Dirigent FastAPI server: the REST API, its authentication, and the health probes."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -14,10 +14,10 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "dirigent-client==0.16.6",
-    "dirigent-common==0.16.6",
-    "dirigent-core==0.16.6",
-    "dirigent-examples==0.16.6",
+    "dirigent-client==0.17.0",
+    "dirigent-common==0.17.0",
+    "dirigent-core==0.17.0",
+    "dirigent-examples==0.17.0",
     "fastapi>=0.141.1",
 ]
 

{dirigent_server-0.16.6 → dirigent_server-0.17.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-server"
-version = "0.16.6"
+version = "0.17.0"
 description = "Dirigent FastAPI server: the REST API, its authentication, and the health probes."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -11,10 +11,10 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "dirigent-client==0.16.6",
-    "dirigent-common==0.16.6",
-    "dirigent-core==0.16.6",
-    "dirigent-examples==0.16.6",
+    "dirigent-client==0.17.0",
+    "dirigent-common==0.17.0",
+    "dirigent-core==0.17.0",
+    "dirigent-examples==0.17.0",
     "fastapi>=0.141.1",
 ]
 

{dirigent_server-0.16.6 → dirigent_server-0.17.0}/src/dirigent_server/app.py

@@ -60,21 +60,23 @@ def create_app(
 
     @asynccontextmanager
     async def lifespan(app: FastAPI) -> AsyncGenerator[None]:
-        """Open the database engine for the process, and dispose of it on shutdown."""
+        """Open the database engine for the process, and dispose of it on every exit path."""
         engine = create_engine(resolved)
         app.state.engine = engine
         app.state.session_factory = create_session_factory(engine)
         app.state.health_checks = build_registry(engine)
-        await _bootstrap(app)
-        await _apply_startup_directory(app)
-        clock = await _start_scheduler(app, embed=embed)
-        _logger.info(
-            "server starting",
-            database="sqlite" if resolved.is_sqlite else "postgresql",
-            blocks=len(app.state.services.host.block_ids),
-            scheduler=embed,
-        )
+        app.state.scheduler = None
+        clock: asyncio.Task[None] | None = None
         try:
+            await _bootstrap(app)
+            await _apply_startup_directory(app)
+            clock = await _start_scheduler(app, embed=embed)
+            _logger.info(
+                "server starting",
+                database="sqlite" if resolved.is_sqlite else "postgresql",
+                blocks=len(app.state.services.host.block_ids),
+                scheduler=embed,
+            )
             yield
         finally:
             await _stop_scheduler(app, clock)
@@ -105,7 +107,6 @@ def create_app(
 
 async def _start_scheduler(app: FastAPI, *, embed: bool) -> asyncio.Task[None] | None:
     """Start the embedded scheduler as a task in the API's own event loop."""
-    app.state.scheduler = None
     if not embed:
         return None
     scheduler = Scheduler(app.state.session_factory, app.state.services)

{dirigent_server-0.16.6 → dirigent_server-0.17.0}/src/dirigent_server/errors.py

@@ -1,6 +1,6 @@
 """One error envelope for every refusal, in the shape RFC 9457 describes."""
 
-from collections.abc import Awaitable, Callable
+from collections.abc import Awaitable, Callable, Mapping, Sequence
 from http import HTTPStatus
 from typing import Any, cast
 
@@ -10,46 +10,61 @@ from fastapi.responses import JSONResponse
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
 from dirigent_client.schemas import Problem
+from dirigent_common import Issue, JsonMap, Message, validation_issues
 from dirigent_core import __version__
+from dirigent_core.errors import DomainError
 from dirigent_core.logging import redact_path
 from dirigent_server.logging import get_logger
+from dirigent_server.messages import HTTP_ERROR, INTERNAL, REQUEST_INVALID
 
 VERSION_HEADER = "X-Dirigent-Version"
 
-INTERNAL_DETAIL = "the server failed to handle this request; the server log has the detail"
+INTERNAL_DETAIL = INTERNAL.render()
 
 _logger = get_logger("errors")
 
 
-def render(status: int, detail: str, *, problems: list[str] | None = None, instance: str | None = None) -> Problem:
+class Refusal(DomainError):
+    """A refusal a route makes for which no core class already exists."""
+
+    def __init__(
+        self,
+        message: Message,
+        /,
+        *,
+        status: int = 400,
+        headers: Mapping[str, str] | None = None,
+        **params: Any,
+    ) -> None:
+        """Carry the status this refusal is answered with, and any header it has to set."""
+        super().__init__(message, **params)
+        self.status = status
+        self.headers = dict(headers) if headers else None
+
+
+def render(
+    status: int,
+    detail: str,
+    *,
+    code: str,
+    params: JsonMap | None = None,
+    problems: Sequence[Issue] = (),
+    instance: str | None = None,
+) -> Problem:
     """Build the one problem shape, from whichever handler is answering."""
     try:
         title = HTTPStatus(status).phrase
     except ValueError:  # pragma: no cover - a non-standard status from a plugin
         title = "Error"
-    return Problem(status=status, title=title, detail=detail, problems=problems or [], instance=instance)
-
-
-def _problems_of(detail: Any) -> tuple[str, list[str]]:
-    """Split whatever was raised into one sentence and, when there is one, a list."""
-    if isinstance(detail, str):
-        return detail, []
-    if isinstance(detail, list):
-        rendered = [_one(item) for item in cast(list[object], detail)]
-        return "; ".join(rendered), rendered
-    return str(detail), []
-
-
-def _one(item: object) -> str:
-    """Render one entry of a problem list, whether it is a string or a pydantic error."""
-    if isinstance(item, str):
-        return item
-    if isinstance(item, dict):
-        mapping = cast(dict[str, Any], item)
-        location = ".".join(str(part) for part in mapping.get("loc", []))
-        message = str(mapping.get("msg", mapping))
-        return f"{location}: {message}" if location else message
-    return str(item)
+    return Problem(
+        status=status,
+        title=title,
+        detail=detail,
+        code=code,
+        params=params or {},
+        problems=list(problems),
+        instance=instance,
+    )
 
 
 def _where(request: Request) -> str:
@@ -74,11 +89,18 @@ async def _stamp_version(request: Request, call_next: Callable[[Request], Awaita
 
 
 async def http_error(request: Request, error: Exception) -> JSONResponse:
-    """Render an HTTPException as a problem."""
+    """Render an HTTPException as a problem: the framework's own 404, 405 and the like."""
     if not isinstance(error, StarletteHTTPException):  # pragma: no cover - registered for this class
         return await unhandled(request, error)
-    detail, problems = _problems_of(error.detail)
-    response = answer(render(error.status_code, detail, problems=problems, instance=_where(request)))
+    detail = str(error.detail)
+    problem = render(
+        error.status_code,
+        detail,
+        code=HTTP_ERROR.code,
+        params={"status": error.status_code, "detail": detail},
+        instance=_where(request),
+    )
+    response = answer(problem)
     if isinstance(error, HTTPException) and error.headers:
         response.headers.update(error.headers)
     return response
@@ -88,8 +110,40 @@ async def validation_error(request: Request, error: Exception) -> JSONResponse:
     """Render a request-validation failure as a problem with its field list intact."""
     if not isinstance(error, RequestValidationError):  # pragma: no cover - registered for this class
         return await unhandled(request, error)
-    detail, problems = _problems_of(error.errors())
-    return answer(render(422, detail, problems=problems, instance=_where(request)))
+    issues = validation_issues(cast("list[dict[str, Any]]", error.errors()))
+    detail = "; ".join(str(issue) for issue in issues)
+    return answer(
+        render(
+            422,
+            detail,
+            code=REQUEST_INVALID.code,
+            params={"detail": detail},
+            problems=issues,
+            instance=_where(request),
+        )
+    )
+
+
+async def domain_error(request: Request, error: Exception) -> JSONResponse:
+    """Render a refusal raised anywhere in the domain, at the status its class carries."""
+    if not isinstance(error, DomainError):  # pragma: no cover - registered for this class
+        return await unhandled(request, error)
+    # A refusal that carries a list answers with the list: the problems are the refusal, and
+    # the sentence before them only repeats what the caller can read there.
+    listed = "; ".join(str(issue) for issue in error.problems)
+    problem = render(
+        error.status,
+        listed or str(error),
+        code=error.code,
+        params=error.params,
+        problems=error.problems,
+        instance=_where(request),
+    )
+    response = answer(problem)
+    headers = getattr(error, "headers", None)
+    if headers:
+        response.headers.update(cast("Mapping[str, str]", headers))
+    return response
 
 
 async def unhandled(request: Request, error: Exception) -> JSONResponse:
@@ -105,7 +159,7 @@ async def unhandled(request: Request, error: Exception) -> JSONResponse:
         error=f"{type(error).__name__}: {error}",
         exc_info=error,
     )
-    return answer(render(500, INTERNAL_DETAIL, instance=_where(request)))
+    return answer(render(500, INTERNAL_DETAIL, code=INTERNAL.code, instance=_where(request)))
 
 
 def install_error_handlers(app: FastAPI) -> None:
@@ -113,4 +167,5 @@ def install_error_handlers(app: FastAPI) -> None:
     app.middleware("http")(_stamp_version)
     app.add_exception_handler(StarletteHTTPException, http_error)
     app.add_exception_handler(RequestValidationError, validation_error)
+    app.add_exception_handler(DomainError, domain_error)
     app.add_exception_handler(Exception, unhandled)

dirigent_server-0.17.0/src/dirigent_server/messages.py

@@ -0,0 +1,99 @@
+"""Every refusal the API makes that no core class already names, catalogued."""
+
+from dirigent_common import Catalogue
+
+SERVER = Catalogue("server")
+
+REQUEST_INVALID = SERVER.define("request_invalid", "{detail}")
+
+HTTP_ERROR = SERVER.define("http", "{detail}")
+
+INTERNAL = SERVER.define("internal", "the server failed to handle this request; the server log has the detail")
+
+UNAUTHENTICATED = SERVER.define("unauthenticated", "authentication required: present a bearer token or log in")
+
+FORBIDDEN = SERVER.define("forbidden", "not permitted for your role")
+
+CROSS_SITE = SERVER.define(
+    "cross_site",
+    "this write was initiated by another site, and a session cookie may not be spent across "
+    "origins; automation authenticating with a bearer token is unaffected",
+)
+
+BAD_CREDENTIALS = SERVER.define("bad_credentials", "invalid username or password")
+
+TOO_MANY_LOGINS = SERVER.define(
+    "too_many_logins",
+    "too many login attempts; this instance accepts {per_minute} a minute",
+)
+
+NO_TOKEN = SERVER.define("no_token", "no live token named {name}")
+
+NO_USER_TOKEN = SERVER.define("no_user_token", "no live token named {name} for {username}")
+
+ACCOUNT_GONE = SERVER.define("account_gone", "the authenticated account is gone")
+
+NO_USER = SERVER.define("no_user", "no user named {username}")
+
+NO_NOTIFICATION = SERVER.define("no_notification", "no notification {id}")
+
+NO_ALERT_RULE = SERVER.define("no_alert_rule", "no alert rule coded {code}")
+
+NO_TRIGGER_DOCUMENT = SERVER.define("no_trigger_document", "no triggers document coded {code}")
+
+NO_CONNECTION = SERVER.define("no_connection", "no connection coded {code}")
+
+CONNECTION_EXISTS = SERVER.define("connection_exists", "a connection coded {code} exists")
+
+CONNECTION_REFERENCED = SERVER.define(
+    "connection_referenced",
+    "connection {code} is still referenced; delete what uses it first",
+)
+
+REDACTED_SECRET = SERVER.define(
+    "redacted_secret",
+    "{fields} came back as {redacted}, which is what a read shows for a secret "
+    "that is set, not a secret. Send the real value, or leave the field out to keep what is stored.",
+)
+
+UNKNOWN_CONNECTION_KIND = SERVER.define("unknown_connection_kind", "no connection kind {kind} is installed ({known})")
+
+CONNECTION_CONFIG_INVALID = SERVER.define("connection_config_invalid", "{detail}")
+
+NO_SCHEMA = SERVER.define("no_schema", "no schema coded {code}")
+
+SCHEMA_EXISTS = SERVER.define("schema_exists", "a schema coded {code} exists")
+
+DOCUMENT_REFUSED = SERVER.define("document_refused", "{detail}")
+
+PRUNE_NAMES_NOTHING = SERVER.define(
+    "prune_names_nothing",
+    "keep names no codes, and pruning against an empty set would deactivate every directory pipeline",
+)
+
+NO_BLOCK = SERVER.define("no_block", "no block {block_id} is installed")
+
+NO_RUN = SERVER.define("no_run", "no run {run_id}")
+
+RUN_DEFINITION_GONE = SERVER.define("run_definition_gone", "the run's definition is gone")
+
+BAD_SINCE = SERVER.define("bad_since", "{detail}")
+
+NOT_A_DURATION = SERVER.define("not_a_duration", "{since} is not a duration")
+
+NO_ARTIFACT = SERVER.define("no_artifact", "no artifact {artifact_id}")
+
+ARTIFACT_EMPTY = SERVER.define("artifact_empty", "artifact {artifact_id} holds no content")
+
+IDEMPOTENCY_KEY_REQUIRED = SERVER.define(
+    "idempotency_key_required",
+    "an Idempotency-Key header is required, so a retried request creates one attempt",
+)
+
+NO_ATTEMPT = SERVER.define("no_attempt", "no attempt {attempt_id}")
+
+TOO_MANY_TAILS = SERVER.define("too_many_tails", "you already have {maximum} streams open on this server")
+
+NO_ICON = SERVER.define("no_icon", "this bundle carries no icon")
+
+BAD_CURSOR = SERVER.define("bad_cursor", "{name}={after} is not a cursor this listing gave out")

{dirigent_server-0.16.6 → dirigent_server-0.17.0}/src/dirigent_server/pagination.py

@@ -11,7 +11,10 @@ from collections.abc import Callable
 from typing import Annotated
 from uuid import UUID
 
-from fastapi import HTTPException, Query, status
+from fastapi import Query, status
+
+from dirigent_server.errors import Refusal
+from dirigent_server.messages import BAD_CURSOR
 
 DEFAULT_PAGE = 50
 
@@ -37,9 +40,8 @@ def uuid_cursor(after: str | None) -> UUID | None:
     try:
         return UUID(after)
     except ValueError as error:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-            detail=f"after={after!r} is not a cursor this listing gave out",
+        raise Refusal(
+            BAD_CURSOR, status=status.HTTP_422_UNPROCESSABLE_CONTENT, name="after", after=repr(after)
         ) from error
 
 
@@ -50,7 +52,4 @@ def int_cursor(after: str | None, *, name: str = "after") -> int | None:
     try:
         return int(after)
     except ValueError as error:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-            detail=f"{name}={after!r} is not a cursor this listing gave out",
-        ) from error
+        raise Refusal(BAD_CURSOR, status=status.HTTP_422_UNPROCESSABLE_CONTENT, name=name, after=repr(after)) from error

{dirigent_server-0.16.6 → dirigent_server-0.17.0}/src/dirigent_server/routes/alerts.py

@@ -4,7 +4,7 @@ from datetime import timedelta
 from typing import Annotated
 from uuid import UUID
 
-from fastapi import APIRouter, HTTPException, Query, Response, status
+from fastapi import APIRouter, Query, Response, status
 
 from dirigent_client.enums import NotificationStatus
 from dirigent_client.schemas import (
@@ -18,7 +18,6 @@ from dirigent_client.schemas import (
 )
 from dirigent_common.durations import format_duration
 from dirigent_core.alerting import (
-    AlertError,
     AlertRuleRequest,
     create_rule,
     delete_rule,
@@ -32,6 +31,8 @@ from dirigent_core.alerting import (
 )
 from dirigent_core.models import AlertRule, Connection, Notification, Pipeline, Run
 from dirigent_server.dependencies import ServicesDep, SessionDep
+from dirigent_server.errors import Refusal
+from dirigent_server.messages import NO_ALERT_RULE, NO_NOTIFICATION
 from dirigent_server.pagination import DEFAULT_PAGE, AfterParam, LimitParam, clip, uuid_cursor
 from dirigent_server.security import OperatorDep, PrincipalDep
 from dirigent_server.transactions import Transactional
@@ -94,26 +95,23 @@ async def add_rule(
     payload: AlertRuleIn, session: SessionDep, services: ServicesDep, principal: OperatorDep
 ) -> AlertRuleOut:
     """Declare an alert rule, refusing a notifier or a pipeline this instance does not have."""
-    try:
-        rule = await create_rule(
-            session,
-            services,
-            AlertRuleRequest(
-                code=payload.code,
-                name=payload.name,
-                description=payload.description,
-                event=payload.event,
-                notifier=payload.notifier,
-                scope=payload.scope,
-                pipeline=payload.pipeline,
-                connection=payload.connection,
-                template=payload.template,
-                body=payload.body,
-                throttle=payload.throttle,
-            ),
-        )
-    except AlertError as error:
-        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_CONTENT, detail=str(error)) from error
+    rule = await create_rule(
+        session,
+        services,
+        AlertRuleRequest(
+            code=payload.code,
+            name=payload.name,
+            description=payload.description,
+            event=payload.event,
+            notifier=payload.notifier,
+            scope=payload.scope,
+            pipeline=payload.pipeline,
+            connection=payload.connection,
+            template=payload.template,
+            body=payload.body,
+            throttle=payload.throttle,
+        ),
+    )
     return render(rule, payload.pipeline, payload.connection)
 
 
@@ -131,10 +129,7 @@ async def change_rule(code: str, payload: AlertRuleUpdate, session: SessionDep,
     the caller left out is left as it was.
     """
     rule = await _rule_or_404(session, code)
-    try:
-        await update_rule(session, rule, payload.model_dump(exclude_unset=True))
-    except AlertError as error:
-        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_CONTENT, detail=str(error)) from error
+    await update_rule(session, rule, payload.model_dump(exclude_unset=True))
     return render(rule, await _pipeline_code(session, rule), await _connection_code(session, rule.connection_id))
 
 
@@ -161,17 +156,14 @@ async def test_notifier(
     payload: TestRequest, session: SessionDep, services: ServicesDep, principal: OperatorDep
 ) -> TestQueued:
     """Queue one message through a channel, on the same path a real alert takes."""
-    try:
-        notification = await queue_test_message(
-            session,
-            services,
-            notifier=payload.notifier,
-            connection=payload.connection,
-            subject=payload.subject,
-            body=payload.body,
-        )
-    except AlertError as error:
-        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_CONTENT, detail=str(error)) from error
+    notification = await queue_test_message(
+        session,
+        services,
+        notifier=payload.notifier,
+        connection=payload.connection,
+        subject=payload.subject,
+        body=payload.body,
+    )
     return TestQueued(notification_id=notification.id, notifier=notification.notifier)
 
 
@@ -231,10 +223,7 @@ async def retry(
 ) -> NotificationOut:
     """Make one notification due now, so a worker takes it on its next pass."""
     row = await _notification_or_404(session, notification_id)
-    try:
-        await retry_notification(session, row)
-    except AlertError as error:
-        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(error)) from error
+    await retry_notification(session, row)
     return await _notification(session, services, row)
 
 
@@ -267,7 +256,7 @@ async def _notification_or_404(session: SessionDep, notification_id: UUID) -> No
     """Find one notification, or refuse with the id that named nothing."""
     row = await find_notification(session, notification_id)
     if row is None:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"no notification {notification_id}")
+        raise Refusal(NO_NOTIFICATION, status=status.HTTP_404_NOT_FOUND, id=notification_id)
     return row
 
 
@@ -275,7 +264,7 @@ async def _rule_or_404(session: SessionDep, code: str) -> AlertRule:
     """Find one alert rule, or refuse with the code that named nothing."""
     rule = await find_rule(session, code)
     if rule is None:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"no alert rule coded {code!r}")
+        raise Refusal(NO_ALERT_RULE, status=status.HTTP_404_NOT_FOUND, code=repr(code))
     return rule
 
 

{dirigent_server-0.16.6 → dirigent_server-0.17.0}/src/dirigent_server/routes/auth.py

@@ -1,6 +1,6 @@
 """Logging in, logging out, and asking who you are."""
 
-from fastapi import APIRouter, HTTPException, Request, Response, status
+from fastapi import APIRouter, Request, Response, status
 
 from dirigent_client.enums import TokenKind
 from dirigent_client.schemas import (
@@ -15,8 +15,6 @@ from dirigent_client.schemas import (
 from dirigent_core.auth import (
     SESSION_LIFETIME,
     Principal,
-    WeakPassword,
-    WrongPassword,
     authenticate,
     change_password,
     issue_token,
@@ -28,7 +26,9 @@ from dirigent_core.auth import find_user as find_user_row
 from dirigent_core.models import User
 from dirigent_core.ratelimit import TokenBucket
 from dirigent_server.dependencies import SessionDep, SettingsDep
+from dirigent_server.errors import Refusal
 from dirigent_server.logging import get_logger
+from dirigent_server.messages import ACCOUNT_GONE, BAD_CREDENTIALS, NO_TOKEN, TOO_MANY_LOGINS
 from dirigent_server.pagination import DEFAULT_PAGE, AfterParam, LimitParam, clip, uuid_cursor
 from dirigent_server.security import (
     AdminDep,
@@ -68,7 +68,7 @@ async def login(
     _limit_login(request, payload.username, per_minute=settings.login_rate_per_minute)
     user = await authenticate(session, payload.username, payload.password.get_secret_value())
     if user is None:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="invalid username or password")
+        raise Refusal(BAD_CREDENTIALS, status=status.HTTP_401_UNAUTHORIZED)
     issued = await issue_token(session, user, name="session", kind=TokenKind.SESSION, lifetime=SESSION_LIFETIME)
     set_session_cookie(
         response,
@@ -91,10 +91,11 @@ def _limit_login(request: Request, username: str, *, per_minute: int) -> None:
     for scope, key in (("address", f"address:{address}"), ("account", f"user:{username}")):
         if not LOGIN_BUCKETS.allow(key, per_minute=per_minute):
             _logger.warning("login rate limited", scope=scope, address=address, limit=per_minute)
-            raise HTTPException(
-                status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-                detail=f"too many login attempts; this instance accepts {per_minute} a minute",
+            raise Refusal(
+                TOO_MANY_LOGINS,
+                status=status.HTTP_429_TOO_MANY_REQUESTS,
                 headers={"Retry-After": "60"},
+                per_minute=per_minute,
             )
 
 
@@ -131,18 +132,13 @@ async def change_own_password(
     out of the page they made it from. An API token is not a session and is untouched.
     """
     user = await _require_user(session, principal.username)
-    try:
-        await change_password(
-            session,
-            user,
-            payload.current_password.get_secret_value(),
-            payload.new_password.get_secret_value(),
-            keep=principal.token_id,
-        )
-    except WrongPassword as error:
-        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=str(error)) from error
-    except WeakPassword as error:
-        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_CONTENT, detail=str(error)) from error
+    await change_password(
+        session,
+        user,
+        payload.current_password.get_secret_value(),
+        payload.new_password.get_secret_value(),
+        keep=principal.token_id,
+    )
     return Response(status_code=status.HTTP_204_NO_CONTENT)
 
 
@@ -206,7 +202,7 @@ async def create_api_token(payload: TokenRequest, session: SessionDep, principal
 async def revoke_api_token(name: str, session: SessionDep, principal: AdminDep) -> Response:
     """Revoke the caller's live tokens of the given name."""
     if not await revoke_token(session, user_id=principal.user_id, name=name):
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"no live token named {name!r}")
+        raise Refusal(NO_TOKEN, status=status.HTTP_404_NOT_FOUND, name=repr(name))
     return Response(status_code=status.HTTP_204_NO_CONTENT)
 
 
@@ -214,5 +210,5 @@ async def _require_user(session: SessionDep, username: str) -> User:
     """Read the account a principal names."""
     user = await find_user_row(session, username)
     if user is None:  # pragma: no cover - a resolved principal always has its row
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="the authenticated account is gone")
+        raise Refusal(ACCOUNT_GONE, status=status.HTTP_401_UNAUTHORIZED)
     return user

{dirigent_server-0.16.6 → dirigent_server-0.17.0}/src/dirigent_server/routes/blocks.py

@@ -2,10 +2,12 @@
 
 from typing import Annotated
 
-from fastapi import APIRouter, HTTPException, Query, status
+from fastapi import APIRouter, Query, status
 
 from dirigent_client.schemas import BlockEntry, BlockKind, Catalog
 from dirigent_server.dependencies import ServicesDep
+from dirigent_server.errors import Refusal
+from dirigent_server.messages import NO_BLOCK
 from dirigent_server.security import PrincipalDep
 from dirigent_server.transactions import Transactional
 
@@ -35,5 +37,5 @@ async def get_block(block_id: str, services: ServicesDep, principal: PrincipalDe
     """Serve one catalog entry."""
     entry = services.host.catalog().block(block_id)
     if entry is None:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"no block {block_id!r} is installed")
+        raise Refusal(NO_BLOCK, status=status.HTTP_404_NOT_FOUND, block_id=repr(block_id))
     return entry