rename kwargs to no underscore for consistency

Author: agnesnatasya

redis/asyncio/client.py

@@ -652,7 +652,7 @@ async def execute_command(self, *args, **options):
             if not self.connection:
                 await pool.release(conn)
                 if "ITER" in command_name.upper():
-                    pool.cleanup(iter_req_id=options.get("_iter_req_id", None))
+                    pool.cleanup(iter_req_id=options.get("iter_req_id", None))
 
     async def parse_response(
         self, connection: Connection, command_name: Union[str, bytes], **options

redis/asyncio/sentinel.py

@@ -230,7 +230,7 @@ def cleanup(self, **options):
         Remove the SCAN ITER family command's request id from the dictionary
         """
         self._iter_req_id_to_replica_address.pop(
-            options.get("_iter_req_id", None), None
+            options.get("iter_req_id", None), None
         )
 
     async def get_connection(
@@ -250,7 +250,7 @@ async def get_connection(
         should go to the same replica.
         """
         # If not an iter command or in master mode, call superclass' implementation
-        if not (iter_req_id := options.get("_iter_req_id", None)) or self.is_master:
+        if not (iter_req_id := options.get("iter_req_id", None)) or self.is_master:
             return await super().get_connection(command_name, *keys, **options)
 
         # Check if this iter request has already been directed to a particular server

redis/commands/core.py

@@ -3046,7 +3046,7 @@ def scan_iter(
                 match=match,
                 count=count,
                 _type=_type,
-                _iter_req_id=iter_req_id,
+                iter_req_id=iter_req_id,
                 **kwargs,
             )
             yield from data
@@ -3094,7 +3094,7 @@ def sscan_iter(
         iter_req_id = uuid.uuid4()
         while cursor != 0:
             cursor, data = self.sscan(
-                name, cursor=cursor, match=match, count=count, _iter_req_id=iter_req_id
+                name, cursor=cursor, match=match, count=count, iter_req_id=iter_req_id
             )
             yield from data
 
@@ -3154,7 +3154,7 @@ def hscan_iter(
                 match=match,
                 count=count,
                 no_values=no_values,
-                _iter_req_id=iter_req_id,
+                iter_req_id=iter_req_id,
             )
             if no_values:
                 yield from data
@@ -3216,7 +3216,7 @@ def zscan_iter(
                 match=match,
                 count=count,
                 score_cast_func=score_cast_func,
-                _iter_req_id=iter_req_id,
+                iter_req_id=iter_req_id,
             )
             yield from data
 
@@ -3254,7 +3254,7 @@ async def scan_iter(
                 match=match,
                 count=count,
                 _type=_type,
-                _iter_req_id=iter_req_id,
+                iter_req_id=iter_req_id,
                 **kwargs,
             )
             for d in data:
@@ -3281,7 +3281,7 @@ async def sscan_iter(
         cursor = "0"
         while cursor != 0:
             cursor, data = await self.sscan(
-                name, cursor=cursor, match=match, count=count, _iter_req_id=iter_req_id
+                name, cursor=cursor, match=match, count=count, iter_req_id=iter_req_id
             )
             for d in data:
                 yield d
@@ -3315,7 +3315,7 @@ async def hscan_iter(
                 match=match,
                 count=count,
                 no_values=no_values,
-                _iter_req_id=iter_req_id,
+                iter_req_id=iter_req_id,
             )
             if no_values:
                 for it in data:
@@ -3353,7 +3353,7 @@ async def zscan_iter(
                 match=match,
                 count=count,
                 score_cast_func=score_cast_func,
-                _iter_req_id=iter_req_id,
+                iter_req_id=iter_req_id,
             )
             for d in data:
                 yield d

redis/sentinel.py

@@ -263,7 +263,7 @@ def cleanup(self, **options):
         """
         breakpoint()
         self._iter_req_id_to_replica_address.pop(
-            options.get("_iter_req_id", None), None
+            options.get("iter_req_id", None), None
         )
 
     def get_connection(
@@ -283,7 +283,7 @@ def get_connection(
         should go to the same replica.
         """
         # If not an iter command or in master mode, call superclass' implementation
-        if not (iter_req_id := options.get("_iter_req_id", None)) or self.is_master:
+        if not (iter_req_id := options.get("iter_req_id", None)) or self.is_master:
             return super().get_connection(command_name, *keys, **options)
 
         # Check if this iter request has already been directed to a particular server

tests/test_asyncio/test_commands.py

@@ -1402,8 +1402,8 @@ async def test_zscan_iter(self, r: redis.Redis):
         pairs = [k async for k in r.zscan_iter("a", match="a")]
         assert set(pairs) == {(b"a", 1)}
 
-    async def test_scan_iter_family_executes_commands_with_same_iter_req_id(self):
-        """Assert that all calls to execute_command receives the _iter_req_id kwarg"""
+    async def test_scan_iter_family_executes_commands_with_sameiter_req_id(self):
+        """Assert that all calls to execute_command receives the iter_req_id kwarg"""
         import uuid
 
         from redis.commands.core import AsyncScanCommands
@@ -1416,10 +1416,10 @@ async def test_scan_iter_family_executes_commands_with_same_iter_req_id(self):
             uuid, "uuid4", return_value="uuid"
         ):
             [a async for a in AsyncScanCommands().scan_iter()]
-            mock_execute_command.assert_called_with("SCAN", "0", _iter_req_id="uuid")
+            mock_execute_command.assert_called_with("SCAN", "0", iter_req_id="uuid")
             [a async for a in AsyncScanCommands().sscan_iter("")]
             mock_execute_command.assert_called_with(
-                "SSCAN", "", "0", _iter_req_id="uuid"
+                "SSCAN", "", "0", iter_req_id="uuid"
             )
         with mock.patch.object(
             AsyncScanCommands, "execute_command", mock.AsyncMock(return_value=(0, {}))
@@ -1428,11 +1428,11 @@ async def test_scan_iter_family_executes_commands_with_same_iter_req_id(self):
         ):
             [a async for a in AsyncScanCommands().hscan_iter("")]
             mock_execute_command.assert_called_with(
-                "HSCAN", "", "0", no_values=None, _iter_req_id="uuid"
+                "HSCAN", "", "0", no_values=None, iter_req_id="uuid"
             )
             [a async for a in AsyncScanCommands().zscan_iter("")]
             mock_execute_command.assert_called_with(
-                "ZSCAN", "", "0", score_cast_func=mock.ANY, _iter_req_id="uuid"
+                "ZSCAN", "", "0", score_cast_func=mock.ANY, iter_req_id="uuid"
             )
 
     # SET COMMANDS

tests/test_asyncio/test_sentinel_managed_connection.py

@@ -124,15 +124,15 @@ async def test_connects_to_same_address_if_same_id_replica(
     connection_pool_replica_mock: SentinelConnectionPool,
 ) -> None:
     """
-    Assert that the connection address is the same if the ``_iter_req_id`` is the same
+    Assert that the connection address is the same if the ``iter_req_id`` is the same
     when we are in replica mode using a
     :py:class:`~redis.asyncio.sentinel.SentinelConnectionPool`.
     """
     connection_for_req_1 = await connection_pool_replica_mock.get_connection(
-        "ANY", _iter_req_id=1
+        "ANY", iter_req_id=1
     )
     assert same_address(
-        await connection_pool_replica_mock.get_connection("ANY", _iter_req_id=1),
+        await connection_pool_replica_mock.get_connection("ANY", iter_req_id=1),
         connection_for_req_1,
     )
 
@@ -141,32 +141,32 @@ async def test_connects_to_same_conn_object_if_same_id_and_conn_released_replica
     connection_pool_replica_mock: SentinelConnectionPool,
 ) -> None:
     """
-    Assert that the connection object is the same if the ``_iter_req_id`` is the same
+    Assert that the connection object is the same if the ``iter_req_id`` is the same
     when we are in replica mode using a
     :py:class:`~redis.asyncio.sentinel.SentinelConnectionPool`
     and if we release the connection back to the connection pool before
     trying to connect again.
     """
     connection_for_req_1 = await connection_pool_replica_mock.get_connection(
-        "ANY", _iter_req_id=1
+        "ANY", iter_req_id=1
     )
     await connection_pool_replica_mock.release(connection_for_req_1)
     assert (
-        await connection_pool_replica_mock.get_connection("ANY", _iter_req_id=1)
+        await connection_pool_replica_mock.get_connection("ANY", iter_req_id=1)
         == connection_for_req_1
     )
 
 
-async def test_connects_to_diff_address_if_no_iter_req_id_replica(
+async def test_connects_to_diff_address_if_noiter_req_id_replica(
     connection_pool_replica_mock: SentinelConnectionPool,
 ) -> None:
     """
-    Assert that the connection object is different if no _iter_req_id is supplied.
+    Assert that the connection object is different if no iter_req_id is supplied.
     In reality, they can be the same, but in this case, we're not
     releasing the connection to the pool so they should always be different.
     """
     connection_for_req_1 = await connection_pool_replica_mock.get_connection(
-        "ANY", _iter_req_id=1
+        "ANY", iter_req_id=1
     )
     connection_for_random_req = await connection_pool_replica_mock.get_connection(
         "ANYY"
@@ -182,43 +182,43 @@ async def test_connects_to_diff_address_if_no_iter_req_id_replica(
     )
 
 
-async def test_connects_to_same_address_if_same_iter_req_id_master(
+async def test_connects_to_same_address_if_sameiter_req_id_master(
     connection_pool_master_mock: SentinelConnectionPool,
 ) -> None:
     """
-    Assert that the connection address is the same if the ``_iter_req_id`` is the same
+    Assert that the connection address is the same if the ``iter_req_id`` is the same
     when we are in master mode using a
     :py:class:`~redis.asyncio.sentinel.SentinelConnectionPool`.
     """
     connection_for_req_1 = await connection_pool_master_mock.get_connection(
-        "ANY", _iter_req_id=1
+        "ANY", iter_req_id=1
     )
     assert same_address(
-        await connection_pool_master_mock.get_connection("ANY", _iter_req_id=1),
+        await connection_pool_master_mock.get_connection("ANY", iter_req_id=1),
         connection_for_req_1,
     )
 
 
-async def test_connects_to_same_conn_object_if_same_iter_req_id_and_released_master(
+async def test_connects_to_same_conn_object_if_sameiter_req_id_and_released_master(
     connection_pool_master_mock: SentinelConnectionPool,
 ) -> None:
     """
-    Assert that the connection address is the same if the ``_iter_req_id`` is the same
+    Assert that the connection address is the same if the ``iter_req_id`` is the same
     when we are in master mode using a
     :py:class:`~redis.asyncio.sentinel.SentinelConnectionPool`
     and if we release the connection back to the connection pool before
     trying to connect again.
     """
     connection_for_req_1 = await connection_pool_master_mock.get_connection(
-        "ANY", _iter_req_id=1
+        "ANY", iter_req_id=1
     )
     assert same_address(
-        await connection_pool_master_mock.get_connection("ANY", _iter_req_id=1),
+        await connection_pool_master_mock.get_connection("ANY", iter_req_id=1),
         connection_for_req_1,
     )
 
 
-async def test_connects_to_same_address_if_no_iter_req_id_master(
+async def test_connects_to_same_address_if_noiter_req_id_master(
     connection_pool_master_mock: SentinelConnectionPool,
 ) -> None:
     """
@@ -228,7 +228,7 @@ async def test_connects_to_same_address_if_no_iter_req_id_master(
     :py:class:`~redis.asyncio.sentinel.SentinelConnectionPool`.
     """
     connection_for_req_1 = await connection_pool_master_mock.get_connection(
-        "ANY", _iter_req_id=1
+        "ANY", iter_req_id=1
     )
     connection_for_random_req = await connection_pool_master_mock.get_connection("ANYY")
     assert same_address(connection_for_random_req, connection_for_req_1)
@@ -252,4 +252,4 @@ async def test_scan_iter_family_cleans_up(
     r = Redis(connection_pool=connection_pool_replica_mock)
 
     [k async for k in r.scan_iter("a")]
-    assert not connection_pool_replica_mock._iter_req_id_to_replica_address
+    assert not connection_pool_replica_mock.iter_req_id_to_replica_address

tests/test_commands.py

@@ -2235,8 +2235,8 @@ def test_zscan_iter(self, r):
         pairs = list(r.zscan_iter("a", match="a"))
         assert set(pairs) == {(b"a", 1)}
 
-    def test_scan_iter_family_executes_commands_with_same_iter_req_id(self):
-        """Assert that all calls to execute_command receives the _iter_req_id kwarg"""
+    def test_scan_iter_family_executes_commands_with_sameiter_req_id(self):
+        """Assert that all calls to execute_command receives the iter_req_id kwarg"""
         import uuid
 
         from redis.commands.core import ScanCommands
@@ -2247,10 +2247,10 @@ def test_scan_iter_family_executes_commands_with_same_iter_req_id(self):
             uuid, "uuid4", return_value="uuid"
         ):
             [a for a in ScanCommands().scan_iter()]
-            mock_execute_command.assert_called_with("SCAN", "0", _iter_req_id="uuid")
+            mock_execute_command.assert_called_with("SCAN", "0", iter_req_id="uuid")
             [a for a in ScanCommands().sscan_iter("")]
             mock_execute_command.assert_called_with(
-                "SSCAN", "", "0", _iter_req_id="uuid"
+                "SSCAN", "", "0", iter_req_id="uuid"
             )
         with mock.patch.object(
             ScanCommands, "execute_command", mock.Mock(return_value=(0, {}))
@@ -2259,11 +2259,11 @@ def test_scan_iter_family_executes_commands_with_same_iter_req_id(self):
         ):
             [a for a in ScanCommands().hscan_iter("")]
             mock_execute_command.assert_called_with(
-                "HSCAN", "", "0", no_values=None, _iter_req_id="uuid"
+                "HSCAN", "", "0", no_values=None, iter_req_id="uuid"
             )
             [a for a in ScanCommands().zscan_iter("")]
             mock_execute_command.assert_called_with(
-                "ZSCAN", "", "0", score_cast_func=mock.ANY, _iter_req_id="uuid"
+                "ZSCAN", "", "0", score_cast_func=mock.ANY, iter_req_id="uuid"
             )
 
     # SET COMMANDS