rapyer 1.1.6__py3-none-any.whl → 1.2.0__py3-none-any.whl

rapyer/__init__.py

@@ -3,9 +3,9 @@
 from rapyer.base import (
     AtomicRedisModel,
     aget,
+    afind,
     find_redis_models,
     ainsert,
-    get,
     alock_from_key,
 )
 from rapyer.init import init_rapyer, teardown_rapyer
@@ -15,7 +15,7 @@ __all__ = [
     "init_rapyer",
     "teardown_rapyer",
     "aget",
-    "get",
+    "afind",
     "find_redis_models",
     "ainsert",
     "alock_from_key",

rapyer/base.py

@@ -6,7 +6,7 @@ import logging
 import pickle
 import uuid
 from contextlib import AbstractAsyncContextManager
-from typing import ClassVar, Any, get_origin
+from typing import ClassVar, Any, get_origin, Optional
 
 from pydantic import (
     BaseModel,
@@ -18,6 +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 rapyer.config import RedisConfig
 from rapyer.context import _context_var, _context_xx_pipe
 from rapyer.errors.base import (
@@ -25,6 +29,7 @@ from rapyer.errors.base import (
     PersistentNoScriptError,
     UnsupportedIndexedFieldError,
     CantSerializeRedisValueError,
+    RapyerModelDoesntExistError,
 )
 from rapyer.fields.expression import ExpressionField, AtomicField, Expression
 from rapyer.fields.index import IndexAnnotation
@@ -50,12 +55,7 @@ from rapyer.utils.pythonic import safe_issubclass
 from rapyer.utils.redis import (
     acquire_lock,
     update_keys_in_pipeline,
-    refresh_ttl_if_needed,
 )
-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
 
 logger = logging.getLogger("rapyer")
 
@@ -103,25 +103,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)
@@ -169,8 +150,13 @@ class AtomicRedisModel(BaseModel):
         field_path = self.field_path
         return f"${field_path}" if field_path else "$"
 
-    def should_refresh(self):
-        return self.Meta.refresh_ttl and self.Meta.ttl is not None
+    @classmethod
+    def should_refresh(cls):
+        return cls.Meta.refresh_ttl and cls.Meta.ttl is not None
+
+    async def refresh_ttl_if_needed(self):
+        if self.should_refresh():
+            await self.Meta.redis.expire(self.key, self.Meta.ttl)
 
     @classmethod
     def redis_schema(cls, redis_name: str = ""):
@@ -296,11 +282,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
@@ -329,12 +310,6 @@ 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)
@@ -349,12 +324,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")
@@ -363,12 +332,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")
@@ -395,24 +358,19 @@ 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 refresh_ttl_if_needed(
-            self.Meta.redis, self.key, self.Meta.ttl, self.Meta.refresh_ttl
-        )
+        await self.refresh_ttl_if_needed()
 
     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:
@@ -427,17 +385,10 @@ class AtomicRedisModel(BaseModel):
         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
-        )
+        if cls.should_refresh():
+            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:
@@ -448,16 +399,32 @@ class AtomicRedisModel(BaseModel):
         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
-        )
+        await self.refresh_ttl_if_needed()
         return instance
 
+    @classmethod
+    def create_redis_model(cls, model_dump: dict, key: str) -> Optional[Self]:
+        context = {REDIS_DUMP_FLAG_NAME: True, FAILED_FIELDS_KEY: set()}
+        try:
+            model = cls.model_validate(model_dump, context=context)
+            model.key = key
+        except ValidationError as exc:
+            logger.debug(
+                "Skipping key %s due to validation error during afind: %s",
+                key,
+                exc,
+            )
+            return None
+        model.key = key
+        model._failed_fields = context.get(FAILED_FIELDS_KEY, set())
+        return model
+
     @classmethod
     async def afind(cls, *args):
         # Separate keys (str) from expressions (Expression)
         provided_keys = [arg for arg in args if isinstance(arg, str)]
         expressions = [arg for arg in args if isinstance(arg, Expression)]
+        raise_on_missing = bool(provided_keys)
 
         if provided_keys and expressions:
             logger.warning(
@@ -493,22 +460,17 @@ class AtomicRedisModel(BaseModel):
         instances = []
         for model, key in zip(models, targeted_keys):
             if model is None:
+                if raise_on_missing:
+                    raise KeyNotFound(f"{key} is missing in redis")
                 continue
-            context = {REDIS_DUMP_FLAG_NAME: True, FAILED_FIELDS_KEY: set()}
-            try:
-                model = cls.model_validate(model[0], context=context)
-            except ValidationError as exc:
-                logger.debug(
-                    "Skipping key %s due to validation error during afind: %s",
-                    key,
-                    exc,
-                )
+            if not cls.Meta.is_fake_redis:
+                model = model[0]
+            model = cls.create_redis_model(model, key)
+            if model is None:
                 continue
-            model.key = key
-            model._failed_fields = context.get(FAILED_FIELDS_KEY, set())
             instances.append(model)
 
-        if cls.Meta.ttl is not None and cls.Meta.refresh_ttl:
+        if cls.should_refresh():
             async with cls.Meta.redis.pipeline() as pipe:
                 for model in instances:
                     pipe.expire(model.key, cls.Meta.ttl)
@@ -529,24 +491,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")
@@ -558,19 +507,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(
@@ -582,18 +518,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
@@ -605,21 +529,9 @@ 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:
             try:
@@ -629,12 +541,12 @@ 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)
+            _context_xx_pipe.set(ignore_redis_error)
             yield redis_model
             commands_backup = list(pipe.command_stack)
             noscript_on_first_attempt = False
@@ -647,10 +559,10 @@ class AtomicRedisModel(BaseModel):
             except NoScriptError:
                 noscript_on_first_attempt = True
             except ResponseError as exc:
-                if ignore_if_deleted:
+                if ignore_redis_error:
                     logger.warning(
                         "Swallowed ResponseError during pipeline.execute() with "
-                        "ignore_if_deleted=True for key %r: %s",
+                        "ignore_redis_error=True for key %r: %s",
                         getattr(self, "key", None),
                         exc,
                     )
@@ -693,6 +605,16 @@ class AtomicRedisModel(BaseModel):
             if isinstance(attr, RedisType):
                 attr._base_model_link = self
 
+        pipeline = _context_var.get()
+        if pipeline is not None:
+            serialized = self.model_dump(
+                mode="json",
+                context={REDIS_DUMP_FLAG_NAME: True},
+                include={name},
+            )
+            json_path = f"{self.json_path}.{name}"
+            pipeline.json().set(self.key, json_path, serialized[name])
+
     def __eq__(self, other):
         if not isinstance(other, BaseModel):
             return False
@@ -720,13 +642,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]
@@ -736,6 +651,52 @@ async def aget(redis_key: str) -> AtomicRedisModel:
     return await klass.aget(redis_key)
 
 
+async def afind(*redis_keys: str, skip_missing: bool = False) -> list[AtomicRedisModel]:
+    if not redis_keys:
+        return []
+
+    redis_model_mapping = {klass.__name__: klass for klass in REDIS_MODELS}
+
+    key_to_class: dict[str, type[AtomicRedisModel]] = {}
+    for key in redis_keys:
+        class_name = key.split(":")[0]
+        if class_name not in redis_model_mapping:
+            raise RapyerModelDoesntExistError(
+                class_name, f"Unknown model class: {class_name}"
+            )
+        key_to_class[key] = redis_model_mapping[class_name]
+
+    models_data = await AtomicRedisModel.Meta.redis.json().mget(
+        keys=redis_keys, path="$"
+    )
+
+    instances = []
+    instances_by_class: dict[type[AtomicRedisModel], list[AtomicRedisModel]] = {}
+
+    for data, key in zip(models_data, redis_keys):
+        if data is None:
+            if not skip_missing:
+                raise KeyNotFound(f"{key} is missing in redis")
+            continue
+        klass = key_to_class[key]
+        if not klass.Meta.is_fake_redis:
+            data = data[0]
+        model = klass.create_redis_model(data, key)
+        if model is None:
+            continue
+        instances.append(model)
+        instances_by_class.setdefault(klass, []).append(model)
+
+    async with AtomicRedisModel.Meta.redis.pipeline() as pipe:
+        for klass, class_instances in instances_by_class.items():
+            if klass.should_refresh():
+                for model in class_instances:
+                    pipe.expire(model.key, klass.Meta.ttl)
+        await pipe.execute()
+
+    return instances
+
+
 def find_redis_models() -> list[type[AtomicRedisModel]]:
     return REDIS_MODELS
 
@@ -744,6 +705,8 @@ async def ainsert(*models: Unpack[AtomicRedisModel]) -> list[AtomicRedisModel]:
     async with AtomicRedisModel.Meta.redis.pipeline() as pipe:
         for model in models:
             pipe.json().set(model.key, model.json_path, model.redis_dump())
+            if model.Meta.ttl is not None:
+                pipe.expire(model.key, model.Meta.ttl)
         await pipe.execute()
     return models
 

rapyer/config.py

@@ -28,3 +28,5 @@ class RedisConfig:
     safe_load_all: bool = False
     # If True, use JSON serialization for fields that support it instead of pickle
     prefer_normal_json_dump: bool = False
+    # Set to True when using FakeRedis to normalize JSON responses
+    is_fake_redis: bool = False

rapyer/errors/__init__.py

@@ -5,6 +5,9 @@ from rapyer.errors.base import (
     RapyerError,
     ScriptsNotInitializedError,
     UnsupportedIndexedFieldError,
+    RapyerModelDoesntExistError,
+    CantSerializeRedisValueError,
+    KeyNotFound,
 )
 
 __all__ = [
@@ -12,6 +15,9 @@ __all__ = [
     "FindError",
     "PersistentNoScriptError",
     "RapyerError",
+    "KeyNotFound",
     "ScriptsNotInitializedError",
     "UnsupportedIndexedFieldError",
+    "RapyerModelDoesntExistError",
+    "CantSerializeRedisValueError",
 ]

rapyer/errors/base.py

@@ -10,6 +10,14 @@ class KeyNotFound(RapyerError):
     pass
 
 
+class RapyerModelDoesntExistError(RapyerError):
+    """Raised when a model doesn't exist."""
+
+    def __init__(self, model_name: str, *args):
+        super().__init__(*args)
+        self.model_name = model_name
+
+
 class FindError(RapyerError):
     """Raised when a model cannot be found."""
 

rapyer/fields/expression.py

@@ -1,6 +1,7 @@
 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

rapyer/init.py

@@ -1,11 +1,16 @@
 import logging
 
 import redis.asyncio as redis_async
-from rapyer.base import REDIS_MODELS
-from rapyer.scripts import register_scripts
 from redis import ResponseError
 from redis.asyncio.client import Redis
 
+from rapyer.base import REDIS_MODELS
+from rapyer.scripts import register_scripts
+
+
+def is_fakeredis(client) -> bool:
+    return "fakeredis" in type(client).__module__
+
 
 async def init_rapyer(
     redis: str | Redis = None,
@@ -24,12 +29,14 @@ async def init_rapyer(
     if isinstance(redis, str):
         redis = redis_async.from_url(redis, decode_responses=True, max_connections=20)
 
+    is_fake_redis = is_fakeredis(redis)
     if redis is not None:
-        await register_scripts(redis)
+        await register_scripts(redis, is_fake_redis)
 
     for model in REDIS_MODELS:
         if redis is not None:
             model.Meta.redis = redis
+            model.Meta.is_fake_redis = is_fake_redis
         if ttl is not None:
             model.Meta.ttl = ttl
         if prefer_normal_json_dump is not None:

rapyer/scripts/__init__.py

@@ -0,0 +1,47 @@
+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,
+    NUM_POW_FLOAT_SCRIPT_NAME,
+    NUM_POW_SCRIPT_NAME,
+    NUM_TRUEDIV_SCRIPT_NAME,
+    REMOVE_RANGE_SCRIPT_NAME,
+    STR_APPEND_SCRIPT_NAME,
+    STR_MUL_SCRIPT_NAME,
+)
+from rapyer.scripts.registry import (
+    _REGISTERED_SCRIPT_SHAS,
+    arun_sha,
+    get_scripts,
+    get_scripts_fakeredis,
+    handle_noscript_error,
+    register_scripts,
+    run_sha,
+)
+
+SCRIPTS = get_scripts()
+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",
+    "NUM_POW_FLOAT_SCRIPT_NAME",
+    "NUM_POW_SCRIPT_NAME",
+    "NUM_TRUEDIV_SCRIPT_NAME",
+    "REMOVE_RANGE_SCRIPT_NAME",
+    "SCRIPTS",
+    "SCRIPTS_FAKEREDIS",
+    "STR_APPEND_SCRIPT_NAME",
+    "STR_MUL_SCRIPT_NAME",
+    "arun_sha",
+    "handle_noscript_error",
+    "register_scripts",
+    "run_sha",
+]

rapyer/scripts/constants.py

@@ -0,0 +1,12 @@
+REMOVE_RANGE_SCRIPT_NAME = "remove_range"
+NUM_MUL_SCRIPT_NAME = "num_mul"
+NUM_FLOORDIV_SCRIPT_NAME = "num_floordiv"
+NUM_MOD_SCRIPT_NAME = "num_mod"
+NUM_POW_SCRIPT_NAME = "num_pow"
+NUM_POW_FLOAT_SCRIPT_NAME = "num_pow_float"
+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/scripts/loader.py

@@ -0,0 +1,54 @@
+from functools import lru_cache
+from importlib import resources
+
+
+VARIANTS = {
+    "redis": {
+        "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": {
+        "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""",
+    },
+}
+
+
+@lru_cache(maxsize=None)
+def _load_template(category: str, name: str) -> str:
+    package = f"rapyer.scripts.lua.{category}"
+    filename = f"{name}.lua"
+    return resources.files(package).joinpath(filename).read_text()
+
+
+def load_script(category: str, name: str, variant: str = "redis") -> str:
+    template = _load_template(category, name)
+    replacements = VARIANTS[variant]
+    result = template
+    for placeholder, value in replacements.items():
+        result = result.replace(f"--[[{placeholder}]]", value)
+    return result