zrb 0.28.1__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/component/messagebus/rabbitmq/publisher.py

@@ -1,101 +0,0 @@
-import asyncio
-import logging
-from typing import Any, Optional
-
-import aiormq
-from component.messagebus.messagebus import (
-    MessageSerializer,
-    Publisher,
-    must_get_message_serializer,
-)
-from component.messagebus.rabbitmq.admin import RMQAdmin, must_get_rmq_admin
-from pydantic import BaseModel
-
-
-class RMQPublisher(Publisher):
-    def __init__(
-        self,
-        logger: logging.Logger,
-        connection_string: str,
-        serializer: Optional[MessageSerializer] = None,
-        rmq_admin: Optional[RMQAdmin] = None,
-        retry: int = 5,
-        retry_interval: int = 10,
-        identifier="rmq-publisher",
-    ):
-        self.logger = logger
-        self.rmq_admin = must_get_rmq_admin(
-            logger=logger, rmq_admin=rmq_admin, connection_string=connection_string
-        )
-        self.connection_string = connection_string
-        self.connection: Optional[aiormq.Connection] = None
-        self.serializer = must_get_message_serializer(serializer)
-        self.retry = retry
-        self.retry_interval = retry_interval
-        self.identifier = identifier
-
-    async def publish(self, event_name: str, message: Any):
-        await self.rmq_admin.create_events([event_name])
-        queue_name = self.rmq_admin.get_queue_name(event_name)
-        exchange_name = self.rmq_admin.get_exchange_name(event_name)
-        if isinstance(message, BaseModel):
-            message = message.model_dump()
-        for attempt in range(self.retry):
-            try:
-                await self._connect()
-                self.logger.info(f"🐰 [{self.identifier}] Get channel")
-                self.logger.info(
-                    f'🐰 [{self.identifier}] Publish to "{queue_name}": ' + f"{message}"
-                )
-                await self.channel.basic_publish(
-                    body=self.serializer.encode(event_name, message),
-                    exchange=exchange_name,
-                    routing_key=queue_name if exchange_name == "" else "",
-                )
-                return
-            except (asyncio.CancelledError, GeneratorExit, Exception) as e:
-                self.logger.error(
-                    f"🐰 [{self.identifier}] Failed to publish message: {e}"
-                )
-                await self._disconnect()
-                await asyncio.sleep(self.retry_interval)
-                continue
-        self.logger.error(
-            f"🐰 [{self.identifier}] Failed to publish message after "
-            + f"{self.retry} attempts"
-        )
-        raise RuntimeError("Failed to publish message after retrying")
-
-    async def _connect(self):
-        try:
-            connection_created = False
-            if self.connection is None or self.connection.is_closed:
-                self.logger.info(f"🐰 [{self.identifier}] Create publisher connection")
-                self.connection = await aiormq.connect(self.connection_string)
-                self.logger.info(f"🐰 [{self.identifier}] Publisher connection created")
-                connection_created = True
-            if connection_created or self.channel is None or self.channel.is_closed:
-                self.logger.info(f"🐰 [{self.identifier}] Get publisher channel")
-                self.channel = await self.connection.channel()
-                self.logger.info(f"🐰 [{self.identifier}] publisher channel created")
-        except (asyncio.CancelledError, GeneratorExit, Exception):
-            self.logger.error(f"🐰 [{self.identifier}]", exc_info=True)
-            raise Exception("Cannot connect")
-
-    async def _disconnect(self):
-        try:
-            if self.channel is not None and not self.channel.is_closed:
-                self.logger.info(f"🐰 [{self.identifier}] Close publisher channel")
-                await self.channel.close()
-                self.logger.info(f"🐰 [{self.identifier}] Publisher channel closed")
-        except (asyncio.CancelledError, GeneratorExit, Exception):
-            self.logger.error(f"🐰 [{self.identifier}]", exc_info=True)
-        try:
-            if self.connection is not None and not self.connection.is_closed:
-                self.logger.info(f"🐰 [{self.identifier}] Close publisher connection")
-                await self.connection.close()
-                self.logger.info(f"🐰 [{self.identifier}] Publisher connection closed")
-        except (asyncio.CancelledError, GeneratorExit, Exception):
-            self.logger.error(f"🐰 [{self.identifier}]", exc_info=True)
-        self.connection = None
-        self.channel = None

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/component/model/__init__.py

@@ -1,3 +0,0 @@
-from component.model.repo_model import RepoModel
-
-assert RepoModel

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/component/model/repo_model.py

@@ -1,50 +0,0 @@
-from typing import Generic, Optional, Type, TypeVar
-
-from component.repo.repo import Repo
-from component.repo.search_filter import SearchFilter
-from pydantic import BaseModel
-
-Schema = TypeVar("Schema", bound=BaseModel)
-SchemaData = TypeVar("SchemaData", bound=BaseModel)
-SchemaResult = TypeVar("SchemaResult", bound=BaseModel)
-
-
-class RepoModel(Generic[Schema, SchemaData, SchemaResult]):
-    schema_result_cls: Type[SchemaResult]
-
-    def __init__(self, repo: Repo[Schema, SchemaData]):
-        self.repo = repo
-
-    async def get_by_id(self, id: str) -> Schema:
-        return await self.repo.get_by_id(id)
-
-    async def get_all(self) -> list[Schema]:
-        count = await self.repo.count()
-        limit = 1000
-        schema_list: list[Schema] = []
-        for offset in range(0, count, limit):
-            partial_schema_list = await self.repo.get(limit=limit, offset=offset)
-            schema_list += partial_schema_list
-        return schema_list
-
-    async def get(
-        self,
-        search_filter: Optional[SearchFilter] = None,
-        limit: int = 100,
-        offset: int = 0,
-    ) -> SchemaResult:
-        count = await self.repo.count(search_filter)
-        data = await self.repo.get(search_filter, limit, offset)
-        return self.schema_result_cls(count=count, data=data)
-
-    async def count(self, search_filter: Optional[SearchFilter] = None) -> int:
-        return await self.repo.count(search_filter)
-
-    async def insert(self, data: SchemaData) -> Schema:
-        return await self.repo.insert(data)
-
-    async def update(self, id: str, data: SchemaData) -> Schema:
-        return await self.repo.update(id, data)
-
-    async def delete(self, id: str) -> Schema:
-        return await self.repo.delete(id)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/component/repo/__init__.py

@@ -1,9 +0,0 @@
-from component.repo.db_entity_mixin import DBEntityMixin
-from component.repo.db_repo import DBRepo
-from component.repo.repo import Repo
-from component.repo.search_filter import SearchFilter
-
-assert Repo
-assert DBRepo
-assert DBEntityMixin
-assert SearchFilter

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/component/repo/db_entity_mixin.py

@@ -1,17 +0,0 @@
-from helper.value import utcnow
-from sqlalchemy import Column, DateTime, String
-from sqlalchemy.orm import declarative_mixin
-from ulid import ULID
-
-
-def generate_primary_key() -> str:
-    return str(ULID())
-
-
-@declarative_mixin
-class DBEntityMixin:
-    id = Column(String(36), primary_key=True, index=True, default=generate_primary_key)
-    created_at = Column(DateTime, default=utcnow)
-    created_by = Column(String(36), nullable=True)
-    updated_at = Column(DateTime, nullable=True)
-    updated_by = Column(String(36), nullable=True)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/component/repo/db_repo.py

@@ -1,275 +0,0 @@
-import logging
-from collections.abc import Mapping
-from typing import Any, Optional, Type, TypeVar
-
-from component.repo.repo import Repo
-from component.repo.search_filter import SearchFilter
-from helper.value import utcnow
-from pydantic import BaseModel
-from sqlalchemy import or_
-from sqlalchemy.engine import Engine
-from sqlalchemy.orm import Session
-from sqlalchemy.orm.attributes import InstrumentedAttribute
-from sqlalchemy.sql._typing import _ColumnExpressionArgument
-from ulid import ULID
-
-Schema = TypeVar("Schema", bound=BaseModel)
-SchemaData = TypeVar("SchemaData", bound=BaseModel)
-DBEntity = TypeVar("DBEntity", bound=Any)
-
-
-class DBRepo(Repo[Schema, SchemaData]):
-    schema_cls: Type[Schema]
-    db_entity_cls: Type[DBEntity]
-
-    def __init__(
-        self,
-        logger: logging.Logger,
-        engine: Engine,
-    ):
-        self.logger = logger
-        self.engine = engine
-        self.db_entity_attribute_names: list[str] = dir(self.db_entity_cls)
-        self._keyword_fields: Optional[list[InstrumentedAttribute]] = None
-
-    async def get_by_id(self, id: str) -> Schema:
-        """
-        Find a record by id.
-        """
-        db = self._get_db_session()
-        try:
-            search_filter = self.db_entity_cls.id == id
-            db_entity = self._get_one_by_criterion(db, search_filter)
-            return self._db_entity_to_schema(db, db_entity)
-        finally:
-            db.close()
-
-    async def get(
-        self,
-        search_filter: Optional[SearchFilter] = None,
-        limit: int = 100,
-        offset: int = 0,
-    ) -> list[Schema]:
-        """
-        Find multiple records by keyword with limit and offset.
-        """
-        db = self._get_db_session()
-        try:
-            search_filter = self._ensure_search_filter(search_filter)
-            criterion = self._search_filter_to_criterion(search_filter)
-            db_entities = self._get_by_criterion(db, criterion, limit, offset)
-            return [
-                self._db_entity_to_schema(db, db_entity) for db_entity in db_entities
-            ]
-        finally:
-            db.close()
-
-    async def count(self, search_filter: Optional[SearchFilter] = None) -> int:
-        """
-        Count records by keyword.
-        """
-        db = self._get_db_session()
-        try:
-            search_filter = self._ensure_search_filter(search_filter)
-            criterion = self._search_filter_to_criterion(search_filter)
-            return self._count_by_criterion(db, criterion)
-        finally:
-            db.close()
-
-    async def insert(self, data: SchemaData) -> Schema:
-        """
-        Insert a new record.
-        """
-        db = self._get_db_session()
-        try:
-            db_entity = self.db_entity_cls(
-                **self._schema_data_to_db_entity_map(db, data),
-            )
-            if "id" in self.db_entity_attribute_names:
-                new_id = self.generate_id()
-                db_entity.id = new_id
-            if "created_at" in self.db_entity_attribute_names:
-                db_entity.created_at = utcnow()
-            if "updated_at" in self.db_entity_attribute_names:
-                db_entity.updated_at = utcnow()
-            db.add(db_entity)
-            db.commit()
-            db.refresh(db_entity)
-            return self._db_entity_to_schema(db, db_entity)
-        except Exception:
-            self.logger.error(
-                f"Error while inserting into {self.db_entity_cls} "
-                + f"with schema_data: {data}"
-            )
-            raise
-        finally:
-            db.close()
-
-    def generate_id(self) -> str:
-        return str(ULID())
-
-    async def update(self, id: str, data: SchemaData) -> Schema:
-        """
-        Update a record.
-        """
-        db = self._get_db_session()
-        try:
-            db_entity = self._get_one_by_criterion(db, self.db_entity_cls.id == id)
-            db_entity_map = self._schema_data_to_db_entity_map(db, data)
-            for field, value in db_entity_map.items():
-                if field == "created_at" or field == "created_by":
-                    continue
-                setattr(db_entity, field, value)
-            if "updated_at" in self.db_entity_attribute_names:
-                db_entity.updated_at = utcnow()
-            db.add(db_entity)
-            db.commit()
-            db.refresh(db_entity)
-            return self._db_entity_to_schema(db, db_entity)
-        except Exception:
-            self.logger.error(
-                f"Error while updating {self.db_entity_cls} "
-                + f"with id: {id}, schema_data: {data}"
-            )
-            raise
-        finally:
-            db.close()
-
-    async def delete(self, id: str) -> Schema:
-        """
-        Delete a record.
-        """
-        db = self._get_db_session()
-        try:
-            db_entity = self._get_one_by_criterion(db, self.db_entity_cls.id == id)
-            db.delete(db_entity)
-            db.commit()
-            return self._db_entity_to_schema(db, db_entity)
-        except Exception:
-            self.logger.error(
-                f"Error while deleting {self.db_entity_cls} with id: {id}"
-            )
-            raise
-        finally:
-            db.close()
-
-    def _get_db_session(self) -> Session:
-        """
-        Return a db session.
-        """
-        return Session(self.engine, expire_on_commit=False)
-
-    def _get_by_criterion(
-        self,
-        db: Session,
-        criterion: _ColumnExpressionArgument[bool],
-        limit: int = 100,
-        offset: int = 0,
-    ) -> list[DBEntity]:
-        try:
-            db_query = db.query(self.db_entity_cls).filter(criterion)
-            if "created_at" in self.db_entity_attribute_names:
-                db_query = db_query.order_by(self.db_entity_cls.created_at.desc())
-            return db_query.offset(offset).limit(limit).all()
-        except Exception:
-            self.logger.error(
-                f"Error while getting {self.db_entity_cls} "
-                + f"with criterion: {criterion}, "
-                + f"limit: {limit}, offset: {offset}"
-            )
-            raise
-
-    def _count_by_criterion(
-        self, db: Session, criterion: _ColumnExpressionArgument[bool]
-    ) -> int:
-        try:
-            return db.query(self.db_entity_cls).filter(criterion).count()
-        except Exception:
-            self.logger.error(
-                f"Error while counting for {self.db_entity_cls} "
-                + f"with criterion: {criterion}"
-            )
-            raise
-
-    def _get_one_by_criterion(
-        self, db: Session, criterion: _ColumnExpressionArgument[bool]
-    ) -> DBEntity:
-        try:
-            db_entity = db.query(self.db_entity_cls).filter(criterion).first()
-            if db_entity is None:
-                raise ValueError(
-                    f"Not found: Cannot find a {self.db_entity_cls} "
-                    + f"with criterion: {criterion}"
-                )
-            return db_entity
-        except Exception:
-            self.logger.error(
-                f"Error while getting a {self.db_entity_cls} "
-                + f"with criterion: {criterion}"
-            )
-            raise
-
-    def _schema_data_to_db_entity_map(
-        self, db: Session, schema_data: SchemaData
-    ) -> Mapping[str, Any]:
-        """
-        Convert entity_data into dictionary
-        The result of this convertion is used for inserting/updating db_entity.
-        """
-        entity_dict = schema_data.model_dump()
-        return {
-            field: value
-            for field, value in entity_dict.items()
-            if field in self.db_entity_attribute_names
-        }
-
-    def _db_entity_to_schema(self, db: Session, db_entity: DBEntity) -> Schema:
-        """
-        Convert db_entity into schema.
-        """
-        return self.schema_cls.from_orm(db_entity)
-
-    def _search_filter_to_criterion(
-        self, search_filter: SearchFilter
-    ) -> _ColumnExpressionArgument[bool]:
-        """
-        Return keyword filtering.
-        The result is usually used to invoke find/count.
-        """
-        keyword = search_filter.keyword
-        if keyword == "":
-            return True
-        like_keyword = "%{}%".format(keyword)
-        keyword_criterion = [
-            keyword_field.like(like_keyword)
-            for keyword_field in self._get_keyword_fields()
-        ]
-        return or_(*keyword_criterion)
-
-    def _get_keyword_fields(self) -> list[InstrumentedAttribute]:
-        """
-        Return list of fields for keyword filtering
-        """
-        if self._keyword_fields is not None:
-            return self._keyword_fields
-        self._keyword_fields = []
-        for field_name in self.db_entity_attribute_names:
-            field = getattr(self.db_entity_cls, field_name, None)
-            if type(field) != InstrumentedAttribute:
-                continue
-            field_type = getattr(field, "type", None)
-            if field_type is None:
-                continue
-            str_field_type = str(field_type)
-            if not (
-                str_field_type.upper().startswith("VARCHAR")
-                or str_field_type.upper().startswith("TEXT")
-            ):
-                continue
-            self._keyword_fields.append(field)
-        return self._keyword_fields
-
-    def _ensure_search_filter(self, search_filter: Optional[SearchFilter]):
-        if search_filter is None:
-            return SearchFilter(keyword="", criterion={})
-        return search_filter

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/component/repo/repo.py

@@ -1,36 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Generic, Optional, TypeVar
-
-from component.repo.search_filter import SearchFilter
-from pydantic import BaseModel
-
-SchemaData = TypeVar("SchemaData", bound=BaseModel)
-Schema = TypeVar("Schema", bound=BaseModel)
-
-
-class Repo(Generic[Schema, SchemaData], ABC):
-    @abstractmethod
-    async def get_by_id(self, id: str) -> Schema:
-        pass
-
-    @abstractmethod
-    async def get(
-        self, search_filter: Optional[SearchFilter], limit: int, offset: int
-    ) -> list[Schema]:
-        pass
-
-    @abstractmethod
-    async def count(self, search_filter: Optional[SearchFilter]) -> int:
-        pass
-
-    @abstractmethod
-    async def insert(self, data: SchemaData) -> Schema:
-        pass
-
-    @abstractmethod
-    async def update(self, id: str, data: SchemaData) -> Schema:
-        pass
-
-    @abstractmethod
-    async def delete(self, id: str) -> Schema:
-        pass

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/component/repo/search_filter.py

@@ -1,9 +0,0 @@
-from collections.abc import Mapping
-from typing import Any
-
-from pydantic import BaseModel
-
-
-class SearchFilter(BaseModel):
-    keyword: str
-    criterion: Mapping[str, Any]

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/component/rpc/__init__.py

@@ -1,8 +0,0 @@
-from component.rpc.messagebus.caller import MessagebusCaller
-from component.rpc.messagebus.server import MessagebusServer
-from component.rpc.rpc import Caller, Server
-
-assert Caller
-assert Server
-assert MessagebusCaller
-assert MessagebusServer

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/component/rpc/messagebus/caller.py

@@ -1,85 +0,0 @@
-import asyncio
-import logging
-from collections.abc import Callable
-from typing import Any
-
-from component.messagebus.messagebus import Admin, Consumer, Publisher
-from component.rpc.rpc import Caller, Message, Result
-from ulid import ULID
-
-
-class MessagebusCaller(Caller):
-    def __init__(
-        self,
-        logger: logging.Logger,
-        admin: Admin,
-        publisher: Publisher,
-        consumer_factory: Callable[[], Consumer],
-        timeout: float = 30,
-        check_reply_interval: float = 0.05,
-    ):
-        self.logger = logger
-        self.admin = admin
-        self.publisher = publisher
-        self.consumer_factory = consumer_factory
-        self.timeout = timeout
-        self.check_reply_interval = check_reply_interval
-
-    async def call(self, rpc_name: str, *args: Any, **kwargs: Any):
-        random_uuid = str(ULID())
-        reply_event_name = f"reply_{rpc_name}_{random_uuid}"
-        await self.admin.create_events([reply_event_name])
-        reply_consumer = self.consumer_factory()
-        reply_received_event = asyncio.Event()
-        call_result, call_error = None, None
-
-        @reply_consumer.register(reply_event_name)
-        async def consume_reply(result_dict: Any):
-            nonlocal call_result, call_error
-            result = Result.from_dict(result_dict)
-            call_result, call_error = result.result, result.error
-            reply_received_event.set()
-            await reply_consumer.stop()
-
-        try:
-            task = asyncio.create_task(reply_consumer.start())
-            await self.publisher.publish(
-                rpc_name,
-                Message(
-                    reply_event=reply_event_name, args=args, kwargs=kwargs
-                ).to_dict(),
-            )
-            await asyncio.gather(task)
-            await asyncio.wait_for(reply_received_event.wait(), timeout=self.timeout)
-        except asyncio.TimeoutError:
-            self.logger.error(
-                "🤙 [messagebus-rpc-caller] "
-                + f"Timeout while waiting for reply event {reply_event_name}"
-            )
-            raise Exception(
-                f"Timeout while waiting for reply event: {reply_event_name}"
-            )
-        finally:
-            await self._clean_up(reply_consumer, reply_event_name)
-        # raise call_error or return call_result
-        if call_error != "":
-            self.logger.error(
-                "🤙 [messagebus-rpc-caller] RPC "
-                + f'"{rpc_name}" returning error: {call_error}'
-            )
-            raise Exception(call_error)
-        self.logger.info(
-            "🤙 [messagebus-rpc-caller] RPC "
-            + f'"{rpc_name}" returning result: {call_result}'
-        )
-        return call_result
-
-    async def _clean_up(self, reply_consumer: Consumer, reply_event_name: str):
-        try:
-            await reply_consumer.stop()
-        except (asyncio.CancelledError, GeneratorExit, Exception):
-            self.logger.error("🤙 [messagebus-rpc-caller]", exc_info=True)
-        try:
-            await self.admin.delete_events([reply_event_name])
-        except (asyncio.CancelledError, GeneratorExit, Exception):
-            self.logger.error("🤙 [messagebus-rpc-caller]", exc_info=True)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/component/rpc/messagebus/server.py

@@ -1,61 +0,0 @@
-import inspect
-import logging
-from collections.abc import Mapping
-from typing import Any
-
-from component.messagebus.messagebus import Consumer, Publisher
-from component.rpc.rpc import Message, Result, Server, TRPCHandler
-from pydantic import BaseModel
-
-
-class MessagebusServer(Server):
-    def __init__(
-        self, logger: logging.Logger, consumer: Consumer, publisher: Publisher
-    ):
-        self.logger = logger
-        self.consumer = consumer
-        self.publisher = publisher
-
-    async def start(self):
-        await self.consumer.start()
-
-    async def stop(self):
-        await self.consumer.stop()
-
-    def register(self, rpc_name):
-        def wrapper(handler: TRPCHandler):
-            @self.consumer.register(rpc_name)
-            async def event_handler(message_dict: Mapping[str, Any]):
-                message: Message = Message.from_dict(message_dict)
-                args = message.args
-                kwargs = message.kwargs
-                reply_event = message.reply_event
-                # get reply
-                self.logger.info(
-                    "🤙 [messagebus-rpc-server] "
-                    + f"Invoke RPC: {rpc_name} "
-                    + f", args: {args} "
-                    + f", kwargs: {kwargs} "
-                    + f", reply_event: {reply_event}"
-                )
-                try:
-                    result = await self._run_handler(handler, *args, **kwargs)
-                    if isinstance(result, BaseModel):
-                        result = result.model_dump()
-                    # publish result
-                    await self.publisher.publish(
-                        reply_event, Result(result=result).to_dict()
-                    )
-                except Exception as e:
-                    self.logger.error(e, exc_info=True)
-                    # publish error
-                    await self.publisher.publish(
-                        reply_event, Result(error=f"{e}").to_dict()
-                    )
-
-        return wrapper
-
-    async def _run_handler(self, handler: TRPCHandler, *args: Any, **kwargs: Any):
-        if inspect.iscoroutinefunction(handler):
-            return await handler(*args, **kwargs)
-        return handler(*args, **kwargs)