rapyer 1.1.3__tar.gz → 1.1.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapyer
-Version: 1.1.3
+Version: 1.1.5
 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
@@ -23,7 +23,12 @@ Classifier: Topic :: Database :: Database Engines/Servers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Classifier: Operating System :: OS Independent
+Provides-Extra: test
+Requires-Dist: fakeredis[json,lua] (>=2.20.0) ; extra == "test"
 Requires-Dist: pydantic (>=2.11.0,<2.13.0)
+Requires-Dist: pytest (>=8.4.2) ; extra == "test"
+Requires-Dist: pytest-asyncio (>=0.25.0) ; extra == "test"
+Requires-Dist: pytest-cov (>=6.0.0) ; extra == "test"
 Requires-Dist: redis[async] (>=6.0.0,<7.1.0)
 Project-URL: Bug Tracker, https://github.com/imaginary-cherry/rapyer/issues
 Project-URL: Changelog, https://github.com/imaginary-cherry/rapyer/releases

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

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "rapyer"
-version = "1.1.3"
+version = "1.1.5"
 description = "Pydantic models with Redis as the backend"
 authors = [{name = "YedidyaHKfir", email = "yedidyakfir@gmail.com"}]
 readme = "README.md"
@@ -51,6 +51,14 @@ dependencies = [
     "pydantic>=2.11.0, <2.13.0",
 ]
 
+[project.optional-dependencies]
+test = [
+    "pytest>=8.4.2",
+    "pytest-asyncio>=0.25.0",
+    "pytest-cov>=6.0.0",
+    "fakeredis[lua,json]>=2.20.0",
+]
+
 [project.urls]
 Homepage = "https://imaginary-cherry.github.io/rapyer/"
 Documentation = "https://imaginary-cherry.github.io/rapyer/"
@@ -67,11 +75,6 @@ packages = [{include = "rapyer"}]
 black = "^25.9.0"
 mypy = "^1.0.0"
 
-[tool.poetry.group.tests.dependencies]
-pytest = "^8.4.2"
-pytest-asyncio = "^0.25.0"
-pytest-cov = "^6.0.0"
-
 [tool.coverage.run]
 source = ["rapyer"]
 omit = ["*/tests/*", "*/test_*"]

{rapyer-1.1.3 → rapyer-1.1.5}/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.5}/rapyer/base.py

@@ -2,9 +2,11 @@ import asyncio
 import base64
 import contextlib
 import functools
+import logging
 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,48 +17,85 @@ 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 redis.exceptions import NoScriptError
+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,
+    PersistentNoScriptError,
+    UnsupportedIndexedFieldError,
+    CantSerializeRedisValueError,
+)
+from rapyer.fields.expression import ExpressionField, AtomicField, Expression
 from rapyer.fields.index import IndexAnnotation
 from rapyer.fields.key import KeyAnnotation
+from rapyer.fields.safe_load import SafeLoadAnnotation
 from rapyer.links import REDIS_SUPPORTED_LINK
-from rapyer.types.base import RedisType, REDIS_DUMP_FLAG_NAME
+from rapyer.scripts import handle_noscript_error
+from rapyer.types.base import RedisType, REDIS_DUMP_FLAG_NAME, FAILED_FIELDS_KEY
 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,
     field_with_flag,
     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.fields import (
+    get_all_pydantic_annotation,
+    is_redis_field,
+    is_type_json_serializable,
+)
+from rapyer.utils.pythonic import safe_issubclass
+from rapyer.utils.redis import (
+    acquire_lock,
+    update_keys_in_pipeline,
+    refresh_ttl_if_needed,
+)
+
+logger = logging.getLogger("rapyer")
 
 
-def make_pickle_field_serializer(field: str):
+def make_pickle_field_serializer(
+    field: str, safe_load: bool = False, can_json: bool = False
+):
     @field_serializer(field, when_used="json-unless-none")
-    def pickle_field_serializer(v, info: FieldSerializationInfo):
+    @classmethod
+    def pickle_field_serializer(cls, v, info: FieldSerializationInfo):
         ctx = info.context or {}
         should_serialize_redis = ctx.get(REDIS_DUMP_FLAG_NAME, False)
-        if should_serialize_redis:
+        # Skip pickling if field CAN be JSON serialized AND user prefers JSON dump
+        field_can_be_json = can_json and cls.Meta.prefer_normal_json_dump
+        if should_serialize_redis and not field_can_be_json:
             return base64.b64encode(pickle.dumps(v)).decode("utf-8")
         return v
 
     pickle_field_serializer.__name__ = f"__serialize_{field}"
 
     @field_validator(field, mode="before")
-    def pickle_field_validator(v, info: ValidationInfo):
+    @classmethod
+    def pickle_field_validator(cls, v, info: ValidationInfo):
         if v is None:
             return v
         ctx = info.context or {}
         should_serialize_redis = ctx.get(REDIS_DUMP_FLAG_NAME, False)
         if should_serialize_redis:
-            return pickle.loads(base64.b64decode(v))
+            try:
+                field_can_be_json = can_json and cls.Meta.prefer_normal_json_dump
+                if should_serialize_redis and not field_can_be_json:
+                    return pickle.loads(base64.b64decode(v))
+                return v
+            except Exception as e:
+                if safe_load:
+                    failed_fields = ctx.setdefault(FAILED_FIELDS_KEY, set())
+                    failed_fields.add(field)
+                    logger.warning("SafeLoad: Failed to deserialize field '%s'", field)
+                    return None
+                raise CantSerializeRedisValueError() from e
         return v
 
     pickle_field_validator.__name__ = f"__deserialize_{field}"
@@ -64,15 +103,40 @@ def make_pickle_field_serializer(field: str):
     return pickle_field_serializer, pickle_field_validator
 
 
+# TODO: Remove in next major version (2.0) - backward compatibility for pickled data
+# This validator handles loading old pickled data for fields that are now JSON-serializable.
+# In 2.0, remove this function and the validator registration in __init_subclass__.
+def make_backward_compat_validator(field: str):
+    @field_validator(field, mode="before")
+    def backward_compat_validator(v, info: ValidationInfo):
+        ctx = info.context or {}
+        should_deserialize_redis = ctx.get(REDIS_DUMP_FLAG_NAME, False)
+        if should_deserialize_redis and isinstance(v, str):
+            try:
+                return pickle.loads(base64.b64decode(v))
+            except Exception:
+                pass
+        return v
+
+    backward_compat_validator.__name__ = f"__backward_compat_{field}"
+    return backward_compat_validator
+
+
 class AtomicRedisModel(BaseModel):
     _pk: str = PrivateAttr(default_factory=lambda: str(uuid.uuid4()))
     _base_model_link: Self | RedisType = PrivateAttr(default=None)
+    _failed_fields: set[str] = PrivateAttr(default_factory=set)
 
     Meta: ClassVar[RedisConfig] = RedisConfig()
     _key_field_name: ClassVar[str | None] = None
+    _safe_load_fields: ClassVar[set[str]] = set()
     _field_name: str = PrivateAttr(default="")
     model_config = ConfigDict(validate_assignment=True, validate_default=True)
 
+    @property
+    def failed_fields(self) -> set[str]:
+        return self._failed_fields
+
     @property
     def pk(self):
         if self._key_field_name:
@@ -106,34 +170,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
@@ -178,11 +241,13 @@ class AtomicRedisModel(BaseModel):
         self._pk = value.split(":", maxsplit=1)[-1]
 
     def __init_subclass__(cls, **kwargs):
-        # Find a field with KeyAnnotation and save its name
+        # Find fields with KeyAnnotation and SafeLoadAnnotation
+        cls._safe_load_fields = set()
         for field_name, annotation in cls.__annotations__.items():
             if has_annotation(annotation, KeyAnnotation):
                 cls._key_field_name = field_name
-                break
+            if has_annotation(annotation, SafeLoadAnnotation):
+                cls._safe_load_fields.add(field_name)
 
         # Redefine annotations to use redis types
         pydantic_annotation = get_all_pydantic_annotation(cls, AtomicRedisModel)
@@ -194,7 +259,13 @@ class AtomicRedisModel(BaseModel):
         original_annotations.update(new_annotation)
         new_annotations = {
             field_name: replace_to_redis_types_in_annotation(
-                annotation, RedisConverter(cls.Meta.redis_type, f".{field_name}")
+                annotation,
+                RedisConverter(
+                    cls.Meta.redis_type,
+                    f".{field_name}",
+                    safe_load=field_name in cls._safe_load_fields
+                    or cls.Meta.safe_load_all,
+                ),
             )
             for field_name, annotation in original_annotations.items()
             if is_redis_field(field_name, annotation)
@@ -210,21 +281,47 @@ class AtomicRedisModel(BaseModel):
             if not is_redis_field(attr_name, attr_type):
                 continue
             if original_annotations[attr_name] == attr_type:
-                serializer, validator = make_pickle_field_serializer(attr_name)
-                setattr(cls, serializer.__name__, serializer)
-                setattr(cls, validator.__name__, validator)
+                default_value = cls.__dict__.get(attr_name, None)
+                can_json = is_type_json_serializable(attr_type, default_value)
+                should_json_serialize = can_json and cls.Meta.prefer_normal_json_dump
+
+                if not should_json_serialize:
+                    is_field_marked_safe = attr_name in cls._safe_load_fields
+                    is_safe_load = is_field_marked_safe or cls.Meta.safe_load_all
+                    serializer, validator = make_pickle_field_serializer(
+                        attr_name, safe_load=is_safe_load, can_json=can_json
+                    )
+                    setattr(cls, serializer.__name__, serializer)
+                    setattr(cls, validator.__name__, validator)
+                else:
+                    # TODO: Remove in 2.0 - backward compatibility for old pickled data
+                    validator = make_backward_compat_validator(attr_name)
+                    setattr(cls, validator.__name__, validator)
                 continue
 
         # 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 +330,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 +350,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 +364,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 +395,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:
@@ -314,24 +415,34 @@ class AtomicRedisModel(BaseModel):
             raise KeyNotFound(f"{key} is missing in redis")
         model_dump = model_dump[0]
 
-        instance = cls.model_validate(model_dump, context={REDIS_DUMP_FLAG_NAME: True})
+        context = {REDIS_DUMP_FLAG_NAME: True, FAILED_FIELDS_KEY: set()}
+        instance = cls.model_validate(model_dump, context=context)
         instance.key = key
+        instance._failed_fields = context.get(FAILED_FIELDS_KEY, set())
+        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)
         if not model_dump:
             raise KeyNotFound(f"{self.key} is missing in redis")
         model_dump = model_dump[0]
-        instance = self.__class__(**model_dump)
+        context = {REDIS_DUMP_FLAG_NAME: True, FAILED_FIELDS_KEY: set()}
+        instance = self.__class__.model_validate(model_dump, context=context)
         instance._pk = self._pk
         instance._base_model_link = self._base_model_link
+        instance._failed_fields = context.get(FAILED_FIELDS_KEY, set())
+        await refresh_ttl_if_needed(
+            self.Meta.redis, self.key, self.Meta.ttl, self.Meta.refresh_ttl
+        )
         return instance
 
     @classmethod
@@ -365,10 +476,18 @@ 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})
+            context = {REDIS_DUMP_FLAG_NAME: True, FAILED_FIELDS_KEY: set()}
+            model = cls.model_validate(model[0], context=context)
             model.key = key
+            model._failed_fields = context.get(FAILED_FIELDS_KEY, set())
             instances.append(model)
         return instances
 
@@ -381,6 +500,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 +509,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 +520,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 +540,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 +563,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,22 +586,24 @@ 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]:
-        async with self.Meta.redis.pipeline() as pipe:
+    ) -> AbstractAsyncContextManager[Self]:
+        async with self.Meta.redis.pipeline(transaction=True) as pipe:
             try:
                 redis_model = await self.__class__.aget(self.key)
                 unset_fields = {
                     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:
@@ -484,7 +611,40 @@ class AtomicRedisModel(BaseModel):
             _context_var.set(pipe)
             _context_xx_pipe.set(ignore_if_deleted)
             yield redis_model
-            await pipe.execute()
+            commands_backup = list(pipe.command_stack)
+            noscript_on_first_attempt = False
+            noscript_on_retry = False
+
+            try:
+                await pipe.execute()
+            except NoScriptError:
+                noscript_on_first_attempt = True
+
+            if noscript_on_first_attempt:
+                await handle_noscript_error(self.Meta.redis)
+                evalsha_commands = [
+                    (args, options)
+                    for args, options in commands_backup
+                    if args[0] == "EVALSHA"
+                ]
+                # Retry execute the pipeline actions
+                async with self.Meta.redis.pipeline(transaction=True) as retry_pipe:
+                    for args, options in evalsha_commands:
+                        retry_pipe.execute_command(*args, **options)
+                    try:
+                        await retry_pipe.execute()
+                    except NoScriptError:
+                        noscript_on_retry = True
+
+            if noscript_on_retry:
+                raise PersistentNoScriptError(
+                    "NOSCRIPT error persisted after re-registering scripts. "
+                    "This indicates a server-side problem with Redis."
+                )
+
+            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 +690,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 +712,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.5}/rapyer/config.py

@@ -21,3 +21,10 @@ class RedisConfig:
     )
     redis_type: dict[type, type] = dataclasses.field(default_factory=create_all_types)
     ttl: int | None = None
+    init_with_rapyer: bool = True
+    # Enable TTL refresh on read/write operations by default
+    refresh_ttl: bool = True
+    # If True, all non-Redis-supported fields are treated as SafeLoad
+    safe_load_all: bool = False
+    # If True, use JSON serialization for fields that support it instead of pickle
+    prefer_normal_json_dump: bool = False