rb-commons 0.7.16__py3-none-any.whl → 0.7.18__py3-none-any.whl

rb_commons/broker/consumer.py

@@ -1,29 +1,29 @@
-from aio_pika import ExchangeType, IncomingMessage
-from rb_commons.configs.rabbitmq import RabbitMQConnection
-
-
-class BaseRabbitMQConsumer:
-    def __init__(self, exchange_name: str, queue_name: str, routing_key: str):
-        self.exchange_name = exchange_name
-        self.queue_name = queue_name
-        self.routing_key = routing_key
-
-    async def setup(self, channel):
-        exchange = await channel.declare_exchange(self.exchange_name, ExchangeType.DIRECT, durable=True)
-        queue = await channel.declare_queue(self.queue_name, durable=True)
-        await queue.bind(exchange, routing_key=self.routing_key)
-        return queue
-
-    async def consume(self):
-        async with RabbitMQConnection.get_channel() as channel:
-            queue = await self.setup(channel)
-            async with queue.iterator() as queue_iter:
-                async for message in queue_iter:
-                    await self.process_message(message)
-
-    async def process_message(self, message: IncomingMessage):
-        async with message.process():
-            await self.handle_message(message.body.decode())
-
-    async def handle_message(self, body: str):
+from aio_pika import ExchangeType, IncomingMessage
+from rb_commons.configs.rabbitmq import RabbitMQConnection
+
+
+class BaseRabbitMQConsumer:
+    def __init__(self, exchange_name: str, queue_name: str, routing_key: str):
+        self.exchange_name = exchange_name
+        self.queue_name = queue_name
+        self.routing_key = routing_key
+
+    async def setup(self, channel):
+        exchange = await channel.declare_exchange(self.exchange_name, ExchangeType.DIRECT, durable=True)
+        queue = await channel.declare_queue(self.queue_name, durable=True)
+        await queue.bind(exchange, routing_key=self.routing_key)
+        return queue
+
+    async def consume(self):
+        async with RabbitMQConnection.get_channel() as channel:
+            queue = await self.setup(channel)
+            async with queue.iterator() as queue_iter:
+                async for message in queue_iter:
+                    await self.process_message(message)
+
+    async def process_message(self, message: IncomingMessage):
+        async with message.process():
+            await self.handle_message(message.body.decode())
+
+    async def handle_message(self, body: str):
         raise NotImplementedError("This method should be overridden by subclasses.")

rb_commons/configs/config.py

@@ -1,52 +1,52 @@
-from typing import Optional, Any
-
-from pydantic import field_validator
-from pydantic_settings import BaseSettings
-
-class CommonConfigs(BaseSettings):
-    service_name: Optional[str] = None
-    service_port: Optional[int] = None
-    service_id: Optional[str] = None
-    service_hostname: Optional[Any] = '127.0.0.1'
-    service_host: Optional[str] = None
-
-#     db
-    POSTGRES_HOST: Optional[str] = None
-    POSTGRES_USER: Optional[str] = None
-    POSTGRES_PORT: Optional[int] = None
-    POSTGRES_PASSWORD: Optional[str] = None
-    POSTGRES_DB: Optional[str] = None
-    DB_ALEMBIC_URL: Optional[str] = None
-
-    # Broker
-
-    RABBITMQ_URL: Optional[str] = None
-
-    DIGITALOCEAN_STORAGE_BUCKET_NAME: Optional[str] = None
-    DIGITALOCEAN_S3_ENDPOINT_URL: Optional[str] = None
-
-    @property
-    def database_url(self) -> Optional[str]:
-        """Construct the database URL if all required fields are present."""
-        required_fields = [
-            self.POSTGRES_USER,
-            self.POSTGRES_PASSWORD,
-            self.POSTGRES_HOST,
-            self.POSTGRES_PORT,
-            self.POSTGRES_DB
-        ]
-        if all(required_fields):
-            return (
-                f"postgresql+asyncpg://{self.POSTGRES_USER}:"
-                f"{self.POSTGRES_PASSWORD}@{self.POSTGRES_HOST}:"
-                f"{self.POSTGRES_PORT}/{self.POSTGRES_DB}"
-            )
-        return None
-
-    class Config:
-        env_file = ".env"
-        env_file_encoding = "utf-8"
-        extra = "ignore"
-
-
+from typing import Optional, Any
+
+from pydantic import field_validator
+from pydantic_settings import BaseSettings
+
+class CommonConfigs(BaseSettings):
+    service_name: Optional[str] = None
+    service_port: Optional[int] = None
+    service_id: Optional[str] = None
+    service_hostname: Optional[Any] = '127.0.0.1'
+    service_host: Optional[str] = None
+
+#     db
+    POSTGRES_HOST: Optional[str] = None
+    POSTGRES_USER: Optional[str] = None
+    POSTGRES_PORT: Optional[int] = None
+    POSTGRES_PASSWORD: Optional[str] = None
+    POSTGRES_DB: Optional[str] = None
+    DB_ALEMBIC_URL: Optional[str] = None
+
+    # Broker
+
+    RABBITMQ_URL: Optional[str] = None
+
+    DIGITALOCEAN_STORAGE_BUCKET_NAME: Optional[str] = None
+    DIGITALOCEAN_S3_ENDPOINT_URL: Optional[str] = None
+
+    @property
+    def database_url(self) -> Optional[str]:
+        """Construct the database URL if all required fields are present."""
+        required_fields = [
+            self.POSTGRES_USER,
+            self.POSTGRES_PASSWORD,
+            self.POSTGRES_HOST,
+            self.POSTGRES_PORT,
+            self.POSTGRES_DB
+        ]
+        if all(required_fields):
+            return (
+                f"postgresql+asyncpg://{self.POSTGRES_USER}:"
+                f"{self.POSTGRES_PASSWORD}@{self.POSTGRES_HOST}:"
+                f"{self.POSTGRES_PORT}/{self.POSTGRES_DB}"
+            )
+        return None
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+
+
 configs = CommonConfigs()

rb_commons/configs/injections.py

@@ -1,9 +1,9 @@
-from typing import Annotated
-from rb_commons.schemes.jwt import Claims
-from fastapi import Request, Depends
-
-
-async def get_claims(request: Request) -> Claims:
-    return Claims.from_headers(dict(request.headers))
-
+from typing import Annotated
+from rb_commons.schemes.jwt import Claims
+from fastapi import Request, Depends
+
+
+async def get_claims(request: Request) -> Claims:
+    return Claims.from_headers(dict(request.headers))
+
 ClaimsDep = Annotated[Claims, Depends(get_claims)]

rb_commons/configs/rabbitmq.py

@@ -1,26 +1,26 @@
-from contextlib import asynccontextmanager
-from aio_pika import connect_robust, Message, ExchangeType
-from rb_commons.configs.config import configs
-
-class RabbitMQConnection:
-    _connection = None
-    _channel = None
-
-    @classmethod
-    @asynccontextmanager
-    async def get_channel(cls):
-        if not cls._connection:
-            cls._connection = await connect_robust(configs.RABBITMQ_URL)
-            cls._channel = await cls._connection.channel()
-
-        try:
-            yield cls._channel
-        finally:
-            pass
-
-    @classmethod
-    async def close(cls):
-        if cls._connection:
-            await cls._connection.close()
-            cls._connection = None
+from contextlib import asynccontextmanager
+from aio_pika import connect_robust, Message, ExchangeType
+from rb_commons.configs.config import configs
+
+class RabbitMQConnection:
+    _connection = None
+    _channel = None
+
+    @classmethod
+    @asynccontextmanager
+    async def get_channel(cls):
+        if not cls._connection:
+            cls._connection = await connect_robust(configs.RABBITMQ_URL)
+            cls._channel = await cls._connection.channel()
+
+        try:
+            yield cls._channel
+        finally:
+            pass
+
+    @classmethod
+    async def close(cls):
+        if cls._connection:
+            await cls._connection.close()
+            cls._connection = None
             cls._channel = None

rb_commons/configs/v2/config.py

@@ -1,52 +1,52 @@
-from typing import Optional, Any
-
-from pydantic import field_validator
-from pydantic_settings import BaseSettings
-
-class CommonConfigs(BaseSettings):
-    service_name: Optional[str] = None
-    service_port: Optional[int] = None
-    service_id: Optional[str] = None
-    service_hostname: Optional[Any] = '127.0.0.1'
-    service_host: Optional[str] = None
-
-#     db
-    POSTGRES_HOST: Optional[str] = None
-    POSTGRES_USER: Optional[str] = None
-    POSTGRES_PORT: Optional[int] = None
-    POSTGRES_PASSWORD: Optional[str] = None
-    POSTGRES_DB: Optional[str] = None
-    DB_ALEMBIC_URL: Optional[str] = None
-
-    # Broker
-
-    RABBITMQ_URL: Optional[str] = None
-
-    DIGITALOCEAN_STORAGE_BUCKET_NAME: Optional[str] = None
-    DIGITALOCEAN_S3_ENDPOINT_URL: Optional[str] = None
-
-    @property
-    def database_url(self) -> Optional[str]:
-        """Construct the database URL if all required fields are present."""
-        required_fields = [
-            self.POSTGRES_USER,
-            self.POSTGRES_PASSWORD,
-            self.POSTGRES_HOST,
-            self.POSTGRES_PORT,
-            self.POSTGRES_DB
-        ]
-        if all(required_fields):
-            return (
-                f"postgresql+asyncpg://{self.POSTGRES_USER}:"
-                f"{self.POSTGRES_PASSWORD}@{self.POSTGRES_HOST}:"
-                f"{self.POSTGRES_PORT}/{self.POSTGRES_DB}"
-            )
-        return None
-
-    class Config:
-        env_file = "/robosell/.env"
-        env_file_encoding = "utf-8"
-        extra = "ignore"
-
-
+from typing import Optional, Any
+
+from pydantic import field_validator
+from pydantic_settings import BaseSettings
+
+class CommonConfigs(BaseSettings):
+    service_name: Optional[str] = None
+    service_port: Optional[int] = None
+    service_id: Optional[str] = None
+    service_hostname: Optional[Any] = '127.0.0.1'
+    service_host: Optional[str] = None
+
+#     db
+    POSTGRES_HOST: Optional[str] = None
+    POSTGRES_USER: Optional[str] = None
+    POSTGRES_PORT: Optional[int] = None
+    POSTGRES_PASSWORD: Optional[str] = None
+    POSTGRES_DB: Optional[str] = None
+    DB_ALEMBIC_URL: Optional[str] = None
+
+    # Broker
+
+    RABBITMQ_URL: Optional[str] = None
+
+    DIGITALOCEAN_STORAGE_BUCKET_NAME: Optional[str] = None
+    DIGITALOCEAN_S3_ENDPOINT_URL: Optional[str] = None
+
+    @property
+    def database_url(self) -> Optional[str]:
+        """Construct the database URL if all required fields are present."""
+        required_fields = [
+            self.POSTGRES_USER,
+            self.POSTGRES_PASSWORD,
+            self.POSTGRES_HOST,
+            self.POSTGRES_PORT,
+            self.POSTGRES_DB
+        ]
+        if all(required_fields):
+            return (
+                f"postgresql+asyncpg://{self.POSTGRES_USER}:"
+                f"{self.POSTGRES_PASSWORD}@{self.POSTGRES_HOST}:"
+                f"{self.POSTGRES_PORT}/{self.POSTGRES_DB}"
+            )
+        return None
+
+    class Config:
+        env_file = "/robosell/.env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+
+
 configs = CommonConfigs()

rb_commons/http/base_api.py

@@ -1,96 +1,96 @@
-import json
-import requests
-from rb_commons.http.exceptions import BadRequestException, InternalException
-from requests import RequestException
-
-class BaseAPI:
-    def __init__(self, base_url: str):
-        self.BASE_URL = base_url
-
-    def _make_request(self, method: str, path: str, data: dict = None,
-                      params: dict = None, headers: dict = None, reset_base_url: bool = False, form_encoded: bool = False) -> requests.Response:
-        """
-        A general method to make HTTP requests (GET, POST, etc.)
-
-        This method abstracts the process of making HTTP requests, allowing for
-        different types of requests (GET, POST, PUT, DELETE) to be easily performed
-        by specifying the method and other parameters. This adheres to the DRY
-        (Don't Repeat Yourself) principle by centralizing request handling.
-
-        :param method: HTTP method to use for the request (e.g., 'GET', 'POST', 'PUT', 'DELETE').
-        :param path: The API endpoint path to which the request is made. This should be
-                     relative to the base URL defined in the class.
-        :param data: Optional dictionary containing the data to be sent in the body of
-                     the request (used for POST and PUT requests). Default is None.
-        :param params: Optional dictionary containing query parameters to be included
-                       in the request URL. Default is None.
-        :param headers: Optional dictionary containing any custom headers to be sent
-                        with the request. Default is None.
-        :return: Response object containing the server's response to the HTTP request.
-        :raises HttpException: Raises a custom HttpException if the request fails for
-                             any reason, including invalid HTTP methods, network issues,
-                             or JSON parsing errors.
-
-        The method constructs the full URL from the base URL and the provided path.
-        It uses a dictionary to map HTTP methods to their respective request functions
-        from the requests library. After making the request, it checks the response
-        status and attempts to parse the response as JSON.
-        """
-        url = self.BASE_URL + path
-
-        if reset_base_url:
-            url = path
-
-        try:
-            request_methods = {
-                'POST': requests.post,
-                'GET': requests.get,
-                'PUT': requests.put,
-                'DELETE': requests.delete
-            }
-
-            if method not in request_methods:
-                raise BadRequestException(f"Unsupported HTTP method: {method}")
-
-            kwargs = {
-                'params': params,
-                'headers': headers,
-                'data' if form_encoded else 'json': data
-            }
-
-            response = request_methods[method](url, **kwargs)
-
-            try:
-                if response.text.strip():
-                    data = response.json()
-                else:
-                    data = {}
-            except ValueError as e:
-                error_message = data.get("message") or data.get("detail") or response.text
-                raise BadRequestException(f"Invalid JSON response", additional_info={"error_message": error_message})
-            if not (200 <= response.status_code < 300):
-                error_message = data.get("message") or data.get("detail") or response.text
-                raise BadRequestException(f"Unexpected error occured", additional_info={"error_message": error_message})
-
-            return response
-
-        except RequestException as e:
-            raise BadRequestException(f"Request exception: {str(e)}", additional_info={"error_message": str(e)})
-        except BadRequestException:
-            raise
-        except (json.JSONDecodeError, ValueError) as e:
-            raise InternalException(f"Failed to parse JSON: {str(e)}")
-        except Exception as e:
-            raise InternalException(f"Unhandled error: {str(e)}")
-
-    def _post(self, path: str, data: dict | list, headers: dict = None, params: dict = None, reset_base_url: bool = False, form_encoded: bool = False) -> requests.Response:
-        return self._make_request('POST', path, data=data, headers=headers, params=params, reset_base_url=reset_base_url, form_encoded=form_encoded)
-
-    def _get(self, path: str, params: dict = None, headers: dict = None, reset_base_url: bool = False, form_encoded: bool = False) -> requests.Response:
-        return self._make_request('GET', path, params=params, headers=headers, reset_base_url=reset_base_url, form_encoded=form_encoded)
-
-    def _put(self, path: str, params: dict = None, data: dict = None, headers: dict = None, reset_base_url: bool = False, form_encoded: bool = False) -> requests.Response:
-        return self._make_request('PUT', path, params=params, data=data, headers=headers, reset_base_url=reset_base_url, form_encoded=form_encoded)
-
-    def _delete(self, path: str, headers: dict = None, reset_base_url: bool = False, form_encoded: bool = False) -> requests.Response:
-        return self._make_request('DELETE', path, headers=headers, reset_base_url=reset_base_url, form_encoded=form_encoded)
+import json
+import requests
+from rb_commons.http.exceptions import BadRequestException, InternalException
+from requests import RequestException
+
+class BaseAPI:
+    def __init__(self, base_url: str):
+        self.BASE_URL = base_url
+
+    def _make_request(self, method: str, path: str, data: dict = None,
+                      params: dict = None, headers: dict = None, reset_base_url: bool = False, form_encoded: bool = False) -> requests.Response:
+        """
+        A general method to make HTTP requests (GET, POST, etc.)
+
+        This method abstracts the process of making HTTP requests, allowing for
+        different types of requests (GET, POST, PUT, DELETE) to be easily performed
+        by specifying the method and other parameters. This adheres to the DRY
+        (Don't Repeat Yourself) principle by centralizing request handling.
+
+        :param method: HTTP method to use for the request (e.g., 'GET', 'POST', 'PUT', 'DELETE').
+        :param path: The API endpoint path to which the request is made. This should be
+                     relative to the base URL defined in the class.
+        :param data: Optional dictionary containing the data to be sent in the body of
+                     the request (used for POST and PUT requests). Default is None.
+        :param params: Optional dictionary containing query parameters to be included
+                       in the request URL. Default is None.
+        :param headers: Optional dictionary containing any custom headers to be sent
+                        with the request. Default is None.
+        :return: Response object containing the server's response to the HTTP request.
+        :raises HttpException: Raises a custom HttpException if the request fails for
+                             any reason, including invalid HTTP methods, network issues,
+                             or JSON parsing errors.
+
+        The method constructs the full URL from the base URL and the provided path.
+        It uses a dictionary to map HTTP methods to their respective request functions
+        from the requests library. After making the request, it checks the response
+        status and attempts to parse the response as JSON.
+        """
+        url = self.BASE_URL + path
+
+        if reset_base_url:
+            url = path
+
+        try:
+            request_methods = {
+                'POST': requests.post,
+                'GET': requests.get,
+                'PUT': requests.put,
+                'DELETE': requests.delete
+            }
+
+            if method not in request_methods:
+                raise BadRequestException(f"Unsupported HTTP method: {method}")
+
+            kwargs = {
+                'params': params,
+                'headers': headers,
+                'data' if form_encoded else 'json': data
+            }
+
+            response = request_methods[method](url, **kwargs)
+
+            try:
+                if response.text.strip():
+                    data = response.json()
+                else:
+                    data = {}
+            except ValueError as e:
+                error_message = data.get("message") or data.get("detail") or response.text
+                raise BadRequestException(f"Invalid JSON response", additional_info={"error_message": error_message})
+            if not (200 <= response.status_code < 300):
+                error_message = data.get("message") or data.get("detail") or response.text
+                raise BadRequestException(f"Unexpected error occured", additional_info={"error_message": error_message})
+
+            return response
+
+        except RequestException as e:
+            raise BadRequestException(f"Request exception: {str(e)}", additional_info={"error_message": str(e)})
+        except BadRequestException:
+            raise
+        except (json.JSONDecodeError, ValueError) as e:
+            raise InternalException(f"Failed to parse JSON: {str(e)}")
+        except Exception as e:
+            raise InternalException(f"Unhandled error: {str(e)}")
+
+    def _post(self, path: str, data: dict | list, headers: dict = None, params: dict = None, reset_base_url: bool = False, form_encoded: bool = False) -> requests.Response:
+        return self._make_request('POST', path, data=data, headers=headers, params=params, reset_base_url=reset_base_url, form_encoded=form_encoded)
+
+    def _get(self, path: str, params: dict = None, headers: dict = None, reset_base_url: bool = False, form_encoded: bool = False) -> requests.Response:
+        return self._make_request('GET', path, params=params, headers=headers, reset_base_url=reset_base_url, form_encoded=form_encoded)
+
+    def _put(self, path: str, params: dict = None, data: dict = None, headers: dict = None, reset_base_url: bool = False, form_encoded: bool = False) -> requests.Response:
+        return self._make_request('PUT', path, params=params, data=data, headers=headers, reset_base_url=reset_base_url, form_encoded=form_encoded)
+
+    def _delete(self, path: str, headers: dict = None, reset_base_url: bool = False, form_encoded: bool = False) -> requests.Response:
+        return self._make_request('DELETE', path, headers=headers, reset_base_url=reset_base_url, form_encoded=form_encoded)

rb_commons/http/consul.py

@@ -1,44 +1,44 @@
-import aiocache
-import consul
-from fastapi import HTTPException, Request
-from rb_commons.configs.config import configs
-
-
-class ServiceDiscovery:
-    def __init__(self, host: str, port: int) -> None:
-        self.consul_client = consul.Consul(host=host, port=port)
-        self.cache = aiocache.Cache(aiocache.SimpleMemoryCache)
-
-    async def _get_service_instances(self, service_name: str) -> dict:
-        """Get a healthy service instance from Consul"""
-        index, services = self.consul_client.health.service(service_name, passing=True)
-
-        if not services:
-            raise HTTPException(status_code=503,
-                                detail="Service not available")
-        return services
-
-    def _select_instance(self, instances: list, host: str) -> dict:
-        """Select instance using consistent hashing"""
-        if not instances:
-            raise HTTPException(status_code=503, detail="No healthy instances")
-
-        key = host
-        hash_value = hash(key)
-        return instances[hash_value % len(instances)]
-
-    async def _get_cached_service_instances(self, service_name: str) -> list:
-        """Get service instances with caching"""
-        cache_key = f"service:{service_name}"
-        instances = await self.cache.get(cache_key)
-        if not instances:
-            instances = await self._get_service_instances(service_name)
-            if instances:
-                await self.cache.set(cache_key, instances, ttl=30)  # Cache for 30 seconds
-        return instances
-
-    def _build_instance_url(self, instance: dict) -> str:
-        """Build target URL with proper path handling"""
-        service_address = instance['Service']['Address'] or instance['Node']['Address']
-        service_port = instance['Service']['Port']
+import aiocache
+import consul
+from fastapi import HTTPException, Request
+from rb_commons.configs.config import configs
+
+
+class ServiceDiscovery:
+    def __init__(self, host: str, port: int) -> None:
+        self.consul_client = consul.Consul(host=host, port=port)
+        self.cache = aiocache.Cache(aiocache.SimpleMemoryCache)
+
+    async def _get_service_instances(self, service_name: str) -> dict:
+        """Get a healthy service instance from Consul"""
+        index, services = self.consul_client.health.service(service_name, passing=True)
+
+        if not services:
+            raise HTTPException(status_code=503,
+                                detail="Service not available")
+        return services
+
+    def _select_instance(self, instances: list, host: str) -> dict:
+        """Select instance using consistent hashing"""
+        if not instances:
+            raise HTTPException(status_code=503, detail="No healthy instances")
+
+        key = host
+        hash_value = hash(key)
+        return instances[hash_value % len(instances)]
+
+    async def _get_cached_service_instances(self, service_name: str) -> list:
+        """Get service instances with caching"""
+        cache_key = f"service:{service_name}"
+        instances = await self.cache.get(cache_key)
+        if not instances:
+            instances = await self._get_service_instances(service_name)
+            if instances:
+                await self.cache.set(cache_key, instances, ttl=30)  # Cache for 30 seconds
+        return instances
+
+    def _build_instance_url(self, instance: dict) -> str:
+        """Build target URL with proper path handling"""
+        service_address = instance['Service']['Address'] or instance['Node']['Address']
+        service_port = instance['Service']['Port']
         return f"http://{service_address}:{service_port}"