fastapi-rtk 0.2.27__py3-none-any.whl → 1.0.13__py3-none-any.whl

fastapi_rtk/api/model_rest_api.py

@@ -15,16 +15,16 @@ from pydantic import BaseModel, ConfigDict, Field, create_model
 from sqlalchemy.ext.asyncio import AsyncSession, async_scoped_session
 from sqlalchemy.orm import Session, scoped_session
 
-from ..backends.sqla.filters import BaseFilter
+from ..backends.sqla.filters import BaseFilter, BaseOprFilter
 from ..backends.sqla.interface import SQLAInterface
 from ..backends.sqla.model import Model
-from ..bases.db import DBQueryParams
-from ..bases.session import AbstractSession
-from ..const import AVAILABLE_ROUTES, PERMISSION_PREFIX
+from ..bases import AbstractFileManager, AbstractSession, DBQueryParams
+from ..const import AVAILABLE_ROUTES, PERMISSION_PREFIX, ErrorCode
 from ..decorators import expose, permission_name, priority
 from ..dependencies import current_permissions, has_access_dependency
-from ..exceptions import raise_exception
+from ..exceptions import HTTPWithValidationException, raise_exception
 from ..globals import g
+from ..lang.lazy_text import translate
 from ..schemas import (
     PRIMARY_KEY,
     BaseResponseMany,
@@ -39,7 +39,6 @@ from ..schemas import (
     RelInfo,
 )
 from ..setting import Setting
-from ..types import ExportMode
 from ..utils import (
     AsyncTaskRunner,
     CSVJSONConverter,
@@ -171,19 +170,6 @@ class ModelRestApi(BaseApi):
     """
     The maximum page size for the related fields in add_columns, edit_columns, and search_columns properties.
     """
-    file_manager = lazy(
-        lambda self: g.file_manager.get_instance_with_subfolder(self.resource_name)
-    )
-    """
-    The file manager instance for the API. Defaults to `g.file_manager` with the subfolder set to the resource name.
-    """
-    image_manager = lazy(
-        lambda self: g.image_manager.get_instance_with_subfolder(self.resource_name)
-    )
-    """
-    The image manager instance for the API. Defaults to `g.image_manager` with the subfolder set to the resource name.
-    """
-
     routes: list[AVAILABLE_ROUTES] = lazy(
         lambda self: [
             x
@@ -219,6 +205,19 @@ class ModelRestApi(BaseApi):
     """
     The list of routes to exclude from protection. Defaults to `[]`.
     """
+    expose_params: dict[AVAILABLE_ROUTES, dict[str, Any]] = lazy(lambda: dict())
+    """
+    Additional parameters to pass to the `expose` decorator for each route. See `expose` decorator for more information.
+
+    Example:
+    ```python
+    expose_params = {
+        'image': {
+            'description': 'Custom description for image endpoint',
+        },
+    }
+    ```
+    """
     base_order: Tuple[str, Literal["asc", "desc"]] | None = None
     """
     The default order for the list endpoint. Set this to set the default order for the list endpoint.
@@ -239,6 +238,26 @@ class ModelRestApi(BaseApi):
     ]
     ```
     """
+    base_opr_filters: List[Tuple[Type[BaseOprFilter], Any]] | None = None
+    """
+    The default opr filters to apply for the following endpoints: `download`, `list`, `show`, `add`, and `edit`. Defaults to None.
+
+    Example:
+    ```python
+    base_opr_filters = [
+        [FilterEqualOnNameAndAge, "active"],
+    ]
+    ```
+    """
+    opr_filters: List[Type[BaseOprFilter]] | None = None
+    """
+    The list of opr filters to be exposed to the user. Defaults to None, which means no opr filters will be exposed.
+
+    Example:
+    ```python
+    opr_filters = [FilterEqualOnNameAndAge]
+    ```
+    """
     label_columns = lazy(lambda: dict[str, str]())
     """
     The label for each column in the list columns and show columns properties.
@@ -257,6 +276,8 @@ class ModelRestApi(BaseApi):
             {col: col for col in self.order_columns},
             type=str,
         )
+        if self.order_columns
+        else typing.Annotated[str, pydantic.AfterValidator(lambda _: None)]
     )
     """
     The enum for the order columns in the list endpoint.
@@ -412,34 +433,24 @@ class ModelRestApi(BaseApi):
         lambda self: merge_schema(
             InfoResponse,
             {
-                "add_title": (str, Field(default=self.add_title)),
-                "edit_title": (str, Field(default=self.edit_title)),
+                "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_translations": (
+                    dict,
+                    Field(default_factory=lambda: self.add_jsonforms_translations),
+                ),
+                "edit_translations": (
+                    dict,
+                    Field(default_factory=lambda: self.edit_jsonforms_translations),
+                ),
                 "add_type": (
                     typing.Literal["json"] | typing.Literal["form"],
-                    Field(
-                        default="form"
-                        if any(
-                            x
-                            in self.datamodel.get_file_column_list()
-                            + self.datamodel.get_image_column_list()
-                            for x in self.add_columns
-                        )
-                        else "json"
-                    ),
+                    Field(default="form" if self._is_form_data_add else "json"),
                 ),
                 "edit_type": (
                     typing.Literal["json"] | typing.Literal["form"],
-                    Field(
-                        default="form"
-                        if any(
-                            x
-                            in self.datamodel.get_file_column_list()
-                            + self.datamodel.get_image_column_list()
-                            for x in self.edit_columns
-                        )
-                        else "json"
-                    ),
+                    Field(default="form" if self._is_form_data_edit else "json"),
                 ),
             },
             name=f"{self.__class__.__name__}-InfoResponse",
@@ -451,6 +462,17 @@ class ModelRestApi(BaseApi):
     DO NOT MODIFY UNLESS YOU KNOW WHAT YOU ARE DOING.
     """
 
+    """
+    -------------
+     LIST
+    -------------
+    """
+
+    list_query_count_enabled = True
+    """
+    Whether to enable counting the total number of items in the list endpoint. Defaults to `True`.
+    """
+
     """
     -------------
      TITLES
@@ -458,25 +480,37 @@ class ModelRestApi(BaseApi):
     """
 
     list_title = lazy(
-        lambda self: "List " + self._prettify_name(self.datamodel.obj.__name__)
+        lambda self: translate(
+            "List {ModelName}", ModelName=self.datamodel.obj.__name__
+        ),
+        cache=False,
     )
     """
     The title for the list endpoint. If not provided, Defaults to "List {ModelName}".
     """
     show_title = lazy(
-        lambda self: "Show " + self._prettify_name(self.datamodel.obj.__name__)
+        lambda self: translate(
+            "Show {ModelName}", ModelName=self.datamodel.obj.__name__
+        ),
+        cache=False,
     )
     """
     The title for the show endpoint. If not provided, Defaults to "Show {ModelName}".
     """
     add_title = lazy(
-        lambda self: "Add " + self._prettify_name(self.datamodel.obj.__name__)
+        lambda self: translate(
+            "Add {ModelName}", ModelName=self.datamodel.obj.__name__
+        ),
+        cache=False,
     )
     """
     The title for the add endpoint. If not provided, Defaults to "Add {ModelName}".
     """
     edit_title = lazy(
-        lambda self: "Edit " + self._prettify_name(self.datamodel.obj.__name__)
+        lambda self: translate(
+            "Edit {ModelName}", ModelName=self.datamodel.obj.__name__
+        ),
+        cache=False,
     )
     """
     The title for the edit endpoint. If not provided, Defaults to "Edit {ModelName}".
@@ -531,17 +565,25 @@ class ModelRestApi(BaseApi):
     The list of columns to display in the edit endpoint. If not provided, all columns will be displayed.
     """
     search_columns = lazy(
-        lambda self: self.datamodel.get_search_column_list(
-            list_columns=self.list_columns
-        )
+        lambda self: [
+            x
+            for x in self.datamodel.get_search_column_list(
+                list_columns=self.list_columns
+            )
+            if x not in self.search_exclude_columns
+        ]
     )
     """
     The list of columns that are allowed to be filtered in the list endpoint. If not provided, all columns will be allowed.
     """
     order_columns = lazy(
-        lambda self: self.datamodel.get_order_column_list(
-            list_columns=self.list_columns
-        )
+        lambda self: [
+            x
+            for x in self.datamodel.get_order_column_list(
+                list_columns=self.list_columns
+            )
+            if x not in self.order_exclude_columns
+        ]
     )
     """
     The list of columns that can be ordered in the list endpoint. If not provided, all columns will be allowed.
@@ -573,6 +615,10 @@ class ModelRestApi(BaseApi):
     """
     The list of columns to exclude from the search columns.
     """
+    order_exclude_columns = lazy(lambda: list[str]())
+    """
+    The list of columns to exclude from the order columns.
+    """
 
     """
     -------------
@@ -619,6 +665,10 @@ class ModelRestApi(BaseApi):
     """
     The `JSONForms` uischema for the add endpoint. If not provided, it will let `JSONForms` generate the uischema.
     """
+    add_jsonforms_translations: dict[str, dict[str, str]] | None = None
+    """
+    The `JSONForms` translations for the add endpoint.
+    """
     edit_jsonforms_schema: Dict[str, Any] | None = None
     """
     The `JSONForms` schema for the edit endpoint. If not provided, Defaults to the schema generated from the `edit_columns` property.
@@ -627,6 +677,10 @@ class ModelRestApi(BaseApi):
     """
     The `JSONForms` uischema for the edit endpoint. If not provided, it will let `JSONForms` generate the uischema.
     """
+    edit_jsonforms_translations: dict[str, dict[str, str]] | None = None
+    """
+    The `JSONForms` translations for the edit endpoint.
+    """
 
     """
     -------------
@@ -667,6 +721,7 @@ class ModelRestApi(BaseApi):
             with_name=False,
             name=f"{self.__class__.__name__}-AddObjSchema",
             hide_sensitive_columns=False,
+            is_form_data=self._is_form_data_add,
         )
     )
     """
@@ -682,6 +737,7 @@ class ModelRestApi(BaseApi):
             optional=True,
             name=f"{self.__class__.__name__}-EditObjSchema",
             hide_sensitive_columns=False,
+            is_form_data=self._is_form_data_edit,
         )
     )
     """
@@ -707,12 +763,7 @@ class ModelRestApi(BaseApi):
                 name=f"{self.__class__.__name__}-AddSchema",
             ),
             fastapi.Form(media_type="multipart/form-data")
-            if any(
-                x
-                in self.datamodel.get_file_column_list()
-                + self.datamodel.get_image_column_list()
-                for x in self.add_columns
-            )
+            if self._is_form_data_add
             else None,
         ]
     )
@@ -733,12 +784,7 @@ class ModelRestApi(BaseApi):
                 name=f"{self.__class__.__name__}-EditSchema",
             ),
             fastapi.Form(media_type="multipart/form-data")
-            if any(
-                x
-                in self.datamodel.get_file_column_list()
-                + self.datamodel.get_image_column_list()
-                for x in self.edit_columns
-            )
+            if self._is_form_data_edit
             else None,
         ]
     )
@@ -852,6 +898,32 @@ class ModelRestApi(BaseApi):
     """
     A flag to indicate if the default info schema is used.
 
+    DO NOT MODIFY.
+    """
+    _is_form_data_add = lazy(
+        lambda self: any(
+            x
+            in self.datamodel.get_file_column_list()
+            + self.datamodel.get_image_column_list()
+            for x in self.add_columns
+        )
+    )
+    """
+    A flag to indicate if the add endpoint is using form data.
+
+    DO NOT MODIFY.
+    """
+    _is_form_data_edit = lazy(
+        lambda self: any(
+            x
+            in self.datamodel.get_file_column_list()
+            + self.datamodel.get_image_column_list()
+            for x in self.edit_columns
+        )
+    )
+    """
+    A flag to indicate if the edit endpoint is using form data.
+
     DO NOT MODIFY.
     """
 
@@ -916,6 +988,14 @@ class ModelRestApi(BaseApi):
         # Instantiate all the filters
         if self.base_filters:
             self.base_filters = self._init_filters(self.datamodel, self.base_filters)
+        if self.base_opr_filters:
+            self.base_opr_filters = self._init_filters(
+                self.datamodel, [["", *x] for x in self.base_opr_filters]
+            )
+            self.base_opr_filters = [x[1:] for x in self.base_opr_filters]
+        if self.opr_filters:
+            self.opr_filters = [x(self.datamodel) for x in self.opr_filters]
+            self.datamodel.opr_filters = self.opr_filters
 
         field_keys = [
             "add_query_rel_fields",
@@ -961,6 +1041,28 @@ class ModelRestApi(BaseApi):
         """
         return current_permissions(self)
 
+    def get_q_and_session_count_factory(self):
+        """
+        Returns a dependency that yields a tuple of (QuerySchema, session or None).
+
+        If `list_query_count_enabled` is False or `q.with_count` is False, the session will be None.
+
+        Returns:
+            Callable[..., Coroutine[Any, Any, Tuple[QuerySchema, AsyncSession | Session | None]]]: The dependency that yields the tuple.
+        """
+        session_factory = self.datamodel.get_session_factory()
+
+        async def dependency(q: self.query_schema = Depends()):  # type: ignore
+            q: QuerySchema = q
+            if not self.list_query_count_enabled or not q.with_count:
+                yield q, None
+                return
+
+            async for session in session_factory():
+                yield q, session
+
+        return dependency
+
     """
     -------------
      ROUTES
@@ -981,12 +1083,15 @@ class ModelRestApi(BaseApi):
         expose(
             "/_image/{filename}",
             methods=["GET"],
-            name="Get Image",
-            description="Get an image from the application.",
-            response_class=FileResponse,
-            dependencies=[Depends(has_access_dependency(self, "image"))]
-            if "image" in self.protected_routes
-            else None,
+            **{
+                "name": "Get Image",
+                "description": f"Get an image associated with an existing {self.datamodel.obj.__name__} item.",
+                "response_class": FileResponse,
+                "dependencies": [Depends(has_access_dependency(self, "image"))]
+                if "image" in self.protected_routes
+                else None,
+                **self.expose_params.get("image", {}),
+            },
         )(self.image_headless)
 
     def file(self):
@@ -1003,12 +1108,15 @@ class ModelRestApi(BaseApi):
         expose(
             "/_file/{filename}",
             methods=["GET"],
-            name="Get File",
-            description="Get a file from the application.",
-            response_class=FileResponse,
-            dependencies=[Depends(has_access_dependency(self, "file"))]
-            if "file" in self.protected_routes
-            else None,
+            **{
+                "name": "Get File",
+                "description": f"Get a file associated with an existing {self.datamodel.obj.__name__} item.",
+                "response_class": FileResponse,
+                "dependencies": [Depends(has_access_dependency(self, "file"))]
+                if "file" in self.protected_routes
+                else None,
+                **self.expose_params.get("file", {}),
+            },
         )(self.file_headless)
 
     def info(self):
@@ -1020,12 +1128,15 @@ class ModelRestApi(BaseApi):
         expose(
             "/_info",
             methods=["GET"],
-            name="Get Info",
-            description="Get the info for this API's Model.",
-            response_model=self.info_return_schema | typing.Any,
-            dependencies=[Depends(has_access_dependency(self, "info"))]
-            if "info" in self.protected_routes
-            else None,
+            **{
+                "name": "Get Info",
+                "description": f"Get metadata information about the model {self.datamodel.obj.__name__}. such as add/edit columns, filter options, titles, and JSONForms schemas.",
+                "response_model": self.info_return_schema | typing.Any,
+                "dependencies": [Depends(has_access_dependency(self, "info"))]
+                if "info" in self.protected_routes
+                else None,
+                **self.expose_params.get("info", {}),
+            },
         )(self.info_headless)
 
     def download(self):
@@ -1037,11 +1148,14 @@ class ModelRestApi(BaseApi):
         expose(
             "/download",
             methods=["GET"],
-            name="Download",
-            description="Download list of items in CSV format.",
-            dependencies=[Depends(has_access_dependency(self, "download"))]
-            if "download" in self.protected_routes
-            else None,
+            **{
+                "name": "Download",
+                "description": f"Download list of {self.datamodel.obj.__name__} items as a CSV file with support for filtering, ordering, and global search.",
+                "dependencies": [Depends(has_access_dependency(self, "download"))]
+                if "download" in self.protected_routes
+                else None,
+                **self.expose_params.get("download", {}),
+            },
         )(self.download_headless)
 
     #! Disabled until further notice
@@ -1068,11 +1182,14 @@ class ModelRestApi(BaseApi):
         expose(
             "/bulk/{handler}",
             methods=["POST"],
-            name="Bulk",
-            description="Handle bulk operations.",
-            dependencies=[Depends(has_access_dependency(self, "bulk"))]
-            if "bulk" in self.protected_routes
-            else None,
+            **{
+                "name": "Bulk",
+                "description": f"Handle bulk operations for the model {self.datamodel.obj.__name__} that are set in the API.",
+                "dependencies": [Depends(has_access_dependency(self, "bulk"))]
+                if "bulk" in self.protected_routes
+                else None,
+                **self.expose_params.get("bulk", {}),
+            },
         )(self.bulk_headless)
 
     def get_list(self):
@@ -1084,12 +1201,15 @@ class ModelRestApi(BaseApi):
         expose(
             "/",
             methods=["GET"],
-            name="Get items",
-            description="Get a list of items.",
-            response_model=self.list_return_schema | typing.Any,
-            dependencies=[Depends(has_access_dependency(self, "get"))]
-            if "get_list" in self.protected_routes
-            else None,
+            **{
+                "name": "Get items",
+                "description": f"Get a list of {self.datamodel.obj.__name__} items with support for column selection, filtering, ordering, pagination, and global search.",
+                "response_model": self.list_return_schema | typing.Any,
+                "dependencies": [Depends(has_access_dependency(self, "get"))]
+                if "get_list" in self.protected_routes
+                else None,
+                **self.expose_params.get("get_list", {}),
+            },
         )(self.get_list_headless)
 
     def get(self):
@@ -1101,12 +1221,15 @@ class ModelRestApi(BaseApi):
         expose(
             "/{id}",
             methods=["GET"],
-            name="Get item",
-            description="Get a single item.",
-            response_model=self.show_return_schema | typing.Any,
-            dependencies=[Depends(has_access_dependency(self, "get"))]
-            if "get" in self.protected_routes
-            else None,
+            **{
+                "name": "Get item",
+                "description": f"Get a single {self.datamodel.obj.__name__} item.",
+                "response_model": self.show_return_schema | typing.Any,
+                "dependencies": [Depends(has_access_dependency(self, "get"))]
+                if "get" in self.protected_routes
+                else None,
+                **self.expose_params.get("get", {}),
+            },
         )(self.get_headless)
 
     def post(self):
@@ -1118,12 +1241,15 @@ class ModelRestApi(BaseApi):
         expose(
             "/",
             methods=["POST"],
-            name="Add item",
-            description="Add a new item.",
-            response_model=self.add_return_schema | typing.Any,
-            dependencies=[Depends(has_access_dependency(self, "post"))]
-            if "post" in self.protected_routes
-            else None,
+            **{
+                "name": "Add item",
+                "description": f"Add a new {self.datamodel.obj.__name__} item.",
+                "response_model": self.add_return_schema | typing.Any,
+                "dependencies": [Depends(has_access_dependency(self, "post"))]
+                if "post" in self.protected_routes
+                else None,
+                **self.expose_params.get("post", {}),
+            },
         )(self.post_headless)
 
     def put(self):
@@ -1135,12 +1261,15 @@ class ModelRestApi(BaseApi):
         expose(
             "/{id}",
             methods=["PUT"],
-            name="Update item",
-            description="Update an item.",
-            response_model=self.edit_return_schema | typing.Any,
-            dependencies=[Depends(has_access_dependency(self, "put"))]
-            if "put" in self.protected_routes
-            else None,
+            **{
+                "name": "Update item",
+                "description": f"Update an existing {self.datamodel.obj.__name__} item.",
+                "response_model": self.edit_return_schema | typing.Any,
+                "dependencies": [Depends(has_access_dependency(self, "put"))]
+                if "put" in self.protected_routes
+                else None,
+                **self.expose_params.get("put", {}),
+            },
         )(self.put_headless)
 
     def delete(self):
@@ -1152,12 +1281,15 @@ class ModelRestApi(BaseApi):
         expose(
             "/{id}",
             methods=["DELETE"],
-            response_model=GeneralResponse | typing.Any,
-            name="Delete item",
-            description="Delete an item.",
-            dependencies=[Depends(has_access_dependency(self, "delete"))]
-            if "delete" in self.protected_routes
-            else None,
+            **{
+                "name": "Delete item",
+                "description": f"Delete an existing {self.datamodel.obj.__name__} item.",
+                "response_model": GeneralResponse | typing.Any,
+                "dependencies": [Depends(has_access_dependency(self, "delete"))]
+                if "delete" in self.protected_routes
+                else None,
+                **self.expose_params.get("delete", {}),
+            },
         )(self.delete_headless)
 
     """
@@ -1177,12 +1309,12 @@ class ModelRestApi(BaseApi):
                     filename = pre_image
                 else:
                     return pre_image
-            is_image_exist = self.image_manager.file_exists(filename)
+            is_image_exist = self.datamodel.image_manager.file_exists(filename)
             if not is_image_exist:
                 raise HTTPException(
-                    status_code=404, detail=f"Image '{filename}' not found."
+                    fastapi.status.HTTP_404_NOT_FOUND, ErrorCode.IMAGE_NOT_FOUND
                 )
-            return StreamingResponse(self.image_manager.stream_file(filename))
+            return StreamingResponse(self.datamodel.image_manager.stream_file(filename))
 
     async def file_headless(self, filename: str):
         """
@@ -1195,12 +1327,12 @@ class ModelRestApi(BaseApi):
                     filename = pre_file
                 else:
                     return pre_file
-            is_file_exist = self.file_manager.file_exists(filename)
+            is_file_exist = self.datamodel.file_manager.file_exists(filename)
             if not is_file_exist:
                 raise HTTPException(
-                    status_code=404, detail=f"File '{filename}' not found."
+                    fastapi.status.HTTP_404_NOT_FOUND, ErrorCode.FILE_NOT_FOUND
                 )
-            return StreamingResponse(self.file_manager.stream_file(filename))
+            return StreamingResponse(self.datamodel.file_manager.stream_file(filename))
 
     async def info_headless(
         self,
@@ -1241,7 +1373,7 @@ class ModelRestApi(BaseApi):
         q: QuerySchema = SelfType.with_depends().query_schema,
         session: AsyncSession
         | Session = SelfDepends().datamodel.get_download_session_factory,
-        export_mode: ExportMode = "simplified",
+        export_mode: CSVJSONConverter.ExportMode = "simplified",
         delimiter: str = ",",
         quotechar: str = '"',
         label: str = "",
@@ -1253,7 +1385,7 @@ class ModelRestApi(BaseApi):
         Args:
             body (QueryBody): The query body.
             session (AsyncSession | Session): A database scoped session.
-            export_mode (str): The export mode. Can be "simplified" or "detailed". Defaults to "simplified".
+            export_mode (ExportMode): The export mode. Can be "simplified" or "detailed". Defaults to "simplified".
             delimiter (str): The delimiter for the CSV file. Defaults to ",".
             quotechar (str): Quote character for the CSV file. Defaults to '"'.
             label (str): The label for the CSV file. Defaults to the resource name.
@@ -1290,7 +1422,7 @@ class ModelRestApi(BaseApi):
 
             if check_validity:
                 await smart_run(self.datamodel.close, session)
-                return GeneralResponse(detail="OK")
+                return GeneralResponse(detail=translate("OK"))
 
             params = self._handle_query_params(q)
             params["page_size"] = 100  # Set a default page size for export
@@ -1337,7 +1469,7 @@ class ModelRestApi(BaseApi):
     #     """
     #     if not file.content_type.endswith("csv"):
     #         raise HTTPException(
-    #             status_code=400,
+    #             fastapi.status.HTTP_400_BAD_REQUEST,
     #             detail="Invalid file type. Only CSV files are allowed.",
     #         )
 
@@ -1368,11 +1500,13 @@ class ModelRestApi(BaseApi):
         async with AsyncTaskRunner():
             bulk_handler: Callable | None = getattr(self, f"bulk_{handler}", None)
             if not bulk_handler:
-                raise HTTPException(status_code=404, detail="Handler not found")
+                raise 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(status_code=404, detail=str(e))
+                raise HTTPException(fastapi.status.HTTP_404_NOT_FOUND, str(e))
 
     async def bulk_handler(
         self,
@@ -1407,19 +1541,17 @@ class ModelRestApi(BaseApi):
 
     async def get_list_headless(
         self,
-        q: QuerySchema = SelfType.with_depends().query_schema,
         session: AsyncSession | Session = SelfDepends().datamodel.get_session_factory,
-        session_count: AsyncSession
-        | Session = SelfDepends().datamodel.get_session_factory,
+        q_session_count: tuple[
+            QuerySchema, AsyncSession | Session | None
+        ] = SelfDepends().get_q_and_session_count_factory,
     ):
         """
         Retrieves all items in a headless mode.
 
         Args:
-            q (QuerySchema): The query schema.
-            query (QueryManager): The query manager object.
             session (AsyncSession | Session): A database scoped session.
-            session_count (AsyncSession | Session): A database scoped session for counting.
+            q_session_count (tuple[QuerySchema, AsyncSession | Session | None]): A tuple of query schema and a database scoped session for counting.
 
         Returns:
             list_return_schema: The list return schema.
@@ -1428,6 +1560,7 @@ class ModelRestApi(BaseApi):
             If you are overriding this method, make sure to copy all the decorators too.
         """
         async with AsyncTaskRunner():
+            q, session_count = q_session_count
             self._validate_query_parameters(q)
             params = self._handle_query_params(q)
             try:
@@ -1435,9 +1568,14 @@ class ModelRestApi(BaseApi):
                     task_items = tg.create_task(
                         smart_run(self.datamodel.get_many, session, params)
                     )
-                    task_count = tg.create_task(
-                        smart_run(self.datamodel.count, session_count, params)
-                    )
+                    if session_count:
+                        task_count = tg.create_task(
+                            smart_run(self.datamodel.count, session_count, params)
+                        )
+                    else:
+                        task_count = tg.create_task(
+                            asyncio.sleep(0, result=None)
+                        )  # Dummy task
                 items, count = await task_items, await task_count
                 pks, data = self.datamodel.convert_to_result(items)
                 schema = self.list_return_schema
@@ -1500,10 +1638,13 @@ class ModelRestApi(BaseApi):
                     "list_columns": self.show_select_columns,
                     "where_id": id,
                     "filter_classes": self.base_filters,
+                    "opr_filter_classes": self.base_opr_filters,
                 },
             )
             if not item:
-                raise HTTPException(status_code=404, detail="Item not found")
+                raise HTTPException(
+                    fastapi.status.HTTP_404_NOT_FOUND, ErrorCode.ITEM_NOT_FOUND
+                )
             pk, data = self.datamodel.convert_to_result(item)
             body = await smart_run(
                 self.show_return_schema,
@@ -1606,10 +1747,13 @@ class ModelRestApi(BaseApi):
                         "list_columns": self.show_select_columns,
                         "where_id": id,
                         "filter_classes": self.base_filters,
+                        "opr_filter_classes": self.base_opr_filters,
                     },
                 )
                 if not item:
-                    raise HTTPException(status_code=404, detail="Item not found")
+                    raise HTTPException(
+                        fastapi.status.HTTP_404_NOT_FOUND, ErrorCode.ITEM_NOT_FOUND
+                    )
                 body_json = await smart_run(
                     self._process_body,
                     session,
@@ -1681,10 +1825,13 @@ class ModelRestApi(BaseApi):
                         "list_columns": self.show_select_columns,
                         "where_id": id,
                         "filter_classes": self.base_filters,
+                        "opr_filter_classes": self.base_opr_filters,
                     },
                 )
                 if not item:
-                    raise HTTPException(status_code=404, detail="Item not found")
+                    raise HTTPException(
+                        fastapi.status.HTTP_404_NOT_FOUND, ErrorCode.ITEM_NOT_FOUND
+                    )
                 pre_delete = await smart_run(
                     self.pre_delete,
                     item,
@@ -1700,19 +1847,29 @@ class ModelRestApi(BaseApi):
                     x
                     for x in self.datamodel.get_file_column_list()
                     + self.datamodel.get_image_column_list()
-                    if getattr(item, x, None)
                 ]
+                schema = self.datamodel.generate_schema(
+                    file_and_image_columns,
+                    with_id=False,
+                    with_name=False,
+                    with_property=False,
+                )
+                schema_data = schema.model_validate(item, from_attributes=True)
                 for column in file_and_image_columns:
                     fm = (
-                        self.file_manager
+                        self.datamodel.file_manager
                         if self.datamodel.is_file(column)
-                        else self.image_manager
+                        else self.datamodel.image_manager
                     )
-                    AsyncTaskRunner.add_task(
-                        lambda fm=fm, filename=getattr(item, column): smart_run(
-                            fm.delete_file, filename
+                    filenames = getattr(schema_data, column, None) or []
+                    if not isinstance(filenames, list):
+                        filenames = [filenames]
+                    for filename in filenames:
+                        AsyncTaskRunner.add_task(
+                            lambda fm=fm, filename=filename: smart_run(
+                                fm.delete_file, filename
+                            )
                         )
-                    )
                 await smart_run(self.datamodel.delete, session, item)
             post_delete = await smart_run(
                 self.post_delete,
@@ -1724,8 +1881,7 @@ class ModelRestApi(BaseApi):
                     item = post_delete
                 else:
                     return post_delete
-            body = GeneralResponse(detail="Item deleted")
-            return body
+            return fastapi.Response(status_code=fastapi.status.HTTP_204_NO_CONTENT)
 
     """
     -------------
@@ -1942,12 +2098,12 @@ class ModelRestApi(BaseApi):
                 type = related_interface.id_schema | RelInfo
                 if optional or self.datamodel.is_nullable(col):
                     type = (
-                        type
-                        | None
-                        | typing.Annotated[
+                        typing.Annotated[
                             typing.Literal["null"],
                             pydantic.AfterValidator(lambda _: None),
                         ]
+                        | type
+                        | None
                     )
                 rel_schema[col] = (
                     type,
@@ -1962,9 +2118,7 @@ class ModelRestApi(BaseApi):
                 )
                 if optional or self.datamodel.is_nullable(col):
                     type = (
-                        type
-                        | None
-                        | typing.Annotated[
+                        typing.Annotated[
                             list[str],
                             pydantic.AfterValidator(
                                 lambda value: []
@@ -1972,6 +2126,8 @@ class ModelRestApi(BaseApi):
                                 else value
                             ),
                         ]
+                        | type
+                        | None
                     )
                 related_interface = self.datamodel.get_related_interface(col)
                 rel_schema[col] = (
@@ -2203,32 +2359,52 @@ class ModelRestApi(BaseApi):
                         continue
 
                     fm = (
-                        self.file_manager
+                        self.datamodel.file_manager
                         if self.datamodel.is_file(key)
-                        else self.image_manager
+                        else self.datamodel.image_manager
                     )
 
-                    # Delete existing file or image if it is being updated
-                    if item and hasattr(item, key) and getattr(item, key):
-                        old_filename = getattr(item, key)
-                        AsyncTaskRunner.add_task(
-                            lambda fm=fm, old_filename=old_filename: smart_run(
-                                fm.delete_file, old_filename
-                            ),
-                            tags=["file"],
+                    if self.datamodel.is_files(key) or self.datamodel.is_images(key):
+                        value = [x for x in value if x]  # Remove None values
+                        old_filenames = (
+                            [x for x in value if isinstance(x, str)] if value else []
                         )
+                        if item and hasattr(item, key) and getattr(item, key):
+                            actual_old_filenames = getattr(item, key)
+                            # Delete only the files or images that are not in the new old_filenames
+                            for filename in actual_old_filenames:
+                                if filename not in old_filenames:
+                                    AsyncTaskRunner.add_task(
+                                        lambda fm=fm, old_filename=filename: smart_run(
+                                            fm.delete_file, old_filename
+                                        ),
+                                        tags=["file"],
+                                    )
+
+                        new_filenames = []
+                        # Loop through value instead of only file values so the order is maintained
+                        for file in value:
+                            if file in old_filenames:
+                                new_filenames.append(file)
+                                continue
+                            new_filenames.append(
+                                await self._process_body_file(fm, file, key)
+                            )
+                        value = new_filenames
+                    else:
+                        # Delete existing file or image if it is being updated
+                        if item and hasattr(item, key) and getattr(item, key):
+                            filename = getattr(item, key)
+                            AsyncTaskRunner.add_task(
+                                lambda fm=fm, old_filename=filename: smart_run(
+                                    fm.delete_file, old_filename
+                                ),
+                                tags=["file"],
+                            )
 
-                    # Only process if the value exists and is not None
-                    if value:
-                        new_name = fm.generate_name(value.filename)
-                        content = await value.read()
-                        AsyncTaskRunner.add_task(
-                            lambda fm=fm, content=content, new_name=new_name: smart_run(
-                                fm.save_content_to_file, content, new_name
-                            ),
-                            tags=["file"],
-                        )
-                        value = new_name
+                        # Only process if the value exists and is not None
+                        if value:
+                            value = await self._process_body_file(fm, value, key)
 
                 new_body[key] = value
                 continue
@@ -2259,8 +2435,17 @@ class ModelRestApi(BaseApi):
                 )
                 # If the length is not equal, then some items were not found
                 if len(related_items) != len(value):
-                    raise HTTPException(
-                        status_code=400, detail=f"Some items in {key} not found"
+                    raise HTTPWithValidationException(
+                        fastapi.status.HTTP_400_BAD_REQUEST,
+                        "greater_than"
+                        if len(value) < len(related_items)
+                        else "less_than",
+                        "body",
+                        key,
+                        translate(
+                            "Number of items in '{column}' does not match the number of items found.",
+                            column=key,
+                        ),
                     )
 
                 new_body[key] = related_items
@@ -2273,11 +2458,57 @@ class ModelRestApi(BaseApi):
                 params={"where_id": value, "filter_classes": filter_dict.get(key)},
             )
             if not related_item:
-                raise HTTPException(400, detail=f"{key} not found")
+                raise HTTPWithValidationException(
+                    fastapi.status.HTTP_400_BAD_REQUEST,
+                    "missing",
+                    "body",
+                    key,
+                    translate(
+                        "Could not find related item for column '{column}'", column=key
+                    ),
+                )
             new_body[key] = related_item
 
         return new_body
 
+    async def _process_body_file(
+        self, fm: AbstractFileManager, file: fastapi.UploadFile, key: str
+    ):
+        """
+        Process the file upload by saving it using the provided file manager and returning the new filename.
+
+        Args:
+            fm (AbstractFileManager): The file manager to handle file operations.
+            file (fastapi.UploadFile): The uploaded file.
+            key (str): The key of the file in the request body.
+
+        Raises:
+            HTTPWithValidationException: If the file type is not allowed.
+
+        Returns:
+            str: The new filename after saving the file.
+        """
+        new_name = fm.generate_name(file.filename)
+        if not fm.is_filename_allowed(new_name):
+            raise HTTPWithValidationException(
+                fastapi.status.HTTP_400_BAD_REQUEST,
+                "value_error",
+                "body",
+                key,
+                translate(
+                    "File type from '{filename}' is not allowed.",
+                    filename=file.filename,
+                ),
+            )
+        content = await file.read()
+        AsyncTaskRunner.add_task(
+            lambda fm=fm, content=content, new_name=new_name: smart_run(
+                fm.save_content_to_file, content, new_name
+            ),
+            tags=["file"],
+        )
+        return new_name
+
     """
     -----------------------------------------
          HELPER FUNCTIONS
@@ -2395,12 +2626,18 @@ class ModelRestApi(BaseApi):
         Returns:
             dict: The generated JSONForms schema.
         """
-        jsonforms_schema = schema.model_json_schema()
+        cache_key = f"jsonforms_schema_{schema.__name__}"
+        jsonforms_schema = self.cache.get(cache_key)
+        if not jsonforms_schema:
+            self.cache[cache_key] = jsonforms_schema = schema.model_json_schema()
 
         # Remove unused vars
         jsonforms_schema.pop("$defs", None)
 
-        for key, value in jsonforms_schema["properties"].items():
+        result = jsonforms_schema.copy()
+        result["properties"] = jsonforms_schema["properties"].copy()
+        for key, value in result["properties"].items():
+            value = value.copy()
             label = self.label_columns.get(key)
             if label:
                 value["title"] = label
@@ -2411,25 +2648,23 @@ class ModelRestApi(BaseApi):
 
             if self.datamodel.is_file(key) or self.datamodel.is_image(key):
                 value["type"] = "string"
-                value["contentMediaType"] = (
-                    ", ".join(
-                        [
-                            f"application/{ext}"
-                            for ext in self.file_manager.allowed_extensions
-                        ]
-                    )
-                    if self.file_manager.allowed_extensions
-                    else ""
-                    if self.datamodel.is_file(key)
-                    else ", ".join(
-                        [
-                            f"image/{ext}"
-                            for ext in self.image_manager.allowed_extensions
-                        ]
+                allowed_extensions = self.datamodel.list_columns[
+                    key
+                ].type.allowed_extensions
+                if allowed_extensions is None:
+                    allowed_extensions = (
+                        "" if self.datamodel.is_file(key) else "image/*"
                     )
-                    if self.image_manager.allowed_extensions
-                    else "image/*"
-                )
+                else:
+                    prefix = "application" if self.datamodel.is_file(key) else "image"
+                    allowed_extensions = [
+                        f"{prefix}/{ext}" for ext in allowed_extensions
+                    ]
+                value["contentMediaType"] = ", ".join(allowed_extensions)
+                if self.datamodel.is_files(key) or self.datamodel.is_images(key):
+                    current_value = value.copy()
+                    value["type"] = "array"
+                    value["items"] = current_value
             elif self.datamodel.is_boolean(key):
                 value["type"] = "boolean"
             elif self.datamodel.is_integer(key):
@@ -2488,14 +2723,15 @@ class ModelRestApi(BaseApi):
             value.pop("anyOf", None)
             value.pop("default", None)
             value.pop("$ref", None)
+            value.pop("const", None)
 
             # Check whether the value should be a `secret`
             if key in g.sensitive_data.get(self.datamodel.obj.__name__, []):
                 value["format"] = "password"
 
-            jsonforms_schema["properties"][key] = value
+            result["properties"][key] = value
 
-        return jsonforms_schema
+        return result
 
     async def _export_data(
         self,
@@ -2504,7 +2740,7 @@ class ModelRestApi(BaseApi):
         label_columns: dict[str, str],
         schema: type[BaseModel],
         *,
-        export_mode: ExportMode = "simplified",
+        export_mode: CSVJSONConverter.ExportMode = "simplified",
         delimiter: str = ",",
         quotechar: str = '"',
     ):
@@ -2540,11 +2776,8 @@ class ModelRestApi(BaseApi):
 
         async for chunk in data:
             for item in chunk:
-                async with AsyncTaskRunner():
-                    item_model = schema.model_validate(item, from_attributes=True)
-                item_dict = item_model.model_dump(mode="json")
-                row = CSVJSONConverter._json_to_csv(
-                    item_dict,
+                row = await CSVJSONConverter.ajson_to_csv_single(
+                    item,
                     list_columns=list_columns,
                     delimiter=delimiter,
                     export_mode=export_mode,
@@ -2604,9 +2837,17 @@ class ModelRestApi(BaseApi):
                             },
                         )
                         if len(items) != len(item):
-                            raise HTTPException(
-                                status_code=400,
-                                detail=f"Length of {col} does not match the number of items found.",
+                            raise HTTPWithValidationException(
+                                fastapi.status.HTTP_400_BAD_REQUEST,
+                                "greater_than"
+                                if len(item) < len(items)
+                                else "less_than",
+                                "body",
+                                col,
+                                translate(
+                                    "Number of items in '{column}' does not match the number of items found.",
+                                    column=col,
+                                ),
                             )
                         item = items
                         continue
@@ -2659,14 +2900,26 @@ class ModelRestApi(BaseApi):
         Raises:
             HTTPException: If any of the filters or columns are invalid.
         """
-        for filter in q.filters:
+        for index, col in enumerate(q.columns):
+            if col not in self.list_select_columns:
+                raise HTTPWithValidationException(
+                    fastapi.status.HTTP_400_BAD_REQUEST,
+                    "invalid_key",
+                    "query",
+                    f"columns[{index}]",
+                    translate("Invalid column: {column}", column=col),
+                    input=q.columns,
+                )
+        for index, filter in enumerate(q.filters):
             if filter.col not in self.search_columns:
-                raise HTTPException(
-                    status_code=400, detail=f"Invalid filter: {filter.col}"
+                raise HTTPWithValidationException(
+                    fastapi.status.HTTP_400_BAD_REQUEST,
+                    "invalid_key",
+                    "query",
+                    f"filters[{index}]",
+                    translate("Invalid filter: {column}", column=filter.col),
+                    input=filter,
                 )
-        for col in q.columns:
-            if col not in self.list_select_columns:
-                raise HTTPException(status_code=400, detail=f"Invalid column: {col}")
 
     def _handle_query_params(self, q: QuerySchema):
         """
@@ -2690,6 +2943,8 @@ class ModelRestApi(BaseApi):
             order_direction=q.order_direction or base_order_direction,
             filters=q.filters,
             filter_classes=self.base_filters,
+            opr_filters=q.opr_filters,
+            opr_filter_classes=self.base_opr_filters,
             global_filter=(self.list_columns, q.global_filter)
             if q.global_filter
             else None,