fastapi-rtk 1.0.6__tar.gz → 1.0.7__tar.gz

{fastapi_rtk-1.0.6 → fastapi_rtk-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-rtk
-Version: 1.0.6
+Version: 1.0.7
 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-1.0.7/fastapi_rtk/_version.py

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

{fastapi_rtk-1.0.6 → fastapi_rtk-1.0.7}/fastapi_rtk/api/model_rest_api.py

@@ -1,5 +1,4 @@
 import asyncio
-import copy
 import csv
 import enum
 import re
@@ -256,9 +255,7 @@ class ModelRestApi(BaseApi):
 
     Example:
     ```python
-    opr_filters = [
-        [FilterEqualOnNameAndAge],
-    ]
+    opr_filters = [FilterEqualOnNameAndAge]
     ```
     """
     label_columns = lazy(lambda: dict[str, str]())
@@ -2591,12 +2588,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
@@ -2621,7 +2624,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):
@@ -2688,9 +2691,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,

{fastapi_rtk-1.0.6 → fastapi_rtk-1.0.7}/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

{fastapi_rtk-1.0.6 → fastapi_rtk-1.0.7}/fastapi_rtk/backends/sqla/model.py

@@ -125,16 +125,18 @@ class Model(sqlalchemy.ext.asyncio.AsyncAttrs, BasicModel, DeclarativeBase):
     def get_pk_attrs(cls):
         return [col.name for col in cls.__mapper__.primary_key]
 
-    async def load(self, cols: list[str] | str):
+    async def load(self, *cols: list[str] | str):
         """
-        Asynchronously load the specified columns for the current instance.
+        Asynchronously loads the specified columns of the model instance.
 
         Args:
-            cols (list[str] | str): A list of column names to load or a single column name.
+            *cols (list[str] | str): The columns to load. Can be a list of strings or individual string arguments.
         """
+        cols = [
+            item for col in cols for item in (col if isinstance(col, list) else [col])
+        ]
+
         async with AsyncTaskRunner() as runner:
-            if isinstance(cols, str):
-                cols = [cols]
             for col in cols:
                 runner.add_task(getattr(self.awaitable_attrs, col))
 

{fastapi_rtk-1.0.6 → fastapi_rtk-1.0.7}/fastapi_rtk/bases/filter.py

@@ -51,7 +51,7 @@ class AbstractBaseOprFilter(AbstractBaseFilter[T]):
     """
 
     @abc.abstractmethod
-    def apply(self, statement, value) -> T:
+    def apply(self, statement: T, value) -> T:
         """
         Apply the filter to the given SQLAlchemy Select statement.
 

{fastapi_rtk-1.0.6 → fastapi_rtk-1.0.7}/fastapi_rtk/const.py

@@ -76,7 +76,7 @@ DEFAULT_COOKIE_NAME = "dataTactics"
 DEFAULT_BASEDIR = "app"
 DEFAULT_STATIC_FOLDER = DEFAULT_BASEDIR + "/static"
 DEFAULT_TEMPLATE_FOLDER = DEFAULT_BASEDIR + "/templates"
-DEFAULT_PROFILER_FOLDER = DEFAULT_STATIC_FOLDER + "/profiles"
+DEFAULT_PROFILER_FOLDER = DEFAULT_STATIC_FOLDER + "/profiler"
 DEFAULT_LANG_FOLDER = DEFAULT_BASEDIR + "/lang"
 DEFAULT_LANGUAGES = "en,de"
 DEFAULT_TRANSLATIONS_KEY = "translations"

{fastapi_rtk-1.0.6 → fastapi_rtk-1.0.7}/fastapi_rtk/utils/self_dependencies.py

@@ -1,6 +1,6 @@
 import fastapi
 
-__al__ = ["SelfDepends", "SelfType"]
+__all__ = ["SelfDepends", "SelfType"]
 
 
 class BaseSelf:

fastapi_rtk-1.0.6/fastapi_rtk/_version.py

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