rapyer 1.1.7__tar.gz → 1.2.1__tar.gz

{rapyer-1.1.7 → rapyer-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapyer
-Version: 1.1.7
+Version: 1.2.1
 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.7 → rapyer-1.2.1}/pyproject.toml

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

{rapyer-1.1.7 → rapyer-1.2.1}/rapyer/__init__.py

@@ -6,8 +6,8 @@ from rapyer.base import (
     afind,
     find_redis_models,
     ainsert,
-    get,
     alock_from_key,
+    apipeline,
 )
 from rapyer.init import init_rapyer, teardown_rapyer
 
@@ -17,8 +17,8 @@ __all__ = [
     "teardown_rapyer",
     "aget",
     "afind",
-    "get",
     "find_redis_models",
     "ainsert",
     "alock_from_key",
+    "apipeline",
 ]

{rapyer-1.1.7 → rapyer-1.2.1}/rapyer/base.py

@@ -18,13 +18,10 @@ from pydantic import (
     ValidationError,
 )
 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, ResponseError
-from typing_extensions import deprecated
+from redis.client import Pipeline
 
 from rapyer.config import RedisConfig
-from rapyer.context import _context_var, _context_xx_pipe
+from rapyer.context import _context_var
 from rapyer.errors.base import (
     KeyNotFound,
     PersistentNoScriptError,
@@ -37,7 +34,7 @@ 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.scripts import handle_noscript_error
+from rapyer.scripts import registry as scripts_registry
 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
@@ -57,6 +54,9 @@ 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 redis.exceptions import NoScriptError, ResponseError
 
 logger = logging.getLogger("rapyer")
 
@@ -104,25 +104,6 @@ def make_pickle_field_serializer(
     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)
@@ -170,6 +151,10 @@ class AtomicRedisModel(BaseModel):
         field_path = self.field_path
         return f"${field_path}" if field_path else "$"
 
+    @property
+    def client(self):
+        return _context_var.get() or self.Meta.redis
+
     @classmethod
     def should_refresh(cls):
         return cls.Meta.refresh_ttl and cls.Meta.ttl is not None
@@ -302,11 +287,6 @@ class AtomicRedisModel(BaseModel):
                     )
                     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
@@ -335,18 +315,12 @@ class AtomicRedisModel(BaseModel):
     def is_inner_model(self) -> bool:
         return bool(self.field_name)
 
-    @deprecated(
-        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()  # 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)
+        await self.client.json().set(self.key, self.json_path, model_dump)
         if self.Meta.ttl is not None:
             nx = not self.Meta.refresh_ttl
-            await self.Meta.redis.expire(self.key, self.Meta.ttl, nx=nx)
+            await self.client.expire(self.key, self.Meta.ttl, nx=nx)
         return self
 
     def redis_dump(self):
@@ -355,12 +329,6 @@ class AtomicRedisModel(BaseModel):
     def redis_dump_json(self):
         return self.model_dump_json(context={REDIS_DUMP_FLAG_NAME: True})
 
-    @deprecated(
-        "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()  # pragma: no cover
-
     async def aduplicate(self) -> Self:
         if self.is_inner_model():
             raise RuntimeError("Can only duplicate from top level model")
@@ -369,12 +337,6 @@ class AtomicRedisModel(BaseModel):
         await duplicated.asave()
         return duplicated
 
-    @deprecated(
-        "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)  # pragma: no cover
-
     async def aduplicate_many(self, num: int) -> list[Self]:
         if self.is_inner_model():
             raise RuntimeError("Can only duplicate from top level model")
@@ -401,7 +363,7 @@ class AtomicRedisModel(BaseModel):
             for field_name in kwargs.keys()
         }
 
-        async with self.Meta.redis.pipeline() as pipe:
+        async with self.Meta.redis.pipeline(transaction=True) as pipe:
             update_keys_in_pipeline(pipe, self.key, **json_path_kwargs)
             await pipe.execute()
         await self.refresh_ttl_if_needed()
@@ -409,14 +371,11 @@ class AtomicRedisModel(BaseModel):
     async def aset_ttl(self, ttl: int) -> None:
         if self.is_inner_model():
             raise RuntimeError("Can only set TTL from top level model")
-        await self.Meta.redis.expire(self.key, 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)  # pragma: no cover
+        pipeline = _context_var.get()
+        if pipeline is not None:
+            pipeline.expire(self.key, ttl)
+        else:
+            await self.Meta.redis.expire(self.key, ttl)
 
     @classmethod
     async def aget(cls, key: str) -> Self:
@@ -435,12 +394,6 @@ class AtomicRedisModel(BaseModel):
             await cls.Meta.redis.expire(key, cls.Meta.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()  # 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:
@@ -543,24 +496,11 @@ class AtomicRedisModel(BaseModel):
                     pipe.expire(model.key, cls.Meta.ttl)
             await pipe.execute()
 
-    @classmethod
-    @deprecated(
-        "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)  # pragma: no cover
-
     @classmethod
     async def adelete_by_key(cls, key: str) -> bool:
         client = _context_var.get() or cls.Meta.redis
         return await client.delete(key) == 1
 
-    @deprecated(
-        "function delete is deprecated and will be removed in rapyer 1.2.0, use adelete instead"
-    )
-    async def delete(self):
-        return await self.adelete()  # pragma: no cover
-
     async def adelete(self):
         if self.is_inner_model():
             raise RuntimeError("Can only delete from inner model")
@@ -572,19 +512,6 @@ class AtomicRedisModel(BaseModel):
             *[model if isinstance(model, str) else model.key for model in args]
         )
 
-    @classmethod
-    @contextlib.asynccontextmanager
-    @deprecated(
-        "lock_from_key function is deprecated and will be removed in rapyer 1.2.0, use alock_from_key instead"
-    )
-    async def lock_from_key(
-        cls, key: str, action: str = "default", save_at_end: bool = False
-    ) -> 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(
@@ -596,18 +523,6 @@ class AtomicRedisModel(BaseModel):
             if save_at_end:
                 await redis_model.asave()
 
-    @contextlib.asynccontextmanager
-    @deprecated(
-        "lock function is deprecated and will be removed in rapyer 1.2.0, use alock instead"
-    )
-    async def lock(
-        self, action: str = "default", save_at_end: bool = False
-    ) -> 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
@@ -619,23 +534,13 @@ class AtomicRedisModel(BaseModel):
             self.__dict__.update(unset_fields)
             yield redis_model
 
-    @contextlib.asynccontextmanager
-    @deprecated(
-        "pipeline function is deprecated and will be removed in rapyer 1.2.0, use apipeline instead"
-    )
-    async def pipeline(
-        self, ignore_if_deleted: bool = False
-    ) -> 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
+        self, ignore_redis_error: bool = False
     ) -> AbstractAsyncContextManager[Self]:
-        async with self.Meta.redis.pipeline(transaction=True) as pipe:
+        async with apipeline(
+            ignore_redis_error=ignore_redis_error, _meta=self.Meta
+        ) as pipe:
             try:
                 redis_model = await self.__class__.aget(self.key)
                 unset_fields = {
@@ -643,61 +548,17 @@ class AtomicRedisModel(BaseModel):
                 }
                 self.__dict__.update(unset_fields)
             except (TypeError, KeyNotFound):
-                if ignore_if_deleted:
+                if ignore_redis_error:
                     redis_model = self
                 else:
                     raise
-            _context_var.set(pipe)
-            _context_xx_pipe.set(ignore_if_deleted)
             yield redis_model
-            commands_backup = list(pipe.command_stack)
-            noscript_on_first_attempt = False
-            noscript_on_retry = False
 
-            try:
-                if self.should_refresh():
-                    pipe.expire(self.key, self.Meta.ttl)
-                await pipe.execute()
-            except NoScriptError:
-                noscript_on_first_attempt = True
-            except ResponseError as exc:
-                if ignore_if_deleted:
-                    logger.warning(
-                        "Swallowed ResponseError during pipeline.execute() with "
-                        "ignore_if_deleted=True for key %r: %s",
-                        getattr(self, "key", None),
-                        exc,
-                    )
-                else:
-                    raise
-
-            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."
-                )
-
-            _context_var.set(None)
-            _context_xx_pipe.set(False)
+            if self.should_refresh():
+                pipe.expire(self.key, self.Meta.ttl)
 
     def __setattr__(self, name: str, value: Any) -> None:
-        if name not in self.__annotations__ or value is None:
+        if name not in self.__class__.model_fields or value is None:
             super().__setattr__(name, value)
             return
 
@@ -744,13 +605,6 @@ class AtomicRedisModel(BaseModel):
 REDIS_MODELS: list[type[AtomicRedisModel]] = []
 
 
-@deprecated(
-    "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)  # 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]
@@ -832,3 +686,56 @@ async def alock_from_key(
         yield redis_model
         if save_at_end and redis_model is not None:
             await redis_model.asave()
+
+
+@contextlib.asynccontextmanager
+async def apipeline(
+    ignore_redis_error: bool = False, _meta: RedisConfig = None
+) -> AbstractAsyncContextManager[Pipeline]:
+    _meta = _meta or AtomicRedisModel.Meta
+    redis = _meta.redis
+    async with redis.pipeline(transaction=True) as pipe:
+        pipe_prev = _context_var.set(pipe)
+    try:
+        yield pipe
+        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
+        except ResponseError as exc:
+            if ignore_redis_error:
+                logger.warning(
+                    "Swallowed ResponseError during pipeline.execute() with "
+                    "ignore_redis_error=True: %s",
+                    exc,
+                )
+            else:
+                raise
+
+        if noscript_on_first_attempt:
+            await scripts_registry.handle_noscript_error(redis, _meta)
+            evalsha_commands = [
+                (args, options)
+                for args, options in commands_backup
+                if args[0] == "EVALSHA"
+            ]
+            # Retry execute the pipeline actions
+            async with 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."
+            )
+    finally:
+        _context_var.reset(pipe_prev)

{rapyer-1.1.7 → rapyer-1.2.1}/rapyer/context.py

@@ -7,6 +7,3 @@ from redis.asyncio.client import Redis
 _context_var: contextvars.ContextVar[Optional["Redis"]] = contextvars.ContextVar(
     "redis", default=None
 )
-_context_xx_pipe: contextvars.ContextVar[bool] = contextvars.ContextVar(
-    "redis_xx_pipe", default=False
-)

{rapyer-1.1.7 → rapyer-1.2.1}/rapyer/scripts/__init__.py

@@ -1,5 +1,7 @@
 from rapyer.scripts.constants import (
     DATETIME_ADD_SCRIPT_NAME,
+    DICT_POP_SCRIPT_NAME,
+    DICT_POPITEM_SCRIPT_NAME,
     NUM_FLOORDIV_SCRIPT_NAME,
     NUM_MOD_SCRIPT_NAME,
     NUM_MUL_SCRIPT_NAME,
@@ -12,6 +14,7 @@ from rapyer.scripts.constants import (
 )
 from rapyer.scripts.registry import (
     _REGISTERED_SCRIPT_SHAS,
+    arun_sha,
     get_scripts,
     get_scripts_fakeredis,
     handle_noscript_error,
@@ -24,6 +27,8 @@ SCRIPTS_FAKEREDIS = get_scripts_fakeredis()
 
 __all__ = [
     "DATETIME_ADD_SCRIPT_NAME",
+    "DICT_POP_SCRIPT_NAME",
+    "DICT_POPITEM_SCRIPT_NAME",
     "NUM_FLOORDIV_SCRIPT_NAME",
     "NUM_MOD_SCRIPT_NAME",
     "NUM_MUL_SCRIPT_NAME",
@@ -35,6 +40,7 @@ __all__ = [
     "SCRIPTS_FAKEREDIS",
     "STR_APPEND_SCRIPT_NAME",
     "STR_MUL_SCRIPT_NAME",
+    "arun_sha",
     "handle_noscript_error",
     "register_scripts",
     "run_sha",

{rapyer-1.1.7 → rapyer-1.2.1}/rapyer/scripts/constants.py

@@ -1,3 +1,6 @@
+REDIS_VARIANT = "redis"
+FAKEREDIS_VARIANT = "fakeredis"
+
 REMOVE_RANGE_SCRIPT_NAME = "remove_range"
 NUM_MUL_SCRIPT_NAME = "num_mul"
 NUM_FLOORDIV_SCRIPT_NAME = "num_floordiv"
@@ -8,3 +11,5 @@ NUM_TRUEDIV_SCRIPT_NAME = "num_truediv"
 STR_APPEND_SCRIPT_NAME = "str_append"
 STR_MUL_SCRIPT_NAME = "str_mul"
 DATETIME_ADD_SCRIPT_NAME = "datetime_add"
+DICT_POP_SCRIPT_NAME = "dict_pop"
+DICT_POPITEM_SCRIPT_NAME = "dict_popitem"

{rapyer-1.1.7 → rapyer-1.2.1}/rapyer/scripts/loader.py

@@ -1,19 +1,40 @@
 from functools import lru_cache
 from importlib import resources
 
+from rapyer.scripts.constants import FAKEREDIS_VARIANT, REDIS_VARIANT
 
 VARIANTS = {
-    "redis": {
+    REDIS_VARIANT: {
         "EXTRACT_ARRAY": "local arr = cjson.decode(arr_json)[1]",
         "EXTRACT_VALUE": "local value = tonumber(cjson.decode(current_json)[1])",
         "EXTRACT_STR": "local value = cjson.decode(current_json)[1]",
         "EXTRACT_DATETIME": "local value = cjson.decode(current_json)[1]",
+        "DICT_EXTRACT_VALUE": "local extracted = cjson.decode(value)[1]",
+        "DICT_EXTRACT_POPITEM": """local parsed = cjson.decode(value)
+if type(parsed) == 'table' then
+    for _, v in pairs(parsed) do
+        extracted = v
+        break
+    end
+else
+    extracted = parsed
+end""",
     },
-    "fakeredis": {
+    FAKEREDIS_VARIANT: {
         "EXTRACT_ARRAY": "local arr = cjson.decode(arr_json)",
         "EXTRACT_VALUE": "local value = tonumber(cjson.decode(current_json)[1])",
         "EXTRACT_STR": "local value = cjson.decode(current_json)[1]",
         "EXTRACT_DATETIME": "local value = cjson.decode(current_json)[1]",
+        "DICT_EXTRACT_VALUE": "local extracted = cjson.decode(value)[1]",
+        "DICT_EXTRACT_POPITEM": """local parsed = cjson.decode(value)
+if type(parsed) == 'table' then
+    for _, v in pairs(parsed) do
+        extracted = v
+        break
+    end
+else
+    extracted = parsed
+end""",
     },
 }
 
@@ -25,7 +46,7 @@ def _load_template(category: str, name: str) -> str:
     return resources.files(package).joinpath(filename).read_text()
 
 
-def load_script(category: str, name: str, variant: str = "redis") -> str:
+def load_script(category: str, name: str, variant: str = REDIS_VARIANT) -> str:
     template = _load_template(category, name)
     replacements = VARIANTS[variant]
     result = template

rapyer-1.2.1/rapyer/scripts/lua/dict/pop.lua

@@ -0,0 +1,13 @@
+local key = KEYS[1]
+local path = ARGV[1]
+local target_key = ARGV[2]
+
+local value = redis.call('JSON.GET', key, path .. '.' .. target_key)
+
+if value and value ~= '[]' and value ~= 'null' then
+    redis.call('JSON.DEL', key, path .. '.' .. target_key)
+    --[[DICT_EXTRACT_VALUE]]
+    return extracted
+else
+    return nil
+end

rapyer-1.2.1/rapyer/scripts/lua/dict/popitem.lua

@@ -0,0 +1,29 @@
+local key = KEYS[1]
+local path = ARGV[1]
+
+local keys = redis.call('JSON.OBJKEYS', key, path)
+
+if not keys or #keys == 0 then
+    return nil
+end
+
+if type(keys[1]) == 'table' then
+    keys = keys[1]
+end
+
+if not keys or #keys == 0 then
+    return nil
+end
+
+local first_key = tostring(keys[1])
+local value = redis.call('JSON.GET', key, path .. '.' .. first_key)
+
+if not value then
+    return nil
+end
+
+redis.call('JSON.DEL', key, path .. '.' .. first_key)
+
+local extracted
+--[[DICT_EXTRACT_POPITEM]]
+return {first_key, extracted}

{rapyer-1.1.7 → rapyer-1.2.1}/rapyer/scripts/registry.py

@@ -1,17 +1,27 @@
-from rapyer.errors import ScriptsNotInitializedError
+from typing import TYPE_CHECKING
+
+from rapyer.errors import PersistentNoScriptError, ScriptsNotInitializedError
 from rapyer.scripts.constants import (
     DATETIME_ADD_SCRIPT_NAME,
+    DICT_POP_SCRIPT_NAME,
+    DICT_POPITEM_SCRIPT_NAME,
+    FAKEREDIS_VARIANT,
     NUM_FLOORDIV_SCRIPT_NAME,
     NUM_MOD_SCRIPT_NAME,
     NUM_MUL_SCRIPT_NAME,
     NUM_POW_FLOAT_SCRIPT_NAME,
     NUM_POW_SCRIPT_NAME,
     NUM_TRUEDIV_SCRIPT_NAME,
+    REDIS_VARIANT,
     REMOVE_RANGE_SCRIPT_NAME,
     STR_APPEND_SCRIPT_NAME,
     STR_MUL_SCRIPT_NAME,
 )
 from rapyer.scripts.loader import load_script
+from redis.exceptions import NoScriptError
+
+if TYPE_CHECKING:
+    from rapyer.config import RedisConfig
 
 SCRIPT_REGISTRY: list[tuple[str, str, str]] = [
     ("list", "remove_range", REMOVE_RANGE_SCRIPT_NAME),
@@ -24,6 +34,8 @@ SCRIPT_REGISTRY: list[tuple[str, str, str]] = [
     ("string", "append", STR_APPEND_SCRIPT_NAME),
     ("string", "mul", STR_MUL_SCRIPT_NAME),
     ("datetime", "add", DATETIME_ADD_SCRIPT_NAME),
+    ("dict", "pop", DICT_POP_SCRIPT_NAME),
+    ("dict", "popitem", DICT_POPITEM_SCRIPT_NAME),
 ]
 
 _REGISTERED_SCRIPT_SHAS: dict[str, str] = {}
@@ -37,29 +49,54 @@ def _build_scripts(variant: str) -> dict[str, str]:
 
 
 def get_scripts() -> dict[str, str]:
-    return _build_scripts("redis")
+    return _build_scripts(REDIS_VARIANT)
 
 
 def get_scripts_fakeredis() -> dict[str, str]:
-    return _build_scripts("fakeredis")
+    return _build_scripts(FAKEREDIS_VARIANT)
 
 
 async def register_scripts(redis_client, is_fakeredis: bool = False) -> None:
-    variant = "fakeredis" if is_fakeredis else "redis"
+    variant = FAKEREDIS_VARIANT if is_fakeredis else REDIS_VARIANT
     scripts = _build_scripts(variant)
     for name, script_text in scripts.items():
         sha = await redis_client.script_load(script_text)
         _REGISTERED_SCRIPT_SHAS[name] = sha
 
 
-def run_sha(pipeline, script_name: str, keys: int, *args) -> None:
+def get_script(script_name: str):
     sha = _REGISTERED_SCRIPT_SHAS.get(script_name)
     if sha is None:
         raise ScriptsNotInitializedError(
             f"Script '{script_name}' not loaded. Did you forget to call init_rapyer()?"
         )
+    return sha
+
+
+def run_sha(pipeline, script_name: str, keys: int, *args):
+    sha = get_script(script_name)
     pipeline.evalsha(sha, keys, *args)
 
 
-async def handle_noscript_error(redis_client) -> None:
-    await register_scripts(redis_client)
+async def arun_sha(
+    client, redis_config: "RedisConfig", script_name: str, keys: int, *args
+):
+    sha = get_script(script_name)
+    try:
+        return await client.evalsha(sha, keys, *args)
+    except NoScriptError:
+        pass
+
+    await handle_noscript_error(client, redis_config)
+    sha = get_script(script_name)
+    try:
+        return await client.evalsha(sha, keys, *args)
+    except NoScriptError as e:
+        raise PersistentNoScriptError(
+            "NOSCRIPT error persisted after re-registering scripts. "
+            "This indicates a server-side problem with Redis."
+        ) from e
+
+
+async def handle_noscript_error(redis_client, redis_config: "RedisConfig"):
+    await register_scripts(redis_client, is_fakeredis=redis_config.is_fake_redis)

{rapyer-1.1.7 → rapyer-1.2.1}/rapyer/types/base.py

@@ -9,7 +9,6 @@ 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.errors.base import CantSerializeRedisValueError
@@ -74,12 +73,6 @@ class RedisType(ABC):
     def json_field_path(self, field_name: str):
         return f"${self.sub_field_path(field_name)}"
 
-    @deprecated(
-        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()  # pragma: no cover
-
     async def asave(self) -> Self:
         model_dump = self._adapter.dump_python(
             self, mode="json", context={REDIS_DUMP_FLAG_NAME: True}
@@ -90,12 +83,6 @@ class RedisType(ABC):
             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()  # pragma: no cover
-
     async def aload(self):
         redis_value = await self.client.json().get(self.key, self.field_path)
         if redis_value is None:

{rapyer-1.1.7 → rapyer-1.2.1}/rapyer/types/dct.py

@@ -2,6 +2,7 @@ from typing import TypeVar, Generic, get_args, Any, TypeAlias, TYPE_CHECKING
 
 from pydantic_core import core_schema
 
+from rapyer.scripts import arun_sha, DICT_POP_SCRIPT_NAME, DICT_POPITEM_SCRIPT_NAME
 from rapyer.types.base import (
     GenericRedisType,
     RedisType,
@@ -12,80 +13,6 @@ from rapyer.utils.redis import update_keys_in_pipeline
 
 T = TypeVar("T")
 
-# Redis Lua script for atomic get-and-delete operation
-POP_SCRIPT = """
-local key = KEYS[1]
-local path = ARGV[1]
-local target_key = ARGV[2]
-
--- Get the value from the JSON object
-local value = redis.call('JSON.GET', key, path .. '.' .. target_key)
-
-if value and value ~= '[]' and value ~= 'null' then
-    -- Delete the key from the JSON object
-    redis.call('JSON.DEL', key, path .. '.' .. target_key)
-
-    -- Parse and return the actual value
-    local parsed = cjson.decode(value)
-    return parsed[1]  -- Return first element if it's an array
-else
-    return nil
-end
-"""
-
-
-# Redis Lua script for atomic get-arbitrary-key-and-delete operation
-POPITEM_SCRIPT = """
-local key = KEYS[1]
-local path = ARGV[1]
-
--- Get all the keys from the JSON object
-local keys = redis.call('JSON.OBJKEYS', key, path)
-
--- Return nil if no keys exist
-if not keys or #keys == 0 then
-    return nil
-end
-
--- Handle nested arrays - Redis sometimes wraps results
-if type(keys[1]) == 'table' then
-    keys = keys[1]
-end
-
--- Check again after unwrapping
-if not keys or #keys == 0 then
-    return nil
-end
-
-local first_key = tostring(keys[1])
-
--- Get the value for this key
-local value = redis.call('JSON.GET', key, path .. '.' .. first_key)
-
--- Return nil if value doesn't exist
-if not value then
-    return nil
-end
-
--- Delete the key from the JSON object
-redis.call('JSON.DEL', key, path .. '.' .. first_key)
-
--- Parse the JSON string
-local parsed_value = cjson.decode(value)
-
--- If it's a table/object, return the first value
-if type(parsed_value) == 'table' then
-    for _, v in pairs(parsed_value) do
-        return {first_key, v}  -- Return first value found
-    end
-    -- If table is empty, return nil
-    return nil
-end
-
--- Otherwise return the parsed value as-is
-return {first_key, parsed_value}
-"""
-
 
 class RedisDict(dict[str, T], GenericRedisType, Generic[T]):
     original_type = dict
@@ -108,10 +35,13 @@ class RedisDict(dict[str, T], GenericRedisType, Generic[T]):
 
     def update(self, m=None, /, **kwargs):
         if self.pipeline:
-            m_redis_val = self._adapter.dump_python(
-                m, mode="json", context={REDIS_DUMP_FLAG_NAME: True}
+            m_redis_val = (
+                self._adapter.dump_python(
+                    m, mode="json", context={REDIS_DUMP_FLAG_NAME: True}
+                )
+                if m
+                else {}
             )
-            m_redis_val = m_redis_val or {}
             kwargs_redis_val = self._adapter.dump_python(
                 kwargs, mode="json", context={REDIS_DUMP_FLAG_NAME: True}
             )
@@ -175,14 +105,19 @@ class RedisDict(dict[str, T], GenericRedisType, Generic[T]):
             await self.refresh_ttl_if_needed()
 
     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)
+        result = await arun_sha(
+            self.client,
+            self.Meta,
+            DICT_POP_SCRIPT_NAME,
+            1,
+            self.key,
+            self.json_path,
+            key,
+        )
         super().pop(key, None)
         await self.refresh_ttl_if_needed()
 
         if result is None:
-            # Key doesn't exist in Redis
             return default
 
         return self._adapter.validate_python(
@@ -190,8 +125,14 @@ class RedisDict(dict[str, T], GenericRedisType, Generic[T]):
         )[key]
 
     async def apopitem(self):
-        # Execute the script atomically
-        result = await self.client.eval(POPITEM_SCRIPT, 1, self.key, self.json_path)
+        result = await arun_sha(
+            self.client,
+            self.Meta,
+            DICT_POPITEM_SCRIPT_NAME,
+            1,
+            self.key,
+            self.json_path,
+        )
         await self.refresh_ttl_if_needed()
 
         if result is not None:

{rapyer-1.1.7 → rapyer-1.2.1}/rapyer/types/integer.py

@@ -1,7 +1,6 @@
 from typing import TypeAlias, TYPE_CHECKING
 
 from redis.commands.search.field import NumericField
-from typing_extensions import deprecated
 
 from rapyer.scripts import (
     run_sha,
@@ -20,12 +19,6 @@ class RedisInt(int, RedisType):
     def redis_schema(cls, field_name: str):
         return NumericField(f"$.{field_name}", as_name=field_name)
 
-    @deprecated(
-        f"increase function is deprecated and will become sync function in rapyer 1.2.0, use aincrease() instead"
-    )
-    async def increase(self, amount: int = 1):
-        return await self.aincrease(amount)
-
     async def aincrease(self, amount: int = 1):
         result = await self.client.json().numincrby(self.key, self.json_path, amount)
         await self.refresh_ttl_if_needed()