Fixing linter errors - dues to backporting from master where formatter is updated

Author: petyaslavova

redis/asyncio/cluster.py

@@ -139,11 +139,13 @@ class RedisCluster(AbstractRedis, AbstractRedisCluster, AsyncRedisClusterCommand
         | Enable read from replicas in READONLY mode.
           When set to true, read commands will be assigned between the primary and
           its replications in a Round-Robin manner.
-          The data read from replicas is eventually consistent with the data in primary nodes.
+          The data read from replicas is eventually consistent
+          with the data in primary nodes.
     :param load_balancing_strategy:
         | Enable read from replicas in READONLY mode and defines the load balancing
           strategy that will be used for cluster node selection.
-          The data read from replicas is eventually consistent with the data in primary nodes.
+          The data read from replicas is eventually consistent
+          with the data in primary nodes.
     :param reinitialize_steps:
         | Specifies the number of MOVED errors that need to occur before reinitializing
           the whole cluster topology. If a MOVED error occurs and the cluster does not
@@ -800,9 +802,11 @@ async def _execute_command(
                     target_node = self.nodes_manager.get_node_from_slot(
                         slot,
                         self.read_from_replicas and args[0] in READ_COMMANDS,
-                        self.load_balancing_strategy
-                        if args[0] in READ_COMMANDS
-                        else None,
+                        (
+                            self.load_balancing_strategy
+                            if args[0] in READ_COMMANDS
+                            else None
+                        ),
                     )
                     moved = False
 
@@ -1276,7 +1280,8 @@ def get_node_from_slot(
 
         try:
             if len(self.slots_cache[slot]) > 1 and load_balancing_strategy:
-                # get the server index using the strategy defined in load_balancing_strategy
+                # get the server index using the strategy defined
+                # in load_balancing_strategy
                 primary_name = self.slots_cache[slot][0].name
                 node_idx = self.read_load_balancer.get_server_index(
                     primary_name, len(self.slots_cache[slot]), load_balancing_strategy

redis/cluster.py

@@ -558,7 +558,8 @@ def __init__(
         :param load_balancing_strategy:
              Enable read from replicas in READONLY mode and defines the load balancing
              strategy that will be used for cluster node selection.
-             The data read from replicas is eventually consistent with the data in primary nodes.
+             The data read from replicas is eventually consistent
+             with the data in primary nodes.
         :param dynamic_startup_nodes:
              Set the RedisCluster's startup nodes to all of the discovered nodes.
              If true (default value), the cluster's discovered nodes will be used to
@@ -1190,9 +1191,11 @@ def _execute_command(self, target_node, *args, **kwargs):
                     target_node = self.nodes_manager.get_node_from_slot(
                         slot,
                         self.read_from_replicas and command in READ_COMMANDS,
-                        self.load_balancing_strategy
-                        if command in READ_COMMANDS
-                        else None,
+                        (
+                            self.load_balancing_strategy
+                            if command in READ_COMMANDS
+                            else None
+                        ),
                     )
                     moved = False
 
@@ -1366,7 +1369,7 @@ def get_server_index(
         self,
         primary: str,
         list_size: int,
-        load_balancing_strategy: LoadBalancingStrategy = LoadBalancingStrategy.ROUND_ROBIN,
+        load_balancing_strategy: LoadBalancingStrategy = LoadBalancingStrategy.ROUND_ROBIN,  # noqa: line too long ignored
     ) -> int:
         if load_balancing_strategy == LoadBalancingStrategy.RANDOM_REPLICA:
             return self._get_random_replica_index(list_size)

tests/test_asyncio/test_cluster.py

@@ -152,7 +152,6 @@ async def get_mocked_redis_client(
     with mock.patch.object(ClusterNode, "execute_command") as execute_command_mock:
 
         async def execute_command(*_args, **_kwargs):
-
             if _args[0] == "CLUSTER SLOTS":
                 if cluster_slots_raise_error:
                     raise ResponseError()
@@ -197,7 +196,8 @@ def __del__(self):
                 @property
                 def connection_pool(self):
                     # Required abstract property implementation
-                    return self.nodes_manager.get_default_node().redis_connection.connection_pool
+                    default_node = self.nodes_manager.get_default_node()
+                    return default_node.redis_connection.connection_pool
 
             return await MockedRedisCluster(*args, **kwargs)
 
@@ -1643,23 +1643,23 @@ async def test_cluster_bitop_not_empty_string(self, r: RedisCluster) -> None:
 
     @skip_if_server_version_lt("2.6.0")
     async def test_cluster_bitop_not(self, r: RedisCluster) -> None:
-        test_str = b"\xAA\x00\xFF\x55"
+        test_str = b"\xaa\x00\xff\x55"
         correct = ~0xAA00FF55 & 0xFFFFFFFF
         await r.set("{foo}a", test_str)
         await r.bitop("not", "{foo}r", "{foo}a")
         assert int(binascii.hexlify(await r.get("{foo}r")), 16) == correct
 
     @skip_if_server_version_lt("2.6.0")
     async def test_cluster_bitop_not_in_place(self, r: RedisCluster) -> None:
-        test_str = b"\xAA\x00\xFF\x55"
+        test_str = b"\xaa\x00\xff\x55"
         correct = ~0xAA00FF55 & 0xFFFFFFFF
         await r.set("{foo}a", test_str)
         await r.bitop("not", "{foo}a", "{foo}a")
         assert int(binascii.hexlify(await r.get("{foo}a")), 16) == correct
 
     @skip_if_server_version_lt("2.6.0")
     async def test_cluster_bitop_single_string(self, r: RedisCluster) -> None:
-        test_str = b"\x01\x02\xFF"
+        test_str = b"\x01\x02\xff"
         await r.set("{foo}a", test_str)
         await r.bitop("and", "{foo}res1", "{foo}a")
         await r.bitop("or", "{foo}res2", "{foo}a")
@@ -1670,8 +1670,8 @@ async def test_cluster_bitop_single_string(self, r: RedisCluster) -> None:
 
     @skip_if_server_version_lt("2.6.0")
     async def test_cluster_bitop_string_operands(self, r: RedisCluster) -> None:
-        await r.set("{foo}a", b"\x01\x02\xFF\xFF")
-        await r.set("{foo}b", b"\x01\x02\xFF")
+        await r.set("{foo}a", b"\x01\x02\xff\xff")
+        await r.set("{foo}b", b"\x01\x02\xff")
         await r.bitop("and", "{foo}res1", "{foo}a", "{foo}b")
         await r.bitop("or", "{foo}res2", "{foo}a", "{foo}b")
         await r.bitop("xor", "{foo}res3", "{foo}a", "{foo}b")

tests/test_backoff.py

@@ -1,7 +1,6 @@
 from unittest.mock import Mock
 
 import pytest
-
 from redis.backoff import ExponentialWithJitterBackoff
 
 

tests/test_cluster.py

@@ -4,10 +4,10 @@
 import socket
 import socketserver
 import threading
-from typing import List
 import warnings
 from queue import LifoQueue, Queue
 from time import sleep
+from typing import List
 from unittest.mock import DEFAULT, Mock, call, patch
 
 import pytest
@@ -213,7 +213,8 @@ def __del__(self):
                 @property
                 def connection_pool(self):
                     # Required abstract property implementation
-                    return self.nodes_manager.get_default_node().redis_connection.connection_pool
+                    default_node = self.nodes_manager.get_default_node()
+                    return default_node.redis_connection.connection_pool
 
             return MockedRedisCluster(*args, **kwargs)
 
@@ -1766,23 +1767,23 @@ def test_cluster_bitop_not_empty_string(self, r):
 
     @skip_if_server_version_lt("2.6.0")
     def test_cluster_bitop_not(self, r):
-        test_str = b"\xAA\x00\xFF\x55"
+        test_str = b"\xaa\x00\xff\x55"
         correct = ~0xAA00FF55 & 0xFFFFFFFF
         r["{foo}a"] = test_str
         r.bitop("not", "{foo}r", "{foo}a")
         assert int(binascii.hexlify(r["{foo}r"]), 16) == correct
 
     @skip_if_server_version_lt("2.6.0")
     def test_cluster_bitop_not_in_place(self, r):
-        test_str = b"\xAA\x00\xFF\x55"
+        test_str = b"\xaa\x00\xff\x55"
         correct = ~0xAA00FF55 & 0xFFFFFFFF
         r["{foo}a"] = test_str
         r.bitop("not", "{foo}a", "{foo}a")
         assert int(binascii.hexlify(r["{foo}a"]), 16) == correct
 
     @skip_if_server_version_lt("2.6.0")
     def test_cluster_bitop_single_string(self, r):
-        test_str = b"\x01\x02\xFF"
+        test_str = b"\x01\x02\xff"
         r["{foo}a"] = test_str
         r.bitop("and", "{foo}res1", "{foo}a")
         r.bitop("or", "{foo}res2", "{foo}a")
@@ -1793,8 +1794,8 @@ def test_cluster_bitop_single_string(self, r):
 
     @skip_if_server_version_lt("2.6.0")
     def test_cluster_bitop_string_operands(self, r):
-        r["{foo}a"] = b"\x01\x02\xFF\xFF"
-        r["{foo}b"] = b"\x01\x02\xFF"
+        r["{foo}a"] = b"\x01\x02\xff\xff"
+        r["{foo}b"] = b"\x01\x02\xff"
         r.bitop("and", "{foo}res1", "{foo}a", "{foo}b")
         r.bitop("or", "{foo}res2", "{foo}a", "{foo}b")
         r.bitop("xor", "{foo}res3", "{foo}a", "{foo}b")