From 99726e881db867c9d46404729355a64d9306edf1 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 30 Oct 2026 18:37:46 +0000 Subject: [PATCH] feat(redis): add explicit non-retrying direct eval transport --- litellm/redis/transport/batch.py | 11 ++--- litellm/redis/transport/contract.py | 6 +++ litellm/redis/transport/redis_py.py | 21 +++++++++- tests/unit/redis/stores/test_pod_lock.py | 3 ++ tests/unit/redis/transport/test_redis_py.py | 45 +++++++++++++++++++++ 5 files changed, 80 insertions(+), 6 deletions(-) diff --git a/litellm/redis/transport/batch.py b/litellm/redis/transport/batch.py index 6e283c89ce8..7585410181c 100644 --- a/litellm/redis/transport/batch.py +++ b/litellm/redis/transport/batch.py @@ -62,10 +62,11 @@ def _is_missing_script(failure: Exception) -> bool: class _Op(Generic[_T]): - __slots__ = ("caller", "future", "settled_hooks", "spec", "target") + __slots__ = ("caller", "future", "retry_missing_script", "settled_hooks", "spec", "target") - def __init__(self, spec: OpSpec[_T]) -> None: + def __init__(self, spec: OpSpec[_T], *, retry_missing_script: bool) -> None: self.spec: Final = spec + self.retry_missing_script: Final = retry_missing_script self.future: Final[asyncio.Future[_T]] = asyncio.get_running_loop().create_future() self.future.add_done_callback(_mark_retrieved) self.settled_hooks: Final[list[SettledHook[_T]]] = [] # mutable-ok: append-only registry @@ -92,7 +93,7 @@ class _Op(Generic[_T]): except Exception as e: # noqa: BLE001 # a reply this op cannot decode fails this op alone self.future.set_exception(e) return None - if _is_missing_script(failure): + if self.retry_missing_script and _is_missing_script(failure): return self.settle_alone() self.recover(failure) return None @@ -154,8 +155,8 @@ class PipelineBatch: _misses: set[str] = field(default_factory=set) # mutable-ok: keys a read of this batch found absent flushes: int = 0 - def declare(self, spec: OpSpec[_T]) -> BatchResult[_T]: - op: Final = _Op(spec) + def declare(self, spec: OpSpec[_T], *, retry_missing_script: bool = True) -> BatchResult[_T]: + op: Final = _Op(spec, retry_missing_script=retry_missing_script) self._pending.append(op) # pyright: ignore[reportArgumentType] # heterogeneous ops share the flush loop return BatchResult(self, op) diff --git a/litellm/redis/transport/contract.py b/litellm/redis/transport/contract.py index 2552a54f9c2..a7c8c2a0192 100644 --- a/litellm/redis/transport/contract.py +++ b/litellm/redis/transport/contract.py @@ -84,6 +84,10 @@ class RedisCommandBatch(Protocol): def eval(self, script: str, keys: Sequence[str], args: Sequence[Arg]) -> BatchReply[EvalReply | RedisFailure]: ... + def eval_direct( + self, script: str, keys: Sequence[str], args: Sequence[Arg] + ) -> BatchReply[EvalReply | RedisFailure]: ... + async def flush(self) -> None: ... @@ -128,6 +132,8 @@ class RedisTransport(Protocol): async def eval(self, script: str, keys: Sequence[str], args: Sequence[Arg]) -> EvalReply | RedisFailure: ... + async def eval_direct(self, script: str, keys: Sequence[str], args: Sequence[Arg]) -> EvalReply | RedisFailure: ... + def batch( self, *, transaction: bool = False, raise_on_error: bool = False, name: str = "redis_batch" ) -> RedisCommandBatch: ... diff --git a/litellm/redis/transport/redis_py.py b/litellm/redis/transport/redis_py.py index af6c0adfa73..99819448757 100644 --- a/litellm/redis/transport/redis_py.py +++ b/litellm/redis/transport/redis_py.py @@ -115,6 +115,12 @@ class RedisPyTransport: await self._run("eval", lambda: _evalsha_or_eval(self.client(), script, sha, namespaced, args)) ) + async def eval_direct(self, script: str, keys: Sequence[str], args: Sequence[Arg]) -> EvalReply | RedisFailure: + namespaced: Final = tuple(self._key(key) for key in keys) + return _eval_reply( + await self._run("eval_direct", lambda: self.client().eval(script, len(namespaced), *namespaced, *args)) + ) + def batch( self, *, transaction: bool = False, raise_on_error: bool = False, name: str = "redis_batch" ) -> "RedisPyCommandBatch": @@ -355,13 +361,26 @@ class RedisPyCommandBatch: async def flush(self) -> None: await self.engine.flush() + def eval_direct( + self, script: str, keys: Sequence[str], args: Sequence[Arg] + ) -> BatchResult[EvalReply | RedisFailure]: + names: Final = tuple(self.transport._key(key) for key in keys) # pyright: ignore[reportPrivateUsage] # the batch is the transport's own + return self._declare( + lambda pipe: _one(pipe.eval(script, len(names), *names, *args)), + lambda replies: _eval_reply(replies[0]), + lambda: self.transport.eval_direct(script, keys, args), + retry_missing_script=False, + ) + def _declare( self, queue: Callable[[RedisPipeline], int], decode: Callable[[Sequence[object]], _T | RedisFailure], alone: Callable[[], Awaitable[_T | RedisFailure]], + *, + retry_missing_script: bool = True, ) -> BatchResult[_T | RedisFailure]: - return self.engine.declare(_Command(queue, decode, alone)) + return self.engine.declare(_Command(queue, decode, alone), retry_missing_script=retry_missing_script) def _note_read( self, diff --git a/tests/unit/redis/stores/test_pod_lock.py b/tests/unit/redis/stores/test_pod_lock.py index e06abc9937a..cb23a4736c8 100644 --- a/tests/unit/redis/stores/test_pod_lock.py +++ b/tests/unit/redis/stores/test_pod_lock.py @@ -29,6 +29,9 @@ class ExpiredLockTransport: async def eval(self, script: str, keys: Sequence[str], args: Sequence[Arg]) -> EvalReply | RedisFailure: raise AssertionError("unexpected eval") + async def eval_direct(self, script: str, keys: Sequence[str], args: Sequence[Arg]) -> EvalReply | RedisFailure: + raise AssertionError("unexpected eval_direct") + async def incrby(self, key: str, amount: int) -> NoReturn: raise AssertionError("unexpected incrby") diff --git a/tests/unit/redis/transport/test_redis_py.py b/tests/unit/redis/transport/test_redis_py.py index 075ced876a5..633f4274be0 100644 --- a/tests/unit/redis/transport/test_redis_py.py +++ b/tests/unit/redis/transport/test_redis_py.py @@ -159,6 +159,51 @@ async def test_eval_namespaces_keys_and_returns_nested_replies( assert await raw.get("ns:k") == b"w" +@pytest.mark.asyncio +@pytest.mark.parametrize("mode", ("direct", "batch", "transaction")) +async def test_direct_eval_preserves_wire_replies_namespace_and_single_event( + server: fakeredis.FakeServer, raw: fakeredis.FakeAsyncRedis, mode: str +) -> None: + events: Final = _RecordingEvents() + cache: Final = fake_redis_cache(server, namespace="ns", service_logger=events) + await _settle() + before: Final = len(events.seen) + transport: Final = cache.transport() + executor: Final = transport if mode == "direct" else transport.batch(transaction=mode == "transaction") + + assert await executor.eval_direct(_ECHO, ("ns:key",), ("value", 7)) == (b"value", 7, (b"ns:key",)) + assert await raw.get("ns:key") == b"value" + assert await raw.get("ns:ns:key") is None + await _settle() + assert tuple((event.outcome, event.call_type) for event in events.seen[before:]) == ( + ("success", "eval_direct" if mode == "direct" else "redis_batch"), + ) + + +@pytest.mark.asyncio +@pytest.mark.parametrize("mode", ("direct", "batch", "transaction")) +async def test_direct_eval_never_replays_a_write_followed_by_noscript_error( + server: fakeredis.FakeServer, raw: fakeredis.FakeAsyncRedis, mode: str +) -> None: + events: Final = _RecordingEvents() + cache: Final = fake_redis_cache(server, namespace="ns", service_logger=events) + await _settle() + before: Final = len(events.seen) + transport: Final = cache.transport() + executor: Final = transport if mode == "direct" else transport.batch(transaction=mode == "transaction") + script: Final = "redis.call('INCR', KEYS[1]); return redis.error_reply('NOSCRIPT written already')" + + failure: Final = await executor.eval_direct(script, ("key",), ()) + + assert isinstance(failure, RedisFailure) and failure.kind == "server" + assert "written already" in failure.message + assert await raw.get("ns:key") == b"1" + await _settle() + assert tuple((event.outcome, event.call_type) for event in events.seen[before:]) == ( + ("failure", "eval_direct") if mode == "direct" else ("success", "redis_batch"), + ) + + @pytest.mark.asyncio @pytest.mark.parametrize("decode_responses", (False, True)) async def test_eval_preserves_empty_arrays_and_sibling_order(