fastapi-rtk 2.3.2__tar.gz → 2.3.3__tar.gz

{fastapi_rtk-2.3.2 → fastapi_rtk-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-rtk
-Version: 2.3.2
+Version: 2.3.3
 Summary: A package that provides a set of tools to build a FastAPI application with a Class-Based CRUD API.
 Project-URL: Homepage, https://codeberg.org/datatactics/fastapi-rtk
 Project-URL: Issues, https://codeberg.org/datatactics/fastapi-rtk/issues

fastapi_rtk-2.3.3/fastapi_rtk/_version.py

@@ -0,0 +1 @@
+__version__ = "2.3.3"

{fastapi_rtk-2.3.2 → fastapi_rtk-2.3.3}/fastapi_rtk/api/base_api.py

@@ -1,14 +1,13 @@
 import typing
-from typing import TYPE_CHECKING, Any, Dict
 
-from fastapi import APIRouter, Depends
+import fastapi
 
 from ..const import PERMISSION_PREFIX, logger
 from ..registry import APIRouteRegistry
 from ..utils import T, lazy_self, update_signature
 from ..utils import lazy as o_lazy
 
-if TYPE_CHECKING:
+if typing.TYPE_CHECKING:
     from ..fastapi_react_toolkit import FastAPIReactToolkit
 
 __all__ = ["BaseApi"]
@@ -103,14 +102,14 @@ class BaseApi:
     """
     The FastAPIReactToolkit object. Automatically set when the API is added to the toolkit.
     """
-    cache: Dict[str, Any] = lazy(lambda self: dict())
+    cache: typing.Dict[str, typing.Any] = lazy(lambda self: dict())
     """
     The cache for the API.
     
     DO NOT MODIFY.
     """
     router = lazy(
-        lambda self: APIRouter(
+        lambda self: fastapi.APIRouter(
             prefix=f"/api/{self.version}/{self.resource_name}",
             tags=[self.__class__.__name__],
         )
@@ -139,7 +138,7 @@ class BaseApi:
         """
         pass
 
-    def integrate_router(self, app: APIRouter):
+    def integrate_router(self, app: fastapi.APIRouter):
         """
         Integrates the router into the FastAPI app.
 
@@ -157,7 +156,7 @@ class BaseApi:
             if self.toolkit.global_user_dependency and not ignore_g_user:
                 from ..dependencies import set_global_user
 
-                rest_data["dependencies"] = [Depends(set_global_user())] + (
+                rest_data["dependencies"] = [fastapi.Depends(set_global_user())] + (
                     rest_data.get("dependencies") or []
                 )
 
@@ -213,10 +212,10 @@ class BaseApi:
                                 else:
                                     resolved_kwargs[key] = val
                             resolved_dependencies.append(
-                                Depends(func(**resolved_kwargs))
+                                fastapi.Depends(func(**resolved_kwargs))
                             )
                         else:
-                            resolved_dependencies.append(Depends(func))
+                            resolved_dependencies.append(fastapi.Depends(func))
 
                     path, methods, rest_data = (
                         data["path"],

{fastapi_rtk-2.3.2 → fastapi_rtk-2.3.3}/fastapi_rtk/api/model_rest_api/__init__.py

@@ -27,8 +27,6 @@ import typing
 
 import fastapi
 import pydantic
-from fastapi import Depends
-from pydantic import BaseModel, Field
 
 from ...backends.sqla.filters import BaseFilter, BaseOprFilter
 from ...backends.sqla.interface import SQLAInterface
@@ -52,7 +50,7 @@ from ...utils import T, lazy_self, merge_schema
 from ..base_api import BaseApi
 from ._add_mixin import AddMixin
 from ._bulk_mixin import BulkMixin
-from ._columns import ColumnsMixin
+from ._columns_mixin import ColumnsMixin
 from ._delete_mixin import DeleteMixin
 from ._download_mixin import DownloadMixin
 from ._edit_mixin import EditMixin
@@ -275,9 +273,9 @@ class ModelRestApi(
             {
                 "order_column": (
                     self.order_column_enum | None,
-                    Field(default=None),
+                    pydantic.Field(default=None),
                 ),
-                "page_size": (int | None, Field(default=self.page_size)),
+                "page_size": (int | None, pydantic.Field(default=self.page_size)),
             },
             True,
             f"{self.__class__.__name__}-QuerySchema",
@@ -292,8 +290,11 @@ class ModelRestApi(
         lambda self: merge_schema(
             QueryBody,
             {
-                "order_column": (self.order_column_enum | None, Field(default=None)),
-                "page_size": (int | None, Field(default=self.page_size)),
+                "order_column": (
+                    self.order_column_enum | None,
+                    pydantic.Field(default=None),
+                ),
+                "page_size": (int | None, pydantic.Field(default=self.page_size)),
             },
             True,
             f"{self.__class__.__name__}-DownloadBodySchema",
@@ -422,24 +423,38 @@ class ModelRestApi(
         lambda self: merge_schema(
             InfoResponse,
             {
-                "add_title": (str, Field(default_factory=lambda: self.add_title)),
-                "edit_title": (str, Field(default_factory=lambda: self.edit_title)),
-                "filter_options": (dict, Field(default={})),
+                "add_title": (
+                    str,
+                    pydantic.Field(default_factory=lambda: self.add_title),
+                ),
+                "edit_title": (
+                    str,
+                    pydantic.Field(default_factory=lambda: self.edit_title),
+                ),
+                "filter_options": (dict, pydantic.Field(default={})),
                 "add_translations": (
                     dict,
-                    Field(default_factory=lambda: self.add_jsonforms_translations),
+                    pydantic.Field(
+                        default_factory=lambda: self.add_jsonforms_translations
+                    ),
                 ),
                 "edit_translations": (
                     dict,
-                    Field(default_factory=lambda: self.edit_jsonforms_translations),
+                    pydantic.Field(
+                        default_factory=lambda: self.edit_jsonforms_translations
+                    ),
                 ),
                 "add_type": (
                     typing.Literal["json"] | typing.Literal["form"],
-                    Field(default="form" if self._is_form_data_add else "json"),
+                    pydantic.Field(
+                        default="form" if self._is_form_data_add else "json"
+                    ),
                 ),
                 "edit_type": (
                     typing.Literal["json"] | typing.Literal["form"],
-                    Field(default="form" if self._is_form_data_edit else "json"),
+                    pydantic.Field(
+                        default="form" if self._is_form_data_edit else "json"
+                    ),
                 ),
             },
             name=f"{self.__class__.__name__}-InfoResponse",
@@ -646,9 +661,13 @@ class ModelRestApi(
     -------------
     """
 
-    add_jsonforms_schema: typing.Dict[str, typing.Any] | None = None
+    add_jsonforms_schema: (
+        dict[str, typing.Any]
+        | typing.Callable[[], dict | typing.Awaitable[dict]]
+        | None
+    ) = None
     """
-    The `JSONForms` schema for the add endpoint. If not provided, Defaults to the schema generated from the `add_columns` property.
+    The `JSONForms` schema for the add endpoint. If not provided, Defaults to the schema generated from the `add_columns` property. May also be a sync or async callable returning the schema, resolved via `smart_run`.
     """
     add_jsonforms_uischema: typing.Dict[str, typing.Any] | None = None
     """
@@ -688,9 +707,13 @@ class ModelRestApi(
     A workaround for issue https://github.com/eclipsesource/jsonforms/issues/2271
     """
 
-    edit_jsonforms_schema: typing.Dict[str, typing.Any] | None = None
+    edit_jsonforms_schema: (
+        dict[str, typing.Any]
+        | typing.Callable[[], dict | typing.Awaitable[dict]]
+        | None
+    ) = None
     """
-    The `JSONForms` schema for the edit endpoint. If not provided, Defaults to the schema generated from the `edit_columns` property.
+    The `JSONForms` schema for the edit endpoint. If not provided, Defaults to the schema generated from the `edit_columns` property. May also be a sync or async callable returning the schema, resolved via `smart_run`.
     """
     edit_jsonforms_uischema: typing.Dict[str, typing.Any] | None = None
     """
@@ -800,7 +823,7 @@ class ModelRestApi(
     -------------
     """
 
-    add_schema: typing.Type[BaseModel] = lazy(
+    add_schema: typing.Type[pydantic.BaseModel] = lazy(
         lambda self: typing.Annotated[
             self._create_request_schema(
                 merge_schema(
@@ -820,7 +843,7 @@ class ModelRestApi(
 
     DO NOT MODIFY UNLESS YOU KNOW WHAT YOU ARE DOING.
     """
-    edit_schema: typing.Type[BaseModel] = lazy(
+    edit_schema: typing.Type[pydantic.BaseModel] = lazy(
         lambda self: typing.Annotated[
             self._create_request_schema(
                 merge_schema(
@@ -851,7 +874,7 @@ class ModelRestApi(
     ```python
     add_schema_extra_fields = {
         "extra_field": str,
-        "extra_field_with_field_info": (str, Field(default="default_value")),
+        "extra_field_with_field_info": (str, pydantic.Field(default="default_value")),
     }
     ```
     """
@@ -865,7 +888,7 @@ class ModelRestApi(
     ```python
     edit_schema_extra_fields = {
         "extra_field": str,
-        "extra_field_with_field_info": (str, Field(default="default_value")),
+        "extra_field_with_field_info": (str, pydantic.Field(default="default_value")),
     }
     ```
     """
@@ -1103,8 +1126,8 @@ class ModelRestApi(
         """
 
         async def dependency(
-            q: self.query_schema = Depends(),  # type: ignore
-            session=Depends(self.datamodel.get_session_factory()),
+            q: self.query_schema = fastapi.Depends(),  # type: ignore
+            session=fastapi.Depends(self.datamodel.get_session_factory()),
         ):
             q: QuerySchema = q
             if not self.list_query_count_enabled or not q.with_count:

{fastapi_rtk-2.3.2 → fastapi_rtk-2.3.3}/fastapi_rtk/api/model_rest_api/_add_mixin.py

@@ -6,36 +6,18 @@ implementation, ``pre_add`` and ``post_add`` hooks.
 import typing
 
 import pydantic
-from pydantic import BaseModel
 
-from ...backends.sqla.filters import BaseFilter
-from ...backends.sqla.interface import SQLAInterface
 from ...backends.sqla.model import Model
 from ...backends.sqla.session import SQLASession
-from ...const import AVAILABLE_ROUTES
 from ...decorators import expose, permission_name, priority, protect
-from ...schemas import BaseResponseSingle
 from ...utils import AsyncTaskRunner, SelfDepends, SelfType, smart_run
 from ._params import PARAM_BODY_SESSION
+from ._typed_base import _TypedModelRestApi
 
 
-class AddMixin:
+class AddMixin(_TypedModelRestApi):
     """Add endpoint methods for ``ModelRestApi``."""
 
-    if typing.TYPE_CHECKING:
-        # Attributes supplied by the composed ``ModelRestApi`` class via MRO.
-        datamodel: SQLAInterface
-        expose_params: dict[AVAILABLE_ROUTES, dict[str, typing.Any]]
-        add_return_schema: typing.Type[BaseResponseSingle]
-        add_query_rel_fields: dict[
-            str, list[tuple[str, typing.Type[BaseFilter], typing.Any]]
-        ]
-        add_schema_extra_fields: dict[
-            str, type | tuple[type, pydantic.fields.FieldInfo]
-        ]
-        add_schema: typing.Type[BaseModel]
-        protected_routes: typing.List[AVAILABLE_ROUTES]
-
     def post(self):
         """
         Post endpoint for the API.
@@ -54,7 +36,7 @@ class AddMixin:
 
     async def post_headless(
         self,
-        body: BaseModel = SelfType().add_schema,
+        body: pydantic.BaseModel = SelfType().add_schema,
         session: SQLASession = SelfDepends().datamodel.get_session_factory,
     ):
         """

{fastapi_rtk-2.3.2 → fastapi_rtk-2.3.3}/fastapi_rtk/api/model_rest_api/_bulk_mixin.py

@@ -6,24 +6,18 @@ dispatcher, and the subclass-overridable ``bulk_handler``.
 import typing
 
 import fastapi
-from fastapi import Body, HTTPException, Response
 
 from ...backends.sqla.interface import SQLAInterface
 from ...backends.sqla.session import SQLASession
-from ...const import AVAILABLE_ROUTES, ErrorCode
+from ...const import ErrorCode
 from ...decorators import expose, permission_name, priority, protect
 from ...utils import AsyncTaskRunner, SelfDepends, smart_run
+from ._typed_base import _TypedModelRestApi
 
 
-class BulkMixin:
+class BulkMixin(_TypedModelRestApi):
     """Bulk endpoint methods for ``ModelRestApi``."""
 
-    if typing.TYPE_CHECKING:
-        # Attributes supplied by the composed ``ModelRestApi`` class via MRO.
-        datamodel: SQLAInterface
-        expose_params: dict[AVAILABLE_ROUTES, dict[str, typing.Any]]
-        protected_routes: typing.List[AVAILABLE_ROUTES]
-
     def bulk(self):
         """
         Bulk endpoint for the API.
@@ -42,7 +36,7 @@ class BulkMixin:
     async def bulk_headless(
         self,
         handler: str,
-        body: dict | list = Body(...),
+        body: dict | list = fastapi.Body(...),
         session: SQLASession = SelfDepends().datamodel.get_session_factory,
     ):
         """
@@ -64,20 +58,20 @@ class BulkMixin:
                 self, f"bulk_{handler}", None
             )
             if not bulk_handler:
-                raise HTTPException(
+                raise fastapi.HTTPException(
                     fastapi.status.HTTP_404_NOT_FOUND, ErrorCode.HANDLER_NOT_FOUND
                 )
             try:
                 return await smart_run(bulk_handler, body, self.datamodel, session)
             except NotImplementedError as e:
-                raise HTTPException(fastapi.status.HTTP_404_NOT_FOUND, str(e))
+                raise fastapi.HTTPException(fastapi.status.HTTP_404_NOT_FOUND, str(e))
 
     async def bulk_handler(
         self,
         body: dict | list,
         query: SQLAInterface,
         session: SQLASession,
-    ) -> Response:
+    ) -> fastapi.Response:
         """
         Bulk handler for the API, to be implemented by the subclass.
 

fastapi_rtk-2.3.2/fastapi_rtk/api/model_rest_api/_columns.py → fastapi_rtk-2.3.3/fastapi_rtk/api/model_rest_api/_columns_mixin.py

@@ -26,7 +26,6 @@ import typing
 
 import fastapi
 import pydantic
-from pydantic import BaseModel, Field, create_model
 
 from ...backends.sqla.filters import BaseFilter
 from ...backends.sqla.interface import SQLAInterface
@@ -45,22 +44,14 @@ from ...utils import (
     parse_from_values_or_func,
     smart_run,
 )
+from ._typed_base import _TypedModelRestApi
 
 
-class ColumnsMixin:
+class ColumnsMixin(_TypedModelRestApi):
     """
     Column / schema / body helpers shared by every ``ModelRestApi`` route.
     """
 
-    if typing.TYPE_CHECKING:
-        # Attributes supplied by the composed ``ModelRestApi`` class via MRO.
-        # Declared type-only so checkers resolve ``self.attr`` references
-        # inside the mixin without populating runtime ``__annotations__``.
-        datamodel: SQLAInterface
-        label_columns: dict[str, str]
-        description_columns: dict[str, str]
-        cache: dict[str, typing.Any]
-
     def _gen_labels_columns(self, list_columns: typing.List[str]) -> None:
         """
         Auto generates pretty label_columns from list of columns
@@ -152,7 +143,7 @@ class ColumnsMixin:
 
                 result[key] = (
                     value,
-                    Field(**{"default": None} if is_nullable else {}),
+                    pydantic.Field(**{"default": None} if is_nullable else {}),
                 )
             else:
                 result[key] = value
@@ -178,8 +169,8 @@ class ColumnsMixin:
 
     def _create_request_schema(
         self,
-        schema: typing.Type[BaseModel],
-        optional=False,
+        schema: typing.Type[pydantic.BaseModel],
+        optional: bool = False,
         name: str | None = None,
     ):
         """
@@ -220,7 +211,7 @@ class ColumnsMixin:
                     )
                 rel_schema[col] = (
                     type,
-                    Field(**params),
+                    pydantic.Field(**params),
                 )
             else:
                 if not optional:
@@ -247,11 +238,11 @@ class ColumnsMixin:
                 related_interface = self.datamodel.get_related_interface(col)
                 rel_schema[col] = (
                     type,
-                    Field(**params),
+                    pydantic.Field(**params),
                 )
 
         new_schema_name = f"{self.__class__.__name__}-{schema.__name__}"
-        new_schema = create_model(
+        new_schema = pydantic.create_model(
             name or new_schema_name,
             **rel_schema,
             __base__=schema,
@@ -262,7 +253,7 @@ class ColumnsMixin:
     async def _process_body(
         self,
         session: SQLASession,
-        body: BaseModel | typing.Dict[str, typing.Any],
+        body: pydantic.BaseModel | typing.Dict[str, typing.Any],
         filter_dict: dict[str, list[tuple[str, BaseFilter, typing.Any]]],
         exclude: list[str] | None = None,
         *,
@@ -286,7 +277,7 @@ class ColumnsMixin:
         """
         body_json = (
             body.model_dump(exclude_unset=True, exclude=exclude)
-            if isinstance(body, BaseModel)
+            if isinstance(body, pydantic.BaseModel)
             else body
         )
         new_body = {}
@@ -530,7 +521,7 @@ class ColumnsMixin:
 
     def _generate_jsonforms_schema(
         self,
-        schema: type[BaseModel],
+        schema: type[pydantic.BaseModel],
         info_columns: list[ColumnInfo | ColumnEnumInfo | ColumnRelationInfo],
         use_enum: bool
         | typing.Callable[[ColumnInfo | ColumnEnumInfo | ColumnRelationInfo], bool]

{fastapi_rtk-2.3.2 → fastapi_rtk-2.3.3}/fastapi_rtk/api/model_rest_api/_delete_mixin.py

@@ -6,35 +6,20 @@ implementation, ``pre_delete`` and ``post_delete`` hooks.
 import typing
 
 import fastapi
-from fastapi import HTTPException
 
-from ...backends.sqla.filters import BaseFilter, BaseOprFilter
-from ...backends.sqla.interface import SQLAInterface
 from ...backends.sqla.model import Model
 from ...backends.sqla.session import SQLASession
-from ...const import AVAILABLE_ROUTES, ErrorCode
+from ...const import ErrorCode
 from ...decorators import expose, permission_name, priority, protect
 from ...schemas import GeneralResponse
 from ...utils import AsyncTaskRunner, SelfDepends, SelfType, smart_run
 from ._params import PARAM_ID_SESSION
+from ._typed_base import _TypedModelRestApi
 
 
-class DeleteMixin:
+class DeleteMixin(_TypedModelRestApi):
     """Delete endpoint methods for ``ModelRestApi``."""
 
-    if typing.TYPE_CHECKING:
-        # Attributes supplied by the composed ``ModelRestApi`` class via MRO.
-        datamodel: SQLAInterface
-        expose_params: dict[AVAILABLE_ROUTES, dict[str, typing.Any]]
-        protected_routes: typing.List[AVAILABLE_ROUTES]
-        show_select_columns: list[str]
-        base_filters: (
-            typing.List[typing.Tuple[str, typing.Type[BaseFilter], typing.Any]] | None
-        )
-        base_opr_filters: (
-            typing.List[typing.Tuple[typing.Type[BaseOprFilter], typing.Any]] | None
-        )
-
     def delete(self):
         """
         Delete endpoint for the API.
@@ -85,7 +70,7 @@ class DeleteMixin:
                         },
                     )
                     if not item:
-                        raise HTTPException(
+                        raise fastapi.HTTPException(
                             fastapi.status.HTTP_404_NOT_FOUND, ErrorCode.ITEM_NOT_FOUND
                         )
                     pre_delete = await smart_run(

{fastapi_rtk-2.3.2 → fastapi_rtk-2.3.3}/fastapi_rtk/api/model_rest_api/_download_mixin.py

@@ -5,16 +5,13 @@ and the disabled ``_import_data`` upload helper.
 """
 
 import csv
-import typing
 
 import fastapi
-from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
+import fastapi.responses
+import pydantic
 
-from ...backends.sqla.interface import SQLAInterface
 from ...backends.sqla.model import Model
 from ...backends.sqla.session import SQLASession
-from ...const import AVAILABLE_ROUTES
 from ...decorators import expose, permission_name, priority, protect
 from ...exceptions import HTTPWithValidationException
 from ...lang.lazy_text import translate
@@ -27,23 +24,12 @@ from ...utils import (
     SelfType,
     smart_run,
 )
+from ._typed_base import _TypedModelRestApi
 
 
-class DownloadMixin:
+class DownloadMixin(_TypedModelRestApi):
     """Download endpoint methods for ``ModelRestApi``."""
 
-    if typing.TYPE_CHECKING:
-        # Attributes supplied by the composed ``ModelRestApi`` class via MRO.
-        datamodel: SQLAInterface
-        expose_params: dict[AVAILABLE_ROUTES, dict[str, typing.Any]]
-        protected_routes: typing.List[AVAILABLE_ROUTES]
-        resource_name: str
-        list_columns: list[str]
-        label_columns: dict[str, str]
-        list_obj_schema: typing.Type[BaseModel]
-        add_columns: list[str]
-        add_obj_schema: typing.Type[BaseModel]
-
     def download(self):
         """
         Download endpoint for the API.
@@ -116,7 +102,7 @@ class DownloadMixin:
 
             params = self._handle_query_params(q)
             params["page_size"] = 100  # Set a default page size for export
-            return StreamingResponse(
+            return fastapi.responses.StreamingResponse(
                 self._export_data(
                     self.datamodel.yield_per(session, params),
                     list_columns,
@@ -137,7 +123,7 @@ class DownloadMixin:
         data: list[Model],
         list_columns: list[str],
         label_columns: dict[str, str],
-        schema: type[BaseModel],
+        schema: type[pydantic.BaseModel],
         *,
         export_mode: CSVJSONConverter.ExportMode = "simplified",
         delimiter: str = ",",

{fastapi_rtk-2.3.2 → fastapi_rtk-2.3.3}/fastapi_rtk/api/model_rest_api/_edit_mixin.py

@@ -7,44 +7,19 @@ import typing
 
 import fastapi
 import pydantic
-from fastapi import HTTPException
-from pydantic import BaseModel
 
-from ...backends.sqla.filters import BaseFilter, BaseOprFilter
-from ...backends.sqla.interface import SQLAInterface
 from ...backends.sqla.model import Model
 from ...backends.sqla.session import SQLASession
-from ...const import AVAILABLE_ROUTES, ErrorCode
+from ...const import ErrorCode
 from ...decorators import expose, permission_name, priority, protect
-from ...schemas import BaseResponseSingle
 from ...utils import AsyncTaskRunner, SelfDepends, SelfType, smart_run
 from ._params import PARAM_BODY_SESSION
+from ._typed_base import _TypedModelRestApi
 
 
-class EditMixin:
+class EditMixin(_TypedModelRestApi):
     """Edit endpoint methods for ``ModelRestApi``."""
 
-    if typing.TYPE_CHECKING:
-        # Attributes supplied by the composed ``ModelRestApi`` class via MRO.
-        datamodel: SQLAInterface
-        expose_params: dict[AVAILABLE_ROUTES, dict[str, typing.Any]]
-        edit_return_schema: typing.Type[BaseResponseSingle]
-        edit_query_rel_fields: dict[
-            str, list[tuple[str, typing.Type[BaseFilter], typing.Any]]
-        ]
-        edit_schema_extra_fields: dict[
-            str, type | tuple[type, pydantic.fields.FieldInfo]
-        ]
-        edit_schema: typing.Type[BaseModel]
-        show_select_columns: list[str]
-        base_filters: (
-            typing.List[typing.Tuple[str, typing.Type[BaseFilter], typing.Any]] | None
-        )
-        base_opr_filters: (
-            typing.List[typing.Tuple[typing.Type[BaseOprFilter], typing.Any]] | None
-        )
-        protected_routes: typing.List[AVAILABLE_ROUTES]
-
     def put(self):
         """
         Put endpoint for the API.
@@ -64,7 +39,7 @@ class EditMixin:
     async def put_headless(
         self,
         id=SelfType().datamodel.id_schema,
-        body: BaseModel = SelfType().edit_schema,
+        body: pydantic.BaseModel = SelfType().edit_schema,
         session: SQLASession = SelfDepends().datamodel.get_session_factory,
     ):
         """
@@ -97,7 +72,7 @@ class EditMixin:
                         },
                     )
                     if not item:
-                        raise HTTPException(
+                        raise fastapi.HTTPException(
                             fastapi.status.HTTP_404_NOT_FOUND, ErrorCode.ITEM_NOT_FOUND
                         )
                     body_json = await smart_run(