Adding changes related to SET command

Author: petyaslavova

redis/commands/core.py

@@ -50,7 +50,7 @@
     extract_expire_flags,
 )
 
-from .helpers import list_or_args
+from .helpers import at_most_one_value_set, list_or_args
 
 if TYPE_CHECKING:
     import redis.asyncio.client
@@ -1732,8 +1732,8 @@ def __delitem__(self, name: KeyT):
     def delex(
         self,
         name: KeyT,
-        ifeq: Optional[EncodableT] = None,
-        ifne: Optional[EncodableT] = None,
+        ifeq: Optional[Union[bytes, str]] = None,
+        ifne: Optional[Union[bytes, str]] = None,
         ifdeq: Optional[str] = None,  # hex digest
         ifdne: Optional[str] = None,  # hex digest
     ) -> int:
@@ -1752,6 +1752,8 @@ def delex(
                                             and a condition is specified.
             ValueError: if more than one condition is provided.
 
+
+        Requires Redis 8.4 or greater.
         For more information, see https://redis.io/commands/delex
         """
         conds = [x is not None for x in (ifeq, ifne, ifdeq, ifdne)]
@@ -1886,6 +1888,8 @@ def digest(self, name: KeyT) -> Optional[str]:
         Raises:
           - ResponseError if key exists but is not a string
 
+
+        Requires Redis 8.4 or greater.
         For more information, see https://redis.io/commands/digest
         """
         # Bulk string response is already handled (bytes/str based on decode_responses)
@@ -1939,8 +1943,7 @@ def getex(
 
         For more information, see https://redis.io/commands/getex
         """
-        opset = {ex, px, exat, pxat}
-        if len(opset) > 2 or len(opset) > 1 and persist:
+        if not at_most_one_value_set((ex, px, exat, pxat, persist)):
             raise DataError(
                 "``ex``, ``px``, ``exat``, ``pxat``, "
                 "and ``persist`` are mutually exclusive."
@@ -2128,8 +2131,7 @@ def msetex(
         Available since Redis 8.4
         For more information, see https://redis.io/commands/msetex
         """
-        opset = {ex, px, exat, pxat}
-        if len(opset) > 2 or len(opset) > 1 and keepttl:
+        if not at_most_one_value_set((ex, px, exat, pxat, keepttl)):
             raise DataError(
                 "``ex``, ``px``, ``exat``, ``pxat``, "
                 "and ``keepttl`` are mutually exclusive."
@@ -2395,6 +2397,10 @@ def set(
         get: bool = False,
         exat: Optional[AbsExpiryT] = None,
         pxat: Optional[AbsExpiryT] = None,
+        ifeq: Optional[Union[bytes, str]] = None,
+        ifne: Optional[Union[bytes, str]] = None,
+        ifdeq: Optional[str] = None,  # hex digest of current value
+        ifdne: Optional[str] = None,  # hex digest of current value
     ) -> ResponseT:
         """
         Set the value at key ``name`` to ``value``
@@ -2422,35 +2428,67 @@ def set(
         ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
             specified in unix time.
 
+        ``ifeq`` set the value at key ``name`` to ``value`` only if the current
+            value exactly matches the argument.
+            If key doesn’t exist - it won’t be created.
+            (Requires Redis 8.4 or greater)
+
+        ``ifne`` set the value at key ``name`` to ``value`` only if the current
+            value does not exactly match the argument.
+            If key doesn’t exist - it will be created.
+            (Requires Redis 8.4 or greater)
+
+        ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
+            value XXH3 hex digest exactly matches the argument.
+            If key doesn’t exist - it won’t be created.
+            (Requires Redis 8.4 or greater)
+
+        ``ifdne`` set the value at key ``name`` to ``value`` only if the current
+            value XXH3 hex digest does not exactly match the argument.
+            If key doesn’t exist - it will be created.
+            (Requires Redis 8.4 or greater)
+
         For more information, see https://redis.io/commands/set
         """
-        opset = {ex, px, exat, pxat}
-        if len(opset) > 2 or len(opset) > 1 and keepttl:
+
+        if not at_most_one_value_set((ex, px, exat, pxat, keepttl)):
             raise DataError(
                 "``ex``, ``px``, ``exat``, ``pxat``, "
                 "and ``keepttl`` are mutually exclusive."
             )
 
-        if nx and xx:
-            raise DataError("``nx`` and ``xx`` are mutually exclusive.")
+        # Enforce mutual exclusivity among all conditional switches.
+        if not at_most_one_value_set((nx, xx, ifeq, ifne, ifdeq, ifdne)):
+            raise DataError(
+                "``nx``, ``xx``, ``ifeq``, ``ifne``, ``ifdeq``, ``ifdne`` are mutually exclusive."
+            )
 
         pieces: list[EncodableT] = [name, value]
         options = {}
 
-        pieces.extend(extract_expire_flags(ex, px, exat, pxat))
-
-        if keepttl:
-            pieces.append("KEEPTTL")
-
+        # Conditional modifier (exactly one at most)
         if nx:
             pieces.append("NX")
-        if xx:
+        elif xx:
             pieces.append("XX")
+        elif ifeq is not None:
+            pieces.extend(("IFEQ", ifeq))
+        elif ifne is not None:
+            pieces.extend(("IFNE", ifne))
+        elif ifdeq is not None:
+            pieces.extend(("IFDEQ", ifdeq))
+        elif ifdne is not None:
+            pieces.extend(("IFDNE", ifdne))
 
         if get:
             pieces.append("GET")
             options["get"] = True
 
+        pieces.extend(extract_expire_flags(ex, px, exat, pxat))
+
+        if keepttl:
+            pieces.append("KEEPTTL")
+
         return self.execute_command("SET", *pieces, **options)
 
     def __setitem__(self, name: KeyT, value: EncodableT):
@@ -5257,8 +5295,7 @@ def hgetex(
         if not keys:
             raise DataError("'hgetex' should have at least one key provided")
 
-        opset = {ex, px, exat, pxat}
-        if len(opset) > 2 or len(opset) > 1 and persist:
+        if not at_most_one_value_set((ex, px, exat, pxat, persist)):
             raise DataError(
                 "``ex``, ``px``, ``exat``, ``pxat``, "
                 "and ``persist`` are mutually exclusive."
@@ -5403,8 +5440,7 @@ def hsetex(
                 "'items' must contain a list of key/value pairs."
             )
 
-        opset = {ex, px, exat, pxat}
-        if len(opset) > 2 or len(opset) > 1 and keepttl:
+        if not at_most_one_value_set((ex, px, exat, pxat, keepttl)):
             raise DataError(
                 "``ex``, ``px``, ``exat``, ``pxat``, "
                 "and ``keepttl`` are mutually exclusive."

redis/commands/helpers.py

@@ -1,7 +1,7 @@
 import copy
 import random
 import string
-from typing import List, Tuple
+from typing import Any, Iterable, List, Tuple
 
 import redis
 from redis.typing import KeysT, KeyT
@@ -96,3 +96,22 @@ def get_protocol_version(client):
         return client.connection_pool.connection_kwargs.get("protocol")
     elif isinstance(client, redis.cluster.AbstractRedisCluster):
         return client.nodes_manager.connection_kwargs.get("protocol")
+
+
+def at_most_one_value_set(iterable: Iterable[Any]):
+    """
+    Checks that at most one of the values in the iterable is truthy.
+
+    Args:
+        iterable: An iterable of values to check.
+
+    Returns:
+        True if at most one value is truthy, False otherwise.
+
+    Raises:
+        Might raise an error if the values in iterable are not boolean-compatible.
+        For example if the type of the values implement
+        __len__ or __bool__ methods and they raise an error.
+    """
+    values = (bool(x) for x in iterable)
+    return sum(values) <= 1

tests/test_asyncio/test_commands.py

@@ -11,7 +11,7 @@
 
 import pytest
 import pytest_asyncio
-from redis import RedisClusterException, ResponseError
+from redis import DataError, RedisClusterException, ResponseError
 import redis
 from redis import exceptions
 from redis._parsers.helpers import (
@@ -1125,10 +1125,10 @@ async def test_delex_ifdeq_and_ifdne(self, r, val):
 
     @skip_if_server_version_lt("8.3.224")
     async def test_delex_pipeline(self, r):
-        await r.mset({"p1": b"A", "p2": b"B"})
+        await r.mset({"p1{45}": b"A", "p2{45}": b"B"})
         p = r.pipeline()
-        p.delex("p1", ifeq=b"A")
-        p.delex("p2", ifne=b"B")  # false → 0
+        p.delex("p1{45}", ifeq=b"A")
+        p.delex("p2{45}", ifne=b"B")  # false → 0
         p.delex("nope")  # nonexistent → 0
         out = await p.execute()
         assert out == [1, 0, 0]
@@ -1253,7 +1253,7 @@ async def test_digest_response_when_available(self, r, value):
 
     @skip_if_server_version_lt("8.3.224")
     async def test_pipeline_digest(self, r):
-        k1, k2 = "k:d1", "k:d2"
+        k1, k2 = "k:d1{42}", "k:d2{42}"
         await r.mset({k1: b"A", k2: b"B"})
         p = r.pipeline()
         p.digest(k1)
@@ -1849,6 +1849,102 @@ async def test_set_keepttl(self, r: redis.Redis):
         assert await r.get("a") == b"2"
         assert 0 < await r.ttl("a") <= 10
 
+    @skip_if_server_version_lt("8.3.224")
+    async def test_set_ifeq_true_sets_and_returns_true(self, r):
+        await r.delete("k")
+        await r.set("k", b"foo")
+        assert await r.set("k", b"bar", ifeq=b"foo") is True
+        assert await r.get("k") == b"bar"
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_set_ifeq_false_does_not_set_returns_none(self, r):
+        await r.delete("k")
+        await r.set("k", b"foo")
+        assert await r.set("k", b"bar", ifeq=b"nope") is None
+        assert await r.get("k") == b"foo"
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_set_ifne_true_sets(self, r):
+        await r.delete("k")
+        await r.set("k", b"foo")
+        assert await r.set("k", b"bar", ifne=b"zzz") is True
+        assert await r.get("k") == b"bar"
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_set_ifne_false_does_not_set(self, r):
+        await r.delete("k")
+        await r.set("k", b"foo")
+        assert await r.set("k", b"bar", ifne=b"foo") is None
+        assert await r.get("k") == b"foo"
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_set_ifeq_when_key_missing_does_not_create(self, r):
+        await r.delete("k")
+        assert await r.set("k", b"bar", ifeq=b"foo") is None
+        assert await r.exists("k") == 0
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_set_ifne_when_key_missing_creates(self, r):
+        await r.delete("k")
+        assert await r.set("k", b"bar", ifne=b"foo") is True
+        assert await r.get("k") == b"bar"
+
+    @skip_if_server_version_lt("8.3.224")
+    @pytest.mark.parametrize("val", [b"", b"abc", b"The quick brown fox"])
+    async def test_set_ifdeq_and_ifdne(self, r, val):
+        await r.delete("k")
+        await r.set("k", val)
+        d = await self._server_xxh3_digest(r, "k")
+        assert d is not None
+
+        # IFDEQ must match to set; if key missing => won't create
+        assert await r.set("k", b"X", ifdeq=d) is True
+        assert await r.get("k") == b"X"
+
+        await r.delete("k")
+        # key missing + IFDEQ => not created
+        assert await r.set("k", b"Y", ifdeq=d) is None
+        assert await r.exists("k") == 0
+
+        # IFDNE: create when missing, and set when digest differs
+        assert await r.set("k", b"bar", ifdne=d) is True
+        prev_d = await self._server_xxh3_digest(r, "k")
+        assert prev_d is not None
+        # If digest equal → do not set
+        assert await r.set("k", b"zzz", ifdne=prev_d) is None
+        assert await r.get("k") == b"bar"
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_set_with_get_returns_previous_value(self, r):
+        await r.delete("k")
+        # when key didn’t exist → returns None, and key is created if condition allows it
+        prev = await r.set("k", b"v1", get=True, ifne=b"any")  # IFNE on missing creates
+        assert prev is None
+        # subsequent GET returns previous value, regardless of whether set occurs
+        prev2 = await r.set(
+            "k", b"v2", get=True, ifeq=b"v1"
+        )  # matches → set; returns "v1"
+        assert prev2 == b"v1"
+        prev3 = await r.set(
+            "k", b"v3", get=True, ifeq=b"no"
+        )  # no set; returns previous "v2"
+        assert prev3 == b"v2"
+        assert await r.get("k") == b"v2"
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_set_mutual_exclusion_client_side(self, r):
+        await r.delete("k")
+        with pytest.raises(DataError):
+            await r.set("k", b"v", nx=True, ifeq=b"x")
+        with pytest.raises(DataError):
+            await r.set("k", b"v", ifdeq="aa", ifdne="bb")
+        with pytest.raises(DataError):
+            await r.set("k", b"v", ex=1, px=1)
+        with pytest.raises(DataError):
+            await r.set("k", b"v", exat=1, pxat=1)
+        with pytest.raises(DataError):
+            await r.set("k", b"v", ex=1, exat=1)
+
     async def test_setex(self, r: redis.Redis):
         assert await r.setex("a", 60, "1")
         assert await r.get("a") == b"1"