nucliadb 6.7.2.post4874__py3-none-any.whl → 6.10.0.post5705__py3-none-any.whl

nucliadb/reader/api/v1/resource.py

@@ -17,11 +17,12 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
-from typing import Optional, Union
+from typing import cast
 
 from fastapi import Header, HTTPException, Query, Request, Response
 from fastapi_versioning import version
 
+from nucliadb.common import datamanagers
 from nucliadb.common.datamanagers.resources import KB_RESOURCE_SLUG_BASE
 from nucliadb.common.maindb.utils import get_driver
 from nucliadb.common.models_utils import from_proto, to_proto
@@ -58,6 +59,57 @@ from nucliadb_utils.authentication import requires, requires_one
 from nucliadb_utils.utilities import get_audit, get_storage
 
 
+@api.head(
+    f"/{KB_PREFIX}/{{kbid}}/{RESOURCE_PREFIX}/{{rid}}",
+    status_code=200,
+    summary="Head Resource (by id)",
+    responses={404: {"description": "Resource does not exist"}},
+    tags=["Resources"],
+)
+@requires(NucliaDBRoles.READER)
+@version(1)
+async def head_resource_by_uuid(
+    request: Request,
+    kbid: str,
+    rid: str,
+):
+    return await head_resource(kbid=kbid, rid=rid)
+
+
+@api.head(
+    f"/{KB_PREFIX}/{{kbid}}/{RSLUG_PREFIX}/{{rslug}}",
+    status_code=200,
+    summary="Head Resource (by slug)",
+    responses={404: {"description": "Resource does not exist"}},
+    tags=["Resources"],
+)
+@requires(NucliaDBRoles.READER)
+@version(1)
+async def head_resource_by_slug(
+    request: Request,
+    kbid: str,
+    rslug: str,
+):
+    return await head_resource(kbid=kbid, rslug=rslug)
+
+
+async def head_resource(
+    *,
+    kbid: str,
+    rslug: str | None = None,
+    rid: str | None = None,
+) -> None:
+    if all([rslug, rid]) or not any([rslug, rid]):
+        raise ValueError("Either rid or rslug must be provided, but not both")
+    if rid is None:
+        rslug = cast(str, rslug)
+        rid = await datamanagers.atomic.resources.get_resource_uuid_from_slug(kbid=kbid, slug=rslug)
+        if rid is None:
+            raise HTTPException(status_code=404, detail="Resource does not exist")
+    if not await datamanagers.atomic.resources.resource_exists(kbid=kbid, rid=rid):
+        raise HTTPException(status_code=404, detail="Resource does not exist")
+
+
 @api.get(
     f"/{KB_PREFIX}/{{kbid}}/resources",
     status_code=200,
@@ -211,8 +263,8 @@ async def get_resource_by_slug(
 
 async def _get_resource(
     *,
-    rslug: Optional[str] = None,
-    rid: Optional[str] = None,
+    rslug: str | None = None,
+    rid: str | None = None,
     kbid: str,
     show: list[ResourceProperties],
     field_type_filter: list[FieldTypeName],
@@ -269,7 +321,7 @@ async def get_resource_field_rslug_prefix(
     ),
     # not working with latest pydantic/fastapi
     # page: Union[Literal["last", "first"], int] = Query("last"),
-    page: Union[str, int] = Query("last"),
+    page: str | int = Query("last"),
 ) -> Response:
     return await _get_resource_field(
         kbid,
@@ -309,7 +361,7 @@ async def get_resource_field_rid_prefix(
     ),
     # not working with latest pydantic/fastapi
     # page: Union[Literal["last", "first"], int] = Query("last"),
-    page: Union[str, int] = Query("last"),
+    page: str | int = Query("last"),
 ) -> Response:
     return await _get_resource_field(
         kbid,
@@ -328,9 +380,9 @@ async def _get_resource_field(
     field_id: str,
     show: list[ResourceFieldProperties],
     extracted: list[ExtractedDataTypeName],
-    page: Union[str, int],
-    rid: Optional[str] = None,
-    rslug: Optional[str] = None,
+    page: str | int,
+    rid: str | None = None,
+    rslug: str | None = None,
 ) -> Response:
     storage = await get_storage(service_name=SERVICE_NAME)
     driver = get_driver()
@@ -344,7 +396,7 @@ async def _get_resource_field(
             if rid is None:
                 raise HTTPException(status_code=404, detail="Resource does not exist")
 
-        resource = ORMResource(txn, storage, kb, rid)
+        resource = ORMResource(txn, storage, kbid, rid)
         field = await resource.get_field(field_id, pb_field_id, load=True)
         if field is None:
             raise HTTPException(status_code=404, detail="Knowledge Box does not exist")

nucliadb/reader/api/v1/services.py

@@ -18,9 +18,8 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import asyncio
-from typing import Optional, Union
 
-from fastapi import HTTPException
+from fastapi import HTTPException, Path
 from fastapi.responses import StreamingResponse
 from fastapi_versioning import version
 from google.protobuf.json_format import MessageToDict
@@ -69,7 +68,7 @@ from nucliadb_utils.utilities import get_ingest, get_storage
 @version(1)
 async def get_entities(
     request: Request, kbid: str, show_entities: bool = False
-) -> Union[KnowledgeBoxEntities, HTTPClientError]:
+) -> KnowledgeBoxEntities | HTTPClientError:
     if show_entities:
         return HTTPClientError(
             status_code=400,
@@ -169,7 +168,14 @@ async def get_labelsets(kbid: str) -> KnowledgeBoxLabels:
 )
 @requires(NucliaDBRoles.READER)
 @version(1)
-async def get_labelset_endpoint(request: Request, kbid: str, labelset: str) -> LabelSet:
+async def get_labelset_endpoint(
+    request: Request,
+    kbid: str,
+    labelset: str = Path(
+        title="The ID of the labelset to get. This is a unique identifier that should be used at search time.",
+        examples=["categories", "movie-genres", "document-types"],
+    ),
+) -> LabelSet:
     try:
         return await get_labelset(kbid, labelset)
     except KnowledgeBoxNotFound:
@@ -186,7 +192,7 @@ async def get_labelset(kbid: str, labelset_id: str) -> LabelSet:
     kb_exists = await datamanagers.atomic.kb.exists_kb(kbid=kbid)
     if not kb_exists:
         raise KnowledgeBoxNotFound()
-    labelset: Optional[writer_pb2.LabelSet] = await datamanagers.atomic.labelset.get(
+    labelset: writer_pb2.LabelSet | None = await datamanagers.atomic.labelset.get(
         kbid=kbid, labelset_id=labelset_id
     )
     if labelset is None:
@@ -222,17 +228,15 @@ async def get_custom_synonyms(request: Request, kbid: str):
     f"/{KB_PREFIX}/{{kbid}}/notifications",
     status_code=200,
     summary="Knowledge Box Notifications Stream",
-    description="Provides a stream of activity notifications for the given Knowledge Box. The stream will be automatically closed after 2 minutes.",  # noqa: E501
+    description="Provides a stream of activity notifications for the given Knowledge Box. The stream will be automatically closed after 2 minutes.",
     tags=["Knowledge Box Services"],
-    response_description="Each line of the response is a Base64-encoded JSON object representing a notification. Refer to [the internal documentation](https://github.com/nuclia/nucliadb/blob/main/docs/tutorials/KB_NOTIFICATIONS.md) for a more detailed explanation of each notification type.",  # noqa: E501
+    response_description="Each line of the response is a Base64-encoded JSON object representing a notification. Refer to [the internal documentation](https://github.com/nuclia/nucliadb/blob/main/docs/tutorials/KB_NOTIFICATIONS.md) for a more detailed explanation of each notification type.",
     response_model=None,
     responses={"404": {"description": "Knowledge Box not found"}},
 )
 @requires(NucliaDBRoles.READER)
 @version(1)
-async def notifications_endpoint(
-    request: Request, kbid: str
-) -> Union[StreamingResponse, HTTPClientError]:
+async def notifications_endpoint(request: Request, kbid: str) -> StreamingResponse | HTTPClientError:
     if in_standalone_mode():
         return HTTPClientError(
             status_code=404,
@@ -274,10 +278,10 @@ async def exists_kb(kbid: str) -> bool:
 async def processing_status(
     request: Request,
     kbid: str,
-    cursor: Optional[str] = None,
-    scheduled: Optional[bool] = None,
+    cursor: str | None = None,
+    scheduled: bool | None = None,
     limit: int = 20,
-) -> Union[processing.RequestsResults, HTTPClientError]:
+) -> processing.RequestsResults | HTTPClientError:
     if not await exists_kb(kbid=kbid):
         return HTTPClientError(status_code=404, detail="Knowledge Box not found")
 
@@ -294,7 +298,7 @@ async def processing_status(
 
         async def _composition(
             result: processing.RequestsResult,
-        ) -> Optional[processing.RequestsResult]:
+        ) -> processing.RequestsResult | None:
             async with max_simultaneous:
                 resource = await kb.get(result.resource_id)
                 if resource is None:

nucliadb/reader/app.py

@@ -26,6 +26,7 @@ from starlette.middleware.authentication import AuthenticationMiddleware
 from starlette.requests import ClientDisconnect, Request
 from starlette.responses import HTMLResponse
 
+from nucliadb.middleware import ClientErrorPayloadLoggerMiddleware
 from nucliadb.reader import API_PREFIX
 from nucliadb.reader.api.v1.router import api as api_v1
 from nucliadb.reader.lifecycle import lifespan
@@ -49,6 +50,7 @@ middleware.extend(
             backend=NucliaCloudAuthenticationBackend(),
         ),
         Middleware(AuditMiddleware, audit_utility_getter=get_audit),
+        Middleware(ClientErrorPayloadLoggerMiddleware),
     ]
 )
 
@@ -56,7 +58,6 @@ errors.setup_error_handling(importlib.metadata.distribution("nucliadb").version)
 
 fastapi_settings = dict(
     debug=running_settings.debug,
-    middleware=middleware,
     lifespan=lifespan,
     exception_handlers={
         Exception: global_exception_handler,
@@ -78,6 +79,7 @@ def create_application() -> FastAPI:
         prefix_format=f"/{API_PREFIX}/v{{major}}",
         default_version=(1, 0),
         enable_latest=False,
+        middleware=middleware,
         kwargs=fastapi_settings,
     )
 

nucliadb/reader/reader/notifications.py

@@ -21,7 +21,6 @@ import asyncio
 import contextlib
 import uuid
 from collections.abc import AsyncGenerator
-from typing import Optional
 
 import async_timeout
 from nats.aio.msg import Msg
@@ -200,7 +199,7 @@ async def get_resource_title_cached(
     return resource_title
 
 
-async def get_resource_title(kv_driver: Driver, kbid: str, resource_uuid: str) -> Optional[str]:
+async def get_resource_title(kv_driver: Driver, kbid: str, resource_uuid: str) -> str | None:
     async with kv_driver.ro_transaction() as txn:
         basic = await datamanagers.resources.get_basic(txn, kbid=kbid, rid=resource_uuid)
         if basic is None:

nucliadb/search/api/v1/__init__.py

@@ -19,12 +19,15 @@
 #
 from . import (  # noqa: F401
     ask,
+    augment,
     catalog,
     feedback,
     find,
     graph,
+    hydrate,
     knowledgebox,
     predict_proxy,
+    retrieve,
     search,
     suggest,
     summarize,

nucliadb/search/api/v1/ask.py

@@ -18,7 +18,6 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import json
-from typing import Optional, Union
 
 from fastapi import Header, Request, Response
 from fastapi_versioning import version
@@ -67,7 +66,7 @@ async def ask_knowledgebox_endpoint(
         description="When set to true, outputs response as JSON in a non-streaming way. "
         "This is slower and requires waiting for entire answer to be ready.",
     ),
-) -> Union[StreamingResponse, HTTPClientError, Response]:
+) -> StreamingResponse | HTTPClientError | Response:
     current_user: NucliaUser = request.user
     # If present, security groups from AuthorizationBackend overrides any
     # security group of the payload
@@ -116,8 +115,8 @@ async def create_ask_response(
     client_type: NucliaDBClientType,
     origin: str,
     x_synchronous: bool,
-    resource: Optional[str] = None,
-    extra_predict_headers: Optional[dict[str, str]] = None,
+    resource: str | None = None,
+    extra_predict_headers: dict[str, str] | None = None,
 ) -> Response:
     maybe_log_request_payload(kbid, "/ask", ask_request)
     ask_request.max_tokens = parse_max_tokens(ask_request.max_tokens)