better inline

Author: agnesnatasya

redis/asyncio/sentinel.py

@@ -198,23 +198,21 @@ async def get_connection(
     ) -> SentinelManagedConnection:
         """
         Get a connection from the pool.
-        `xxx_scan_iter` commands needs to be handled specially.
+        'xxxscan_iter' ('scan_iter', 'hscan_iter', 'sscan_iter', 'zscan_iter')
+        commands needs to be handled specially.
         If the client is created using a connection pool, in replica mode,
-        all `scan` command-equivalent of the `xxx_scan_iter` commands needs
+        all 'scan' command-equivalent of the 'xxx_scan_iter' commands needs
         to be issued to the same Redis replica.
 
         The way each server positions each key is different with one another,
-        and the cursor acts as the 'offset' of the scan.
-        Hence, all scans coming from a single xxx_scan_iter_channel command
+        and the cursor acts as the offset of the scan.
+        Hence, all scans coming from a single 'xxx_scan_iter_channel' command
         should go to the same replica.
         """
-        # If not an iter command or in master mode, call super()
-        # No custom logic for master, because there's only 1 master.
-        # The bug is only when Redis has the possibility to connect to multiple replicas
+        # 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:
             return await super().get_connection(command_name, *keys, **options)
 
-        # Check if this iter request has already been directed to a particular server
         # Check if this iter request has already been directed to a particular server
         (
             server_host,
@@ -232,8 +230,8 @@ async def get_connection(
         else:
             # Check from the available connections, if any of the connection
             # is connected to the host and port that we want
-            # If yes, use that connection
             for available_connection in self._available_connections.copy():
+                # if yes, use that connection
                 if (
                     available_connection.host == server_host
                     and available_connection.port == server_port
@@ -247,22 +245,20 @@ async def get_connection(
         assert connection
         self._in_use_connections.add(connection)
         try:
-            # ensure this connection is connected to Redis
-            # If this is the first scan request,
-            # just call the SentinelManagedConnection.connect()
-            # This will call rotate_slaves
-            # and connect to a random replica
+            # Ensure this connection is connected to Redis
+            # If this is the first scan request, it will
+            # call rotate_slaves and connect to a random replica
             if server_port is None or server_port is None:
                 await connection.connect()
             # If this is not the first scan request,
-            # connect to the particular address and port
+            # connect to the previous replica.
+            # This will connect to the host and port of the replica
             else:
-                # This will connect to the host and port that we've specified above
                 await connection.connect_to_address(server_host, server_port)
-            # connections that the pool provides should be ready to send
-            # a command. if not, the connection was either returned to the
+            # Connections that the pool provides should be ready to send
+            # a command. If not, the connection was either returned to the
             # pool before all data has been read or the socket has been
-            # closed. either way, reconnect and verify everything is good.
+            # closed. Either way, reconnect and verify everything is good.
             try:
                 if await connection.can_read_destructive():
                     raise ConnectionError("Connection has data") from None
@@ -272,7 +268,7 @@ async def get_connection(
                 if await connection.can_read_destructive():
                     raise ConnectionError("Connection not ready") from None
         except BaseException:
-            # release the connection back to the pool so that we don't
+            # Release the connection back to the pool so that we don't
             # leak it
             await self.release(connection)
             raise
@@ -281,7 +277,6 @@ async def get_connection(
             connection.host,
             connection.port,
         )
-
         return connection