zrb 1.0.0b1__py3-none-any.whl → 1.0.0b2__py3-none-any.whl

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/base_db_repository.py

@@ -1,12 +1,17 @@
+import datetime
+from contextlib import asynccontextmanager
 from typing import Any, Callable, Generic, Type, TypeVar
 
-from my_app_name.common.error import NotFoundError
-from sqlalchemy import Engine
+import ulid
+from my_app_name.common.error import InvalidValueError, NotFoundError
+from my_app_name.common.parser_factory import parse_filter_param, parse_sort_param
+from sqlalchemy import Engine, delete, func, insert, select, update
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
-from sqlmodel import Session, SQLModel, select
+from sqlalchemy.sql import Select
+from sqlmodel import Session, SQLModel
 
 DBModel = TypeVar("DBModel", bound=SQLModel)
-ResponseModel = TypeVar("Model", bound=SQLModel)
+ResponseModel = TypeVar("ResponseModel", bound=SQLModel)
 CreateModel = TypeVar("CreateModel", bound=SQLModel)
 UpdateModel = TypeVar("UpdateModel", bound=SQLModel)
 
@@ -23,112 +28,191 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
         self.engine = engine
         self.is_async = isinstance(engine, AsyncEngine)
 
-    def _to_response(self, db_instance: DBModel) -> ResponseModel:
-        return self.response_model(**db_instance.model_dump())
+    def _select(self) -> Select:
+        return select(self.db_model)
 
-    async def create(self, data: CreateModel) -> ResponseModel:
-        data_dict = data.model_dump(exclude_unset=True)
-        for key, preprocessor in self.column_preprocessors.items():
-            if key in data_dict:
-                data_dict[key] = preprocessor(data_dict[key])
-        db_instance = self.db_model(**data_dict)
-        if self.is_async:
-            async with AsyncSession(self.engine) as session:
-                session.add(db_instance)
-                await session.commit()
-                await session.refresh(db_instance)
-        else:
-            with Session(self.engine) as session:
-                session.add(db_instance)
-                session.commit()
-                session.refresh(db_instance)
-        return self._to_response(db_instance)
+    def _rows_to_responses(self, rows: list[tuple[Any]]) -> list[ResponseModel]:
+        return [self.response_model.model_validate(row[0]) for row in rows]
 
-    async def get_by_id(self, item_id: str) -> ResponseModel:
-        if self.is_async:
-            async with AsyncSession(self.engine) as session:
-                db_instance = await session.get(self.db_model, item_id)
-        else:
-            with Session(self.engine) as session:
-                db_instance = session.get(self.db_model, item_id)
-        if not db_instance:
+    def _ensure_one(self, responses: list[ResponseModel]) -> ResponseModel:
+        if not responses:
             raise NotFoundError(f"{self.entity_name} not found")
-        return self._to_response(db_instance)
+        if len(responses) > 1:
+            raise InvalidValueError(f"Duplicate {self.entity_name}")
+        return responses[0]
 
-    async def get_all(self, page: int = 1, page_size: int = 10) -> list[ResponseModel]:
-        offset = (page - 1) * page_size
-        statement = select(self.db_model).offset(offset).limit(page_size)
+    @asynccontextmanager
+    async def _session_scope(self):
         if self.is_async:
             async with AsyncSession(self.engine) as session:
-                result = await session.execute(statement)
-                results = result.scalars().all()
+                async with session.begin():
+                    yield session
         else:
             with Session(self.engine) as session:
-                results = session.exec(statement).all()
-        return [self._to_response(instance) for instance in results]
-
-    async def update(self, item_id: str, data: UpdateModel) -> ResponseModel:
-        update_data = data.model_dump(exclude_unset=True)
-        for key, value in update_data.items():
-            if key in self.column_preprocessors:
-                update_data[key] = self.column_preprocessors[key](value)
-        if self.is_async:
-            async with AsyncSession(self.engine) as session:
-                db_instance = await session.get(self.db_model, item_id)
-                if not db_instance:
-                    raise NotFoundError(f"{self.entity_name} not found")
-                for key, value in update_data.items():
-                    setattr(db_instance, key, value)
-                session.add(db_instance)
-                await session.commit()
-                await session.refresh(db_instance)
-        else:
-            with Session(self.engine) as session:
-                db_instance = session.get(self.db_model, item_id)
-                if not db_instance:
-                    raise NotFoundError(f"{self.entity_name} not found")
-                for key, value in update_data.items():
-                    setattr(db_instance, key, value)
-                session.add(db_instance)
-                session.commit()
-                session.refresh(db_instance)
-        return self._to_response(db_instance)
-
-    async def delete(self, item_id: str) -> ResponseModel:
+                with session.begin():
+                    yield session
+
+    async def _commit(self, session: Session | AsyncSession):
         if self.is_async:
-            async with AsyncSession(self.engine) as session:
-                db_instance = await session.get(self.db_model, item_id)
-                if not db_instance:
-                    raise NotFoundError(f"{self.entity_name} not found")
-                await session.delete(db_instance)
-                await session.commit()
+            await session.commit()
         else:
-            with Session(self.engine) as session:
-                db_instance = session.get(self.db_model, item_id)
-                if not db_instance:
-                    raise NotFoundError(f"{self.entity_name} not found")
-                session.delete(db_instance)
-                session.commit()
-        return self._to_response(db_instance)
-
-    async def create_bulk(self, data_list: list[CreateModel]) -> list[ResponseModel]:
-        db_instances = []
-        for data in data_list:
-            data_dict = data.model_dump(exclude_unset=True)
-            for key, preprocessor in self.column_preprocessors.items():
-                if key in data_dict:
-                    data_dict[key] = preprocessor(data_dict[key])
-            db_instances.append(self.db_model(**data_dict))
+            session.commit()
+
+    async def _execute_statement(self, session, statement: Any) -> Any:
         if self.is_async:
-            async with AsyncSession(self.engine) as session:
-                session.add_all(db_instances)
-                await session.commit()
-                for instance in db_instances:
-                    await session.refresh(instance)
+            return await session.execute(statement)
         else:
-            with Session(self.engine) as session:
-                session.add_all(db_instances)
-                session.commit()
-                for instance in db_instances:
-                    session.refresh(instance)
-        return [self._to_response(instance) for instance in db_instances]
+            return session.execute(statement)
+
+    async def get_by_id(self, id: str) -> ResponseModel:
+        statement = self._select().where(self.db_model.id == id)
+        async with self._session_scope() as session:
+            result = await self._execute_statement(session, statement)
+            responses = self._rows_to_responses(result.all())
+            return self._ensure_one(responses)
+
+    async def get_by_ids(self, id_list: list[str]) -> list[ResponseModel]:
+        statement = self._select().where(self.db_model.id.in_(id_list))
+        async with self._session_scope() as session:
+            result = await self._execute_statement(session, statement)
+            return [
+                self.db_model(**entity.model_dump())
+                for entity in result.scalars().all()
+            ]
+
+    async def count(self, filter: str | None = None) -> int:
+        count_statement = select(func.count(1)).select_from(self.db_model)
+        if filter:
+            filter_param = parse_filter_param(self.db_model, filter)
+            count_statement = count_statement.where(*filter_param)
+        async with self._session_scope() as session:
+            result = await self._execute_statement(session, count_statement)
+            return result.scalar_one()
+
+    async def get(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        filter: str | None = None,
+        sort: str | None = None,
+    ) -> list[ResponseModel]:
+        offset = (page - 1) * page_size
+        statement = self._select().offset(offset).limit(page_size)
+        if filter:
+            filter_param = parse_filter_param(self.db_model, filter)
+            statement = statement.where(*filter_param)
+        if sort:
+            sort_param = parse_sort_param(self.db_model, sort)
+            statement = statement.order_by(*sort_param)
+        async with self._session_scope() as session:
+            result = await self._execute_statement(session, statement)
+            return [
+                self.db_model(**entity.model_dump())
+                for entity in result.scalars().all()
+            ]
+
+    def _model_to_data_dict(
+        self, data: SQLModel, **additional_data: Any
+    ) -> dict[str, Any]:
+        data_dict = data.model_dump(exclude_unset=True)
+        data_dict.update(additional_data)
+        for key, preprocessor in self.column_preprocessors.items():
+            if key not in data_dict:
+                continue
+            if not hasattr(self.db_model, key):
+                raise InvalidValueError(f"Invalid {self.entity_name} property: {key}")
+            data_dict[key] = preprocessor(data_dict[key])
+        return data_dict
+
+    async def create(self, data: CreateModel) -> DBModel:
+        now = datetime.datetime.now(datetime.timezone.utc)
+        data_dict = self._model_to_data_dict(data, created_at=now, id=ulid.new().str)
+        async with self._session_scope() as session:
+            await self._execute_statement(
+                session, insert(self.db_model).values(**data_dict)
+            )
+            statement = select(self.db_model).where(self.db_model.id == data_dict["id"])
+            result = await self._execute_statement(session, statement)
+            created_entity = result.scalar_one_or_none()
+            if created_entity is None:
+                raise NotFoundError(f"{self.entity_name} not found after creation")
+            return self.db_model(**created_entity.model_dump())
+
+    async def create_bulk(self, data_list: list[CreateModel]) -> list[DBModel]:
+        now = datetime.datetime.now(datetime.timezone.utc)
+        data_dicts = [
+            self._model_to_data_dict(data, created_at=now, id=ulid.new().str)
+            for data in data_list
+        ]
+        async with self._session_scope() as session:
+            await self._execute_statement(
+                session, insert(self.db_model).values(data_dicts)
+            )
+            id_list = [d["id"] for d in data_dicts]
+            statement = select(self.db_model).where(self.db_model.id.in_(id_list))
+            result = await self._execute_statement(session, statement)
+            return [
+                self.db_model(**entity.model_dump())
+                for entity in result.scalars().all()
+            ]
+
+    async def delete(self, id: str) -> DBModel:
+        async with self._session_scope() as session:
+            statement = select(self.db_model).where(self.db_model.id == id)
+            result = await self._execute_statement(session, statement)
+            entity = result.scalar_one_or_none()
+            if not entity:
+                raise NotFoundError(f"{self.entity_name} not found")
+            await self._execute_statement(
+                session, delete(self.db_model).where(self.db_model.id == id)
+            )
+            return self.db_model(**entity.model_dump())
+
+    async def delete_bulk(self, id_list: list[str]) -> list[DBModel]:
+        async with self._session_scope() as session:
+            statement = select(self.db_model).where(self.db_model.id.in_(id_list))
+            result = await self._execute_statement(session, statement)
+            entities = result.scalars().all()
+            await self._execute_statement(
+                session, delete(self.db_model).where(self.db_model.id.in_(id_list))
+            )
+            return [self.db_model(**entity.model_dump()) for entity in entities]
+
+    async def update(self, id: str, data: UpdateModel) -> DBModel:
+        now = datetime.datetime.now(datetime.timezone.utc)
+        update_data = self._model_to_data_dict(data, updated_at=now)
+        async with self._session_scope() as session:
+            statement = (
+                update(self.db_model)
+                .where(self.db_model.id == id)
+                .values(**update_data)
+            )
+            await self._execute_statement(session, statement)
+            result = await self._execute_statement(
+                session, select(self.db_model).where(self.db_model.id == id)
+            )
+            updated_instance = result.scalar_one_or_none()
+            if not updated_instance:
+                raise NotFoundError(f"{self.entity_name} not found")
+            return self.db_model(**updated_instance.model_dump())
+
+    async def update_bulk(self, id_list: list[str], data: UpdateModel) -> list[DBModel]:
+        now = datetime.datetime.now(datetime.timezone.utc)
+        update_data = self._model_to_data_dict(data, updated_at=now)
+        update_data = {k: v for k, v in update_data.items() if v is not None}
+        if not update_data:
+            raise InvalidValueError("No valid update data provided")
+        async with self._session_scope() as session:
+            statement = (
+                update(self.db_model)
+                .where(self.db_model.id.in_(id_list))
+                .values(**update_data)
+            )
+            await self._execute_statement(session, statement)
+            result = await self._execute_statement(
+                session, select(self.db_model).where(self.db_model.id.in_(id_list))
+            )
+            return [
+                self.db_model(**entity.model_dump())
+                for entity in result.scalars().all()
+            ]

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/base_service.py

@@ -1,13 +1,13 @@
+import inspect
 from enum import Enum
-from functools import partial, wraps
+from functools import partial
+from logging import Logger
 from typing import Any, Callable, Sequence
 
 import httpx
-from fastapi import APIRouter, params
-from fastapi.routing import APIRoute
-from fastapi.types import IncEx
-from fastapi.utils import generate_unique_id
-from starlette.responses import JSONResponse, Response
+from fastapi import APIRouter, Depends, params
+from my_app_name.common.error import ClientAPIError
+from pydantic import BaseModel
 
 
 class RouteParam:
@@ -17,62 +17,37 @@ class RouteParam:
         response_model: Any,
         status_code: int | None = None,
         tags: list[str | Enum] | None = None,
-        dependencies: Sequence[params.Depends] | None = None,
         summary: str | None = None,
         description: str = "",
-        response_description: str = "",
-        responses: dict[int | str, dict[str, Any]] | None = None,
         deprecated: bool | None = None,
         methods: set[str] | list[str] | None = None,
-        operation_id: str | None = None,
-        response_model_include: IncEx | None = None,
-        response_model_exclude: IncEx | None = None,
-        response_model_by_alias: bool = True,
-        response_model_exclude_unset: bool = False,
-        response_model_exclude_defaults: bool = False,
-        response_model_exclude_none: bool = False,
-        include_in_schema: bool = True,
-        response_class: type[Response] = Response,
-        name: str | None = None,
-        openapi_extra: dict[str, Any] | None = None,
-        generate_unique_id_function: Callable[[APIRoute], str] | None = None,
         func: Callable | None = None,
     ):
         self.path = path
         self.response_model = response_model
         self.status_code = status_code
         self.tags = tags
-        self.dependencies = dependencies
         self.summary = summary
         self.description = description
-        self.response_description = response_description
-        self.responses = responses
         self.deprecated = deprecated
         self.methods = methods
-        self.operation_id = operation_id
-        self.response_model_include = response_model_include
-        self.response_model_exclude = response_model_exclude
-        self.response_model_by_alias = response_model_by_alias
-        self.response_model_exclude_unset = response_model_exclude_unset
-        self.response_model_exclude_defaults = response_model_exclude_defaults
-        self.response_model_exclude_none = response_model_exclude_none
-        self.include_in_schema = include_in_schema
-        self.response_class = response_class
-        self.name = name
-        self.openapi_extra = openapi_extra
-        self.generate_unique_id_function = generate_unique_id_function
         self.func = func
 
 
 class BaseService:
     _route_params: dict[str, RouteParam] = {}
 
-    def __init__(self):
+    def __init__(self, logger: Logger):
+        self._logger = logger
         self._route_params: dict[str, RouteParam] = {}
         for name, method in self.__class__.__dict__.items():
             if hasattr(method, "__route_param__"):
                 self._route_params[name] = getattr(method, "__route_param__")
 
+    @property
+    def logger(self) -> Logger:
+        return self._logger
+
     @classmethod
     def route(
         cls,
@@ -84,63 +59,40 @@ class BaseService:
         dependencies: Sequence[params.Depends] | None = None,
         summary: str | None = None,
         description: str = None,
-        response_description: str = "Successful Response",
-        responses: dict[int | str, dict[str, Any]] | None = None,
         deprecated: bool | None = None,
         methods: set[str] | list[str] | None = None,
-        operation_id: str | None = None,
-        response_model_include: IncEx | None = None,
-        response_model_exclude: IncEx | None = None,
-        response_model_by_alias: bool = True,
-        response_model_exclude_unset: bool = False,
-        response_model_exclude_defaults: bool = False,
-        response_model_exclude_none: bool = False,
-        include_in_schema: bool = True,
-        response_class: type[Response] = JSONResponse,
-        name: str | None = None,
-        openapi_extra: dict[str, Any] | None = None,
-        generate_unique_id_function: Callable[[APIRoute], str] = generate_unique_id,
     ):
         """
         Decorator to register a method with its HTTP details.
         """
 
         def decorator(func: Callable):
-            @wraps(func)
-            async def wrapped(*args, **kwargs):
-                return await func(*args, **kwargs)
-
+            # Check for Depends in function parameters
+            sig = inspect.signature(func)
+            for param in sig.parameters.values():
+                if param.annotation is Depends or (
+                    hasattr(param.annotation, "__origin__")
+                    and param.annotation.__origin__ is Depends
+                ):
+                    raise ValueError(
+                        f"Depends is not allowed in function parameters. Found in {func.__name__}"  # noqa
+                    )
             # Inject __route_param__ property to the method
             # Method with __route_param__ property will automatically
             # registered to self._route_param and will be automatically exposed
             # into DirectClient and APIClient
-            wrapped.__route_param__ = RouteParam(
+            func.__route_param__ = RouteParam(
                 path=path,
                 response_model=response_model,
                 status_code=status_code,
                 tags=tags,
-                dependencies=dependencies,
                 summary=summary,
                 description=description,
-                response_description=response_description,
-                responses=responses,
                 deprecated=deprecated,
                 methods=methods,
-                operation_id=operation_id,
-                response_model_include=response_model_include,
-                response_model_exclude=response_model_exclude,
-                response_model_by_alias=response_model_by_alias,
-                response_model_exclude_unset=response_model_exclude_unset,
-                response_model_exclude_defaults=response_model_exclude_defaults,
-                response_model_exclude_none=response_model_exclude_none,
-                include_in_schema=include_in_schema,
-                response_class=response_class,
-                name=name,
-                openapi_extra=openapi_extra,
-                generate_unique_id_function=generate_unique_id_function,
                 func=func,
             )
-            return wrapped
+            return func
 
         return decorator
 
@@ -149,10 +101,10 @@ class BaseService:
         Dynamically create a direct client class.
         """
         _methods = self._route_params
-        DirectClient = create_client_class("DirectClient")
+        DirectClient = _create_client_class("DirectClient")
         for name, details in _methods.items():
             func = details.func
-            client_method = create_direct_client_method(func, self)
+            client_method = _create_direct_client_method(self._logger, func, self)
             # Use __get__ to make a bounded method,
             # ensuring that client_method use DirectClient as `self`
             setattr(DirectClient, name, client_method.__get__(DirectClient))
@@ -163,10 +115,10 @@ class BaseService:
         Dynamically create an API client class.
         """
         _methods = self._route_params
-        APIClient = create_client_class("APIClient")
+        APIClient = _create_client_class("APIClient")
         # Dynamically generate methods
         for name, param in _methods.items():
-            client_method = create_api_client_method(param, base_url)
+            client_method = _create_api_client_method(self._logger, param, base_url)
             # Use __get__ to make a bounded method,
             # ensuring that client_method use APIClient as `self`
             setattr(APIClient, name, client_method.__get__(APIClient))
@@ -186,29 +138,14 @@ class BaseService:
                 response_model=route_param.response_model,
                 status_code=route_param.status_code,
                 tags=route_param.tags,
-                dependencies=route_param.dependencies,
                 summary=route_param.summary,
                 description=route_param.description,
-                response_description=route_param.response_description,
-                responses=route_param.responses,
                 deprecated=route_param.deprecated,
                 methods=route_param.methods,
-                operation_id=route_param.operation_id,
-                response_model_include=route_param.response_model_include,
-                response_model_exclude=route_param.response_model_exclude,
-                response_model_by_alias=route_param.response_model_by_alias,
-                response_model_exclude_unset=route_param.response_model_exclude_unset,
-                response_model_exclude_defaults=route_param.response_model_exclude_defaults,
-                response_model_exclude_none=route_param.response_model_exclude_none,
-                include_in_schema=route_param.include_in_schema,
-                response_class=route_param.response_class,
-                name=route_param.name,
-                openapi_extra=route_param.openapi_extra,
-                generate_unique_id_function=route_param.generate_unique_id_function,
             )
 
 
-def create_client_class(name):
+def _create_client_class(name):
     class Client:
         pass
 
@@ -216,30 +153,84 @@ def create_client_class(name):
     return Client
 
 
-def create_direct_client_method(func: Callable, service: BaseService):
+def _create_direct_client_method(logger: Logger, func: Callable, service: BaseService):
     async def client_method(self, *args, **kwargs):
         return await func(service, *args, **kwargs)
 
     return client_method
 
 
-def create_api_client_method(param: RouteParam, base_url: str):
-    _url = param.path
-    _methods = [method.lower() for method in param.methods]
-
-    async def client_method(self, *args, **kwargs):
+def _create_api_client_method(logger: Logger, param: RouteParam, base_url: str):
+    async def client_method(*args, **kwargs):
+        url = base_url + param.path
+        method = (
+            param.methods[0].lower()
+            if isinstance(param.methods, list)
+            else param.methods.lower()
+        )
+        # Get the signature of the original function
+        sig = inspect.signature(param.func)
+        # Bind the arguments to the signature
+        bound_args = sig.bind(*args, **kwargs)
+        bound_args.apply_defaults()
+        # Analyze parameters
+        params = list(sig.parameters.values())
+        body_params = [
+            p
+            for p in params
+            if p.name != "self" and p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
+        ]
+        # Prepare the request
+        path_params = {}
+        query_params = {}
+        body = {}
+        for name, value in bound_args.arguments.items():
+            if name == "self":
+                continue
+            if f"{{{name}}}" in param.path:
+                path_params[name] = value
+            elif isinstance(value, BaseModel):
+                body = _parse_api_param(value)
+            elif method in ["get", "delete"]:
+                query_params[name] = _parse_api_param(value)
+            elif len(body_params) == 1 and name == body_params[0].name:
+                # If there's only one body parameter, use its value directly
+                body = _parse_api_param(value)
+            else:
+                body[name] = _parse_api_param(value)
+        # Format the URL with path parameters
+        url = url.format(**path_params)
+        logger.info(
+            f"Sending request to {url} with method {method}, json={body}, params={query_params}"  # noqa
+        )
         async with httpx.AsyncClient() as client:
-            url = base_url + _url.format(**kwargs)
-            if "post" in _methods:
-                response = await client.post(url, json=kwargs)
-            elif "put" in _methods:
-                response = await client.put(url, json=kwargs)
-            elif "delete" in _methods:
-                response = await client.delete(url, json=kwargs)
+            if method in ["get", "delete"]:
+                response = await getattr(client, method)(url, params=query_params)
             else:
-                response = await client.get(url, params=kwargs)
-            # Add more HTTP methods as needed
-            response.raise_for_status()
+                response = await getattr(client, method)(
+                    url, json=body, params=query_params
+                )
+            logger.info(
+                f"Received response: status={response.status_code}, content={response.content}"
+            )
+            if response.status_code >= 400:
+                error_detail = (
+                    response.json()
+                    if response.headers.get("content-type") == "application/json"
+                    else response.text
+                )
+                raise ClientAPIError(response.status_code, error_detail)
             return response.json()
 
     return client_method
+
+
+def _parse_api_param(data: Any) -> Any:
+    if isinstance(data, BaseModel):
+        return data.model_dump()
+    elif isinstance(data, list):
+        return [_parse_api_param(item) for item in data]
+    elif isinstance(data, dict):
+        return {key: _parse_api_param(value) for key, value in data.items()}
+    else:
+        return data

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/{db_engine.py → db_engine_factory.py}

@@ -2,4 +2,4 @@ from my_app_name.config import APP_DB_URL
 from sqlmodel import create_engine
 
 connect_args = {"check_same_thread": False}
-engine = create_engine(APP_DB_URL, connect_args=connect_args)
+db_engine = create_engine(APP_DB_URL, connect_args=connect_args, echo=True)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/error.py

@@ -6,3 +6,15 @@ from fastapi import HTTPException
 class NotFoundError(HTTPException):
     def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
         super().__init__(404, {"message": message}, headers)
+
+
+class InvalidValueError(HTTPException):
+    def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
+        super().__init__(422, {"message": message}, headers)
+
+
+class ClientAPIError(HTTPException):
+    def __init__(
+        self, status_code: int, message: str, headers: Dict[str, str] | None = None
+    ) -> None:
+        super().__init__(status_code, {"message": message}, headers)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/logger_factory.py

@@ -0,0 +1,10 @@
+import logging
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+
+# Create a logger for your application
+logger: logging.Logger = logging.getLogger("fastapp")

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/parser_factory.py

@@ -0,0 +1,7 @@
+from my_app_name.common.util.parser import (
+    create_default_filter_param_parser,
+    create_default_sort_param_parser,
+)
+
+parse_filter_param = create_default_filter_param_parser()
+parse_sort_param = create_default_sort_param_parser()