fastapi-rtk 0.2.60__py3-none-any.whl → 1.0.18__py3-none-any.whl

fastapi_rtk/__init__.py

@@ -156,7 +156,6 @@ __all__ = [
     "docs",
     # .dependencies
     "set_global_user",
-    "permissions",
     "current_permissions",
     "has_access_dependency",
     # .exceptions

fastapi_rtk/_version.py

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

fastapi_rtk/api/model_rest_api.py

@@ -1,5 +1,4 @@
 import asyncio
-import copy
 import csv
 import enum
 import re
@@ -206,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.
@@ -243,9 +255,7 @@ class ModelRestApi(BaseApi):
 
     Example:
     ```python
-    opr_filters = [
-        [FilterEqualOnNameAndAge],
-    ]
+    opr_filters = [FilterEqualOnNameAndAge]
     ```
     """
     label_columns = lazy(lambda: dict[str, str]())
@@ -266,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.
@@ -450,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
@@ -542,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.
@@ -584,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.
+    """
 
     """
     -------------
@@ -1006,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.
+        """
+
+        async def dependency(
+            q: self.query_schema = Depends(),  # type: ignore
+            session=Depends(self.datamodel.get_session_factory()),
+        ):
+            q: QuerySchema = q
+            if not self.list_query_count_enabled or not q.with_count:
+                # TODO: Find a better way to not request session count when not needed
+                return q, None
+            return q, session
+
+        return dependency
+
     """
     -------------
      ROUTES
@@ -1026,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):
@@ -1048,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):
@@ -1065,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):
@@ -1082,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
@@ -1113,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):
@@ -1129,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):
@@ -1146,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):
@@ -1163,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):
@@ -1180,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):
@@ -1197,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)
 
     """
@@ -1454,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.
@@ -1475,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:
@@ -1482,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
@@ -2274,6 +2365,7 @@ class ModelRestApi(BaseApi):
                     )
 
                     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 []
                         )
@@ -2534,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
@@ -2564,7 +2662,7 @@ class ModelRestApi(BaseApi):
                     ]
                 value["contentMediaType"] = ", ".join(allowed_extensions)
                 if self.datamodel.is_files(key) or self.datamodel.is_images(key):
-                    current_value = copy.deepcopy(value)
+                    current_value = value.copy()
                     value["type"] = "array"
                     value["items"] = current_value
             elif self.datamodel.is_boolean(key):
@@ -2631,9 +2729,9 @@ class ModelRestApi(BaseApi):
             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,
@@ -2678,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,

fastapi_rtk/auth/auth.py

@@ -142,15 +142,6 @@ class Authenticator(BaseAuthenticator):
         except HTTPException as e:
             if not default_to_none:
                 raise e
-
-        # Retrieve list of apis, that user has access to
-        if user:
-            user.permissions = []
-            for role in user.roles:
-                for permission_api in role.permissions:
-                    user.permissions.append(permission_api.api.name)
-            user.permissions = list(set(user.permissions))
-
         return user, token
 
 

fastapi_rtk/backends/sqla/db.py

@@ -34,6 +34,7 @@ LOAD_TYPE_MAPPING = {
 
 class LoadColumn(typing.TypedDict):
     statement: Select[tuple[T]] | _AbstractLoad
+    statement_type: typing.Literal["select", "joinedload", "selectinload"] | None
     type: typing.Literal["defer", "some", "all"]
     columns: list[str]
     related_columns: collections.defaultdict[str, "LoadColumn"]
@@ -42,6 +43,7 @@ class LoadColumn(typing.TypedDict):
 def create_load_column(statement: Select[tuple[T]] | _AbstractLoad | None = None):
     return LoadColumn(
         statement=statement,
+        statement_type=None,
         type="defer",
         columns=[],
         related_columns=collections.defaultdict(create_load_column),
@@ -104,7 +106,7 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
                     statement = statement.options(cache_option)
             return statement
 
-        load_column = self._load_columns_recursively(statement, list_columns)
+        load_column = self._load_columns_recursively(statement, "select", list_columns)
         logger.debug(f"Load Column:\n{prettify_dict(load_column)}")
         return self._load_columns_from_dictionary(statement, load_column, list_columns)
 
@@ -365,27 +367,32 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
         return statement
 
     def _load_columns_recursively(
-        self, statement: Select[tuple[T]] | _AbstractLoad, columns: list[str]
+        self,
+        statement: Select[tuple[T]] | _AbstractLoad,
+        statement_type: typing.Literal["select", "joinedload", "selectinload"],
+        columns: list[str],
     ):
         """
         Load specified columns into the given SQLAlchemy statement. This returns a dictionary that can be used with the `load_columns_from_dictionary` method.
 
         Args:
             statement (Select[tuple[T]] | _AbstractLoad): The SQLAlchemy statement to which the columns will be loaded.
+            statement_type (typing.Literal["select", "joinedload", "selectinload"]): The type of statement to use for loading.
             columns (list[str]): A list of column names to be loaded.
 
         Returns:
             dict: A dictionary that can be used with the `load_columns_from_dictionary` method.
         """
         load_column = create_load_column(statement)
+        load_column["statement_type"] = statement_type
         for col in columns:
             sub_col = ""
             if "." in col:
                 col, sub_col = col.split(".", 1)
 
-            # If it is not a relation, load only the column if it is in the user column list, else skip
+            # If it is not a relation, load only the column if it is in the column list, else skip
             if not self.datamodel.is_relation(col):
-                if col in self.datamodel.get_user_column_list():
+                if col in self.datamodel.get_column_list():
                     load_column["columns"].append(col)
                     load_column["type"] = "some"
                 continue
@@ -393,10 +400,18 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
             if self.datamodel.is_relation_one_to_one(
                 col
             ) or self.datamodel.is_relation_many_to_one(col):
+                load_column["related_columns"][col]["statement_type"] = (
+                    load_column["related_columns"][col]["statement_type"]
+                    or "joinedload"
+                )
                 load_column["related_columns"][col]["statement"] = load_column[
                     "related_columns"
                 ][col]["statement"] or joinedload(self.datamodel.obj.load_options(col))
             else:
+                load_column["related_columns"][col]["statement_type"] = (
+                    load_column["related_columns"][col]["statement_type"]
+                    or "selectinload"
+                )
                 load_column["related_columns"][col]["statement"] = load_column[
                     "related_columns"
                 ][col]["statement"] or selectinload(
@@ -410,7 +425,9 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
                 load_column["related_columns"][col] = deep_merge(
                     load_column["related_columns"][col],
                     interface.query._load_columns_recursively(
-                        load_column["related_columns"][col]["statement"], [sub_col]
+                        load_column["related_columns"][col]["statement"],
+                        load_column["related_columns"][col]["statement_type"],
+                        [sub_col],
                     ),
                     rules={
                         "type": lambda x1, x2: LOAD_TYPE_MAPPING[x2]
@@ -427,8 +444,8 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
                 load_column["related_columns"][col]["type"] = "all"
                 continue
 
-            # Skip if the sub column is not in the user column list or if it is a relation
-            if sub_col not in interface.get_user_column_list() or interface.is_relation(
+            # Skip if the sub column is not in the column list or if it is a relation
+            if sub_col not in interface.get_column_list() or interface.is_relation(
                 sub_col
             ):
                 continue
@@ -437,3 +454,11 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
             load_column["related_columns"][col]["type"] = "some"
 
         return load_column
+
+    def _convert_id_into_dict(self, id):
+        # Cast the id into the right type based on the pk column type
+        pk_dict = super()._convert_id_into_dict(id)
+        for pk in pk_dict:
+            col_type = self.datamodel.list_columns[pk].type.python_type
+            pk_dict[pk] = col_type(pk_dict[pk])
+        return pk_dict

fastapi_rtk/backends/sqla/filters.py

@@ -617,6 +617,22 @@ class SQLAFilterConverter:
                 FilterIn,
             ],
         ),
+        (
+            "is_files",
+            [
+                FilterTextContains,
+                # TODO: Make compatible filters
+                # FilterEqual,
+                # FilterNotEqual,
+                # FilterStartsWith,
+                # FilterNotStartsWith,
+                # FilterEndsWith,
+                # FilterNotEndsWith,
+                # FilterContains,
+                # FilterNotContains,
+                # FilterIn,
+            ],
+        ),
         (
             "is_integer",
             [