fastapi-rtk 1.0.5__py3-none-any.whl → 1.0.7__py3-none-any.whl

fastapi_rtk/_version.py

@@ -1 +1 @@
-__version__ = "1.0.5"
+__version__ = "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/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/backends/sqla/interface.py

@@ -7,9 +7,7 @@ from typing import Annotated, Literal, Type
 
 import fastapi
 import marshmallow_sqlalchemy
-import pydantic
 import sqlalchemy
-import sqlalchemy.exc
 from pydantic import (
     AfterValidator,
     BeforeValidator,
@@ -45,7 +43,6 @@ from ...utils import (
     lazy_import,
     lazy_self,
     safe_call,
-    safe_call_sync,
     smart_run,
 )
 from .db import SQLAQueryBuilder
@@ -682,57 +679,6 @@ class SQLAInterface(AbstractInterface[ModelType, Session | AsyncSession, Column]
 
         return result
 
-    def _generate_schema_from_dict(self, schema_dict):
-        # Allow await for deferrable columns
-        deferrable_columns = [
-            key for key in schema_dict.keys() if key in self.list_properties
-        ]
-        model_name = schema_dict.get("__name__", "UnknownModel")
-        if deferrable_columns:
-
-            async def fill_deferrable(model: Model, col: str):
-                try:
-                    return getattr(model, col)
-                except sqlalchemy.exc.MissingGreenlet:
-                    logger.warning(
-                        f"'MissingGreenlet' error when accessing {model.__class__.__name__}.{col} to create pydantic model {model_name}, trying to await it instead."
-                    )
-                    try:
-                        await getattr(model.awaitable_attrs, col)
-                    except Exception as e:
-                        return_value = (
-                            []
-                            if self.is_relation_one_to_many(col)
-                            or self.is_relation_many_to_many(col)
-                            else None
-                        )
-                        logger.error(
-                            f"Error when awaiting {model.__class__.__name__}.{col} to create pydantic model {model_name}, returning {return_value} instead: {e}"
-                        )
-                        return return_value
-                    return getattr(model, col)
-
-            async def fill_deferables(data: Model):
-                async with AsyncTaskRunner():
-                    for col in deferrable_columns:
-                        AsyncTaskRunner.add_task(
-                            lambda col=col: fill_deferrable(data, col)
-                        )
-
-            def fill_deferrables_validator(data):
-                if isinstance(data, Model):
-                    safe_call_sync(fill_deferables(data))
-                return data
-
-            decorated_func = pydantic.model_validator(mode="before")(
-                fill_deferrables_validator
-            )
-            schema_dict["__validators__"] = schema_dict.get("__validators__", {})
-            schema_dict["__validators__"][fill_deferrables_validator.__name__] = (
-                decorated_func
-            )
-        return super()._generate_schema_from_dict(schema_dict)
-
     """
     --------------------------------------------------------------------------------------------------------
         SQLA RELATED METHODS - ONLY IN SQLAInterface

fastapi_rtk/backends/sqla/model.py

@@ -13,7 +13,7 @@ from sqlalchemy.util.typing import Literal
 from ...bases.model import BasicModel
 from ...const import DEFAULT_METADATA_KEY
 from ...exceptions import FastAPIReactToolkitException
-from ...utils import smart_run_sync
+from ...utils import AsyncTaskRunner, smart_run_sync
 
 __all__ = ["Model", "metadata", "metadatas", "Base"]
 
@@ -125,6 +125,21 @@ 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):
+        """
+        Asynchronously loads the specified columns of the model instance.
+
+        Args:
+            *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:
+            for col in cols:
+                runner.add_task(getattr(self.awaitable_attrs, col))
+
 
 class Table(SA_Table):
     """

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/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/utils/async_task_runner.py

@@ -9,6 +9,8 @@ from .prettify_dict import prettify_dict
 
 __all__ = ["AsyncTaskRunner"]
 
+T = typing.TypeVar("T")
+
 
 class CallerInfo(typing.TypedDict):
     """
@@ -36,26 +38,37 @@ class AsyncTaskException(AsyncTaskRunnerException):
         self.caller = caller
 
 
-def wrap_in_async_task_exception(
-    task: typing.Callable[[], typing.Coroutine | None] | typing.Coroutine,
-    /,
-    caller: CallerInfo | None = None,
-):
-    async def wrapper():
-        try:
-            tsk = task
-            if callable(tsk):
-                tsk = tsk()
-            if tsk is None:
-                return None
-            return await tsk
-        except Exception as e:
-            raise AsyncTaskException(str(e), original_exception=e, caller=caller) from e
+class ResultAccessor(typing.Generic[T]):
+    """Helper class that can be awaited OR accessed directly."""
+
+    def __init__(self, task: "AsyncTask[T]"):
+        self._task = task
+
+    def __await__(self):
+        """Allow awaiting: await task.result"""
+        return self._task.__await__()
+
+    def __repr__(self) -> str:
+        """Direct access without await - returns value or raises error."""
+        return repr(self._ensure_result())
 
-    return wrapper
+    def __str__(self) -> str:
+        """Direct access without await - returns value or raises error."""
+        return str(self._ensure_result())
 
+    # Make it behave like the actual value when accessed
+    def __getattr__(self, name):
+        return getattr(self._ensure_result(), name)
 
-class AsyncTask:
+    def _ensure_result(self):
+        if not hasattr(self._task, "_result"):
+            raise RuntimeError(
+                "Task has not been executed yet. Await the task to get the result."
+            )
+        return self._task._result
+
+
+class AsyncTask(typing.Generic[T]):
     """
     Represents a task to be run asynchronously.
 
@@ -64,19 +77,51 @@ class AsyncTask:
 
     def __init__(
         self,
-        task: typing.Callable[[], typing.Coroutine | None] | typing.Coroutine,
+        task: typing.Callable[..., typing.Awaitable[T]] | typing.Awaitable[T],
         /,
         caller: CallerInfo | None = None,
         tags: list[str] | None = None,
     ):
-        self.task = wrap_in_async_task_exception(task, caller=caller)
+        self.task = task
         self.caller = caller
         self.tags = tags or []
 
+    @property
+    def result(self):
+        """
+        Provides access to the result of the task.
+
+        Returns:
+            ResultAccessor[T]: An accessor that can be awaited or accessed directly.
+        """
+        return ResultAccessor(self)
+
     def __call__(self):
-        if callable(self.task):
-            return self.task()
-        return self.task
+        return self._run()
+
+    def __await__(self):
+        return self._run().__await__()
+
+    async def _run(self):
+        """
+        Runs the task and caches the result.
+
+        Returns:
+            T: The result of the task.
+        """
+        if hasattr(self, "_result"):
+            return self._result
+
+        try:
+            coro = self.task
+            if callable(coro):
+                coro = coro()
+            self._result = await coro
+            return self._result
+        except Exception as e:
+            raise AsyncTaskException(
+                str(e), original_exception=e, caller=self.caller
+            ) from e
 
 
 class AsyncTaskRunner:
@@ -144,19 +189,59 @@ class AsyncTaskRunner:
         """
         self.run_tasks_even_if_exception = run_tasks_even_if_exception
 
+    @typing.overload
     @classmethod
     def add_task(
         cls,
-        *tasks: typing.Callable[[], typing.Coroutine | None] | typing.Coroutine,
+        task: typing.Callable[..., typing.Awaitable[T]]
+        | typing.Awaitable[T]
+        | AsyncTask[T],
+        *,
+        tags: list[str] | None = None,
+        instance: "AsyncTaskRunner | None" = None,
+    ) -> AsyncTask[T]: ...
+
+    @typing.overload
+    @classmethod
+    def add_task(
+        cls,
+        task1: typing.Callable[..., typing.Awaitable[T]]
+        | typing.Awaitable[T]
+        | AsyncTask[T],
+        task2: typing.Callable[..., typing.Awaitable[T]]
+        | typing.Awaitable[T]
+        | AsyncTask[T],
+        *tasks: typing.Callable[..., typing.Awaitable[T]]
+        | typing.Awaitable[T]
+        | AsyncTask[T],
+        tags: list[str] | None = None,
+        instance: "AsyncTaskRunner | None" = None,
+    ) -> list[AsyncTask[T]]: ...
+    @classmethod
+    def add_task(
+        cls,
+        *tasks: typing.Callable[..., typing.Awaitable[T]]
+        | typing.Awaitable[T]
+        | AsyncTask[T],
         tags: list[str] | None = None,
         instance: "AsyncTaskRunner | None" = None,
     ):
+        """
+        Adds one or more tasks to the current context's task list. The tasks will be executed when exiting the context.
+
+        Args:
+            tags (list[str] | None, optional): Tags to associate with the tasks. Defaults to None.
+            instance (AsyncTaskRunner | None, optional): The AsyncTaskRunner instance to add tasks to. Defaults to None.
+
+        Returns:
+            AsyncTask[T] | list[AsyncTask[T]]: The added task(s).
+        """
         task_list = cls._get_current_task_list("add_task", instance=instance)
         # Get caller info
         frame = inspect.currentframe()
         caller = inspect.getouterframes(frame, 2)[1] if frame else None
 
-        async_tasks = [
+        async_tasks: list[AsyncTask[T]] = [
             AsyncTask(
                 task,
                 caller=CallerInfo(
@@ -171,6 +256,7 @@ class AsyncTaskRunner:
             for task in tasks
         ]
         task_list.extend(async_tasks)
+        return async_tasks if len(async_tasks) > 1 else async_tasks[0]
 
     @classmethod
     def remove_tasks_by_tag(
@@ -215,16 +301,16 @@ class AsyncTaskRunner:
             return
 
         if tasks:
-            exceptions: list[AsyncTaskException] = []
+            exceptions_with_index = list[tuple[AsyncTaskException, int]]()
             futures = await asyncio.gather(
                 *(task() for task in tasks), return_exceptions=True
             )
-            for future in futures:
+            for index, future in enumerate(futures):
                 if isinstance(future, AsyncTaskException):
                     # Handle exceptions from tasks
-                    exceptions.append(future)
+                    exceptions_with_index.append((future, index))
 
-            if exceptions:
+            if exceptions_with_index:
                 raise AsyncTaskRunnerException(
                     f"\n{
                         prettify_dict(
@@ -238,7 +324,7 @@ class AsyncTaskRunner:
                                             tb.format_exception(exc.original_exception)
                                         ),
                                     }
-                                    for index, exc in enumerate(exceptions)
+                                    for exc, index in exceptions_with_index
                                 },
                             }
                         )

fastapi_rtk/utils/self_dependencies.py

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

{fastapi_rtk-1.0.5.dist-info → fastapi_rtk-1.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-rtk
-Version: 1.0.5
+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.5.dist-info → fastapi_rtk-1.0.7.dist-info}/RECORD

@@ -1,8 +1,8 @@
 fastapi_rtk/__init__.py,sha256=acLIihNMCZI3prFTq0cru1-k3kPjSZb2hhcqNrW7xJo,6203
-fastapi_rtk/_version.py,sha256=B9kKWJLln1i8LjtkcYecvNWGLTrez4gCUOHtnPlInFo,22
+fastapi_rtk/_version.py,sha256=BW7SWRpHoxuOQZ67pS20yog2LWYl-nK7-BEFBNrHGgA,22
 fastapi_rtk/apis.py,sha256=6X_Lhl98m7lKrDRybg2Oe24pLFLJ29eCOQSwCAvpKhY,172
 fastapi_rtk/config.py,sha256=9PZF9E5i1gxmnsZEprZZKxVHSk0dFEklJSplX9NEqdo,14036
-fastapi_rtk/const.py,sha256=huvh4Zor77fgUkhU4-x6LgkOglSxeKXOlXdhnai_5CQ,4905
+fastapi_rtk/const.py,sha256=sEj_cYeerj9pVwbCu0k5Sy1EYpdr1EHzUjqqbnporgc,4905
 fastapi_rtk/db.py,sha256=nAPIibCCyaGm7Kw9updiVx5LWASkdfX01GxG5Gp12hM,24505
 fastapi_rtk/decorators.py,sha256=HqAFSiO0l5_M0idWs0IcY24FdzbAcDQDQoifM_WgZAQ,14515
 fastapi_rtk/dependencies.py,sha256=H31uMZRA0FdZZXmzIVS2j9gBAovJDYdb_5ZgmrKd9qc,6070
@@ -21,7 +21,7 @@ fastapi_rtk/types.py,sha256=-LPnTIbHvqJW81__gab3EWrhjNmznHhptz0BtXkEAHQ,3612
 fastapi_rtk/version.py,sha256=D2cmQf2LNeHOiEfcNzVOOfcAmuLvPEmGEtZv5G54D0c,195
 fastapi_rtk/api/__init__.py,sha256=MwFR7HHppnhbjZGg3sOdQ6nqy9uxnHHXvicpswNFMNA,245
 fastapi_rtk/api/base_api.py,sha256=42I9v3b25lqxNAMDGEtajA5-btIDSyUWF0xMDgGkA8c,8078
-fastapi_rtk/api/model_rest_api.py,sha256=PQwR_ya4rrzlZlHDl8lr3z7y1SH8mRbgiVRX2TrjsGk,104924
+fastapi_rtk/api/model_rest_api.py,sha256=8ztCFUSYMAn74QcVKN9lNYDOSWixsXHCpLHtc9RAShA,105175
 fastapi_rtk/auth/__init__.py,sha256=iX7O41NivBYDfdomEaqm4lUx9KD17wI4g3EFLF6kUTw,336
 fastapi_rtk/auth/auth.py,sha256=MZmuueioiMbSHjd_F3frKEqCA3yjtanRWyKOy6CnOd0,20994
 fastapi_rtk/auth/hashers/__init__.py,sha256=uBThFj2VPPSMSioxYTktNiM4-mVgtDAjTpKA3ZzWxxs,110
@@ -45,11 +45,11 @@ fastapi_rtk/backends/generic/model.py,sha256=olRvHD57CCKnZoyia7EcvecZfXjN-ku17gx
 fastapi_rtk/backends/generic/session.py,sha256=J8OJSuGcFkZiOg7SJIbkKnMUlo_njQjRJ1vNl4k8Ve4,19053
 fastapi_rtk/backends/sqla/__init__.py,sha256=p4TRI65-R6TM6G_-OAnwYV7Hk9WVkKsnhN2sFta1-cU,1795
 fastapi_rtk/backends/sqla/column.py,sha256=KutGcyFr3ZeHFTL8c313I4CNxosGq54neLLB7N53GZs,240
-fastapi_rtk/backends/sqla/db.py,sha256=hnE1jQFZai96IaQ7jWqAsiEK0PXnGpMgvgZIGSlPBsM,17245
+fastapi_rtk/backends/sqla/db.py,sha256=8VUU-S4W2WWpkROR178dj0ahCirP5CKP7fPyoz25Ui0,18135
 fastapi_rtk/backends/sqla/exceptions.py,sha256=rRtvgXyDwGSbjvJIPJIOjOBYytvNv9VXkZOBy6p2J80,61
 fastapi_rtk/backends/sqla/filters.py,sha256=H2eholy7VTfVwcBTAV0BWO6NXJYA-eDp_YvptLFKO3E,20927
-fastapi_rtk/backends/sqla/interface.py,sha256=7JQ1hK49PDd2_E8KeEiivbWot3zP7ZiZifmVI7-eYZY,30058
-fastapi_rtk/backends/sqla/model.py,sha256=dkhnVvpKAqYAqtRYl9JsARCqEqmhc6wgGy9JHj4TNdQ,6612
+fastapi_rtk/backends/sqla/interface.py,sha256=9I2JiShqmyakfgdXE-DA5TW35xdvMs_-pDDccKnX5cA,27678
+fastapi_rtk/backends/sqla/model.py,sha256=N0fxuAHbw_RCfFPRw-cjWQdBEanfogLRXOUEPqZ1Qac,7168
 fastapi_rtk/backends/sqla/session.py,sha256=di52RhRWzUchcquWMU9KKd0F1N5te1GfAtcfCnekiwI,412
 fastapi_rtk/backends/sqla/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastapi_rtk/backends/sqla/extensions/audit/__init__.py,sha256=CaVc9fV584PVazvGGMOKwX4xC3OvIae9kXBx6xQAj5g,131
@@ -61,7 +61,7 @@ fastapi_rtk/backends/sqla/extensions/geoalchemy2/geometry_converter.py,sha256=sc
 fastapi_rtk/bases/__init__.py,sha256=v3tMVuX20UbvjI_mTWpDAePWAA38e3pjlYEiICgY4j8,440
 fastapi_rtk/bases/db.py,sha256=D27BhF89J0OaLHjALDCa85eNf35lBaTz6VV7EDa4wuM,18711
 fastapi_rtk/bases/file_manager.py,sha256=d1ZZaY-OgDxjSWQ49DNQNSDHKznzr-03wki_eR2iU2A,8230
-fastapi_rtk/bases/filter.py,sha256=b9DNgW9M6pLv0eMTnaGUaYpPX1ZSloo6OCvdxGpCNNE,1837
+fastapi_rtk/bases/filter.py,sha256=XmWTcLaIcBj9pKF1PMAKdwSnZNpdT8Df3uLeUIOGUDE,1840
 fastapi_rtk/bases/interface.py,sha256=Cq9Duxa3w-tw342P424h88fc0_X1DoxCdTa3rAN-6jM,45380
 fastapi_rtk/bases/model.py,sha256=nUZf0AVs0Mzqh2u_ALiRNYN1bfOU9PzYLvEFHDQ57Y0,1692
 fastapi_rtk/bases/session.py,sha256=Q92cRW0nI5IYSsBXLkTJjK5ztMSBNRt-olMwxTIeel0,173
@@ -106,7 +106,7 @@ fastapi_rtk/security/sqla/apis.py,sha256=J3BCqSnaX-w9raTA5LHa7muW24kA09nAm9kN6b3
 fastapi_rtk/security/sqla/models.py,sha256=dwIZHNU-6b1r0M2swlYyRtSgI1e1hnvav6d6jdmffM8,8096
 fastapi_rtk/security/sqla/security_manager.py,sha256=eBXhDTjqQYySCKQXnD6wEeHBGw8oytwVvmKpi9btNYI,17371
 fastapi_rtk/utils/__init__.py,sha256=0X4BwrVDl4S3mB7DLyHaZVednefMjRIjBIDT3yv_CHM,1875
-fastapi_rtk/utils/async_task_runner.py,sha256=JYXjVPxkWH1pxXImkjlebAOcn2noEUbX-vwpBWw3WGg,12778
+fastapi_rtk/utils/async_task_runner.py,sha256=HzykQSdeAmNjZfVB5vUDVwrSCVFr8__67ACQk60pSsk,15545
 fastapi_rtk/utils/class_factory.py,sha256=jlVw8yCh-tYsMnR5Hm8fgxtL0kvXwnhe6DPJA1sUh7k,598
 fastapi_rtk/utils/csv_json_converter.py,sha256=7szrPiB7DrK5S-s2GaHVCmEP9_OXk9RFwbZmRtAKM5A,14036
 fastapi_rtk/utils/deep_merge.py,sha256=PHtKJgXfCngOBGVliX9aVlEFcwCxr-GlzU-w6vjgAIs,2426
@@ -119,15 +119,15 @@ fastapi_rtk/utils/multiple_async_contexts.py,sha256=-juAliUeG4XI1J-p31KknsJvzvM5
 fastapi_rtk/utils/prettify_dict.py,sha256=VKve-52fE9usIzflD3mNtvql_p5F2jq9HYBTJF_1MX0,662
 fastapi_rtk/utils/pydantic.py,sha256=c4TGu6fP5qmsMJcEerhgq3R1iTpJn_1oA91d43GaVlo,2408
 fastapi_rtk/utils/run_utils.py,sha256=2aieVAGp4e7vByzkwnmXk5c-crLl-Ia1rwdHl6LRQ34,6237
-fastapi_rtk/utils/self_dependencies.py,sha256=ZTpJZFFnh3MhhS5PwsgJ9TeVgcV6gwSS962c7udLzds,4101
+fastapi_rtk/utils/self_dependencies.py,sha256=SjX8BOC3UvuLxfElo1MMgugCX8ZEgsCgLy0g011a4UU,4102
 fastapi_rtk/utils/smartdefaultdict.py,sha256=UdA_N1eQ3TooE9_ci0O_5QKUjGkQfo-c2BwEX5OkXfY,645
 fastapi_rtk/utils/sqla.py,sha256=To4PhsO5orPJVqjdLh5C9y_xPgiy8-zhrJdSqhR_tsc,690
 fastapi_rtk/utils/timezone.py,sha256=62S0pPWuDFFXxV1YTFCsc4uKiSP_Ba36Fv7S3gYjfhs,570
 fastapi_rtk/utils/update_signature.py,sha256=PIzZgNpGEwvDNgQ3G51Zi-QhVV3mbxvUvSwDwf_-yYs,2209
 fastapi_rtk/utils/use_default_when_none.py,sha256=H2HqhKy_8eYk3i1xijEjuaKak0oWkMIkrdz6T7DK9QU,469
 fastapi_rtk/utils/werkzeug.py,sha256=1Gv-oyqSmhVGrmNbB9fDqpqJzPpANOzWf4zMMrhW9UA,3245
-fastapi_rtk-1.0.5.dist-info/METADATA,sha256=4qQ4mOrd3rvE3SU3590DJYKggS00IhLaCPq8DGF8ZPI,1270
-fastapi_rtk-1.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastapi_rtk-1.0.5.dist-info/entry_points.txt,sha256=UuTkxSVIokSlVN28TMhoxzRRUaPxlVRSH3Gsx6yip60,53
-fastapi_rtk-1.0.5.dist-info/licenses/LICENSE,sha256=NDrWi4Qwcxal3u1r2lBWGA6TVh3OeW7yMan098mQz98,1073
-fastapi_rtk-1.0.5.dist-info/RECORD,,
+fastapi_rtk-1.0.7.dist-info/METADATA,sha256=yuKVrabzSpcffX7GiyKHtzOgZQLY4HHwFnaVp8hP-UQ,1270
+fastapi_rtk-1.0.7.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+fastapi_rtk-1.0.7.dist-info/entry_points.txt,sha256=UuTkxSVIokSlVN28TMhoxzRRUaPxlVRSH3Gsx6yip60,53
+fastapi_rtk-1.0.7.dist-info/licenses/LICENSE,sha256=NDrWi4Qwcxal3u1r2lBWGA6TVh3OeW7yMan098mQz98,1073
+fastapi_rtk-1.0.7.dist-info/RECORD,,

{fastapi_rtk-1.0.5.dist-info → fastapi_rtk-1.0.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any