zrb 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/messagebus/rabbitmq/publisher.py

@@ -1,16 +1,16 @@
+import asyncio
+import logging
 from typing import Any, Optional
+
+import aiormq
 from core.messagebus.messagebus import (
-    Publisher,  MessageSerializer, must_get_message_serializer
-)
-from core.messagebus.rabbitmq.admin import (
-    RMQAdmin, must_get_rmq_admin
+    MessageSerializer,
+    Publisher,
+    must_get_message_serializer,
 )
+from core.messagebus.rabbitmq.admin import RMQAdmin, must_get_rmq_admin
 from pydantic import BaseModel
 
-import aiormq
-import asyncio
-import logging
-
 
 class RMQPublisher(Publisher):
     def __init__(
@@ -20,14 +20,12 @@ class RMQPublisher(Publisher):
         serializer: Optional[MessageSerializer] = None,
         rmq_admin: Optional[RMQAdmin] = None,
         retry: int = 5,
-        retry_interval: int = 5,
-        identifier='rmq-publisher'
+        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
+            logger=logger, rmq_admin=rmq_admin, connection_string=connection_string
         )
         self.connection_string = connection_string
         self.connection: Optional[aiormq.Connection] = None
@@ -41,84 +39,63 @@ class RMQPublisher(Publisher):
         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.dict()
+            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}] Get channel")
                 self.logger.info(
-                    f'🐰 [{self.identifier}] Publish to "{queue_name}": ' +
-                    f'{message}'
+                    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 '',
+                    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}'
+                    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'
+            f"🐰 [{self.identifier}] Failed to publish message after "
+            + f"{self.retry} attempts"
         )
-        raise RuntimeError('Failed to publish message after retrying')
+        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.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'
-                )
+                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'
-                )
+            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'
-                )
+                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')
+            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'
-                )
+                self.logger.info(f"🐰 [{self.identifier}] Close publisher channel")
                 await self.channel.close()
-                self.logger.info(
-                    f'🐰 [{self.identifier}] Publisher channel closed'
-                )
+                self.logger.info(f"🐰 [{self.identifier}] Publisher channel closed")
         except (asyncio.CancelledError, GeneratorExit, Exception):
-            self.logger.error(f'🐰 [{self.identifier}]', exc_info=True)
+            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'
-                )
+                self.logger.info(f"🐰 [{self.identifier}] Close publisher connection")
                 await self.connection.close()
-                self.logger.info(
-                    f'🐰 [{self.identifier}] Publisher connection closed'
-                )
+                self.logger.info(f"🐰 [{self.identifier}] Publisher connection closed")
         except (asyncio.CancelledError, GeneratorExit, Exception):
-            self.logger.error(f'🐰 [{self.identifier}]', exc_info=True)
+            self.logger.error(f"🐰 [{self.identifier}]", exc_info=True)
         self.connection = None
         self.channel = None

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/model/repo_model.py

@@ -1,11 +1,12 @@
-from typing import Generic, List, Optional, TypeVar, Type
-from pydantic import BaseModel
+from typing import Generic, List, Optional, Type, TypeVar
+
 from core.repo.repo import Repo
 from core.repo.search_filter import SearchFilter
+from pydantic import BaseModel
 
-Schema = TypeVar('Schema', bound=BaseModel)
-SchemaData = TypeVar('SchemaData', bound=BaseModel)
-SchemaResult = TypeVar('SchemaResult', bound=BaseModel)
+Schema = TypeVar("Schema", bound=BaseModel)
+SchemaData = TypeVar("SchemaData", bound=BaseModel)
+SchemaResult = TypeVar("SchemaResult", bound=BaseModel)
 
 
 class RepoModel(Generic[Schema, SchemaData, SchemaResult]):
@@ -22,15 +23,15 @@ class RepoModel(Generic[Schema, SchemaData, SchemaResult]):
         limit = 1000
         schema_list: List[Schema] = []
         for offset in range(0, count, limit):
-            partial_schema_list = await self.repo.get(
-                limit=limit, offset=offset
-            )
+            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
+        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)

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/repo/__init__.py

@@ -1,6 +1,6 @@
-from core.repo.repo import Repo
-from core.repo.db_repo import DBRepo
 from core.repo.db_entity_mixin import DBEntityMixin
+from core.repo.db_repo import DBRepo
+from core.repo.repo import Repo
 from core.repo.search_filter import SearchFilter
 
 assert Repo

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/repo/db_entity_mixin.py

@@ -1,7 +1,6 @@
+from helper.value import utcnow
 from sqlalchemy import Column, DateTime, String
 from sqlalchemy.orm import declarative_mixin
-from helper.value import utcnow
-
 from ulid import ULID
 
 
@@ -10,10 +9,8 @@ def generate_primary_key() -> str:
 
 
 @declarative_mixin
-class DBEntityMixin():
-    id = Column(
-        String(36), primary_key=True, index=True, default=generate_primary_key
-    )
+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)

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/repo/db_repo.py

@@ -1,20 +1,20 @@
-from typing import Any, List, Mapping, Optional, TypeVar, Type
+import logging
+from typing import Any, List, Mapping, Optional, Type, TypeVar
+
+from core.repo.repo import Repo
+from core.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 core.repo.search_filter import SearchFilter
-from core.repo.repo import Repo
-from helper.value import utcnow
-
 from ulid import ULID
-import logging
 
-Schema = TypeVar('Schema', bound=BaseModel)
-SchemaData = TypeVar('SchemaData', bound=BaseModel)
-DBEntity = TypeVar('DBEntity', bound=Any)
+Schema = TypeVar("Schema", bound=BaseModel)
+SchemaData = TypeVar("SchemaData", bound=BaseModel)
+DBEntity = TypeVar("DBEntity", bound=Any)
 
 
 class DBRepo(Repo[Schema, SchemaData]):
@@ -22,7 +22,9 @@ class DBRepo(Repo[Schema, SchemaData]):
     db_entity_cls: Type[DBEntity]
 
     def __init__(
-        self, logger: logging.Logger, engine: Engine,
+        self,
+        logger: logging.Logger,
+        engine: Engine,
     ):
         self.logger = logger
         self.engine = engine
@@ -30,9 +32,9 @@ class DBRepo(Repo[Schema, SchemaData]):
         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
@@ -42,28 +44,29 @@ class DBRepo(Repo[Schema, SchemaData]):
             db.close()
 
     async def get(
-        self, search_filter: Optional[SearchFilter] = None,
-        limit: int = 100, offset: int = 0
+        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
+                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)
@@ -73,20 +76,20 @@ class DBRepo(Repo[Schema, SchemaData]):
             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:
+            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:
+            if "created_at" in self.db_entity_attribute_names:
                 db_entity.created_at = utcnow()
-            if 'updated_at' in self.db_entity_attribute_names:
+            if "updated_at" in self.db_entity_attribute_names:
                 db_entity.updated_at = utcnow()
             db.add(db_entity)
             db.commit()
@@ -94,8 +97,8 @@ class DBRepo(Repo[Schema, SchemaData]):
             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}'
+                f"Error while inserting into {self.db_entity_cls} "
+                + f"with schema_data: {data}"
             )
             raise
         finally:
@@ -105,20 +108,18 @@ class DBRepo(Repo[Schema, SchemaData]):
         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 = 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':
+                if field == "created_at" or field == "created_by":
                     continue
                 setattr(db_entity, field, value)
-            if 'updated_at' in self.db_entity_attribute_names:
+            if "updated_at" in self.db_entity_attribute_names:
                 db_entity.updated_at = utcnow()
             db.add(db_entity)
             db.commit()
@@ -126,58 +127,54 @@ class DBRepo(Repo[Schema, SchemaData]):
             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}'
+                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_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}'
+                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
+        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()
-                )
+            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}'
+                f"Error while getting {self.db_entity_cls} "
+                + f"with criterion: {criterion}, "
+                + f"limit: {limit}, offset: {offset}"
             )
             raise
 
@@ -185,13 +182,11 @@ class DBRepo(Repo[Schema, SchemaData]):
         self, db: Session, criterion: _ColumnExpressionArgument[bool]
     ) -> int:
         try:
-            return db.query(self.db_entity_cls).filter(
-                criterion
-            ).count()
+            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}'
+                f"Error while counting for {self.db_entity_cls} "
+                + f"with criterion: {criterion}"
             )
             raise
 
@@ -199,30 +194,28 @@ class DBRepo(Repo[Schema, SchemaData]):
         self, db: Session, criterion: _ColumnExpressionArgument[bool]
     ) -> DBEntity:
         try:
-            db_entity = db.query(self.db_entity_cls).filter(
-                criterion
-            ).first()
+            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}'
+                    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}'
+                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.dict()
+        """
+        entity_dict = schema_data.model_dump()
         return {
             field: value
             for field, value in entity_dict.items()
@@ -230,22 +223,22 @@ class DBRepo(Repo[Schema, SchemaData]):
         }
 
     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 == '':
+        if keyword == "":
             return True
-        like_keyword = '%{}%'.format(keyword)
+        like_keyword = "%{}%".format(keyword)
         keyword_criterion = [
             keyword_field.like(like_keyword)
             for keyword_field in self._get_keyword_fields()
@@ -253,9 +246,9 @@ class DBRepo(Repo[Schema, SchemaData]):
         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 = []
@@ -263,13 +256,13 @@ class DBRepo(Repo[Schema, SchemaData]):
             field = getattr(self.db_entity_cls, field_name, None)
             if type(field) != InstrumentedAttribute:
                 continue
-            field_type = getattr(field, 'type', None)
+            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')
+                str_field_type.upper().startswith("VARCHAR")
+                or str_field_type.upper().startswith("TEXT")
             ):
                 continue
             self._keyword_fields.append(field)
@@ -277,5 +270,5 @@ class DBRepo(Repo[Schema, SchemaData]):
 
     def _ensure_search_filter(self, search_filter: Optional[SearchFilter]):
         if search_filter is None:
-            return SearchFilter(keyword='', criterion={})
+            return SearchFilter(keyword="", criterion={})
         return search_filter

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/repo/repo.py

@@ -1,14 +1,14 @@
-from typing import Generic, List, Optional, TypeVar
-from pydantic import BaseModel
 from abc import ABC, abstractmethod
+from typing import Generic, List, Optional, TypeVar
+
 from core.repo.search_filter import SearchFilter
+from pydantic import BaseModel
 
-SchemaData = TypeVar('SchemaData', bound=BaseModel)
-Schema = TypeVar('Schema', bound=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

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/repo/search_filter.py

@@ -1,4 +1,5 @@
 from typing import Any, Mapping
+
 from pydantic import BaseModel
 
 

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/rpc/__init__.py

@@ -1,6 +1,6 @@
-from core.rpc.rpc import Caller, Server
 from core.rpc.messagebus.caller import MessagebusCaller
 from core.rpc.messagebus.server import MessagebusServer
+from core.rpc.rpc import Caller, Server
 
 assert Caller
 assert Server