Python: command WAIT

glide-core/src/protobuf/redis_request.proto

@@ -238,6 +238,7 @@ enum RequestType {
     FunctionRestore = 197;
     XPending = 198;
     XGroupSetId = 199;
+    Wait = 200;
 }
 
 message Command {

glide-core/src/request_type.rs

@@ -208,6 +208,7 @@ pub enum RequestType {
     FunctionRestore = 197,
     XPending = 198,
     XGroupSetId = 199,
+    Wait = 200,
 }
 
 fn get_two_word_command(first: &str, second: &str) -> Cmd {
@@ -419,6 +420,7 @@ impl From<::protobuf::EnumOrUnknown<ProtobufRequestType>> for RequestType {
             ProtobufRequestType::FunctionRestore => RequestType::FunctionRestore,
             ProtobufRequestType::XPending => RequestType::XPending,
             ProtobufRequestType::XGroupSetId => RequestType::XGroupSetId,
+            ProtobufRequestType::Wait => RequestType::Wait,
         }
     }
 }
@@ -628,6 +630,7 @@ impl RequestType {
             RequestType::FunctionRestore => Some(get_two_word_command("FUNCTION", "RESTORE")),
             RequestType::XPending => Some(cmd("XPENDING")),
             RequestType::XGroupSetId => Some(get_two_word_command("XGROUP", "SETID")),
+            RequestType::Wait => Some(cmd("WAIT")),
         }
     }
 }

python/python/glide/async_commands/cluster_commands.py

@@ -658,3 +658,33 @@ async def lolwut(
             TClusterResponse[str],
             await self._execute_command(RequestType.Lolwut, args, route),
         )
+
+    async def wait(
+        self,
+        numreplicas: int,
+        timeout: int,
+        route: Optional[Route] = None,
+    ) -> int:
+        """
+        Blocks the current client until all the previous write commands are successfully transferred
+        and acknowledged by at least `numreplicas` of replicas. If `timeout` is
+        reached, the command returns even if the specified number of replicas were not yet reached.
+
+        See https://valkey.io/commands/wait for more details.
+
+        Args:
+            numreplicas (int): The number of replicas to reach.
+            timeout (int): The timeout value specified in milliseconds.
+
+        Returns:
+            str: The number of replicas reached by all the writes performed in the context of the current connection.
+
+        Examples:
+            >>> await client.set("key", "value");
+            >>> await client.wait(1, 1000);
+        """
+        args = [str(numreplicas), str(timeout)]
+        return cast(
+            int,
+            await self._execute_command(RequestType.Wait, args, route),
+        )

python/python/glide/async_commands/standalone_commands.py

@@ -595,3 +595,32 @@ async def lolwut(
             str,
             await self._execute_command(RequestType.Lolwut, args),
         )
+
+    async def wait(
+        self,
+        numreplicas: int,
+        timeout: int,
+    ) -> int:
+        """
+        Blocks the current client until all the previous write commands are successfully transferred
+        and acknowledged by at least `numreplicas` of replicas. If `timeout` is
+        reached, the command returns even if the specified number of replicas were not yet reached.
+
+        See https://valkey.io/commands/wait for more details.
+
+        Args:
+            numreplicas (int): The number of replicas to reach.
+            timeout (int): The timeout value specified in milliseconds.
+
+        Returns:
+            str: The number of replicas reached by all the writes performed in the context of the current connection.
+
+        Examples:
+            >>> await client.set("key", "value");
+            >>> await client.wait(1, 1000);
+        """
+        args = [str(numreplicas), str(timeout)]
+        return cast(
+            int,
+            await self._execute_command(RequestType.Wait, args),
+        )

python/python/glide/async_commands/transaction.py

@@ -4135,4 +4135,26 @@ def copy(
 
         return self.append_command(RequestType.Copy, args)
 
+    def wait(
+        self: TTransaction,
+        numreplicas: int,
+        timeout: int,
+    ) -> TTransaction:
+        """
+        Blocks the current client until all the previous write commands are successfully transferred
+        and acknowledged by at least `numreplicas` of replicas. If `timeout` is
+        reached, the command returns even if the specified number of replicas were not yet reached.
+
+        See https://valkey.io/commands/wait for more details.
+
+        Args:
+            numreplicas (int): The number of replicas to reach.
+            timeout (int): The timeout value specified in milliseconds.
+
+        Command Response:
+            str: The number of replicas reached by all the writes performed in the context of the current connection.
+        """
+        args = [str(numreplicas), str(timeout)]
+        return self.append_command(RequestType.Wait, args)
+
     # TODO: add all CLUSTER commands

python/python/tests/test_async_client.py

@@ -6970,6 +6970,15 @@ async def test_copy_database(self, redis_client: GlideClient):
         finally:
             assert await redis_client.select(0) == OK
 
+    @pytest.mark.parametrize("cluster_mode", [True, False])
+    @pytest.mark.parametrize("protocol", [ProtocolVersion.RESP2, ProtocolVersion.RESP3])
+    async def test_wait(self, redis_client: TGlideClient):
+        key = f"{{key}}-1{get_random_string(5)}"
+        value = get_random_string(5)
+
+        await redis_client.set(key, value)
+        assert await redis_client.wait(1, 1000) >= 0
+
     @pytest.mark.parametrize("cluster_mode", [True, False])
     @pytest.mark.parametrize("protocol", [ProtocolVersion.RESP2, ProtocolVersion.RESP3])
     async def test_lolwut(self, redis_client: TGlideClient):

python/python/tests/test_transaction.py

@@ -560,6 +560,8 @@ async def transaction_test(
     args.append("one")
     transaction.srandmember_count(key7, 1)
     args.append(["one"])
+    transaction.wait(1, 1000)
+    args.append(0)
     transaction.flushall(FlushMode.ASYNC)
     args.append(OK)
     transaction.flushall()