fastapi-rtk 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

fastapi_rtk/_version.py

@@ -1 +1 @@
-__version__ = "1.0.4"
+__version__ = "1.0.6"

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,19 @@ 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 load the specified columns for the current instance.
+
+        Args:
+            cols (list[str] | str): A list of column names to load or a single column name.
+        """
+        async with AsyncTaskRunner() as runner:
+            if isinstance(cols, str):
+                cols = [cols]
+            for col in cols:
+                runner.add_task(getattr(self.awaitable_attrs, col))
+
 
 class Table(SA_Table):
     """

fastapi_rtk/utils/async_task_runner.py

@@ -2,12 +2,15 @@ import asyncio
 import contextvars
 import functools
 import inspect
+import traceback as tb
 import typing
 
 from .prettify_dict import prettify_dict
 
 __all__ = ["AsyncTaskRunner"]
 
+T = typing.TypeVar("T")
+
 
 class CallerInfo(typing.TypedDict):
     """
@@ -35,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.
 
@@ -63,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:
@@ -143,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(
@@ -170,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(
@@ -214,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(
@@ -233,9 +320,11 @@ class AsyncTaskRunner:
                                     f'Task {index + 1}': {
                                         'message': str(exc),
                                         'caller': exc.caller,
-                                        'traceback': exc.original_exception.__traceback__,
+                                        'traceback': ''.join(
+                                            tb.format_exception(exc.original_exception)
+                                        ),
                                     }
-                                    for index, exc in enumerate(exceptions)
+                                    for exc, index in exceptions_with_index
                                 },
                             }
                         )

{fastapi_rtk-1.0.4.dist-info → fastapi_rtk-1.0.6.dist-info}/METADATA

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

@@ -1,5 +1,5 @@
 fastapi_rtk/__init__.py,sha256=acLIihNMCZI3prFTq0cru1-k3kPjSZb2hhcqNrW7xJo,6203
-fastapi_rtk/_version.py,sha256=acuR_XSJzp4OrQ5T8-Ac5gYe48mUwObuwjRmisFmZ7k,22
+fastapi_rtk/_version.py,sha256=mqMuQB3aqJVPrHHqJMLjqiMKUiJjozc7EPLcX5DpKHg,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
@@ -48,8 +48,8 @@ fastapi_rtk/backends/sqla/column.py,sha256=KutGcyFr3ZeHFTL8c313I4CNxosGq54neLLB7
 fastapi_rtk/backends/sqla/db.py,sha256=hnE1jQFZai96IaQ7jWqAsiEK0PXnGpMgvgZIGSlPBsM,17245
 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=GqWJyb4uq7AK58_zZw5jx4BQ6xWi5thwNqr8WGfnJ6o,7099
 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
@@ -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=PNo0vdKQAUOZ3HqGzU7E232qV8V218hKB7q8_uwx2dM,12653
+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
@@ -126,8 +126,8 @@ fastapi_rtk/utils/timezone.py,sha256=62S0pPWuDFFXxV1YTFCsc4uKiSP_Ba36Fv7S3gYjfhs
 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.4.dist-info/METADATA,sha256=aikWHJ-PodEuoMt2b67pUt1bBo8LaVv4lMk6D9lBTbc,1270
-fastapi_rtk-1.0.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastapi_rtk-1.0.4.dist-info/entry_points.txt,sha256=UuTkxSVIokSlVN28TMhoxzRRUaPxlVRSH3Gsx6yip60,53
-fastapi_rtk-1.0.4.dist-info/licenses/LICENSE,sha256=NDrWi4Qwcxal3u1r2lBWGA6TVh3OeW7yMan098mQz98,1073
-fastapi_rtk-1.0.4.dist-info/RECORD,,
+fastapi_rtk-1.0.6.dist-info/METADATA,sha256=M9gJt_FXPypoq_6Q-U2L6mE9m-9Y_MZpqcorsYAy9iI,1270
+fastapi_rtk-1.0.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+fastapi_rtk-1.0.6.dist-info/entry_points.txt,sha256=UuTkxSVIokSlVN28TMhoxzRRUaPxlVRSH3Gsx6yip60,53
+fastapi_rtk-1.0.6.dist-info/licenses/LICENSE,sha256=NDrWi4Qwcxal3u1r2lBWGA6TVh3OeW7yMan098mQz98,1073
+fastapi_rtk-1.0.6.dist-info/RECORD,,

{fastapi_rtk-1.0.4.dist-info → fastapi_rtk-1.0.6.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