python3-commons 0.0.0__py3-none-any.whl → 0.2.17__py3-none-any.whl

python3_commons/cache.py

@@ -1,7 +1,8 @@
 import logging
 import socket
+from collections.abc import Mapping, Sequence
 from platform import platform
-from typing import Any, Mapping, Sequence
+from typing import Any
 
 import valkey
 from pydantic import RedisDsn
@@ -34,10 +35,9 @@ class AsyncValkeyClient(metaclass=SingletonMeta):
 
     @staticmethod
     def _get_keepalive_options():
-        if platform == 'linux' or platform == 'darwin':
+        if platform in {'linux', 'darwin'}:
             return {socket.TCP_KEEPIDLE: 10, socket.TCP_KEEPINTVL: 5, socket.TCP_KEEPCNT: 5}
-        else:
-            return {}
+        return {}
 
     def _initialize_sentinel(self, dsn: RedisDsn):
         sentinel = Sentinel(
@@ -88,7 +88,7 @@ async def delete(*names: str | bytes | memoryview):
     await get_valkey_client().delete(*names)
 
 
-async def store_bytes(name: str, data: bytes, ttl: int = None, if_not_set: bool = False):
+async def store_bytes(name: str, data: bytes, ttl: int | None = None, *, if_not_set: bool = False):
     r = get_valkey_client()
 
     return await r.set(name, data, ex=ttl, nx=if_not_set)
@@ -100,18 +100,18 @@ async def get_bytes(name: str) -> bytes | None:
     return await r.get(name)
 
 
-async def store(name: str, obj: Any, ttl: int = None, if_not_set: bool = False):
-    return await store_bytes(name, serialize_msgpack_native(obj), ttl, if_not_set)
+async def store(name: str, obj: Any, ttl: int | None = None, *, if_not_set: bool = False):
+    return await store_bytes(name, serialize_msgpack_native(obj), ttl, if_not_set=if_not_set)
 
 
-async def get(name: str, default=None, data_type: Any = None) -> Any:
+async def get(name: str, default: Any | None = None, data_type: Any = None) -> Any | None:
     if data := await get_bytes(name):
         return deserialize_msgpack_native(data, data_type)
 
     return default
 
 
-async def store_string(name: str, data: str, ttl: int = None):
+async def store_string(name: str, data: str, ttl: int | None = None):
     await store_bytes(name, data.encode(), ttl)
 
 
@@ -122,7 +122,7 @@ async def get_string(name: str) -> str | None:
     return None
 
 
-async def store_sequence(name: str, data: Sequence, ttl: int = None):
+async def store_sequence(name: str, data: Sequence, ttl: int | None = None):
     if data:
         try:
             r = get_valkey_client()
@@ -130,8 +130,8 @@ async def store_sequence(name: str, data: Sequence, ttl: int = None):
 
             if ttl:
                 await r.expire(name, ttl)
-        except valkey.exceptions.ConnectionError as e:
-            logger.error(f'Failed to store sequence in cache: {e}')
+        except valkey.exceptions.ConnectionError:
+            logger.exception('Failed to store sequence in cache.')
 
 
 async def get_sequence(name: str, _type: type = list) -> Sequence:
@@ -141,7 +141,7 @@ async def get_sequence(name: str, _type: type = list) -> Sequence:
     return _type(map(deserialize_msgpack_native, lrange))
 
 
-async def store_dict(name: str, data: Mapping, ttl: int = None):
+async def store_dict(name: str, data: Mapping, ttl: int | None = None):
     if data:
         try:
             r = get_valkey_client()
@@ -150,22 +150,20 @@ async def store_dict(name: str, data: Mapping, ttl: int = None):
 
             if ttl:
                 await r.expire(name, ttl)
-        except valkey.exceptions.ConnectionError as e:
-            logger.error(f'Failed to store dict in cache: {e}')
+        except valkey.exceptions.ConnectionError:
+            logger.exception('Failed to store dict in cache.')
 
 
 async def get_dict(name: str, value_data_type=None) -> dict | None:
     r = get_valkey_client()
 
     if data := await r.hgetall(name):
-        data = {k.decode(): deserialize_msgpack(v, value_data_type) for k, v in data.items()}
-
-        return data
+        return {k.decode(): deserialize_msgpack(v, value_data_type) for k, v in data.items()}
 
     return None
 
 
-async def set_dict(name: str, mapping: dict, ttl: int = None):
+async def set_dict(name: str, mapping: dict, ttl: int | None = None):
     if mapping:
         try:
             r = get_valkey_client()
@@ -174,8 +172,8 @@ async def set_dict(name: str, mapping: dict, ttl: int = None):
 
             if ttl:
                 await r.expire(name, ttl)
-        except valkey.exceptions.ConnectionError as e:
-            logger.error(f'Failed to set dict in cache: {e}')
+        except valkey.exceptions.ConnectionError:
+            logger.exception('Failed to set dict in cache.')
 
 
 async def get_dict_item(name: str, key: str, data_type=None, default=None):
@@ -184,39 +182,39 @@ async def get_dict_item(name: str, key: str, data_type=None, default=None):
 
         if data := await r.hget(name, key):
             return deserialize_msgpack_native(data, data_type)
+    except valkey.exceptions.ConnectionError:
+        logger.exception('Failed to get dict item from cache.')
 
-        return default
-    except valkey.exceptions.ConnectionError as e:
-        logger.error(f'Failed to get dict item from cache: {e}')
+        return None
 
-    return None
+    return default
 
 
 async def set_dict_item(name: str, key: str, obj: Any):
     try:
         r = get_valkey_client()
         await r.hset(name, key, serialize_msgpack_native(obj))
-    except valkey.exceptions.ConnectionError as e:
-        logger.error(f'Failed to set dict item in cache: {e}')
+    except valkey.exceptions.ConnectionError:
+        logger.exception('Failed to set dict item in cache.')
 
 
 async def delete_dict_item(name: str, *keys):
     try:
         r = get_valkey_client()
         await r.hdel(name, *keys)
-    except valkey.exceptions.ConnectionError as e:
-        logger.error(f'Failed to delete dict item from cache: {e}')
+    except valkey.exceptions.ConnectionError:
+        logger.exception('Failed to delete dict item from cache.')
 
 
-async def store_set(name: str, value: set, ttl: int = None):
+async def store_set(name: str, value: set, ttl: int | None = None):
     try:
         r = get_valkey_client()
         await r.sadd(name, *map(serialize_msgpack_native, value))
 
         if ttl:
             await r.expire(name, ttl)
-    except valkey.exceptions.ConnectionError as e:
-        logger.error(f'Failed to store set in cache: {e}')
+    except valkey.exceptions.ConnectionError:
+        logger.exception('Failed to store set in cache.')
 
 
 async def has_set_item(name: str, value: str) -> bool:
@@ -224,8 +222,8 @@ async def has_set_item(name: str, value: str) -> bool:
         r = get_valkey_client()
 
         return await r.sismember(name, serialize_msgpack_native(value)) == 1
-    except valkey.exceptions.ConnectionError as e:
-        logger.error(f'Failed to check if set has item in cache: {e}')
+    except valkey.exceptions.ConnectionError:
+        logger.exception('Failed to check if set has item in cache.')
 
     return False
 
@@ -234,8 +232,8 @@ async def add_set_item(name: str, *values: str):
     try:
         r = get_valkey_client()
         await r.sadd(name, *map(serialize_msgpack_native, values))
-    except valkey.exceptions.ConnectionError as e:
-        logger.error(f'Failed to add set item into cache: {e}')
+    except valkey.exceptions.ConnectionError:
+        logger.exception('Failed to add set item into cache.')
 
 
 async def delete_set_item(name: str, value: str):
@@ -249,8 +247,8 @@ async def get_set_members(name: str) -> set[str] | None:
         smembers = await r.smembers(name)
 
         return set(map(deserialize_msgpack_native, smembers))
-    except valkey.exceptions.ConnectionError as e:
-        logger.error(f'Failed to get set members from cache: {e}')
+    except valkey.exceptions.ConnectionError:
+        logger.exception('Failed to get set members from cache.')
 
     return None
 

python3_commons/conf.py

@@ -1,4 +1,6 @@
-from pydantic import Field, HttpUrl, PostgresDsn, RedisDsn, SecretStr
+from typing import Literal
+
+from pydantic import Field, HttpUrl, PostgresDsn, RedisDsn, SecretStr, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
@@ -24,21 +26,50 @@ class ValkeySettings(BaseSettings):
 
 
 class DBSettings(BaseSettings):
-    model_config = SettingsConfigDict(env_prefix='DB_')
+    model_config = SettingsConfigDict(env_prefix='DB_', validate_by_name=True, validate_by_alias=True)
+
+    dsn: PostgresDsn | None = None
+    scheme: str = 'postgresql+asyncpg'
+    host: str = 'localhost'
+    port: int = 5432
+    name: str | None = None
+    user: str | None = None
+    password: SecretStr | None = Field(default=None, alias='DB_PASS')
 
-    dsn: PostgresDsn | None = Field(default=None, serialization_alias='url')
     echo: bool = False
     pool_size: int = 20
     max_overflow: int = 0
     pool_timeout: int = 30
     pool_recycle: int = 1800  # 30 minutes
 
+    @model_validator(mode='after')
+    def build_dsn_if_missing(self) -> 'DBSettings':
+        if self.dsn is None and all(
+            (
+                self.user,
+                self.password,
+                self.name,
+            )
+        ):
+            self.dsn = PostgresDsn.build(
+                scheme=self.scheme,
+                username=self.user,
+                password=self.password.get_secret_value() if self.password else None,
+                host=self.host,
+                port=self.port,
+                path=self.name,
+            )
+
+        return self
+
 
 class S3Settings(BaseSettings):
+    aws_region: str | None = None
+    aws_access_key_id: SecretStr | None = None
+    aws_secret_access_key: SecretStr | None = None
+
     s3_endpoint_url: str | None = None
-    s3_region_name: str | None = None
-    s3_access_key_id: SecretStr = ''
-    s3_secret_access_key: SecretStr = ''
+    s3_addressing_style: Literal['path', 'virtual'] = 'virtual'
     s3_secure: bool = True
     s3_bucket: str | None = None
     s3_bucket_root: str | None = None

python3_commons/db/__init__.py

@@ -1,6 +1,6 @@
 import contextlib
 import logging
-from typing import AsyncGenerator, Callable, Mapping
+from collections.abc import AsyncGenerator, Callable, Mapping
 
 from sqlalchemy import MetaData
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_engine_from_config
@@ -24,17 +24,22 @@ class AsyncSessionManager:
         try:
             return self.db_settings[name]
         except KeyError:
-            logger.error(f'Missing database settings: {name}')
+            logger.exception(f'Missing database settings: {name}')
 
             raise
 
     def async_engine_from_db_settings(self, name):
         db_settings = self.get_db_settings(name)
-        configuration = db_settings.model_dump(by_alias=True)
-        configuration['url'] = str(configuration['url'])
-        engine = async_engine_from_config(configuration, prefix='')
+        configuration = {
+            'url': str(db_settings.dsn),
+            'echo': db_settings.echo,
+            'pool_size': db_settings.pool_size,
+            'max_overflow': db_settings.max_overflow,
+            'pool_timeout': db_settings.pool_timeout,
+            'pool_recycle': db_settings.pool_recycle,
+        }
 
-        return engine
+        return async_engine_from_config(configuration, prefix='')
 
     def get_engine(self, name: str) -> AsyncEngine:
         try:
@@ -57,8 +62,8 @@ class AsyncSessionManager:
 
         return session_maker
 
-    def get_async_session(self, name: str) -> Callable[[], AsyncGenerator[AsyncSession, None]]:
-        async def get_session() -> AsyncGenerator[AsyncSession, None]:
+    def get_async_session(self, name: str) -> Callable[[], AsyncGenerator[AsyncSession]]:
+        async def get_session() -> AsyncGenerator[AsyncSession]:
             session_maker = self.get_session_maker(name)
 
             async with session_maker() as session:
@@ -77,7 +82,7 @@ async def is_healthy(engine: AsyncEngine) -> bool:
             result = await conn.execute('SELECT 1;')
 
             return result.scalar() == 1
-    except Exception as e:
-        logger.error(f'Database connection is not healthy: {e}')
+    except Exception:
+        logger.exception('Database connection is not healthy.')
 
         return False

python3_commons/db/helpers.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Mapping
+from collections.abc import Mapping
 
 import sqlalchemy as sa
 from sqlalchemy import asc, desc, func
@@ -26,11 +26,12 @@ def get_query(
         for order_by_col in order_by.split(','):
             if order_by_col.startswith('-'):
                 direction = desc
-                order_by_col = order_by_col[1:]
+                order_by_col_clean = order_by_col[1:]
             else:
                 direction = asc
+                order_by_col_clean = order_by_col
 
-            order_by_cols[order_by_col] = direction
+            order_by_cols[order_by_col_clean] = direction
 
         order_by_clauses = tuple(
             direction(columns[order_by_col][0]) for order_by_col, direction in order_by_cols.items()
@@ -54,9 +55,6 @@ def get_query(
     else:
         where_parts = None
 
-    if where_parts:
-        where_clause = sa.and_(*where_parts)
-    else:
-        where_clause = None
+    where_clause = sa.and_(*where_parts) if where_parts else None
 
     return where_clause, order_by_clauses

python3_commons/db/models/__init__.py

@@ -1,2 +1,8 @@
-from python3_commons.db.models.auth import ApiKey, User, UserGroup
-from python3_commons.db.models.rbac import RBACApiKeyRole, RBACPermission, RBACRole, RBACRolePermission, RBACUserRole
+from python3_commons.db.models.auth import ApiKey as ApiKey
+from python3_commons.db.models.auth import User as User
+from python3_commons.db.models.auth import UserGroup as UserGroup
+from python3_commons.db.models.rbac import RBACApiKeyRole as RBACApiKeyRole
+from python3_commons.db.models.rbac import RBACPermission as RBACPermission
+from python3_commons.db.models.rbac import RBACRole as RBACRole
+from python3_commons.db.models.rbac import RBACRolePermission as RBACRolePermission
+from python3_commons.db.models.rbac import RBACUserRole as RBACUserRole

python3_commons/db/models/auth.py

@@ -1,7 +1,7 @@
 import uuid
+from datetime import datetime
 
 from fastapi_users_db_sqlalchemy import GUID, SQLAlchemyBaseUserTableUUID
-from pydantic import AwareDatetime
 from sqlalchemy import BIGINT, DateTime, ForeignKey, String
 from sqlalchemy.orm import Mapped, mapped_column
 
@@ -32,4 +32,4 @@ class ApiKey(BaseDBUUIDModel, Base):
     )
     partner_name: Mapped[str] = mapped_column(String, unique=True)
     key: Mapped[str] = mapped_column(String, unique=True)
-    expires_at: Mapped[AwareDatetime | None] = mapped_column(DateTime(timezone=True))
+    expires_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))

python3_commons/db/models/common.py

@@ -1,4 +1,6 @@
-from pydantic import AwareDatetime
+import uuid
+from datetime import datetime
+
 from sqlalchemy import BIGINT, DateTime
 from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy.ext.compiler import compiles
@@ -25,15 +27,15 @@ def use_identity(element, compiler, **kw):
 
 class BaseDBModel:
     id: Mapped[int] = mapped_column(BIGINT, primary_key=True, sort_order=-3)
-    created_at: Mapped[AwareDatetime] = mapped_column(
+    created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True), nullable=False, server_default=UTCNow(), sort_order=-2
     )
-    updated_at: Mapped[AwareDatetime] = mapped_column(DateTime(timezone=True), onupdate=UTCNow(), sort_order=-1)
+    updated_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), onupdate=UTCNow(), sort_order=-1)
 
 
 class BaseDBUUIDModel:
-    uid: Mapped[UUID] = mapped_column(UUID, primary_key=True, sort_order=-3)
-    created_at: Mapped[AwareDatetime] = mapped_column(
+    uid: Mapped[uuid.UUID] = mapped_column(UUID, primary_key=True, sort_order=-3)
+    created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True), nullable=False, server_default=UTCNow(), sort_order=-2
     )
-    updated_at: Mapped[AwareDatetime | None] = mapped_column(DateTime(timezone=True), onupdate=UTCNow(), sort_order=-1)
+    updated_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), onupdate=UTCNow(), sort_order=-1)

python3_commons/db/models/rbac.py

@@ -1,7 +1,7 @@
 import uuid
+from datetime import datetime
 
 from fastapi_users_db_sqlalchemy import GUID
-from pydantic import AwareDatetime
 from sqlalchemy import CheckConstraint, DateTime, ForeignKey, PrimaryKeyConstraint, String
 from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy.orm import Mapped, mapped_column
@@ -55,8 +55,8 @@ class RBACUserRole(Base):
         ForeignKey('rbac_roles.uid', name='fk_rbac_user_roles_role', ondelete='CASCADE'),
         index=True,
     )
-    starts_at: Mapped[AwareDatetime] = mapped_column(DateTime(timezone=True), nullable=False)
-    expires_at: Mapped[AwareDatetime | None] = mapped_column(DateTime(timezone=True))
+    starts_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    expires_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
 
     __table_args__ = (PrimaryKeyConstraint('user_id', 'role_uid', name='pk_rbac_user_roles'),)
 
@@ -74,8 +74,8 @@ class RBACApiKeyRole(Base):
         ForeignKey('rbac_roles.uid', name='fk_rbac_api_key_roles_role', ondelete='CASCADE'),
         index=True,
     )
-    starts_at: Mapped[AwareDatetime] = mapped_column(DateTime(timezone=True), nullable=False)
-    expires_at: Mapped[AwareDatetime | None] = mapped_column(DateTime(timezone=True))
+    starts_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    expires_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
 
     __table_args__ = (PrimaryKeyConstraint('api_key_uid', 'role_uid', name='pk_rbac_api_key_roles'),)
 

python3_commons/fs.py

@@ -1,8 +1,8 @@
+from collections.abc import Generator
 from pathlib import Path
-from typing import Generator
 
 
-def iter_files(root: Path, recursive: bool = True) -> Generator[Path, None, None]:
+def iter_files(root: Path, *, recursive: bool = True) -> Generator[Path]:
     for item in root.iterdir():
         if item.is_file():
             yield item

python3_commons/helpers.py

@@ -1,10 +1,17 @@
+import functools
+import inspect
 import logging
 import shlex
 import threading
+import time
+from abc import ABCMeta
+from collections import defaultdict
+from collections.abc import Mapping, MutableMapping, Sequence
 from datetime import date, datetime, timedelta
 from decimal import ROUND_HALF_UP, Decimal
+from http.cookies import BaseCookie
 from json import dumps
-from typing import Literal, Mapping, Sequence
+from typing import ClassVar, Literal
 from urllib.parse import urlencode
 
 from python3_commons.serializers.json import CustomJSONEncoder
@@ -12,24 +19,24 @@ from python3_commons.serializers.json import CustomJSONEncoder
 logger = logging.getLogger(__name__)
 
 
-class SingletonMeta(type):
+class SingletonMeta(ABCMeta):
     """
     A metaclass that creates a Singleton base class when called.
     """
 
-    _instances = {}
-    _lock = threading.Lock()
+    __instances: ClassVar[MutableMapping] = {}
+    __locks: ClassVar[defaultdict] = defaultdict(threading.Lock)
 
     def __call__(cls, *args, **kwargs):
         try:
-            return cls._instances[cls]
+            return cls.__instances[cls]
         except KeyError:
-            with cls._lock:
+            with cls.__locks[cls]:
                 try:
-                    return cls._instances[cls]
+                    return cls.__instances[cls]
                 except KeyError:
-                    instance = super(SingletonMeta, cls).__call__(*args, **kwargs)
-                    cls._instances[cls] = instance
+                    instance = super().__call__(*args, **kwargs)
+                    cls.__instances[cls] = instance
 
                     return instance
 
@@ -56,13 +63,14 @@ def date_range(start_date, end_date):
 def tries(times):
     def func_wrapper(f):
         async def wrapper(*args, **kwargs):
-            for time in range(times if times > 0 else 1):
+            for _time in range(times if times > 0 else 1):
                 # noinspection PyBroadException
                 try:
                     return await f(*args, **kwargs)
-                except Exception as exc:
-                    if time >= times:
-                        raise exc
+                except Exception:
+                    if _time >= times:
+                        raise
+            return None
 
         return wrapper
 
@@ -81,6 +89,7 @@ def request_to_curl(
     query: Mapping | None = None,
     method: Literal['get', 'post', 'put', 'patch', 'options', 'head', 'delete'] = 'get',
     headers: Mapping | None = None,
+    cookies: BaseCookie[str] | None = None,
     json: Mapping | Sequence | str | None = None,
     data: bytes | None = None,
 ) -> str:
@@ -95,6 +104,10 @@ def request_to_curl(
             curl_cmd.append('-H')
             curl_cmd.append(shlex.quote(header_line))
 
+    if cookies:
+        cookie_str = '; '.join(f'{k}={v.value}' for k, v in cookies.items())
+        curl_cmd.extend(['-b', shlex.quote(cookie_str)])
+
     if json:
         curl_cmd.append('-H')
         curl_cmd.append(shlex.quote('Content-Type: application/json'))
@@ -106,3 +119,21 @@ def request_to_curl(
         curl_cmd.append(shlex.quote(data.decode('utf-8')))
 
     return ' '.join(curl_cmd)
+
+
+def log_execution_time(func):
+    _logger = logging.getLogger(func.__module__)
+
+    @functools.wraps(func)
+    async def wrapper(*args, **kwargs):
+        start_time = time.monotonic()
+
+        try:
+            return await func(*args, **kwargs)
+        finally:
+            elapsed = time.monotonic() - start_time
+            _logger.info(f'{func.__module__}.{func.__name__} executed in {elapsed:.4f} seconds')
+
+    wrapper.__signature__ = inspect.signature(func)
+
+    return wrapper