fastapi-rtk 0.2.27__py3-none-any.whl → 1.0.13__py3-none-any.whl

fastapi_rtk/utils/csv_json_converter.py

@@ -1,9 +1,14 @@
+import abc
 import csv
 import enum
+import inspect
 import json
 import typing
 
-from ..types import ExportMode
+from .run_utils import safe_call
+
+if typing.TYPE_CHECKING:
+    from ..bases import BasicModel
 
 __all__ = ["Line", "CSVJSONConverter"]
 
@@ -23,6 +28,8 @@ class CSVJSONConverter:
     A utility class for converting CSV data to JSON format and vice versa.
     """
 
+    ExportMode = typing.Literal["simplified", "detailed"]
+
     @classmethod
     def csv_to_json(
         cls,
@@ -57,7 +64,7 @@ class CSVJSONConverter:
     @classmethod
     def json_to_csv(
         cls,
-        data: dict[str, typing.Any] | list[dict[str, typing.Any]],
+        data: "dict[str, typing.Any] | list[dict[str, typing.Any]] | BasicModel | list[BasicModel]",
         /,
         *,
         list_columns: list[str],
@@ -71,8 +78,10 @@ class CSVJSONConverter:
         """
         Converts JSON data to CSV format.
 
+        - Data can also be a subclass of `BasicModel` or a list of subclasses of `BasicModel`.
+
         Args:
-            data (dict[str, Any] | list[dict[str, Any]]): The JSON data to be converted.
+            data (dict[str, typing.Any] | list[dict[str, typing.Any]] | BasicModel | list[BasicModel]): The JSON data to be converted. Can also be a subclass of `BasicModel` or a list of subclasses of `BasicModel`.
             list_columns (list[str]): The list of columns to be included in the CSV.
             label_columns (dict[str, str]): The mapping of column names to labels.
             with_header (bool, optional): Whether to include the header in the CSV. Defaults to True.
@@ -93,11 +102,11 @@ class CSVJSONConverter:
             writer.writerow(header)
             csv_data = line.read()
 
-        if isinstance(data, dict):
+        if not isinstance(data, list):
             data = [data]
 
         for item in data:
-            row = cls._json_to_csv(
+            row = cls.json_to_csv_single(
                 item,
                 list_columns=list_columns,
                 delimiter=delimiter,
@@ -110,9 +119,9 @@ class CSVJSONConverter:
         return csv_data.strip()
 
     @classmethod
-    def _json_to_csv(
+    def json_to_csv_single(
         self,
-        data: dict[str, typing.Any],
+        data: "dict[str, typing.Any] | BasicModel",
         /,
         *,
         list_columns: list[str],
@@ -123,8 +132,10 @@ class CSVJSONConverter:
         """
         Converts single JSON object to CSV format.
 
+        - Data can also be a subclass of `BasicModel`.
+
         Args:
-            data (dict[str, Any]): The JSON data to be converted.
+            data (dict[str, typing.Any] | BasicModel): The JSON data to be converted. Can also be a subclass of `BasicModel`.
             list_columns (list[str]): The list of columns to be included in the CSV.
             delimiter (str, optional): The delimiter to use in the CSV. Defaults to ",".
             relation_separator (str, optional): The separator to use for nested keys. Defaults to ".".
@@ -134,40 +145,60 @@ class CSVJSONConverter:
             str: The CSV data as a string.
         """
         csv_data: list[str] = []
+        data_pipeline = DataPipeline()
+        data_pipeline.add_processor(ColumnProcessor(relation_separator))
+        data_pipeline.add_processor(ModelProcessor())
+        data_pipeline.add_processor(
+            ListProcessor(delimiter=delimiter, export_mode=export_mode)
+        )
+        data_pipeline.add_processor(EnumProcessor())
+        data_pipeline.add_processor(FallbackProcessor())
 
         for col in list_columns:
-            sub_col = []
-            if relation_separator in col:
-                col, *sub_col = col.split(relation_separator)
-            curr_val = data.get(col, "")
-            for sub in sub_col:
-                if isinstance(curr_val, dict):
-                    curr_val = curr_val.get(sub, "")
-                else:
-                    curr_val = ""
-
-            if isinstance(curr_val, dict):
-                curr_val = curr_val.get("name_", curr_val)
-            elif isinstance(curr_val, list):
-                curr_val = [
-                    curr_val.get(
-                        "id_" if export_mode == "detailed" else "name_",
-                        json.dumps(curr_val),
-                    )
-                    for curr_val in curr_val
-                ]
-                array_separator = "," if delimiter == ";" else ";"
-                curr_val = array_separator.join(curr_val)
-            elif isinstance(curr_val, enum.Enum):
-                curr_val = curr_val.value
-            if curr_val is not None:
-                if isinstance(curr_val, dict):
-                    curr_val = json.dumps(curr_val)
-                else:
-                    curr_val = str(curr_val)
-            else:
-                curr_val = ""
-            csv_data.append(curr_val)
+            value = data_pipeline.process(data, col)
+            csv_data.append(value)
+
+        return csv_data
+
+    @classmethod
+    async def ajson_to_csv_single(
+        cls,
+        data: "dict[str, typing.Any] | BasicModel",
+        /,
+        *,
+        list_columns: list[str],
+        delimiter=",",
+        relation_separator=".",
+        export_mode: ExportMode = "simplified",
+    ):
+        """
+        Asynchronously converts single JSON object to CSV format.
+
+        - Data can also be a `BasicModel`.
+
+        Args:
+            data (dict[str, typing.Any] | BasicModel): The JSON data to be converted. Can also be a `BasicModel`.
+            list_columns (list[str]): The list of columns to be included in the CSV.
+            delimiter (str, optional): The delimiter to use in the CSV. Defaults to ",".
+            relation_separator (str, optional): The separator to use for nested keys. Defaults to ".".
+            export_mode (ExportMode, optional): Export mode (simplified or detailed). Defaults to "simplified".
+
+        Returns:
+            str: The CSV data as a string.
+        """
+        csv_data: list[str] = []
+        data_pipeline = DataPipeline()
+        data_pipeline.add_processor(AsyncColumnProcessor(relation_separator))
+        data_pipeline.add_processor(ModelProcessor())
+        data_pipeline.add_processor(
+            ListProcessor(delimiter=delimiter, export_mode=export_mode)
+        )
+        data_pipeline.add_processor(EnumProcessor())
+        data_pipeline.add_processor(FallbackProcessor())
+
+        for col in list_columns:
+            value = await data_pipeline.aprocess(data, col)
+            csv_data.append(value)
 
         return csv_data
 
@@ -224,3 +255,175 @@ class CSVJSONConverter:
                 value = value.split(list_delimiter)
                 current[parts[-1]] = [item.strip() for item in value if item.strip()]
         return result
+
+
+class DataPipeline:
+    def __init__(self):
+        self.processors = list[DataProcessor]()
+
+    def add_processor(self, processor: "DataProcessor"):
+        """
+        Adds a data processor to the pipeline.
+
+        Args:
+            processor (DataProcessor): The data processor to add.
+        """
+        self.processors.append(processor)
+
+    def process(self, data: typing.Any, col: str):
+        """
+        Processes the data through the pipeline.
+
+        Args:
+            data (typing.Any): The data to process.
+            col (str): The column to process.
+
+        Returns:
+            typing.Any: The processed data.
+        """
+        for processor in self.processors:
+            data, col, should_continue = processor.process(data, col)
+            if not should_continue:
+                break
+        return data
+
+    async def aprocess(self, data: typing.Any, col: str):
+        """
+        Asynchronously processes the data through the pipeline.
+
+        Args:
+            data (typing.Any): The data to process.
+            col (str): The column to process.
+
+        Returns:
+            typing.Any: The processed data.
+        """
+        for processor in self.processors:
+            data, col, should_continue = await safe_call(processor.process(data, col))
+            if not should_continue:
+                break
+        return data
+
+
+class DataProcessor(abc.ABC):
+    @abc.abstractmethod
+    def process(self, data: typing.Any, col: str) -> tuple[typing.Any, str, bool]:
+        """
+        Processes the data for a specific column.
+
+        Args:
+            data (typing.Any): The data to process.
+            col (str): The column to process.
+
+        Returns:
+            tuple[typing.Any, str, bool]: The processed data, the column name, and a boolean indicating whether to continue processing.
+        """
+        raise NotImplementedError()
+
+
+class ColumnProcessor(DataProcessor):
+    def __init__(self, relation_separator: str = "."):
+        super().__init__()
+        self.relation_separator = relation_separator
+
+    def process(self, data, col):
+        sub_col = []
+        if self.relation_separator in col:
+            col, *sub_col = col.split(self.relation_separator)
+        data = data.get(col, "") if isinstance(data, dict) else getattr(data, col, "")
+        for sub in sub_col:
+            data = (
+                data.get(sub, "") if isinstance(data, dict) else getattr(data, sub, "")
+            )
+        return data, col, True
+
+
+class AsyncColumnProcessor(ColumnProcessor):
+    async def process(self, data, col):
+        data, col, continue_processing = super().process(data, col)
+        if inspect.iscoroutine(data):
+            data = await data
+        return data, col, continue_processing
+
+
+class ModelProcessor(DataProcessor):
+    def __init__(self, attr="name_"):
+        super().__init__()
+        self.attr = attr
+
+    def process(self, data, col):
+        from ..bases import BasicModel
+
+        continue_processing = True
+
+        if isinstance(data, BasicModel):
+            data = getattr(data, self.attr, "")
+            continue_processing = False
+        return data, col, continue_processing
+
+
+class DictProcessor(ModelProcessor):
+    def process(self, data, col):
+        continue_processing = True
+
+        if isinstance(data, dict):
+            data = data.get(self.attr, json.dumps(data))
+            continue_processing = False
+        return data, col, continue_processing
+
+
+class ListProcessor(DataProcessor):
+    def __init__(
+        self,
+        delimiter=",",
+        export_mode: CSVJSONConverter.ExportMode = "simplified",
+        attr_detailed="id_",
+        attr_simplified="name_",
+    ):
+        super().__init__()
+        self.separator = "," if delimiter == ";" else ";"
+        self.export_mode = export_mode
+        self.model_processor = ModelProcessor(
+            attr_detailed if export_mode == "detailed" else attr_simplified
+        )
+        self.dict_processor = DictProcessor(
+            attr_detailed if export_mode == "detailed" else attr_simplified
+        )
+
+    def process(self, data, col):
+        from ..bases import BasicModel
+
+        continue_processing = True
+
+        if isinstance(data, list):
+            processed_list = []
+            for item in data:
+                if isinstance(item, dict):
+                    item_processed, _, _ = self.dict_processor.process(item, col)
+                elif isinstance(item, BasicModel):
+                    item_processed, _, _ = self.model_processor.process(item, col)
+                else:
+                    item_processed = str(item)
+                processed_list.append(item_processed)
+            data = self.separator.join(processed_list)
+            continue_processing = False
+        return data, col, continue_processing
+
+
+class EnumProcessor(DataProcessor):
+    def process(self, data, col):
+        continue_processing = True
+
+        if isinstance(data, enum.Enum):
+            data = data.value
+            continue_processing = False
+        return data, col, continue_processing
+
+
+class FallbackProcessor(DataProcessor):
+    def process(self, data, col):
+        if data is None:
+            data = ""
+        else:
+            data = str(data)
+        return data, col, False

fastapi_rtk/utils/hooks.py

@@ -0,0 +1,34 @@
+import functools
+import typing
+
+__all__ = ["hooks"]
+
+
+def hooks(
+    pre: typing.Callable[..., None] | None = None,
+    post: typing.Callable[..., None] | None = None,
+):
+    """
+    Decorator to add optional pre and post hook methods to a function.
+
+    Args:
+        pre (typing.Callable[..., None] | None): Function to run before the main function. Defaults to None.
+        post (typing.Callable[..., None] | None): Function to run after the main function. Defaults to None.
+
+    Returns:
+        typing.Callable[..., typing.Any]: The decorated function.
+    """
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            if pre:
+                pre(*args, **kwargs)
+            result = func(*args, **kwargs)
+            if post:
+                post(result, *args, **kwargs)
+            return result
+
+        return wrapper
+
+    return decorator

fastapi_rtk/utils/merge_schema.py

@@ -7,7 +7,7 @@ __all__ = ["merge_schema"]
 
 
 def merge_schema(
-    schema: pydantic.BaseModel,
+    schema: typing.Type[pydantic.BaseModel],
     fields: typing.Dict[str, tuple[type, pydantic.fields.FieldInfo]],
     only_update=False,
     name: str | None = None,
@@ -16,13 +16,13 @@ def merge_schema(
     Replace or add fields to the given schema.
 
     Args:
-        schema (BaseModel): The schema to be updated.
+        schema (typing.Type[pydantic.BaseModel]): The schema to be updated.
         fields (Dict[str, tuple[type, Field]]): The fields to be added or updated.
         only_update (bool): If True, only update the fields with the same name. Otherwise, add new fields.
         name (str, optional): The name of the new schema. If not given, the schema name will be suffixed with a random hex string. Defaults to None.
 
     Returns:
-        BaseModel: The updated schema.
+        typing.Type[pydantic.BaseModel]: The updated schema.
     """
     name = name or f"{schema.__name__}-{secrets.token_hex(3)}"
     new_fields = dict()

fastapi_rtk/utils/multiple_async_contexts.py

@@ -0,0 +1,21 @@
+import contextlib
+
+__all__ = ["multiple_async_contexts"]
+
+
+@contextlib.asynccontextmanager
+async def multiple_async_contexts(
+    contexts: list[contextlib.AbstractAsyncContextManager],
+):
+    """
+    Async context manager to enter multiple async contexts.
+
+    Args:
+        contexts (list): A list of async context managers to enter.
+
+    Yields:
+        list: A list of entered context values.
+    """
+    async with contextlib.AsyncExitStack() as stack:
+        entered = [await stack.enter_async_context(ctx) for ctx in contexts]
+        yield entered

fastapi_rtk/utils/pydantic.py

@@ -2,7 +2,7 @@ import typing
 
 import pydantic
 
-__all__ = ["generate_schema_from_typed_dict"]
+__all__ = ["generate_schema_from_typed_dict", "get_pydantic_model_field"]
 
 
 def generate_schema_from_typed_dict(typed_dict: type):
@@ -25,3 +25,48 @@ def generate_schema_from_typed_dict(typed_dict: type):
         else:
             fields[key] = (val, pydantic.Field(...))
     return pydantic.create_model(typed_dict.__name__, **fields)
+
+
+def get_pydantic_model_field(model_cls: typing.Type[pydantic.BaseModel], field: str):
+    """
+    Get the Pydantic model class for a specific field in a Pydantic model.
+
+    Also works if the field is a list of Pydantic models.
+
+    Args:
+        model_cls (typing.Type[pydantic.BaseModel]): The Pydantic model class.
+        field (str): The name of the field.
+
+    Returns:
+        typing.Type[pydantic.BaseModel] | None: The Pydantic model class for the field, or None if not found.
+    """
+    annotation = model_cls.model_fields.get(field).annotation
+    field_types = _get_list_of_singular_type(annotation)
+    return next(
+        (
+            t
+            for t in field_types
+            if isinstance(t, type) and issubclass(t, pydantic.BaseModel)
+        ),
+        None,
+    )
+
+
+def _get_list_of_singular_type(type_or_union: type) -> list[type]:
+    """
+    Recursively extract all singular (leaf) types from a typing.Union, typing.List, etc.
+
+    Args:
+        type_or_union (type): The type to analyze, which may be a generic type like Union or List.
+
+    Returns:
+        list[type]: A list of singular types extracted from the input type.
+    """
+    args = typing.get_args(type_or_union)
+    if not args:
+        # Base case: not a generic type
+        return [type_or_union]
+    result = []
+    for arg in args:
+        result.extend(_get_list_of_singular_type(arg))
+    return result

fastapi_rtk/utils/run_utils.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextvars
 import inspect
 import typing
 from concurrent.futures import ThreadPoolExecutor
@@ -16,6 +17,7 @@ __all__ = [
     "safe_call",
     "safe_call_sync",
     "run_coroutine_in_threadpool",
+    "run_function_in_threadpool",
     "call_with_valid_kwargs",
 ]
 
@@ -119,7 +121,35 @@ def run_coroutine_in_threadpool(
         T: The result of the coroutine.
     """
     with ThreadPoolExecutor(max_workers=max_workers, **kwargs) as executor:
-        future = executor.submit(asyncio.run, coro)
+        ctx = contextvars.copy_context()
+        future = executor.submit(ctx.run, asyncio.run, coro)
+        return future.result()
+
+
+def run_function_in_threadpool(
+    func: typing.Callable[P, T],
+    *args: P.args,
+    max_workers=1,
+    thread_pool_kwargs: dict[str, typing.Any] | None = None,
+    **kwargs: P.kwargs,
+) -> T:
+    """
+    Run a synchronous function in a thread pool executor.
+
+    Args:
+        func (typing.Callable[P, T]): The function to run.
+        *args (P.args): Positional arguments to be passed to the function.
+        max_workers (int, optional): The maximum number of workers in the thread pool. Defaults to 1.
+        thread_pool_kwargs (dict[str, typing.Any] | None, optional): Additional keyword arguments to pass to the `ThreadPoolExecutor`. Defaults to None.
+        **kwargs (P.kwargs): Keyword arguments to be passed to the function.
+
+    Returns:
+        T: The result of the function.
+    """
+    with ThreadPoolExecutor(
+        max_workers=max_workers, **(thread_pool_kwargs or {})
+    ) as executor:
+        future = executor.submit(func, *args, **kwargs)
         return future.result()
 
 

fastapi_rtk/utils/self_dependencies.py

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

fastapi_rtk/utils/use_default_when_none.py

@@ -5,7 +5,7 @@ T = typing.TypeVar("T")
 __all__ = ["use_default_when_none"]
 
 
-def use_default_when_none(value: T, default: T) -> T:
+def use_default_when_none(value: T | None, default: T) -> T:
     """
     Returns the value if it is not None, otherwise returns the default value.
 

fastapi_rtk/version.py

@@ -1 +1,6 @@
-__version__ = "0.2.27"
+__version__ = "0.0.0"
+# Try to import the version from the generated _version.py file
+try:
+    from ._version import __version__  # noqa: F401
+except (ImportError, ModuleNotFoundError):
+    pass

fastapi_rtk-1.0.13.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: fastapi-rtk
+Version: 1.0.13
+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
+Author-email: Matthias Leinweber <m.leinweber@datatactics.de>, Agustinus Nicander Hery <a.hery@datatactics.de>
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.10
+Requires-Dist: alembic>=1.17.0
+Requires-Dist: beautifulsoup4>=4.14.2
+Requires-Dist: fastapi-babel>=1.0.0
+Requires-Dist: fastapi-users[oauth,sqlalchemy]>=14.0.1
+Requires-Dist: fastapi[standard]>=0.119.1
+Requires-Dist: jsonschema2md>=1.7.0
+Requires-Dist: marshmallow-sqlalchemy>=1.4.2
+Requires-Dist: polib>=1.2.0
+Requires-Dist: prometheus-fastapi-instrumentator>=7.1.0
+Requires-Dist: secweb>=1.25.2
+Requires-Dist: sqlalchemy-utils>=0.42.0
+Requires-Dist: uvicorn==0.38.0