python3-commons 0.9.18__tar.gz → 0.9.20__tar.gz

{python3_commons-0.9.18 → python3_commons-0.9.20}/.github/workflows/python-publish.yaml

@@ -21,16 +21,16 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
 
     - name: Install uv
-      uses: astral-sh/setup-uv@v5
+      uses: astral-sh/setup-uv@v6
       with:
         enable-cache: true
         cache-dependency-glob: "uv.lock"
 
     - name: "Set up Python"
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version-file: "pyproject.toml"
 

{python3_commons-0.9.18 → python3_commons-0.9.20}/.github/workflows/release-on-tag-push.yml

@@ -26,16 +26,16 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true
           cache-dependency-glob: "uv.lock"
 
       - name: "Set up Python"
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version-file: "pyproject.toml"
 

{python3_commons-0.9.18 → python3_commons-0.9.20}/.pre-commit-config.yaml

@@ -1,12 +1,12 @@
 repos:
   - repo: https://github.com/astral-sh/uv-pre-commit
-    rev: 0.8.16
+    rev: 0.8.20
     hooks:
       - id: uv-lock
 #      - id: uv-export
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.13.0
+    rev: v0.13.1
     hooks:
       # Run the linter.
       - id: ruff-check

{python3_commons-0.9.18 → python3_commons-0.9.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python3-commons
-Version: 0.9.18
+Version: 0.9.20
 Summary: Re-usable Python3 code
 Author-email: Oleg Korsak <kamikaze.is.waiting.you@gmail.com>
 License-Expression: GPL-3.0
@@ -17,15 +17,15 @@ Requires-Dist: aiohttp[speedups]~=3.12.15
 Requires-Dist: asyncpg~=0.30.0
 Requires-Dist: fastapi-users-db-sqlalchemy~=7.0.0
 Requires-Dist: fastapi-users[sqlalchemy]~=14.0.1
-Requires-Dist: lxml~=6.0.1
+Requires-Dist: lxml~=6.0.2
 Requires-Dist: msgpack~=1.1.1
 Requires-Dist: msgspec~=0.19.0
-Requires-Dist: pydantic[email]~=2.11.7
+Requires-Dist: pydantic[email]~=2.11.9
 Requires-Dist: pydantic-settings~=2.10.1
 Requires-Dist: python-jose==3.5.0
 Requires-Dist: SQLAlchemy[asyncio]~=2.0.43
 Requires-Dist: valkey[libvalkey]~=6.1.1
-Requires-Dist: zeep~=4.3.1
+Requires-Dist: zeep~=4.3.2
 Dynamic: license-file
 
 Re-usable Python3 code

{python3_commons-0.9.18 → python3_commons-0.9.20}/pyproject.toml

@@ -17,22 +17,21 @@ classifiers = [
 ]
 keywords = []
 requires-python = "==3.13.*"
-
 dependencies = [
     "aiobotocore~=2.24.2",
     "aiohttp[speedups]~=3.12.15",
     "asyncpg~=0.30.0",
     "fastapi-users-db-sqlalchemy~=7.0.0",
     "fastapi-users[sqlalchemy]~=14.0.1",
-    "lxml~=6.0.1",
+    "lxml~=6.0.2",
     "msgpack~=1.1.1",
     "msgspec~=0.19.0",
-    "pydantic[email]~=2.11.7",
+    "pydantic[email]~=2.11.9",
     "pydantic-settings~=2.10.1",
     "python-jose==3.5.0",
     "SQLAlchemy[asyncio]~=2.0.43",
     "valkey[libvalkey]~=6.1.1",
-    "zeep~=4.3.1"
+    "zeep~=4.3.2"
 ]
 
 [dependency-groups]
@@ -51,7 +50,7 @@ testing = [
     "pytest",
     "pytest-asyncio",
     "pytest-cov",
-    "pytest-mock"
+    "pytest-mock",
 ]
 
 [project.urls]
@@ -67,13 +66,6 @@ exclude = ["tests"]
 [tool.bdist_wheel]
 universal = true
 
-[tool.pytest.ini_options]
-addopts = [
-    "--verbose"
-]
-norecursedirs = ["dist", "build", ".tox"]
-testpaths = ["tests"]
-
 [tool.ruff]
 line-length = 120
 indent-width = 4
@@ -82,8 +74,69 @@ target-version = "py313"
 [tool.ruff.analyze]
 detect-string-imports = true
 
+[tool.ruff.lint]
+select = [
+    "FAST",
+    "YTT",
+#    "ANN",
+    "I",
+    "E",
+    "W",
+    "PYI",
+
+    "A",
+#    "ARG",
+    "ASYNC",
+    "B",
+    "C4",
+#    "DTZ",
+    "EM",
+    "EXE",
+    "F",
+    "FA",
+    "FBT",
+    "FLY",
+    "FURB",
+#    "G",
+    "ICN",
+    "INP",
+    "ISC",
+    "LOG",
+    "N",
+    "NPY",
+    "PD",
+    "PERF",
+    "PIE",
+    "PLC",
+    "PLE",
+#    "PLR",
+    "PLW",
+    "PT",
+    "PTH",
+    "Q",
+#    "RET",
+    "RSE",
+#    "RUF",
+    "S",
+    "SIM",
+    "SLF",
+    "SLOT",
+    "T20",
+    "TC",
+    "TID",
+    "TRY",
+    "UP",
+]
+ignore = [
+    "ASYNC109",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*.py" = ["S101"]
+
 [tool.ruff.lint.flake8-quotes]
 docstring-quotes = "double"
+inline-quotes = "single"
 
 [tool.ruff.format]
 exclude = ["*.pyi"]
@@ -95,3 +148,11 @@ venvPath = "."
 venv = ".venv"
 reportMatchNotExhaustive = "error"
 reportUnnecessaryComparison = "error"
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+asyncio_mode = "strict"
+asyncio_default_fixture_loop_scope = "function"
+addopts = "--cov biab_legal_mate --cov-fail-under=20 --cov-report term-missing --verbose"
+norecursedirs = ["dist", "build", ".tox"]
+testpaths = ["tests"]

{python3_commons-0.9.18 → python3_commons-0.9.20}/src/python3_commons/api_client.py

@@ -1,10 +1,12 @@
+import errno
 import logging
+from collections.abc import AsyncGenerator, Mapping, Sequence
 from contextlib import asynccontextmanager
 from datetime import UTC, datetime
 from enum import Enum
 from http import HTTPStatus
 from json import dumps
-from typing import AsyncGenerator, Literal, Mapping, Sequence
+from typing import Literal
 from uuid import uuid4
 
 from aiohttp import ClientResponse, ClientSession, ClientTimeout, client_exceptions
@@ -52,8 +54,8 @@ async def request(
     date_path = now.strftime('%Y/%m/%d')
     timestamp = now.strftime('%H%M%S_%f')
     request_id = str(uuid4())[-12:]
-    uri_path = uri[:-1] if uri.endswith('/') else uri
-    uri_path = uri_path[1:] if uri_path.startswith('/') else uri_path
+    uri_path = uri.removesuffix('/')
+    uri_path = uri_path.removeprefix('/')
     url = f'{u[:-1] if (u := str(base_url)).endswith("/") else u}{uri}'
 
     if audit_name:
@@ -90,15 +92,25 @@ async def request(
                 else:
                     match response.status:
                         case HTTPStatus.UNAUTHORIZED:
-                            raise PermissionError('Unauthorized')
+                            msg = 'Unauthorized'
+
+                            raise PermissionError(msg)
                         case HTTPStatus.FORBIDDEN:
-                            raise PermissionError('Forbidden')
+                            msg = 'Forbidden'
+
+                            raise PermissionError(msg)
                         case HTTPStatus.NOT_FOUND:
-                            raise LookupError('Not found')
+                            msg = 'Not found'
+
+                            raise LookupError(msg)
                         case HTTPStatus.BAD_REQUEST:
-                            raise ValueError('Bad request')
+                            msg = 'Bad request'
+
+                            raise ValueError(msg)
                         case HTTPStatus.TOO_MANY_REQUESTS:
-                            raise InterruptedError('Too many requests')
+                            msg = 'Too many requests'
+
+                            raise InterruptedError(msg)
                         case _:
                             response.raise_for_status()
         else:
@@ -116,13 +128,21 @@ async def request(
 
                 yield response
     except client_exceptions.ClientConnectorError as e:
-        raise ConnectionRefusedError('Cient connection error') from e
+        msg = 'Cient connection error'
+
+        raise ConnectionRefusedError(msg) from e
     except client_exceptions.ClientOSError as e:
-        if e.errno == 32:
-            raise ConnectionResetError('Broken pipe') from e
-        elif e.errno == 104:
-            raise ConnectionResetError('Connection reset by peer') from e
+        if e.errno == errno.EPIPE:
+            msg = 'Broken pipe'
+
+            raise ConnectionResetError(msg) from e
+        elif e.errno == errno.ECONNRESET:
+            msg = 'Connection reset by peer'
+
+            raise ConnectionResetError(msg) from e
 
         raise
     except client_exceptions.ServerDisconnectedError as e:
-        raise ConnectionResetError('Server disconnected') from e
+        msg = 'Server disconnected'
+
+        raise ConnectionResetError(msg) from e

{python3_commons-0.9.18 → python3_commons-0.9.20}/src/python3_commons/audit.py

@@ -143,8 +143,8 @@ async def write_audit_data(settings: S3Settings, key: str, data: bytes):
             absolute_path = object_storage.get_absolute_path(f'audit/{key}')
 
             await object_storage.put_object(settings.s3_bucket, absolute_path, io.BytesIO(data), len(data))
-        except Exception as e:
-            logger.error(f'Failed storing object in storage: {e}')
+        except Exception:
+            logger.exception('Failed storing object in storage.')
         else:
             logger.debug(f'Stored object in storage: {key}')
     else:

{python3_commons-0.9.18 → python3_commons-0.9.20}/src/python3_commons/auth.py

@@ -1,6 +1,7 @@
 import logging
+from collections.abc import Callable, Coroutine, MutableMapping, Sequence
 from http import HTTPStatus
-from typing import Annotated, Any, Callable, Coroutine, Sequence, Type, TypeVar
+from typing import Annotated, Any, TypeVar
 
 import aiohttp
 import msgspec
@@ -21,10 +22,7 @@ class TokenData(msgspec.Struct):
 
 
 T = TypeVar('T', bound=TokenData)
-
 OIDC_CONFIG_URL = f'{oidc_settings.authority_url}/.well-known/openid-configuration'
-_JWKS: dict | None = None
-
 bearer_security = HTTPBearer(auto_error=oidc_settings.enabled)
 
 
@@ -32,58 +30,59 @@ async def fetch_openid_config() -> dict:
     """
     Fetch the OpenID configuration (including JWKS URI) from OIDC authority.
     """
-    async with aiohttp.ClientSession() as session:
-        async with session.get(OIDC_CONFIG_URL) as response:
-            if response.status != HTTPStatus.OK:
-                raise HTTPException(
-                    status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail='Failed to fetch OpenID configuration'
-                )
+    async with aiohttp.ClientSession() as session, session.get(OIDC_CONFIG_URL) as response:
+        if response.status != HTTPStatus.OK:
+            raise HTTPException(
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail='Failed to fetch OpenID configuration'
+            )
 
-            return await response.json()
+        return await response.json()
 
 
 async def fetch_jwks(jwks_uri: str) -> dict:
     """
     Fetch the JSON Web Key Set (JWKS) for validating the token's signature.
     """
-    async with aiohttp.ClientSession() as session:
-        async with session.get(jwks_uri) as response:
-            if response.status != HTTPStatus.OK:
-                raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail='Failed to fetch JWKS')
+    async with aiohttp.ClientSession() as session, session.get(jwks_uri) as response:
+        if response.status != HTTPStatus.OK:
+            raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail='Failed to fetch JWKS')
 
-            return await response.json()
+        return await response.json()
 
 
-def get_token_verifier(token_cls: Type[T]) -> Callable[[HTTPAuthorizationCredentials], Coroutine[Any, Any, T | None]]:
+def get_token_verifier[T](
+    token_cls: type[T],
+    jwks: MutableMapping,
+) -> Callable[[HTTPAuthorizationCredentials], Coroutine[Any, Any, T | None]]:
     async def get_verified_token(
         authorization: Annotated[HTTPAuthorizationCredentials, Depends(bearer_security)],
     ) -> T | None:
         """
         Verify the JWT access token using OIDC authority JWKS.
         """
-        global _JWKS
-
         if not oidc_settings.enabled:
             return None
 
         token = authorization.credentials
 
         try:
-            if not _JWKS:
+            if not jwks:
                 openid_config = await fetch_openid_config()
-                _JWKS = await fetch_jwks(openid_config['jwks_uri'])
+                _jwks = await fetch_jwks(openid_config['jwks_uri'])
+                jwks.clear()
+                jwks.update(_jwks)
 
             if oidc_settings.client_id:
-                payload = jwt.decode(token, _JWKS, algorithms=['RS256'], audience=oidc_settings.client_id)
+                payload = jwt.decode(token, jwks, algorithms=['RS256'], audience=oidc_settings.client_id)
             else:
-                payload = jwt.decode(token, _JWKS, algorithms=['RS256'])
+                payload = jwt.decode(token, jwks, algorithms=['RS256'])
 
             token_data = token_cls(**payload)
-
-            return token_data
-        except jwt.ExpiredSignatureError:
-            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail='Token has expired')
+        except jwt.ExpiredSignatureError as e:
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail='Token has expired') from e
         except JWTError as e:
-            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail=f'Token is invalid: {str(e)}')
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail=f'Token is invalid: {str(e)}') from e
+
+        return token_data
 
     return get_verified_token

{python3_commons-0.9.18 → python3_commons-0.9.20}/src/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,7 +35,7 @@ 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 {}
@@ -88,7 +89,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, *, if_not_set: bool = False):
     r = get_valkey_client()
 
     return await r.set(name, data, ex=ttl, nx=if_not_set)
@@ -100,8 +101,8 @@ 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, *, 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:
@@ -130,8 +131,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:
@@ -150,8 +151,8 @@ 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:
@@ -174,8 +175,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,28 +185,28 @@ 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):
@@ -215,8 +216,8 @@ async def store_set(name: str, value: set, ttl: int = None):
 
         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 +225,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 +235,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 +250,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-0.9.18 → python3_commons-0.9.20}/src/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,7 +24,7 @@ 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
 
@@ -63,8 +63,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:
@@ -83,7 +83,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-0.9.18 → python3_commons-0.9.20}/src/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-0.9.18 → python3_commons-0.9.20}/src/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