python3-commons 0.8.10__py3-none-any.whl → 0.8.11__py3-none-any.whl

python3_commons/cache.py

@@ -0,0 +1,249 @@
+import logging
+import socket
+from platform import platform
+from typing import Any, Mapping, Sequence
+
+import valkey
+from pydantic import RedisDsn
+from valkey.asyncio import Valkey, StrictValkey, ConnectionPool, Sentinel
+from valkey.asyncio.retry import Retry
+from valkey.backoff import FullJitterBackoff
+
+from python3_commons.conf import valkey_settings
+from python3_commons.helpers import SingletonMeta
+from python3_commons.serializers.msgspec import (
+    serialize_msgpack, deserialize_msgpack, deserialize_msgpack_native, serialize_msgpack_native
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncValkeyClient(metaclass=SingletonMeta):
+    def __init__(self, dsn: RedisDsn, sentinel_dsn: RedisDsn | None):
+        self._valkey_pool = None
+        self._valkey = None
+
+        if sentinel_dsn:
+            self._initialize_sentinel(sentinel_dsn)
+        else:
+            self._initialize_standard_pool(dsn)
+
+    @staticmethod
+    def _get_keepalive_options():
+        if platform == 'linux' or platform == 'darwin':
+            return {
+                socket.TCP_KEEPIDLE: 10,
+                socket.TCP_KEEPINTVL: 5,
+                socket.TCP_KEEPCNT: 5
+            }
+        else:
+            return {}
+
+    def _initialize_sentinel(self, dsn: RedisDsn):
+        sentinel = Sentinel(
+            [(dsn.host, dsn.port)],
+            socket_connect_timeout=10,
+            socket_timeout=60,
+            password=dsn.password,
+            sentinel_kwargs={'password': dsn.password}
+        )
+
+        ka_options = self._get_keepalive_options()
+
+        self._valkey = sentinel.master_for(
+            'myprimary',
+            valkey_class=StrictValkey,
+            socket_connect_timeout=10,
+            socket_timeout=60,
+            health_check_interval=30,
+            retry_on_timeout=True,
+            retry=Retry(FullJitterBackoff(cap=5, base=1), 5),
+            socket_keepalive=True,
+            socket_keepalive_options=ka_options
+        )
+
+    def _initialize_standard_pool(self, dsn: RedisDsn):
+        self._valkey_pool = ConnectionPool.from_url(str(dsn))
+        self._valkey = StrictValkey(connection_pool=self._valkey_pool)
+
+    def get_client(self) -> Valkey:
+        return self._valkey
+
+
+def get_valkey_client() -> Valkey:
+    return AsyncValkeyClient(valkey_settings.dsn, valkey_settings.sentinel_dsn).get_client()
+
+
+async def delete(name: str):
+    await get_valkey_client().delete(name)
+
+
+async def store_bytes(name: str, data: bytes, ttl: int = None, if_not_set: bool = False):
+    r = get_valkey_client()
+
+    return r.set(name, data, ex=ttl, nx=if_not_set)
+
+
+async def get_bytes(name: str) -> bytes | None:
+    r = get_valkey_client()
+
+    return r.get(name)
+
+
+async def store(name: str, obj: Any, ttl: int = None, if_not_set: bool = False):
+    return store_bytes(name, serialize_msgpack_native(obj), ttl, if_not_set)
+
+
+async def get(name: str, default=None, data_type: Any = None) -> Any:
+    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):
+    await store_bytes(name, data.encode(), ttl)
+
+
+async def get_string(name: str) -> str | None:
+    if data := await get_bytes(name):
+        return data.decode('utf-8')
+
+    return None
+
+
+async def store_sequence(name: str, data: Sequence, ttl: int = None):
+    if data:
+        try:
+            r = get_valkey_client()
+            await r.rpush(name, *map(serialize_msgpack_native, data))
+
+            if ttl:
+                await r.expire(name, ttl)
+        except valkey.exceptions.ConnectionError as e:
+            logger.error(f'Failed to store sequence in cache: {e}')
+
+
+async def get_sequence(name: str, _type: type = list) -> Sequence:
+    r = get_valkey_client()
+
+    return _type(map(deserialize_msgpack_native, r.lrange(name, 0, -1)))
+
+
+async def store_dict(name: str, data: Mapping, ttl: int = None):
+    if data:
+        try:
+            r = get_valkey_client()
+            data = {k: serialize_msgpack_native(v) for k, v in data.items()}
+            await r.hset(name, mapping=data)
+
+            if ttl:
+                await r.expire(name, ttl)
+        except valkey.exceptions.ConnectionError as e:
+            logger.error(f'Failed to store dict in cache: {e}')
+
+
+async def get_dict(name: str, value_data_type=None) -> dict | None:
+    r = get_valkey_client()
+
+    if data := r.hgetall(name):
+        data = {k.decode(): deserialize_msgpack(v, value_data_type) for k, v in data.items()}
+
+        return data
+
+    return None
+
+
+async def set_dict(name: str, mapping: dict, ttl: int = None):
+    if mapping:
+        try:
+            r = get_valkey_client()
+            mapping = {str(k): serialize_msgpack(v) for k, v in mapping.items()}
+            await r.hset(name, mapping=mapping)
+
+            if ttl:
+                await r.expire(name, ttl)
+        except valkey.exceptions.ConnectionError as e:
+            logger.error(f'Failed to set dict in cache: {e}')
+
+
+async def get_dict_item(name: str, key: str, data_type=None, default=None):
+    try:
+        r = get_valkey_client()
+
+        if data := await r.hget(name, key):
+            return deserialize_msgpack_native(data, data_type)
+
+        return default
+    except valkey.exceptions.ConnectionError as e:
+        logger.error(f'Failed to get dict item from cache: {e}')
+
+    return None
+
+
+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}')
+
+
+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}')
+
+
+async def store_set(name: str, value: set, ttl: int = 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}')
+
+
+async def has_set_item(name: str, value: str) -> bool:
+    try:
+        r = get_valkey_client()
+
+        return 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}')
+
+    return False
+
+
+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}')
+
+
+async def delete_set_item(name: str, value: str):
+    r = get_valkey_client()
+    await r.srem(name, serialize_msgpack_native(value))
+
+
+async def get_set_members(name: str) -> set[str] | None:
+    try:
+        r = get_valkey_client()
+
+        return set(map(deserialize_msgpack_native, r.smembers(name)))
+    except valkey.exceptions.ConnectionError as e:
+        logger.error(f'Failed to get set members from cache: {e}')
+
+    return None
+
+
+async def exists(name: str) -> bool:
+    r = get_valkey_client()
+
+    return r.exists(name) == 1

python3_commons/conf.py

@@ -1,4 +1,4 @@
-from pydantic import SecretStr, PostgresDsn, Field
+from pydantic import SecretStr, PostgresDsn, Field, RedisDsn
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
@@ -8,6 +8,13 @@ class CommonSettings(BaseSettings):
     logging_formatter: str = 'default'
 
 
+class ValkeySettings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix='VALKEY_')
+
+    dsn: RedisDsn | None = None
+    sentinel_dsn: RedisDsn | None = None
+
+
 class DBSettings(BaseSettings):
     model_config = SettingsConfigDict(env_prefix='DB_')
 
@@ -31,5 +38,6 @@ class S3Settings(BaseSettings):
 
 
 settings = CommonSettings()
+valkey_settings = ValkeySettings()
 db_settings = DBSettings()
 s3_settings = S3Settings()

{python3_commons-0.8.10.dist-info → python3_commons-0.8.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python3-commons
-Version: 0.8.10
+Version: 0.8.11
 Summary: Re-usable Python3 code
 Author-email: Oleg Korsak <kamikaze.is.waiting.you@gmail.com>
 License: gpl-3
@@ -23,6 +23,7 @@ Requires-Dist: msgspec~=0.19.0
 Requires-Dist: pydantic[email]~=2.11.0
 Requires-Dist: pydantic-settings~=2.8.1
 Requires-Dist: SQLAlchemy[asyncio]~=2.0.40
+Requires-Dist: valkey[libvalkey]~=6.1.0
 Requires-Dist: zeep~=4.3.1
 Provides-Extra: testing
 Requires-Dist: pytest; extra == "testing"

{python3_commons-0.8.10.dist-info → python3_commons-0.8.11.dist-info}/RECORD

@@ -1,7 +1,8 @@
 python3_commons/__init__.py,sha256=0KgaYU46H_IMKn-BuasoRN3C4Hi45KlkHHoPbU9cwiA,189
 python3_commons/api_client.py,sha256=zj6zTF-DhUMu4bjj9VWLi63mVODG_SB47Q5qlmG-Sxg,4539
 python3_commons/audit.py,sha256=DMQ-nrWSs0qilD7wkz_8PV4jXcee75O8FgAm2YIuOiY,6256
-python3_commons/conf.py,sha256=jRk6kraRHVXsajmUPl0NjcZsH4_MgrN1IHlzdg06cSw,1015
+python3_commons/cache.py,sha256=dBxoZw_LB52cAw_RI4KTM5WtJo0MtkhDw1Om_kCLCTU,7354
+python3_commons/conf.py,sha256=Vu6eZ8uHiKFHe3OLdtImrUZe5JH4KH7HULwF5M4kY8U,1232
 python3_commons/fs.py,sha256=wfLjybXndwLqNlOxTpm_HRJnuTcC4wbrHEOaEeCo9Wc,337
 python3_commons/helpers.py,sha256=OmuCF7UeJ6oe-rH1Y4ZYVW_uPQ973lCLsikj01wmNqs,3101
 python3_commons/object_storage.py,sha256=Bte49twIJ4l6VAzIqK6tLx7DFYwijErUmmhWkrZpSJE,4074
@@ -19,9 +20,9 @@ python3_commons/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 python3_commons/serializers/json.py,sha256=P288wWz9ic38QWEMrpp_uwKPYkQiOgvE1cI4WZn6ZCg,808
 python3_commons/serializers/msgpack.py,sha256=tzIGGyDL3UpZnnouCtnxuYDx6InKM_C3PP1N4PN8wd4,1269
 python3_commons/serializers/msgspec.py,sha256=FuZVqOLJb0-lEKrs7dtjhwEbHIpfMUk5yu1hD64zRdc,2038
-python3_commons-0.8.10.dist-info/licenses/AUTHORS.rst,sha256=3R9JnfjfjH5RoPWOeqKFJgxVShSSfzQPIrEr1nxIo9Q,90
-python3_commons-0.8.10.dist-info/licenses/LICENSE,sha256=xxILuojHm4fKQOrMHPSslbyy6WuKAN2RiG74HbrYfzM,34575
-python3_commons-0.8.10.dist-info/METADATA,sha256=mV1IKo0huatH5mjlEfE7VF7b-Xxv5-XIp3S9PxdHtYQ,1150
-python3_commons-0.8.10.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-python3_commons-0.8.10.dist-info/top_level.txt,sha256=lJI6sCBf68eUHzupCnn2dzG10lH3jJKTWM_hrN1cQ7M,16
-python3_commons-0.8.10.dist-info/RECORD,,
+python3_commons-0.8.11.dist-info/licenses/AUTHORS.rst,sha256=3R9JnfjfjH5RoPWOeqKFJgxVShSSfzQPIrEr1nxIo9Q,90
+python3_commons-0.8.11.dist-info/licenses/LICENSE,sha256=xxILuojHm4fKQOrMHPSslbyy6WuKAN2RiG74HbrYfzM,34575
+python3_commons-0.8.11.dist-info/METADATA,sha256=0jX6TPiS5aB8FK2DOS3aF5N0FbDuUFGnp5OlpUjDeDw,1190
+python3_commons-0.8.11.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+python3_commons-0.8.11.dist-info/top_level.txt,sha256=lJI6sCBf68eUHzupCnn2dzG10lH3jJKTWM_hrN1cQ7M,16
+python3_commons-0.8.11.dist-info/RECORD,,