tigrbl_api_hpks 0.1.2.dev9__tar.gz → 0.1.2.dev11__tar.gz

{tigrbl_api_hpks-0.1.2.dev9 → tigrbl_api_hpks-0.1.2.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl_api_hpks
-Version: 0.1.2.dev9
+Version: 0.1.2.dev11
 Summary: High-trust OpenPGP keyserver APIs built on the Tigrbl application engine.
 License: Apache License
                                     Version 2.0, January 2004

{tigrbl_api_hpks-0.1.2.dev9 → tigrbl_api_hpks-0.1.2.dev11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tigrbl_api_hpks"
-version = "0.1.2.dev9"
+version = "0.1.2.dev11"
 description = "High-trust OpenPGP keyserver APIs built on the Tigrbl application engine."
 license = { file = "LICENSE" }
 readme = { file = "README.md", content-type = "text/markdown" }

{tigrbl_api_hpks-0.1.2.dev9 → tigrbl_api_hpks-0.1.2.dev11}/src/tigrbl_api_hpks/api.py

@@ -5,17 +5,14 @@ from __future__ import annotations
 import datetime as dt
 import os
 import tempfile
-from typing import Any, AsyncIterator
+from typing import Any
 from urllib.parse import parse_qs
 
-from tigrbl import TigrblApp
-from tigrbl.router import Router
-from tigrbl.router.decorators import route
-from tigrbl.engine.shortcuts import engine as build_engine
-from tigrbl.responses import Response
+from tigrbl import Router, TigrblApp, Response, Request
+from tigrbl.decorators.router import route
+from tigrbl.shortcuts.engine import engine as build_engine
 from tigrbl.runtime.status import HTTPException
-from tigrbl.security.dependencies import Depends
-from tigrbl.requests import Request
+
 
 from .ops import pks as pks_ops
 from .tables import OpenPGPKey
@@ -30,6 +27,18 @@ def _normalize_fingerprint(value: str) -> str:
     return stripped.upper()
 
 
+def _query_first(request: Request, key: str, default: str = "") -> str:
+    """Extract the first value for a query parameter."""
+    values = request.query.get(key, [])
+    return values[0] if values else default
+
+
+def _path_segment(request: Request, index: int) -> str:
+    """Extract a path segment by index (0-based, after splitting on '/')."""
+    parts = request.path.strip("/").split("/")
+    return parts[index] if index < len(parts) else ""
+
+
 def _response_text(
     content: str,
     *,
@@ -87,17 +96,13 @@ def build_app(
 
     router = Router(prefix="/pks")
 
-    async def get_session() -> AsyncIterator[Any]:
-        async with app.engine.asession() as session:
-            yield session
-
     def _not_found(detail: str = "Not found") -> HTTPException:
         return HTTPException(status_code=404, detail=detail, headers=HPKS_CORS_HEADERS)
 
+    # ---- Legacy HKP endpoints ----
+
     @route(router, "/add", methods=["POST"])
-    async def legacy_add(
-        request: Request, *, db: Any = Depends(get_session)
-    ) -> Response:
+    async def legacy_add(request: Request) -> Response:
         body = request.body.decode("utf-8")
         form_data = parse_qs(body, keep_blank_values=True)
         keytext = form_data.get("keytext", [""])[0]
@@ -107,72 +112,76 @@ def build_app(
                 detail="keytext is required",
                 headers=HPKS_CORS_HEADERS,
             )
-        try:
-            await pks_ops.ingest_armored(db=db, armored=keytext)
-        except ValueError as exc:  # pragma: no cover - defensive
-            raise HTTPException(
-                status_code=422, detail=str(exc), headers=HPKS_CORS_HEADERS
-            ) from exc
+        async with app.engine.asession() as db:
+            try:
+                await pks_ops.ingest_armored(db=db, armored=keytext)
+            except ValueError as exc:
+                raise HTTPException(
+                    status_code=422, detail=str(exc), headers=HPKS_CORS_HEADERS
+                ) from exc
         return _response_text("OK\n", headers=HPKS_CORS_HEADERS)
 
     @route(router, "/lookup", methods=["GET"])
-    async def legacy_lookup(request: Request, *, db: Any = Depends(get_session)):
-        op = request.query_param("op") or ""
-        search = request.query_param("search") or ""
+    async def legacy_lookup(request: Request):
+        op = _query_first(request, "op")
+        search = _query_first(request, "search")
         op_name = op.lower()
         normalized = _normalize_fingerprint(search)
-        if op_name == "index":
-            results = await pks_ops.search_index(db=db, search=search)
-            if not results:
-                raise _not_found()
-            body = pks_ops.render_legacy_index(results, search=search)
-            return _response_text(body, headers=HPKS_CORS_HEADERS)
-        if op_name == "get":
-            if len(normalized) <= 8:
-                raise _not_found()
-            record = await pks_ops.lookup_by_fingerprint(db=db, fingerprint=normalized)
-            if record is None:
-                raise _not_found()
-            return _response_text(
-                record.ascii_armored,
-                media_type="application/pgp-keys",
-                headers=HPKS_CORS_HEADERS,
-            )
-        if op_name == "hget":
-            record = await pks_ops.lookup_by_email_hash(db=db, email_hash=search)
-            if record is None:
-                raise _not_found()
-            return _response_text(
-                record.ascii_armored,
-                media_type="application/pgp-keys",
-                headers=HPKS_CORS_HEADERS,
-            )
+        async with app.engine.asession() as db:
+            if op_name == "index":
+                results = await pks_ops.search_index(db=db, search=search)
+                if not results:
+                    raise _not_found()
+                body = pks_ops.render_legacy_index(results, search=search)
+                return _response_text(body, headers=HPKS_CORS_HEADERS)
+            if op_name == "get":
+                if len(normalized) <= 8:
+                    raise _not_found()
+                record = await pks_ops.lookup_by_fingerprint(
+                    db=db, fingerprint=normalized
+                )
+                if record is None:
+                    raise _not_found()
+                return _response_text(
+                    record.ascii_armored,
+                    media_type="application/pgp-keys",
+                    headers=HPKS_CORS_HEADERS,
+                )
+            if op_name == "hget":
+                record = await pks_ops.lookup_by_email_hash(db=db, email_hash=search)
+                if record is None:
+                    raise _not_found()
+                return _response_text(
+                    record.ascii_armored,
+                    media_type="application/pgp-keys",
+                    headers=HPKS_CORS_HEADERS,
+                )
         raise HTTPException(
             status_code=400,
             detail=f"Unsupported legacy op '{op}'",
             headers=HPKS_CORS_HEADERS,
         )
 
+    # ---- V2 endpoints ----
+
+    # Pattern: /pks/{fingerprint} — the fingerprint is the 2nd segment
     @route(router, "/{fingerprint}", methods=["POST"])
-    async def merge_fingerprint(
-        request: Request,
-        *,
-        fingerprint: str,
-        db: Any = Depends(get_session),
-    ) -> Response:
+    async def merge_fingerprint(request: Request) -> Response:
+        fingerprint = _path_segment(request, 1)
         payload = await request.json() or {}
-        try:
-            record = await pks_ops.merge_json_payload(
-                db=db, fingerprint=fingerprint, payload=payload
-            )
-        except ValueError as exc:
-            raise HTTPException(
-                status_code=422, detail=str(exc), headers=HPKS_CORS_HEADERS
-            ) from exc
+        async with app.engine.asession() as db:
+            try:
+                record = await pks_ops.merge_json_payload(
+                    db=db, fingerprint=fingerprint, payload=payload
+                )
+            except ValueError as exc:
+                raise HTTPException(
+                    status_code=422, detail=str(exc), headers=HPKS_CORS_HEADERS
+                ) from exc
         return _response_json(pks_ops.to_v2_document(record), headers=HPKS_CORS_HEADERS)
 
     @route(router, "/v2/add", methods=["POST"])
-    async def v2_add(request: Request, *, db: Any = Depends(get_session)) -> Response:
+    async def v2_add(request: Request) -> Response:
         content_type = request.headers.get("content-type", "")
         if "application/pgp-keys" not in content_type:
             raise HTTPException(
@@ -185,25 +194,32 @@ def build_app(
             raise HTTPException(
                 status_code=400, detail="Empty payload", headers=HPKS_CORS_HEADERS
             )
-        try:
-            summary = await pks_ops.ingest_binary(db=db, bundle=bundle)
-        except ValueError as exc:
-            raise HTTPException(
-                status_code=422, detail=str(exc), headers=HPKS_CORS_HEADERS
-            ) from exc
+        async with app.engine.asession() as db:
+            try:
+                summary = await pks_ops.ingest_binary(db=db, bundle=bundle)
+            except ValueError as exc:
+                raise HTTPException(
+                    status_code=422, detail=str(exc), headers=HPKS_CORS_HEADERS
+                ) from exc
         return _response_json(summary, status_code=202, headers=HPKS_CORS_HEADERS)
 
+    # Pattern: /pks/v2/index/{query} — the query is the 4th segment
     @route(router, "/v2/index/{query}", methods=["GET"])
-    async def v2_index(query: str, *, db: Any = Depends(get_session)) -> Response:
-        results = await pks_ops.search_index(db=db, search=query)
+    async def v2_index(request: Request) -> Response:
+        query = _path_segment(request, 3)
+        async with app.engine.asession() as db:
+            results = await pks_ops.search_index(db=db, search=query)
         if not results:
             raise _not_found()
         payload = [pks_ops.to_v2_document(rec) for rec in results]
         return _response_json(payload, headers=HPKS_CORS_HEADERS)
 
+    # Pattern: /pks/v2/vfpget/{fingerprint} — fingerprint is the 4th segment
     @route(router, "/v2/vfpget/{fingerprint}", methods=["GET"])
-    async def vfpget(fingerprint: str, *, db: Any = Depends(get_session)) -> Response:
-        record = await pks_ops.lookup_by_fingerprint(db=db, fingerprint=fingerprint)
+    async def vfpget(request: Request) -> Response:
+        fingerprint = _path_segment(request, 3)
+        async with app.engine.asession() as db:
+            record = await pks_ops.lookup_by_fingerprint(db=db, fingerprint=fingerprint)
         if record is None:
             raise _not_found()
         return _response_binary(
@@ -212,9 +228,12 @@ def build_app(
             headers=HPKS_CORS_HEADERS,
         )
 
+    # Pattern: /pks/v2/kidget/{keyid} — keyid is the 4th segment
     @route(router, "/v2/kidget/{keyid}", methods=["GET"])
-    async def kidget(keyid: str, *, db: Any = Depends(get_session)) -> Response:
-        record = await pks_ops.lookup_by_keyid(db=db, key_id=keyid)
+    async def kidget(request: Request) -> Response:
+        keyid = _path_segment(request, 3)
+        async with app.engine.asession() as db:
+            record = await pks_ops.lookup_by_keyid(db=db, key_id=keyid)
         if record is None or (record.version and record.version > 4):
             raise _not_found()
         return _response_binary(
@@ -223,9 +242,12 @@ def build_app(
             headers=HPKS_CORS_HEADERS,
         )
 
+    # Pattern: /pks/v2/authget/{identifier} — identifier is the 4th segment
     @route(router, "/v2/authget/{identifier}", methods=["GET"])
-    async def authget(identifier: str, *, db: Any = Depends(get_session)) -> Response:
-        matches = await pks_ops.search_index(db=db, search=identifier)
+    async def authget(request: Request) -> Response:
+        identifier = _path_segment(request, 3)
+        async with app.engine.asession() as db:
+            matches = await pks_ops.search_index(db=db, search=identifier)
         lowered = identifier.lower()
         record = next(
             (
@@ -243,10 +265,10 @@ def build_app(
             headers=HPKS_CORS_HEADERS,
         )
 
+    # Pattern: /pks/v2/prefixlog/{since} — since is the 4th segment
     @route(router, "/v2/prefixlog/{since}", methods=["GET"])
-    async def prefixlog_route(
-        since: str, *, db: Any = Depends(get_session)
-    ) -> Response:
+    async def prefixlog_route(request: Request) -> Response:
+        since = _path_segment(request, 3)
         try:
             parsed = dt.datetime.fromisoformat(since)
         except ValueError:
@@ -260,12 +282,13 @@ def build_app(
                 ) from None
         if parsed.tzinfo is None:
             parsed = parsed.replace(tzinfo=dt.timezone.utc)
-        prefixes = await pks_ops.prefix_log(db=db, since=parsed)
+        async with app.engine.asession() as db:
+            prefixes = await pks_ops.prefix_log(db=db, since=parsed)
         body = "\r\n".join(prefixes)
         return _response_text(body, headers=HPKS_CORS_HEADERS)
 
     @route(router, "/v2/tokensend", methods=["POST"])
-    async def tokensend(_: Request) -> Response:
+    async def tokensend(request: Request) -> Response:
         return Response(status_code=501, headers=list(HPKS_CORS_HEADERS.items()))
 
     app.include_router(router)

{tigrbl_api_hpks-0.1.2.dev9 → tigrbl_api_hpks-0.1.2.dev11}/src/tigrbl_api_hpks/ops/pks.py

@@ -437,7 +437,11 @@ async def _merge_parsed_key(*, db: Any, parsed: ParsedKey) -> OpenPGPKey:
         payload["bits"] = parsed.bits or existing.bits
         payload["primary_uid"] = parsed.primary_uid or existing.primary_uid
         payload["version"] = parsed.version or existing.version
-    ctx = {"db": db, "payload": payload}
+    ctx = {
+        "db": db,
+        "payload": payload,
+        "path_params": {"item_id": parsed.fingerprint},
+    }
     record = await OpenPGPKey.handlers.merge.handler(ctx)
     await _commit_session(db)
     return record
@@ -540,7 +544,11 @@ async def merge_json_payload(
         "primary_uid": primary_uid or existing.primary_uid,
         "version": payload.get("version") or existing.version,
     }
-    ctx = {"db": db, "payload": merged_payload}
+    ctx = {
+        "db": db,
+        "payload": merged_payload,
+        "path_params": {"item_id": normalized},
+    }
     record = await OpenPGPKey.handlers.merge.handler(ctx)
     await _commit_session(db)
     return record

{tigrbl_api_hpks-0.1.2.dev9 → tigrbl_api_hpks-0.1.2.dev11}/src/tigrbl_api_hpks/tables/openpgp_key.py

@@ -6,7 +6,7 @@ import datetime as dt
 
 from tigrbl.orm.mixins import Mergeable, Timestamped
 from tigrbl.specs import ColumnSpec, F, IO, S, acol
-from tigrbl.table import Base
+from tigrbl.orm.tables import Base
 from tigrbl.types import (
     Boolean,
     Integer,