fix inline comments + rename

Author: agnesnatasya

redis/asyncio/connection.py

@@ -1059,9 +1059,7 @@ class ConnectionPool:
 
     def cleanup(self, **options):
         """
-        Additional cleanup operations that the connection pool might
-        need to do after a SCAN ITER family command is executed.
-
+        Additional cleanup operations that the connection pool might need to do.
         See SentinelManagedConnection for an example cleanup operation that
         might need to be done.
         """

redis/asyncio/sentinel.py

@@ -37,10 +37,9 @@ class SentinelManagedConnection(Connection):
     def __init__(self, **kwargs):
         self.connection_pool = kwargs.pop("connection_pool")
         # To be set to True if we want to prevent
-        # the sentinel managed connection to connect
-        # to the most relevant sentinel in the pool and just
-        # connect to the current self.host and self.port
-        self._is_address_fixed = False
+        # the connection to connect to the most relevant sentinel
+        # in the pool and just connect to the current host and port
+        self._is_address_set = False
         super().__init__(**kwargs)
 
     def __repr__(self):
@@ -54,9 +53,13 @@ def __repr__(self):
             s += host_info
         return s + ")>"
 
-    def fix_address(self, address):
+    def set_address(self, address):
+        """
+        By setting the address, the connection will just connect
+        to the current host and port the next time connect is called.
+        """
         self.host, self.port = address
-        self._is_address_fixed = True
+        self._is_address_set = True
 
     async def connect_to(self, address):
         self.host, self.port = address
@@ -70,15 +73,13 @@ async def _connect_retry(self):
         if self._reader:
             return  # already connected
         # If address is fixed, it means that the connection
-        # is not rotating to the next slave (if the connection pool is in replica mode)
-        if self._is_address_fixed:
+        # just connect to the current host and port
+        if self._is_address_set:
             await self.connect_to((self.host, self.port))
             return
         await self._connect_to_sentinel()
 
     async def _connect_to_sentinel(self):
-        # If same_server is False, connnect to master in master mode
-        # and rotate to the next slave in slave mode
         if self.connection_pool.is_master:
             await self.connect_to(await self.connection_pool.get_master_address())
         else:
@@ -246,7 +247,7 @@ async def get_connection(
                 host=server_host, port=server_port
             )
             # If not, make a new dummy connection object, and set its host and
-            # port to the one that we want later in the call to ``connect_to_address``
+            # port to the one that we want later in the call to ``set_address``
             if not connection:
                 connection = self.make_connection()
         assert connection
@@ -261,7 +262,7 @@ async def get_connection(
             # connect to the previous replica.
             # This will connect to the host and port of the replica
             else:
-                connection.fix_address((server_host, server_port))
+                connection.set_address((server_host, server_port))
             await self.ensure_connection(connection)
         except BaseException:
             # Release the connection back to the pool so that we don't

redis/connection.py

@@ -1106,9 +1106,7 @@ def __repr__(self) -> (str, str):
 
     def cleanup(self, **options):
         """
-        Additional cleanup operations that the connection pool might
-        need to do after a SCAN ITER family command is executed.
-
+        Additional cleanup operations that the connection pool might need to do.
         See SentinelManagedConnection for an example cleanup operation that
         might need to be done.
         """

redis/sentinel.py

@@ -25,7 +25,7 @@ def __init__(self, **kwargs):
         # the sentinel managed connection to connect
         # to the most relevant sentinel in the pool and just
         # connect to the current self.host and self.port
-        self._is_address_fixed = False
+        self._is_address_set = False
         super().__init__(**kwargs)
 
     def __repr__(self):
@@ -39,9 +39,13 @@ def __repr__(self):
             s = s % host_info
         return s
 
-    def fix_address(self, address):
+    def set_address(self, address):
+        """
+        By setting the address, the connection will just connect
+        to the current host and port the next time connect is called.
+        """
         self.host, self.port = address
-        self._is_address_fixed = True
+        self._is_address_set = True
 
     def connect_to(self, address):
         self.host, self.port = address
@@ -54,16 +58,14 @@ def connect_to(self, address):
     def _connect_retry(self):
         if self._sock:
             return  # already connected
-        # If address is fixed, it means that the connection
-        # is not rotating to the next slave (if the connection pool is not master)
-        if self._is_address_fixed:
+        # If address is set, it means that the connection
+        # will just connect to the current host and port.
+        if self._is_address_set:
             self.connect_to((self.host, self.port))
             return
         self._connect_to_sentinel()
 
     def _connect_to_sentinel(self):
-        # If same_server is False, connnect to master in master mode
-        # and rotate to the next slave in slave mode
         if self.connection_pool.is_master:
             self.connect_to(self.connection_pool.get_master_address())
         else:
@@ -317,7 +319,7 @@ def get_connection(
                 host=server_host, port=server_port
             )
             # If not, make a new dummy connection object, and set its host and port
-            # to the one that we want later in the call to ``fix_address``
+            # to the one that we want later in the call to ``set_address``
             if not connection:
                 connection = self.make_connection()
         assert connection
@@ -332,7 +334,7 @@ def get_connection(
             # connect to the previous replica.
             # This will connect to the host and port of the replica
             else:
-                connection.fix_address((server_host, server_port))
+                connection.set_address((server_host, server_port))
             self.ensure_connection(connection)
         except BaseException:
             # Release the connection back to the pool so that we don't

tests/test_asyncio/test_commands.py

@@ -1402,7 +1402,7 @@ 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_sameiter_req_id(self):
+    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"""
         import uuid
 

tests/test_asyncio/test_sentinel_managed_connection.py

@@ -47,9 +47,9 @@ class SentinelManagedConnectionMock(SentinelManagedConnection):
     async def _connect_to_sentinel(self) -> None:
         """
         This simulates the behavior of _connect_to_sentinel when
-        :py:class:`~redis.SentinelConnectionPool`
-        is in replica mode.
-        It'll call rotate_slaves and connect to the next replica.
+        :py:class:`~redis.asyncio.sentinel.SentinelConnectionPool`.
+        In master mode, it'll connect to the master. 
+        In non-master mode, it'll call rotate_slaves and connect to the next replica.
         """
         if self.connection_pool.is_master:
             self.host, self.port = ("master", 1)
@@ -62,7 +62,8 @@ async def _connect_to_sentinel(self) -> None:
 
     async def connect_to(self, address: Tuple[str, int]) -> None:
         """
-        Do nothing, just mock.
+        Do nothing, just mock so it won't try to make a connection to the
+        dummy address.
         """
 
 

tests/test_commands.py

@@ -2235,7 +2235,7 @@ 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_sameiter_req_id(self):
+    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"""
         import uuid
 

tests/test_sentinel_managed_connection.py

@@ -13,9 +13,9 @@ class SentinelManagedConnectionMock(SentinelManagedConnection):
     def _connect_to_sentinel(self) -> None:
         """
         This simulates the behavior of _connect_to_sentinel when
-        :py:class:`~redis.SentinelConnectionPool`
-        is in replica mode.
-        It'll call rotate_slaves and connect to the next replica.
+        :py:class:`~redis.SentinelConnectionPool`.
+        In master mode, it'll connect to the master. 
+        In non-master mode, it'll call rotate_slaves and connect to the next replica.
         """
         if self.connection_pool.is_master:
             self.host, self.port = ("master", 1)
@@ -28,7 +28,8 @@ def _connect_to_sentinel(self) -> None:
 
     def connect_to(self, address: Tuple[str, int]) -> None:
         """
-        Do nothing, this is just to mock.
+        Do nothing, just mock so it won't try to make a connection to the
+        dummy address.
         """
         pass