rapyer 1.1.3__tar.gz → 1.1.4__tar.gz

{rapyer-1.1.3 → rapyer-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapyer
-Version: 1.1.3
+Version: 1.1.4
 Summary: Pydantic models with Redis as the backend
 License: MIT
 Keywords: redis,redis-json,pydantic,pydantic-v2,orm,database,async,nosql,cache,key-value,data-modeling,python,backend,storage,serialization,validation

{rapyer-1.1.3 → rapyer-1.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "rapyer"
-version = "1.1.3"
+version = "1.1.4"
 description = "Pydantic models with Redis as the backend"
 authors = [{name = "YedidyaHKfir", email = "yedidyakfir@gmail.com"}]
 readme = "README.md"

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/__init__.py

@@ -1,6 +1,13 @@
 """Redis Pydantic - Pydantic models with Redis as the backend."""
 
-from rapyer.base import AtomicRedisModel, aget, find_redis_models, ainsert
+from rapyer.base import (
+    AtomicRedisModel,
+    aget,
+    find_redis_models,
+    ainsert,
+    get,
+    alock_from_key,
+)
 from rapyer.init import init_rapyer, teardown_rapyer
 
 __all__ = [
@@ -11,4 +18,5 @@ __all__ = [
     "get",
     "find_redis_models",
     "ainsert",
+    "alock_from_key",
 ]

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/base.py

@@ -4,7 +4,8 @@ import contextlib
 import functools
 import pickle
 import uuid
-from typing import ClassVar, Any, AsyncGenerator
+from contextlib import AbstractAsyncContextManager
+from typing import ClassVar, Any, get_origin
 
 from pydantic import (
     BaseModel,
@@ -15,17 +16,20 @@ from pydantic import (
     field_validator,
 )
 from pydantic_core.core_schema import FieldSerializationInfo, ValidationInfo
+from redis.commands.search.index_definition import IndexDefinition, IndexType
+from redis.commands.search.query import Query
+from typing_extensions import deprecated
+
 from rapyer.config import RedisConfig
 from rapyer.context import _context_var, _context_xx_pipe
-from rapyer.errors.base import KeyNotFound
-from rapyer.fields.expression import ExpressionField
+from rapyer.errors.base import KeyNotFound, UnsupportedIndexedFieldError
+from rapyer.fields.expression import ExpressionField, AtomicField, Expression
 from rapyer.fields.index import IndexAnnotation
 from rapyer.fields.key import KeyAnnotation
 from rapyer.links import REDIS_SUPPORTED_LINK
 from rapyer.types.base import RedisType, REDIS_DUMP_FLAG_NAME
 from rapyer.types.convert import RedisConverter
 from rapyer.typing_support import Self, Unpack
-from rapyer.typing_support import deprecated
 from rapyer.utils.annotation import (
     replace_to_redis_types_in_annotation,
     has_annotation,
@@ -33,9 +37,12 @@ from rapyer.utils.annotation import (
     DYNAMIC_CLASS_DOC,
 )
 from rapyer.utils.fields import get_all_pydantic_annotation, is_redis_field
-from rapyer.utils.redis import acquire_lock, update_keys_in_pipeline
-from redis.commands.search.index_definition import IndexDefinition, IndexType
-from redis.commands.search.query import Query
+from rapyer.utils.pythonic import safe_issubclass
+from rapyer.utils.redis import (
+    acquire_lock,
+    update_keys_in_pipeline,
+    refresh_ttl_if_needed,
+)
 
 
 def make_pickle_field_serializer(field: str):
@@ -106,34 +113,33 @@ class AtomicRedisModel(BaseModel):
         return f"${field_path}" if field_path else "$"
 
     @classmethod
-    def redis_schema(cls):
+    def redis_schema(cls, redis_name: str = ""):
         fields = []
 
         for field_name, field_info in cls.model_fields.items():
             real_type = field_info.annotation
-            if not is_redis_field(field_name, real_type):
-                continue
-
-            if not field_with_flag(field_info, IndexAnnotation):
-                continue
-
             # Check if real_type is a class before using issubclass
-            if isinstance(real_type, type):
-                if issubclass(real_type, AtomicRedisModel):
-                    sub_fields = real_type.redis_schema()
-                    for sub_field in sub_fields:
-                        sub_field.name = f"{field_name}.{sub_field.name}"
-                        fields.append(sub_field)
-                elif issubclass(real_type, RedisType):
-                    field_schema = real_type.redis_schema(field_name)
-                    fields.append(field_schema)
-                else:
-                    raise RuntimeError(
-                        f"Indexed field {field_name} must be redis-supported to be indexed, see {REDIS_SUPPORTED_LINK}"
+            if get_origin(real_type) is not None or not isinstance(real_type, type):
+                if field_with_flag(field_info, IndexAnnotation):
+                    raise UnsupportedIndexedFieldError(
+                        f"Field {field_name} is type {real_type}, and not supported for indexing"
                     )
+                else:
+                    continue
+
+            full_redis_name = f"{redis_name}.{field_name}" if redis_name else field_name
+            if issubclass(real_type, AtomicRedisModel):
+                real_type: type[AtomicRedisModel]
+                sub_fields = real_type.redis_schema(full_redis_name)
+                fields.extend(sub_fields)
+            elif not field_with_flag(field_info, IndexAnnotation):
+                continue
+            elif issubclass(real_type, RedisType):
+                field_schema = real_type.redis_schema(full_redis_name)
+                fields.append(field_schema)
             else:
-                raise RuntimeError(
-                    f"Indexed field {field_name} must be a simple redis-supported type, see {REDIS_SUPPORTED_LINK}"
+                raise UnsupportedIndexedFieldError(
+                    f"Indexed field {field_name} must be redis-supported to be indexed, see {REDIS_SUPPORTED_LINK}"
                 )
 
         return fields
@@ -217,14 +223,27 @@ class AtomicRedisModel(BaseModel):
 
         # Update the redis model list for initialization
         # Skip dynamically created classes from type conversion
-        if cls.__doc__ != DYNAMIC_CLASS_DOC:
+        if cls.__doc__ != DYNAMIC_CLASS_DOC and cls.Meta.init_with_rapyer:
             REDIS_MODELS.append(cls)
 
     @classmethod
-    def init_class(cls):
+    def create_expressions(cls, base_path: str = "") -> dict[str, Expression]:
+        expressions = {}
         for field_name, field_info in cls.model_fields.items():
+            full_field_name = rf"{base_path}\.{field_name}" if base_path else field_name
             field_type = field_info.annotation
-            setattr(cls, field_name, ExpressionField(field_name, field_type))
+            if safe_issubclass(field_type, AtomicRedisModel):
+                expressions[field_name] = AtomicField(
+                    field_name, **field_type.create_expressions(full_field_name)
+                )
+            else:
+                expressions[field_name] = ExpressionField(full_field_name, field_type)
+        return expressions
+
+    @classmethod
+    def init_class(cls):
+        for field_name, field_expression in cls.create_expressions().items():
+            setattr(cls, field_name, field_expression)
 
     def is_inner_model(self) -> bool:
         return bool(self.field_name)
@@ -233,13 +252,14 @@ class AtomicRedisModel(BaseModel):
         f"save function is deprecated and will become sync function in rapyer 1.2.0, use asave() instead"
     )
     async def save(self):
-        return await self.asave()
+        return await self.asave()  # pragma: no cover
 
     async def asave(self) -> Self:
         model_dump = self.redis_dump()
         await self.Meta.redis.json().set(self.key, self.json_path, model_dump)
         if self.Meta.ttl is not None:
-            await self.Meta.redis.expire(self.key, self.Meta.ttl)
+            nx = not self.Meta.refresh_ttl
+            await self.Meta.redis.expire(self.key, self.Meta.ttl, nx=nx)
         return self
 
     def redis_dump(self):
@@ -252,7 +272,7 @@ class AtomicRedisModel(BaseModel):
         "duplicate function is deprecated and will be removed in rapyer 1.2.0, use aduplicate instead"
     )
     async def duplicate(self) -> Self:
-        return await self.aduplicate()
+        return await self.aduplicate()  # pragma: no cover
 
     async def aduplicate(self) -> Self:
         if self.is_inner_model():
@@ -266,7 +286,7 @@ class AtomicRedisModel(BaseModel):
         "duplicate_many function is deprecated and will be removed in rapyer 1.2.0, use aduplicate_many instead"
     )
     async def duplicate_many(self, num: int) -> list[Self]:
-        return await self.aduplicate_many(num)
+        return await self.aduplicate_many(num)  # pragma: no cover
 
     async def aduplicate_many(self, num: int) -> list[Self]:
         if self.is_inner_model():
@@ -297,13 +317,16 @@ class AtomicRedisModel(BaseModel):
         async with self.Meta.redis.pipeline() as pipe:
             update_keys_in_pipeline(pipe, self.key, **json_path_kwargs)
             await pipe.execute()
+        await refresh_ttl_if_needed(
+            self.Meta.redis, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+        )
 
     @classmethod
     @deprecated(
         "get() classmethod is deprecated and will be removed in rapyer 1.2.0, use aget instead"
     )
     async def get(cls, key: str) -> Self:
-        return await cls.aget(key)
+        return await cls.aget(key)  # pragma: no cover
 
     @classmethod
     async def aget(cls, key: str) -> Self:
@@ -316,13 +339,16 @@ class AtomicRedisModel(BaseModel):
 
         instance = cls.model_validate(model_dump, context={REDIS_DUMP_FLAG_NAME: True})
         instance.key = key
+        await refresh_ttl_if_needed(
+            cls.Meta.redis, key, cls.Meta.ttl, cls.Meta.refresh_ttl
+        )
         return instance
 
     @deprecated(
         "load function is deprecated and will be removed in rapyer 1.2.0, use aload() instead"
     )
     async def load(self):
-        return await self.aload()
+        return await self.aload()  # pragma: no cover
 
     async def aload(self) -> Self:
         model_dump = await self.Meta.redis.json().get(self.key, self.json_path)
@@ -332,6 +358,9 @@ class AtomicRedisModel(BaseModel):
         instance = self.__class__(**model_dump)
         instance._pk = self._pk
         instance._base_model_link = self._base_model_link
+        await refresh_ttl_if_needed(
+            self.Meta.redis, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+        )
         return instance
 
     @classmethod
@@ -365,6 +394,12 @@ class AtomicRedisModel(BaseModel):
             # Fetch the actual documents
             models = await cls.Meta.redis.json().mget(keys=keys, path="$")
 
+        if cls.Meta.ttl is not None and cls.Meta.refresh_ttl:
+            async with cls.Meta.redis.pipeline() as pipe:
+                for key in keys:
+                    pipe.expire(key, cls.Meta.ttl)
+                await pipe.execute()
+
         instances = []
         for model, key in zip(models, keys):
             model = cls.model_validate(model[0], context={REDIS_DUMP_FLAG_NAME: True})
@@ -381,6 +416,8 @@ class AtomicRedisModel(BaseModel):
         async with cls.Meta.redis.pipeline() as pipe:
             for model in models:
                 pipe.json().set(model.key, model.json_path, model.redis_dump())
+                if cls.Meta.ttl is not None:
+                    pipe.expire(model.key, cls.Meta.ttl)
             await pipe.execute()
 
     @classmethod
@@ -388,7 +425,7 @@ class AtomicRedisModel(BaseModel):
         "function delete is deprecated and will be removed in rapyer 1.2.0, use adelete instead"
     )
     async def delete_by_key(cls, key: str) -> bool:
-        return await cls.adelete_by_key(key)
+        return await cls.adelete_by_key(key)  # pragma: no cover
 
     @classmethod
     async def adelete_by_key(cls, key: str) -> bool:
@@ -399,7 +436,7 @@ class AtomicRedisModel(BaseModel):
         "function delete is deprecated and will be removed in rapyer 1.2.0, use adelete instead"
     )
     async def delete(self):
-        return await self.adelete()
+        return await self.adelete()  # pragma: no cover
 
     async def adelete(self):
         if self.is_inner_model():
@@ -419,15 +456,17 @@ class AtomicRedisModel(BaseModel):
     )
     async def lock_from_key(
         cls, key: str, action: str = "default", save_at_end: bool = False
-    ) -> AsyncGenerator[Self, None]:
-        async with cls.alock_from_key(key, action, save_at_end) as redis_model:
-            yield redis_model
+    ) -> AbstractAsyncContextManager[Self]:
+        async with cls.alock_from_key(  # pragma: no cover
+            key, action, save_at_end  # pragma: no cover
+        ) as redis_model:  # pragma: no cover
+            yield redis_model  # pragma: no cover
 
     @classmethod
     @contextlib.asynccontextmanager
     async def alock_from_key(
         cls, key: str, action: str = "default", save_at_end: bool = False
-    ) -> AsyncGenerator[Self, None]:
+    ) -> AbstractAsyncContextManager[Self]:
         async with acquire_lock(cls.Meta.redis, f"{key}/{action}"):
             redis_model = await cls.aget(key)
             yield redis_model
@@ -440,14 +479,16 @@ class AtomicRedisModel(BaseModel):
     )
     async def lock(
         self, action: str = "default", save_at_end: bool = False
-    ) -> AsyncGenerator[Self, None]:
-        async with self.alock_from_key(self.key, action, save_at_end) as redis_model:
-            yield redis_model
+    ) -> AbstractAsyncContextManager[Self]:
+        async with self.alock_from_key(  # pragma: no cover
+            self.key, action, save_at_end  # pragma: no cover
+        ) as redis_model:  # pragma: no cover
+            yield redis_model  # pragma: no cover
 
     @contextlib.asynccontextmanager
     async def alock(
         self, action: str = "default", save_at_end: bool = False
-    ) -> AsyncGenerator[Self, None]:
+    ) -> AbstractAsyncContextManager[Self]:
         async with self.alock_from_key(self.key, action, save_at_end) as redis_model:
             unset_fields = {
                 k: redis_model.__dict__[k] for k in redis_model.model_fields_set
@@ -461,14 +502,16 @@ class AtomicRedisModel(BaseModel):
     )
     async def pipeline(
         self, ignore_if_deleted: bool = False
-    ) -> AsyncGenerator[Self, None]:
-        async with self.apipeline(ignore_if_deleted=ignore_if_deleted) as redis_model:
-            yield redis_model
+    ) -> AbstractAsyncContextManager[Self]:
+        async with self.apipeline(  # pragma: no cover
+            ignore_if_deleted=ignore_if_deleted  # pragma: no cover
+        ) as redis_model:  # pragma: no cover
+            yield redis_model  # pragma: no cover
 
     @contextlib.asynccontextmanager
     async def apipeline(
         self, ignore_if_deleted: bool = False
-    ) -> AsyncGenerator[Self, None]:
+    ) -> AbstractAsyncContextManager[Self]:
         async with self.Meta.redis.pipeline() as pipe:
             try:
                 redis_model = await self.__class__.aget(self.key)
@@ -476,7 +519,7 @@ class AtomicRedisModel(BaseModel):
                     k: redis_model.__dict__[k] for k in redis_model.model_fields_set
                 }
                 self.__dict__.update(unset_fields)
-            except (TypeError, IndexError):
+            except (TypeError, KeyNotFound):
                 if ignore_if_deleted:
                     redis_model = self
                 else:
@@ -485,6 +528,9 @@ class AtomicRedisModel(BaseModel):
             _context_xx_pipe.set(ignore_if_deleted)
             yield redis_model
             await pipe.execute()
+            await refresh_ttl_if_needed(
+                self.Meta.redis, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+            )
             _context_var.set(None)
             _context_xx_pipe.set(False)
 
@@ -530,13 +576,15 @@ REDIS_MODELS: list[type[AtomicRedisModel]] = []
     "get function is deprecated and will be removed in rapyer 1.2.0, use aget instead"
 )
 async def get(redis_key: str) -> AtomicRedisModel:
-    return await aget(redis_key)
+    return await aget(redis_key)  # pragma: no cover
 
 
 async def aget(redis_key: str) -> AtomicRedisModel:
     redis_model_mapping = {klass.__name__: klass for klass in REDIS_MODELS}
     class_name = redis_key.split(":")[0]
     klass = redis_model_mapping.get(class_name)
+    if klass is None:
+        raise KeyNotFound(f"{redis_key} is missing in redis")
     return await klass.aget(redis_key)
 
 
@@ -550,3 +598,17 @@ async def ainsert(*models: Unpack[AtomicRedisModel]) -> list[AtomicRedisModel]:
             pipe.json().set(model.key, model.json_path, model.redis_dump())
         await pipe.execute()
     return models
+
+
+@contextlib.asynccontextmanager
+async def alock_from_key(
+    key: str, action: str = "default", save_at_end: bool = False
+) -> AbstractAsyncContextManager[AtomicRedisModel | None]:
+    async with acquire_lock(AtomicRedisModel.Meta.redis, f"{key}/{action}"):
+        try:
+            redis_model = await aget(key)
+        except KeyNotFound:
+            redis_model = None
+        yield redis_model
+        if save_at_end and redis_model is not None:
+            await redis_model.asave()

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/config.py

@@ -21,3 +21,5 @@ class RedisConfig:
     )
     redis_type: dict[type, type] = dataclasses.field(default_factory=create_all_types)
     ttl: int | None = None
+    init_with_rapyer: bool = True
+    refresh_ttl: bool = True  # Enable TTL refresh on read/write operations by default

rapyer-1.1.4/rapyer/errors/__init__.py

@@ -0,0 +1,8 @@
+from rapyer.errors.base import (
+    BadFilterError,
+    FindError,
+    RapyerError,
+    UnsupportedIndexedFieldError,
+)
+
+__all__ = ["BadFilterError", "FindError", "RapyerError", "UnsupportedIndexedFieldError"]

rapyer-1.1.4/rapyer/errors/base.py

@@ -0,0 +1,26 @@
+class RapyerError(Exception):
+    """Base exception for all rapyer errors."""
+
+    pass
+
+
+class KeyNotFound(RapyerError):
+    """Raised when a key is not found in Redis."""
+
+    pass
+
+
+class FindError(RapyerError):
+    """Raised when a model cannot be found."""
+
+    pass
+
+
+class BadFilterError(FindError):
+    """Raised when a filter is invalid."""
+
+    pass
+
+
+class UnsupportedIndexedFieldError(FindError):
+    pass

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/fields/expression.py

@@ -1,12 +1,17 @@
 from typing import Any
 
 from pydantic import TypeAdapter
+
+from rapyer.errors import BadFilterError
 from rapyer.types.base import REDIS_DUMP_FLAG_NAME
+from rapyer.typing_support import Unpack
 
 
 class Expression:
     def create_filter(self) -> str:
-        raise NotImplementedError("Subclasses must implement create_filter")
+        raise NotImplementedError(  # pragma: no cover
+            "Subclasses must implement create_filter"  # pragma: no cover
+        )  # pragma: no cover
 
     def __and__(self, other: "Expression") -> "AndExpression":
         return AndExpression(self, other)
@@ -18,13 +23,22 @@ class Expression:
         return NotExpression(self)
 
 
+class AtomicField(Expression):
+    def __init__(self, field_name: str, **sub_fields: Unpack[Expression]):
+        self.field_name = field_name
+        for sub_field_name, sub_field in sub_fields.items():
+            setattr(self, sub_field_name, sub_field)
+
+
 class ExpressionField(Expression):
     def __init__(self, field_name: str, field_type: Any = None):
         self.field_name = field_name
         self._adapter = TypeAdapter(field_type)
 
     def create_filter(self) -> str:
-        return f"@{self.field_name}:*"
+        raise BadFilterError(
+            "You must use an operator to filter an expression in redis"
+        )
 
     def serialize_value(self, value: Any) -> Any:
         return self._adapter.dump_python(

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/fields/index.py

@@ -1,6 +1,6 @@
 import dataclasses
 from datetime import datetime
-from typing import Annotated, Any, Generic, TypeVar
+from typing import TYPE_CHECKING, Annotated, Any, Generic, TypeAlias, TypeVar
 
 from rapyer.types.datetime import RedisDatetimeTimestamp
 
@@ -33,3 +33,7 @@ class _IndexType(Generic[T]):
 
 
 Index = _IndexType
+
+
+if TYPE_CHECKING:
+    Index: TypeAlias = Annotated[T, IndexAnnotation()]  # pragma: no cover

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/fields/key.py

@@ -1,5 +1,5 @@
 import dataclasses
-from typing import Annotated, Any, Generic, TypeVar
+from typing import TYPE_CHECKING, Annotated, Any, Generic, TypeAlias, TypeVar
 
 
 @dataclasses.dataclass(frozen=True)
@@ -20,5 +20,8 @@ class _KeyType(Generic[T]):
         return Annotated[item, KeyAnnotation()]
 
 
-# Create the Key callable that works both as a function and generic type
 Key = _KeyType
+
+
+if TYPE_CHECKING:
+    Key: TypeAlias = Annotated[T, KeyAnnotation()]  # pragma: no cover

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/init.py

@@ -1,8 +1,9 @@
 import redis.asyncio as redis_async
-from rapyer.base import REDIS_MODELS
 from redis import ResponseError
 from redis.asyncio.client import Redis
 
+from rapyer.base import REDIS_MODELS
+
 
 async def init_rapyer(
     redis: str | Redis = None, ttl: int = None, override_old_idx: bool = True
@@ -36,6 +37,8 @@ async def init_rapyer(
 
 
 async def teardown_rapyer():
+    closed_clients = set()
     for model in REDIS_MODELS:
-        if model.Meta.ttl is not None:
+        if id(model.Meta.redis) not in closed_clients:
+            closed_clients.add(id(model.Meta.redis))
             await model.Meta.redis.aclose()

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/types/base.py

@@ -7,10 +7,12 @@ from typing import get_args, Any, TypeVar, Generic
 from pydantic import GetCoreSchemaHandler, TypeAdapter
 from pydantic_core import core_schema
 from pydantic_core.core_schema import ValidationInfo, CoreSchema, SerializationInfo
+from redis.commands.search.field import TextField
+from typing_extensions import deprecated
+
 from rapyer.context import _context_var
 from rapyer.typing_support import Self
-from rapyer.typing_support import deprecated
-from redis.commands.search.field import TextField
+from rapyer.utils.redis import refresh_ttl_if_needed
 
 REDIS_DUMP_FLAG_NAME = "__rapyer_dumped__"
 
@@ -68,7 +70,7 @@ class RedisType(ABC):
         f"save function is deprecated and will become sync function in rapyer 1.2.0, use asave() instead"
     )
     async def save(self):
-        return await self.asave()
+        return await self.asave()  # pragma: no cover
 
     async def asave(self) -> Self:
         model_dump = self._adapter.dump_python(
@@ -76,26 +78,31 @@ class RedisType(ABC):
         )
         await self.client.json().set(self.key, self.json_path, model_dump)
         if self.Meta.ttl is not None:
-            await self.client.expire(self.key, self.Meta.ttl)
+            nx = not self.Meta.refresh_ttl
+            await self.client.expire(self.key, self.Meta.ttl, nx=nx)
         return self
 
     @deprecated(
         "load function is deprecated and will be removed in rapyer 1.2.0, use aload() instead"
     )
     async def load(self):
-        return await self.aload()
+        return await self.aload()  # pragma: no cover
 
     async def aload(self):
         redis_value = await self.client.json().get(self.key, self.field_path)
         if redis_value is None:
             return None
-        return self._adapter.validate_python(
+        result = self._adapter.validate_python(
             redis_value, context={REDIS_DUMP_FLAG_NAME: True}
         )
+        await refresh_ttl_if_needed(
+            self.client, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+        )
+        return result
 
     @abc.abstractmethod
     def clone(self):
-        pass
+        pass  # pragma: no cover
 
     @classmethod
     def redis_schema(cls, field_name: str):
@@ -134,22 +141,22 @@ class GenericRedisType(RedisType, Generic[T], ABC):
 
     @abc.abstractmethod
     def iterate_items(self):
-        pass
+        pass  # pragma: no cover
 
     @classmethod
     @abc.abstractmethod
     def full_serializer(cls, value, info: SerializationInfo):
-        pass
+        pass  # pragma: no cover
 
     @classmethod
     @abc.abstractmethod
     def full_deserializer(cls, value, info: ValidationInfo):
-        pass
+        pass  # pragma: no cover
 
     @classmethod
     @abc.abstractmethod
     def schema_for_unknown(cls):
-        pass
+        pass  # pragma: no cover
 
     @classmethod
     def __get_pydantic_core_schema__(

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/types/byte.py

@@ -2,6 +2,7 @@ from typing import TypeAlias, TYPE_CHECKING
 
 from pydantic_core import core_schema
 from pydantic_core.core_schema import ValidationInfo, SerializationInfo
+
 from rapyer.types.base import RedisType, REDIS_DUMP_FLAG_NAME
 
 
@@ -14,7 +15,9 @@ class RedisBytes(bytes, RedisType):
     def __iadd__(self, other):
         new_value = self + other
         if self.pipeline:
-            self.pipeline.json().set(self.key, self.json_path, new_value)
+            self.pipeline.json().set(
+                self.key, self.json_path, self.serialize_unknown(new_value)
+            )
         return self.__class__(new_value)
 
     @classmethod
@@ -52,4 +55,4 @@ class RedisBytes(bytes, RedisType):
 
 
 if TYPE_CHECKING:
-    RedisBytes: TypeAlias = RedisBytes | bytes
+    RedisBytes: TypeAlias = RedisBytes | bytes  # pragma: no cover

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/types/convert.py

@@ -1,6 +1,7 @@
 from typing import Any, get_origin
 
 from pydantic import BaseModel, PrivateAttr, TypeAdapter
+
 from rapyer.types.base import RedisType
 from rapyer.utils.annotation import TypeConverter, DYNAMIC_CLASS_DOC
 from rapyer.utils.pythonic import safe_issubclass
@@ -27,9 +28,6 @@ class RedisConverter(TypeConverter):
         return type_to_check in self.supported_types
 
     def convert_flat_type(self, type_to_convert: type) -> type:
-        if type_to_convert is Any:
-            return Any
-
         from rapyer.base import AtomicRedisModel
 
         if safe_issubclass(type_to_convert, AtomicRedisModel):
@@ -74,28 +72,6 @@ class RedisConverter(TypeConverter):
     def covert_generic_type(
         self, type_to_covert: type, generic_values: tuple[type]
     ) -> type:
-        from rapyer.base import AtomicRedisModel
-
-        if safe_issubclass(type_to_covert, AtomicRedisModel):
-            return type(
-                type_to_covert.__name__,
-                (type_to_covert,),
-                dict(
-                    _field_name=PrivateAttr(default=self.field_name),
-                    __doc__=DYNAMIC_CLASS_DOC,
-                ),
-            )
-        if safe_issubclass(type_to_covert, BaseModel):
-            type_to_covert: type[BaseModel]
-            return type(
-                f"Redis{type_to_covert.__name__}",
-                (AtomicRedisModel, type_to_covert),
-                dict(
-                    _field_name=PrivateAttr(default=self.field_name),
-                    __doc__=DYNAMIC_CLASS_DOC,
-                ),
-            )
-
         if safe_issubclass(type_to_covert, RedisType):
             redis_type = type_to_covert
             original_type = type_to_covert.original_type

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/types/datetime.py

@@ -3,9 +3,10 @@ from typing import TYPE_CHECKING
 
 from pydantic_core import core_schema
 from pydantic_core.core_schema import ValidationInfo, SerializationInfo
-from rapyer.types.base import RedisType, REDIS_DUMP_FLAG_NAME
 from redis.commands.search.field import NumericField
 
+from rapyer.types.base import RedisType, REDIS_DUMP_FLAG_NAME
+
 
 class RedisDatetime(datetime, RedisType):
     original_type = datetime
@@ -71,5 +72,5 @@ class RedisDatetimeTimestamp(RedisDatetime):
 
 
 if TYPE_CHECKING:
-    RedisDatetime = RedisDatetime | datetime
-    RedisDatetimeTimestamp = RedisDatetimeTimestamp | datetime
+    RedisDatetime = RedisDatetime | datetime  # pragma: no cover
+    RedisDatetimeTimestamp = RedisDatetimeTimestamp | datetime  # pragma: no cover

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/types/dct.py

@@ -1,7 +1,9 @@
 from typing import TypeVar, Generic, get_args, Any, TypeAlias, TYPE_CHECKING
 
 from pydantic_core import core_schema
+
 from rapyer.types.base import GenericRedisType, RedisType, REDIS_DUMP_FLAG_NAME
+from rapyer.utils.redis import refresh_ttl_if_needed
 from rapyer.utils.redis import update_keys_in_pipeline
 
 T = TypeVar("T")
@@ -136,13 +138,21 @@ class RedisDict(dict[str, T], GenericRedisType, Generic[T]):
         serialized_value = self._adapter.dump_python(
             {key: value}, mode="json", context={REDIS_DUMP_FLAG_NAME: True}
         )
-        return await self.client.json().set(
+        result = await self.client.json().set(
             self.key, self.json_field_path(key), serialized_value[key]
         )
+        await refresh_ttl_if_needed(
+            self.client, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+        )
+        return result
 
     async def adel_item(self, key):
         super().__delitem__(key)
-        return await self.client.json().delete(self.key, self.json_field_path(key))
+        result = await self.client.json().delete(self.key, self.json_field_path(key))
+        await refresh_ttl_if_needed(
+            self.client, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+        )
+        return result
 
     async def aupdate(self, **kwargs):
         self.update(**kwargs)
@@ -157,12 +167,18 @@ class RedisDict(dict[str, T], GenericRedisType, Generic[T]):
             async with self.redis.pipeline() as pipeline:
                 update_keys_in_pipeline(pipeline, self.key, **redis_params)
                 await pipeline.execute()
+            await refresh_ttl_if_needed(
+                self.redis, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+            )
 
     async def apop(self, key, default=None):
         # Execute the script atomically
         result = await self.client.eval(POP_SCRIPT, 1, self.key, self.json_path, key)
         # Key exists in Redis, pop from local dict (it should exist there too)
         super().pop(key, None)
+        await refresh_ttl_if_needed(
+            self.client, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+        )
 
         if result is None:
             # Key doesn't exist in Redis
@@ -175,6 +191,9 @@ class RedisDict(dict[str, T], GenericRedisType, Generic[T]):
     async def apopitem(self):
         # Execute the script atomically
         result = await self.client.eval(POPITEM_SCRIPT, 1, self.key, self.json_path)
+        await refresh_ttl_if_needed(
+            self.client, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+        )
 
         if result is not None:
             redis_key, redis_value = result
@@ -192,7 +211,11 @@ class RedisDict(dict[str, T], GenericRedisType, Generic[T]):
     async def aclear(self):
         self.clear()
         # Clear Redis dict
-        return await self.client.json().set(self.key, self.json_path, {})
+        result = await self.client.json().set(self.key, self.json_path, {})
+        await refresh_ttl_if_needed(
+            self.client, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+        )
+        return result
 
     def clone(self):
         return {
@@ -213,15 +236,13 @@ class RedisDict(dict[str, T], GenericRedisType, Generic[T]):
         }
 
     @classmethod
-    def full_deserializer(cls, value, info: core_schema.ValidationInfo):
+    def full_deserializer(cls, value: dict, info: core_schema.ValidationInfo):
         ctx = info.context or {}
         should_serialize_redis = ctx.get(REDIS_DUMP_FLAG_NAME)
-        if isinstance(value, dict):
-            return {
-                key: cls.deserialize_unknown(item) if should_serialize_redis else item
-                for key, item in value.items()
-            }
-        return value
+        return {
+            key: cls.deserialize_unknown(item) if should_serialize_redis else item
+            for key, item in value.items()
+        }
 
     @classmethod
     def schema_for_unknown(cls):
@@ -229,4 +250,4 @@ class RedisDict(dict[str, T], GenericRedisType, Generic[T]):
 
 
 if TYPE_CHECKING:
-    RedisDict: TypeAlias = RedisDict[T] | dict[str, T]
+    RedisDict: TypeAlias = RedisDict[T] | dict[str, T]  # pragma: no cover

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/types/float.py

@@ -1,8 +1,10 @@
 from typing import TypeAlias, TYPE_CHECKING
 
-from rapyer.types.base import RedisType
 from redis.commands.search.field import NumericField
 
+from rapyer.types.base import RedisType
+from rapyer.utils.redis import refresh_ttl_if_needed
+
 
 class RedisFloat(float, RedisType):
     original_type = float
@@ -13,6 +15,9 @@ class RedisFloat(float, RedisType):
 
     async def aincrease(self, amount: float = 1.0):
         result = await self.client.json().numincrby(self.key, self.json_path, amount)
+        await refresh_ttl_if_needed(
+            self.client, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+        )
         return result[0] if isinstance(result, list) and result else result
 
     def clone(self):
@@ -44,4 +49,4 @@ class RedisFloat(float, RedisType):
 
 
 if TYPE_CHECKING:
-    RedisFloat: TypeAlias = RedisFloat | float
+    RedisFloat: TypeAlias = RedisFloat | float  # pragma: no cover

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/types/integer.py

@@ -1,9 +1,11 @@
 from typing import TypeAlias, TYPE_CHECKING
 
-from rapyer.types.base import RedisType
 from redis.commands.search.field import NumericField
 from typing_extensions import deprecated
 
+from rapyer.types.base import RedisType
+from rapyer.utils.redis import refresh_ttl_if_needed
+
 
 class RedisInt(int, RedisType):
     original_type = int
@@ -20,6 +22,9 @@ class RedisInt(int, RedisType):
 
     async def aincrease(self, amount: int = 1):
         result = await self.client.json().numincrby(self.key, self.json_path, amount)
+        await refresh_ttl_if_needed(
+            self.client, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+        )
         return result[0] if isinstance(result, list) and result else result
 
     def clone(self):
@@ -63,4 +68,4 @@ class RedisInt(int, RedisType):
 
 
 if TYPE_CHECKING:
-    RedisInt: TypeAlias = RedisInt | int
+    RedisInt: TypeAlias = RedisInt | int  # pragma: no cover

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/types/lst.py

@@ -3,9 +3,11 @@ from typing import TypeVar, TYPE_CHECKING
 
 from pydantic_core import core_schema
 from pydantic_core.core_schema import ValidationInfo, SerializationInfo
-from rapyer.types.base import GenericRedisType, RedisType, REDIS_DUMP_FLAG_NAME
 from typing_extensions import TypeAlias
 
+from rapyer.types.base import GenericRedisType, RedisType, REDIS_DUMP_FLAG_NAME
+from rapyer.utils.redis import refresh_ttl_if_needed
+
 T = TypeVar("T")
 
 
@@ -26,6 +28,9 @@ class RedisList(list, GenericRedisType[T]):
         new_val = self.create_new_values([key], [value])[0]
         return new_val
 
+    def sub_field_path(self, key: str):
+        return f"{self.field_path}[{key}]"
+
     def __setitem__(self, key, value):
         if self.pipeline:
             self.pipeline.json().set(self.key, self.json_field_path(key), value)
@@ -34,8 +39,6 @@ class RedisList(list, GenericRedisType[T]):
 
     def __iadd__(self, other):
         self.extend(other)
-        if self.pipeline and other:
-            self.pipeline.json().arrappend(self.key, self.json_path, *other)
         return self
 
     def append(self, __object):
@@ -74,6 +77,9 @@ class RedisList(list, GenericRedisType[T]):
             await self.redis.json().arrappend(
                 self.key, self.json_path, *serialized_object
             )
+            await refresh_ttl_if_needed(
+                self.redis, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+            )
 
     async def aextend(self, __iterable):
         items = list(__iterable)
@@ -90,15 +96,17 @@ class RedisList(list, GenericRedisType[T]):
                 self.json_path,
                 *serialized_items,
             )
+            await refresh_ttl_if_needed(
+                self.redis, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+            )
 
     async def apop(self, index=-1):
         if self:
             self.pop(index)
         arrpop = await self.redis.json().arrpop(self.key, self.json_path, index)
-
-        # Handle empty list case
-        if arrpop is None or (isinstance(arrpop, list) and len(arrpop) == 0):
-            return None
+        await refresh_ttl_if_needed(
+            self.redis, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+        )
 
         # Handle case where arrpop returns [None] for an empty list
         if arrpop[0] is None:
@@ -119,6 +127,9 @@ class RedisList(list, GenericRedisType[T]):
             await self.redis.json().arrinsert(
                 self.key, self.json_path, index, *serialized_object
             )
+            await refresh_ttl_if_needed(
+                self.redis, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+            )
 
     async def aclear(self):
         # Clear local list
@@ -127,6 +138,9 @@ class RedisList(list, GenericRedisType[T]):
         # Clear Redis list
         if not self.pipeline:
             await self.client.json().set(self.key, self.json_path, [])
+            await refresh_ttl_if_needed(
+                self.client, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+            )
 
     def clone(self):
         return [v.clone() if isinstance(v, RedisType) else v for v in self]
@@ -144,16 +158,13 @@ class RedisList(list, GenericRedisType[T]):
         ]
 
     @classmethod
-    def full_deserializer(cls, value, info: ValidationInfo):
+    def full_deserializer(cls, value: list, info: ValidationInfo):
         ctx = info.context or {}
         is_redis_data = ctx.get(REDIS_DUMP_FLAG_NAME)
 
-        if isinstance(value, list):
-            return [
-                cls.deserialize_unknown(item) if is_redis_data else item
-                for item in value
-            ]
-        return value
+        return [
+            cls.deserialize_unknown(item) if is_redis_data else item for item in value
+        ]
 
     @classmethod
     def schema_for_unknown(cls):
@@ -161,4 +172,4 @@ class RedisList(list, GenericRedisType[T]):
 
 
 if TYPE_CHECKING:
-    RedisList: TypeAlias = RedisList[T] | list[T]
+    RedisList: TypeAlias = RedisList[T] | list[T]  # pragma: no cover

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/types/string.py

@@ -17,4 +17,4 @@ class RedisStr(str, RedisType):
 
 
 if TYPE_CHECKING:
-    RedisStr: TypeAlias = RedisStr | str
+    RedisStr: TypeAlias = RedisStr | str  # pragma: no cover

rapyer-1.1.4/rapyer/typing_support.py

@@ -0,0 +1,7 @@
+# For python 3.10 support
+try:
+    from typing import Self, Unpack
+except ImportError:  # pragma: no cover
+    from typing_extensions import Self, Unpack  # pragma: no cover
+
+__all__ = ["Self", "Unpack"]

{rapyer-1.1.3 → rapyer-1.1.4}/rapyer/utils/annotation.py

@@ -10,17 +10,17 @@ DYNAMIC_CLASS_DOC = "___dynamic_class___"
 class TypeConverter(ABC):
     @abc.abstractmethod
     def is_type_support(self, type_to_check: type) -> bool:
-        pass
+        pass  # pragma: no cover
 
     @abc.abstractmethod
     def convert_flat_type(self, type_to_convert: type) -> type:
-        pass
+        pass  # pragma: no cover
 
     @abc.abstractmethod
     def covert_generic_type(
         self, type_to_covert: type, generic_values: tuple[type]
     ) -> type:
-        pass
+        pass  # pragma: no cover
 
 
 def replace_to_redis_types_in_annotation(
@@ -74,13 +74,10 @@ def replace_to_redis_types_in_annotation(
             # If we don't support the origin, just use the original annotation
             origin = annotation
         return origin
-    return annotation
+    return annotation  # pragma: no cover - There is no way to reach this line
 
 
 def has_annotation(field: Any, annotation_type: Any) -> bool:
-    if field is annotation_type:
-        return True
-
     origin = get_origin(field)
     if origin is Annotated:
         args = get_args(field)

rapyer-1.1.4/rapyer/utils/redis.py

@@ -0,0 +1,22 @@
+from contextlib import AbstractAsyncContextManager
+
+from redis.asyncio import Redis
+
+
+def acquire_lock(
+    redis: Redis, key: str, sleep_time: int = 0.1
+) -> AbstractAsyncContextManager[None]:
+    lock_key = f"{key}:lock"
+    return redis.lock(lock_key, sleep=sleep_time)
+
+
+def update_keys_in_pipeline(pipeline, redis_key: str, **kwargs):
+    for json_path, value in kwargs.items():
+        pipeline.json().set(redis_key, json_path, value)
+
+
+async def refresh_ttl_if_needed(
+    redis_client: Redis, key: str, ttl: int | None, refresh_ttl: bool = True
+) -> None:
+    if ttl is not None and refresh_ttl:
+        await redis_client.expire(key, ttl)

rapyer-1.1.3/rapyer/errors/base.py

@@ -1,10 +0,0 @@
-class RapyerError(Exception):
-    """Base exception for all rapyer errors."""
-
-    pass
-
-
-class KeyNotFound(RapyerError):
-    """Raised when a key is not found in Redis."""
-
-    pass

rapyer-1.1.3/rapyer/typing_support.py

@@ -1,13 +0,0 @@
-# For python 3.10 support
-try:
-    from typing import Self, Unpack
-except ImportError:
-    from typing_extensions import Self, Unpack
-
-# For python 3.13 support
-try:
-    from typing import deprecated
-except ImportError:
-    from typing_extensions import deprecated
-
-__all__ = ["Self", "Unpack", "deprecated"]

rapyer-1.1.3/rapyer/utils/redis.py

@@ -1,25 +0,0 @@
-import asyncio
-import contextlib
-import uuid
-from datetime import timedelta
-
-from redis.asyncio import Redis
-
-
-@contextlib.asynccontextmanager
-async def acquire_lock(
-    redis: Redis, key: str, lock_timeout: timedelta | int = 10, sleep_time: int = 0.1
-):
-    lock_key = f"{key}:lock"
-    lock_token = str(uuid.uuid4())
-    while not await redis.set(lock_key, lock_token, nx=True, ex=lock_timeout):
-        await asyncio.sleep(sleep_time)
-    try:
-        yield
-    finally:
-        await redis.delete(lock_key)
-
-
-def update_keys_in_pipeline(pipeline, redis_key: str, **kwargs):
-    for json_path, value in kwargs.items():
-        pipeline.json().set(redis_key, json_path, value)