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

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

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

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

{fastapi_rtk-1.0.5 → fastapi_rtk-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-1.0.5 → fastapi_rtk-1.0.6}/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-1.0.5 → fastapi_rtk-1.0.6}/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-1.0.5/fastapi_rtk/_version.py

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