qena-shared-lib 0.1.1__tar.gz → 0.1.3__tar.gz

{qena_shared_lib-0.1.1 → qena_shared_lib-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qena-shared-lib
-Version: 0.1.1
+Version: 0.1.3
 Summary: A shared tools for other services
 Requires-Python: >=3.10
 Requires-Dist: cronsim~=2.0
@@ -30,6 +30,12 @@ A shared tools for other services. It includes.
 
 # Usage
 
+## Environment variables
+
+- `LOGGER_NAME` root logger name.
+- `UNAUTHORIZED_RESPONSE_CODE` an integer response on an authorized access of resource.
+- `TOKEN_HEADER` to header key for jwt token.
+
 ## Http
 
 To create fastapi app.
@@ -224,13 +230,11 @@ def main() -> FastAPI:
     ...
 
     rabbitmq = RabbitMqManager(
-        listeners=[
-            UserConsumer
-        ],
         logstash=logstash,
         container=builder.container,
     )
 
+    rabbitmq.include_listener(UserConsumer)
     builder.add_singleton(
         service=RabbitMqManager,
         instance=rabbitmq,
@@ -275,6 +279,40 @@ async def get_user(
     return user
 ```
 
+### Flow control
+
+``` py
+@Consumer("UserQueue")
+class UserConsumer(ListenerBase):
+
+    @consume()
+    async def store_user(self, ctx: ListenerContext, user: User):
+        ...
+
+        await ctx.flow_control.request(10)
+
+        ...
+
+```
+
+### Rpc reply
+
+Optionally it is possible to reply to rpc calls, through.
+
+``` py
+@RpcWorker("UserQueue")
+class UserWorker(ListenerBase):
+
+    @execute()
+    async def store_user(self, ctx: ListenerContext, user: User):
+        ...
+
+        await ctx.rpc_reply.reply("Done")
+
+        ...
+```
+
+
 ## Scheduler
 
 ``` py
@@ -314,13 +352,11 @@ def main() -> FastAPI:
     ...
 
     schedule_manager = ScheduleManager(
-        schedulers=[
-            TaskScheduler
-        ],
         logstash=logstash,
         container=builder.container
     )
 
+    schedule_manager.include_scheduler(TaskScheduler)
     builder.with_singleton(
         service=ScheduleManager,
         instance=schedule_manager,

{qena_shared_lib-0.1.1 → qena_shared_lib-0.1.3}/README.md

@@ -13,6 +13,12 @@ A shared tools for other services. It includes.
 
 # Usage
 
+## Environment variables
+
+- `LOGGER_NAME` root logger name.
+- `UNAUTHORIZED_RESPONSE_CODE` an integer response on an authorized access of resource.
+- `TOKEN_HEADER` to header key for jwt token.
+
 ## Http
 
 To create fastapi app.
@@ -207,13 +213,11 @@ def main() -> FastAPI:
     ...
 
     rabbitmq = RabbitMqManager(
-        listeners=[
-            UserConsumer
-        ],
         logstash=logstash,
         container=builder.container,
     )
 
+    rabbitmq.include_listener(UserConsumer)
     builder.add_singleton(
         service=RabbitMqManager,
         instance=rabbitmq,
@@ -258,6 +262,40 @@ async def get_user(
     return user
 ```
 
+### Flow control
+
+``` py
+@Consumer("UserQueue")
+class UserConsumer(ListenerBase):
+
+    @consume()
+    async def store_user(self, ctx: ListenerContext, user: User):
+        ...
+
+        await ctx.flow_control.request(10)
+
+        ...
+
+```
+
+### Rpc reply
+
+Optionally it is possible to reply to rpc calls, through.
+
+``` py
+@RpcWorker("UserQueue")
+class UserWorker(ListenerBase):
+
+    @execute()
+    async def store_user(self, ctx: ListenerContext, user: User):
+        ...
+
+        await ctx.rpc_reply.reply("Done")
+
+        ...
+```
+
+
 ## Scheduler
 
 ``` py
@@ -297,13 +335,11 @@ def main() -> FastAPI:
     ...
 
     schedule_manager = ScheduleManager(
-        schedulers=[
-            TaskScheduler
-        ],
         logstash=logstash,
         container=builder.container
     )
 
+    schedule_manager.include_scheduler(TaskScheduler)
     builder.with_singleton(
         service=ScheduleManager,
         instance=schedule_manager,

{qena_shared_lib-0.1.1 → qena_shared_lib-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qena-shared-lib"
-version = "0.1.1"
+version = "0.1.3"
 description = "A shared tools for other services"
 readme = "README.md"
 requires-python = ">=3.10"

{qena_shared_lib-0.1.1 → qena_shared_lib-0.1.3}/src/qena_shared_lib/rabbitmq/_base.py

@@ -94,7 +94,6 @@ class RabbitMqManager(AsyncEventLoopMixin):
 
     def __init__(
         self,
-        listeners: list[Listener | type[ListenerBase]],
         logstash: BaseLogstashSender,
         parameters: Parameters | str | None = None,
         reconnect_delay: float = 5.0,
@@ -102,24 +101,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
         listener_global_retry_policy: RetryPolicy | None = None,
         container: Container | None = None,
     ):
-        for index, listener in enumerate(listeners):
-            if not isinstance(listener, Listener) and (
-                not isinstance(listener, type)
-                or not issubclass(listener, ListenerBase)
-            ):
-                raise TypeError(
-                    f"listener {index} is {type(listener)}, expected instance of type or subclass of `Listener` or `type[ListenerBase]`"
-                )
-
-        self._listener_classes = [
-            listener_class
-            for listener_class in listeners
-            if isinstance(listener_class, type)
-            and issubclass(listener_class, ListenerBase)
-        ]
-        self._listeners = [
-            listener for listener in listeners if isinstance(listener, Listener)
-        ]
+        self._listeners: list[Listener] = []
 
         if isinstance(parameters, str):
             self._parameters = URLParameters(parameters)
@@ -139,8 +121,6 @@ class RabbitMqManager(AsyncEventLoopMixin):
             type[Exception], ExceptionHandlerContainer
         ] = {}
 
-        self._register_listener_classes()
-
         self.exception_handler(RabbitMQException)(handle_rabbitmq_exception)
         self.exception_handler(ValidationError)(handle_validation_error)
         self.exception_handler(ServiceException)(handle_microservice_exception)
@@ -150,26 +130,6 @@ class RabbitMqManager(AsyncEventLoopMixin):
         self._logstash = logstash
         self._logger = LoggerProvider.default().get_logger("rabbitmq")
 
-    def _register_listener_classes(self):
-        for listener_class in self._listener_classes:
-            inner_listener = getattr(listener_class, LISTENER_ATTRIBUTE, None)
-
-            if inner_listener is None:
-                raise AttributeError(
-                    "listener is possibly not with `Consumer` or `RpcWorker`"
-                )
-
-            if not isinstance(inner_listener, Listener):
-                raise TypeError(
-                    f"listener class {type(listener_class)} is not a type `Listener`, posibilly not decorated with `Consumer` or `RpcWorker`"
-                )
-
-            self._container.register(
-                service=ListenerBase,
-                factory=listener_class,
-                scope=Scope.singleton,
-            )
-
     @property
     def container(self) -> Container:
         return self._container
@@ -239,6 +199,40 @@ class RabbitMqManager(AsyncEventLoopMixin):
 
         return True, None
 
+    def include_listener(self, listener: Listener | type[ListenerBase]):
+        if isinstance(listener, Listener):
+            self._listeners.append(listener)
+
+            return
+
+        if isinstance(listener, type) and issubclass(listener, ListenerBase):
+            self._register_listener_classes(listener)
+
+            return
+
+        raise TypeError(
+            f"listener is {type(listener)}, expected instance of type or subclass of `Listener` or `type[ListenerBase]`"
+        )
+
+    def _register_listener_classes(self, listener_class: type):
+        inner_listener = getattr(listener_class, LISTENER_ATTRIBUTE, None)
+
+        if inner_listener is None:
+            raise AttributeError(
+                "listener is possibly not with `Consumer` or `RpcWorker`"
+            )
+
+        if not isinstance(inner_listener, Listener):
+            raise TypeError(
+                f"listener class {type(listener_class)} is not a type `Listener`, posibilly not decorated with `Consumer` or `RpcWorker`"
+            )
+
+        self._container.register(
+            service=ListenerBase,
+            factory=listener_class,
+            scope=Scope.singleton,
+        )
+
     def include_service(
         self,
         rabbit_mq_service: AbstractRabbitMQService
@@ -407,9 +401,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
         exception = task.exception()
 
         if exception is not None:
-            if not self._disconnected and not isinstance(
-                exception, (ConnectionClosedByClient, ChannelClosedByClient)
-            ):
+            if self._can_reconnect(exception):
                 self._logstash.error(
                     message="couldn't drain the channel pool",
                     exception=exception,
@@ -462,13 +454,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
         if exception is not None:
             if not self._connected and not self._connected_future.done():
                 self._connected_future.set_exception(exception)
-            elif (
-                self._connected
-                and not self._disconnected
-                and not isinstance(
-                    exception, (ConnectionClosedByClient, ChannelClosedByClient)
-                )
-            ):
+            elif self._can_reconnect(exception):
                 self._logstash.error(
                     message="couldn't fill the channel pool",
                     exception=exception,
@@ -538,13 +524,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
         if exception is not None:
             if not self._connected and not self._connected_future.done():
                 self._connected_future.set_exception(exception)
-            elif (
-                self._connected
-                and not self._disconnected
-                and not isinstance(
-                    exception, (ConnectionClosedByClient, ChannelClosedByClient)
-                )
-            ):
+            elif self._can_reconnect(exception):
                 self._logstash.error(
                     message="couldn't configure and initialize all listeners and services",
                     exception=exception,
@@ -671,13 +651,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
 
             return
 
-        if (
-            self._connected
-            and not self._disconnected
-            and not isinstance(
-                exception, (ConnectionClosedByClient, ChannelClosedByClient)
-            )
-        ):
+        if self._can_reconnect(exception):
             self._logstash.error(
                 message="connection to rabbitmq closed unexpectedly, attempting to reconnect",
                 exception=exception,
@@ -696,13 +670,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
         try:
             connected_future = self.connect()
         except Exception as e:
-            if (
-                self._connected
-                and not self._disconnected
-                and not isinstance(
-                    e, (ConnectionClosedByClient, ChannelClosedByClient)
-                )
-            ):
+            if self._can_reconnect(e):
                 if not self._connected_future.done():
                     self._connected_future.set_result(None)
 
@@ -727,15 +695,18 @@ class RabbitMqManager(AsyncEventLoopMixin):
         if exception is None:
             return
 
-        if (
-            self._connected
-            and not self._disconnected
-            and not isinstance(
-                exception, (ConnectionClosedByClient, ChannelClosedByClient)
-            )
-        ):
+        if self._can_reconnect(exception):
             self._logstash.error(
                 message="couldn't reconnect to rabbitmq, attempting to reconnect",
                 exception=exception,
             )
             self._reconnect()
+
+    def _can_reconnect(self, exception: BaseException) -> bool:
+        return (
+            self._connected
+            and not self._disconnected
+            and not isinstance(
+                exception, (ConnectionClosedByClient, ChannelClosedByClient)
+            )
+        )

{qena_shared_lib-0.1.1 → qena_shared_lib-0.1.3}/src/qena_shared_lib/rabbitmq/_exception_handlers.py

@@ -49,6 +49,7 @@ def handle_rabbitmq_exception(
             "listenerName": context.listener_name,
             "exception": "RabbitMQException",
         },
+        exception=exception,
     )
 
 

{qena_shared_lib-0.1.1 → qena_shared_lib-0.1.3}/src/qena_shared_lib/scheduler.py

@@ -181,33 +181,34 @@ class ScheduleManager(AsyncEventLoopMixin):
 
     def __init__(
         self,
-        schedulers: list[Scheduler | type[SchedulerBase]],
         logstash: BaseLogstashSender,
         container: Container | None = None,
     ):
         self._container = container or Container()
         self._logstash = logstash
         self._scheduled_tasks: list[ScheduledTask] = []
-
-        for index, scheduler in enumerate(schedulers):
-            if isinstance(scheduler, Scheduler):
-                self._scheduled_tasks.extend(scheduler.scheduled_tasks)
-            elif isinstance(scheduler, type) and issubclass(
-                scheduler, SchedulerBase
-            ):
-                self._container.register(
-                    service=SchedulerBase,
-                    factory=scheduler,
-                    scope=Scope.singleton,
-                )
-            else:
-                raise TypeError(
-                    f"scheduler {index} is {type(scheduler)}, expected instance of type or subclass of `Scheduler` or `type[SchedulerBase]`"
-                )
-
         self._next_run_in = None
         self._logger = LoggerProvider.default().get_logger("schedule_manager")
 
+    def include_scheduler(self, scheduler: Scheduler | type[SchedulerBase]):
+        if isinstance(scheduler, Scheduler):
+            self._scheduled_tasks.extend(scheduler.scheduled_tasks)
+
+            return
+
+        if isinstance(scheduler, type) and issubclass(scheduler, SchedulerBase):
+            self._container.register(
+                service=SchedulerBase,
+                factory=scheduler,
+                scope=Scope.singleton,
+            )
+
+            return
+
+        raise TypeError(
+            f"scheduler is {type(scheduler)}, expected instance of type or subclass of `Scheduler` or `type[SchedulerBase]`"
+        )
+
     @property
     def container(self) -> Container:
         return self._container
@@ -226,10 +227,7 @@ class ScheduleManager(AsyncEventLoopMixin):
         if not self._aquired_lock():
             return
 
-        if (
-            getattr(self, "_scheduler_task", None) is not None
-            and not self._scheduler_task.done()
-        ):
+        if self._scheduler_task is not None and not self._scheduler_task.done():
             raise RuntimeError("scheduler already running")
 
         self.use_schedulers()
@@ -239,6 +237,8 @@ class ScheduleManager(AsyncEventLoopMixin):
             "tasks" if self.scheduled_task_count > 1 else "task",
         )
 
+        self._scheduler_task = None
+
         if self.scheduled_task_count == 0:
             return
 
@@ -255,7 +255,7 @@ class ScheduleManager(AsyncEventLoopMixin):
             self._scheduled_tasks.extend(scheduler.scheduled_tasks)
 
     def stop(self):
-        if not self._scheduler_task.done():
+        if self._scheduler_task is not None and not self._scheduler_task.done():
             self._scheduler_task.cancel()
 
         self.SCHEDULE_MANAGER_STATE.state("stopped")

{qena_shared_lib-0.1.1 → qena_shared_lib-0.1.3}/src/qena_shared_lib/security.py

@@ -26,14 +26,14 @@ __all__ = [
 ]
 
 
-MESSAGE = "you are not authorized to access request resouce"
+MESSAGE = "you are not authorized to access requested resource"
 RESPONSE_CODE = int(environ.get("UNAUTHORIZED_RESPONSE_CODE") or 0)
 
 
 class PasswordHasher(AsyncEventLoopMixin):
-    def __init__(self):
+    def __init__(self, schemes=None):
         self._crypt_context = CryptContext(
-            schemes=["bcrypt"], deprecated="auto"
+            schemes=schemes or ["bcrypt"], deprecated="auto"
         )
 
     def hash(self, password: str) -> Future[str]:
@@ -92,9 +92,15 @@ class UserInfo(BaseModel):
 async def extract_user_info(
     jwt_adapter: Annotated[JwtAdapter, DependsOn(JwtAdapter)],
     token: Annotated[
-        str | None, Header(alias=environ.get("TOKEN_HEADER") or "authorization")
+        str | None,
+        Header(
+            alias=environ.get("TOKEN_HEADER") or "authorization",
+            include_in_schema=False,
+        ),
+    ] = None,
+    user_agent: Annotated[
+        str | None, Header(alias="user-agent", include_in_schema=False)
     ] = None,
-    user_agent: Annotated[str | None, Header(alias="user-agent")] = None,
 ) -> UserInfo:
     extra = {"userAgent": user_agent} if user_agent is not None else None