lints

Author: agnesnatasya

redis/asyncio/sentinel.py

@@ -60,11 +60,11 @@ async def _connect_retry(self, same_address: bool = False):
         if self._reader:
             return  # already connected
         # If same_server is True, it means that the connection
-        # is not rotating to the next slave (if the connection pool is not master)
+        # is not rotating to the next slave (if the connection pool is in replica mode)
         if same_address:
             self.connect_to(self.host, self.port)
             return
-        # If same_server is False, connnect to master in master mode  
+        # 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())
@@ -84,7 +84,7 @@ async def connect(self):
 
     async def connect_to_same_address(self):
         """
-        Similar to connect, but instead of rotating to the next slave (if not in master mode),
+        Similar to connect, but instead of rotating to the next slave (in replica mode),
         it just connects to the same address of the connection object.
         """
         return await self.retry.call_with_retry(
@@ -94,7 +94,7 @@ async def connect_to_same_address(self):
 
     async def connect_to_address(self, address):
         """
-        Similar to connect, but instead of rotating to the next slave (if not in master mode),
+        Similar to connect, but instead of rotating to the next slave (in replica mode),
         it just connects to the same address of the connection object.
         """
         self.host, self.port = address
@@ -202,13 +202,15 @@ async def rotate_slaves(self) -> AsyncIterator:
             pass
         raise SlaveNotFoundError(f"No slave found for {self.service_name!r}")
 
-    async def ensure_connection_connected_to_address(self, connection: SentinelManagedConnection):
+    async def ensure_connection_connected_to_address(
+        self, connection: SentinelManagedConnection
+    ):
         """
         Ensure the connection is already connected to the server that this connection
         object wants to connect to
 
         Similar to self.ensure_connection, but calling connection.connect()
-        in SentinelManagedConnection (replica mode) will cause the 
+        in SentinelManagedConnection (replica mode) will cause the
         connection object to connect to the next replica in rotation,
         and we don't wnat behavior. Look at get_connection inline docs for details.
 
@@ -217,7 +219,10 @@ async def ensure_connection_connected_to_address(self, connection: SentinelManag
         """
         await connection.connect_to_same_address()
         try:
-            if await connection.can_read_destructive() and connection.client_cache is None:
+            if (
+                await connection.can_read_destructive()
+                and connection.client_cache is None
+            ):
                 raise ConnectionError("Connection has data")
         except (ConnectionError, OSError):
             await connection.disconnect()
@@ -273,7 +278,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_same_address``
+            # port to the one that we want later in the call to ``connect_to_address``
             if not connection:
                 connection = self.make_connection()
         assert connection

redis/client.py

@@ -763,7 +763,6 @@ def reset(self) -> None:
         self.patterns = {}
         self.pending_unsubscribe_patterns = set()
         self.subscribed_event.clear()
-        self.connection_pool.cleanup(iter_req_id=options.get("_iter_req_id", None))
 
     def close(self) -> None:
         self.reset()

redis/connection.py

@@ -737,10 +737,10 @@ def _host_error(self):
 
 class ConnectionsIndexer(Iterable):
     """
-    Data structure that simulates a list of available connections. 
+    Data structure that simulates a list of available connections.
     Instead of list, we keep 2 additional DS to support O(1) operations
     on all of the class' methods.
-    The first DS is indexed on the connection object's ID. 
+    The first DS is indexed on the connection object's ID.
     The second DS is indexed on the address (ip and port) of the connection.
     """
 

redis/sentinel.py

@@ -49,7 +49,7 @@ def _connect_retry(self, same_address: bool = False):
         if same_address:
             self.connect_to((self.host, self.port))
             return
-        # If same_server is False, connnect to master in master mode  
+        # 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())
@@ -62,11 +62,14 @@ def _connect_retry(self, same_address: bool = False):
             raise SlaveNotFoundError  # Never be here
 
     def connect(self):
-        return self.retry.call_with_retry(lambda: self._connect_retry(), lambda error: None)
+        return self.retry.call_with_retry(
+            lambda: self._connect_retry(),
+            lambda error: None
+        )
 
     def connect_to_same_address(self):
         """
-        Similar to connect, but instead of rotating to the next slave (if not in master mode),
+        Similar to connect, but instead of rotating to the next slave (in replica mode),
         it just connects to the same address of the connection object.
         """
         return self.retry.call_with_retry(
@@ -76,14 +79,17 @@ def connect_to_same_address(self):
 
     def connect_to_address(self, address):
         """
-        Similar to connect, but instead of rotating to the next slave (if not in master mode),
+        Similar to connect, but instead of rotating to the next slave (in replica mode),
         it just connects to the address supplied.
         """
         self.host, self.port = address
         return self.connect_to_same_address()
 
     def can_read_same_address(self, timeout=0):
-        """Similar to can_read_same_address, but calls connect_to_same_address instead of connect"""
+        """
+        Similar to can_read_same_address, but calls
+        connect_to_same_address instead of connect
+        """
         sock = self._sock
         if not sock:
             self.connect_to_same_address()
@@ -234,13 +240,15 @@ def rotate_slaves(self):
         "Round-robin slave balancer"
         return self.proxy.rotate_slaves()
 
-    def ensure_connection_connected_to_address(self, connection: SentinelManagedConnection):
+    def ensure_connection_connected_to_address(
+        self, connection: SentinelManagedConnection
+    ):
         """
         Ensure the connection is already connected to the server that this connection
-        object wants to connect to
+        object wants to connect to.
 
         Similar to self.ensure_connection, but calling connection.connect()
-        in SentinelManagedConnection (replica mode) will cause the 
+        in SentinelManagedConnection (replica mode) will cause the
         connection object to connect to the next replica in rotation,
         and we don't wnat behavior. Look at get_connection inline docs for details.
 

tests/test_sentinel_managed_connection.py

@@ -2,11 +2,9 @@
 from unittest import mock
 
 import pytest
-from redis.sentinel import (
-    Sentinel,
-    SentinelConnectionPool,
-    SentinelManagedConnection,
-)
+from redis import Redis
+from redis.sentinel import Sentinel, SentinelConnectionPool, SentinelManagedConnection
+
 
 class SentinelManagedConnectionMock(SentinelManagedConnection):
     def connect_to_same_address(self) -> None:
@@ -211,8 +209,6 @@ def test_scan_iter_in_redis_cleans_up(
     connection_pool_replica_mock: SentinelConnectionPool,
 ):
     """Test that connection pool is correctly cleaned up"""
-    from redis import Redis
-
     r = Redis(connection_pool=connection_pool_replica_mock)
     # Patch the actual sending and parsing response from the Connection object
     # but still let the connection pool does all the necessary work
@@ -221,4 +217,3 @@ def test_scan_iter_in_redis_cleans_up(
     # Test that the iter_req_id for the scan command is cleared at the
     # end of the SCAN ITER command
     assert not connection_pool_replica_mock._iter_req_id_to_replica_address
-