Codestyle changes

Author: vladvildanov

redis/connection.py

@@ -8,7 +8,7 @@
 from abc import abstractmethod
 from itertools import chain
 from queue import Empty, Full, LifoQueue
-from time import time, sleep
+from time import sleep, time
 from typing import Any, Callable, List, Optional, Type, Union
 from urllib.parse import parse_qs, unquote, urlparse
 
@@ -20,8 +20,8 @@
     CacheInterface,
     CacheToolsFactory,
 )
-from . import scheduler
 
+from . import scheduler
 from ._parsers import Encoder, _HiredisParser, _RESP2Parser, _RESP3Parser
 from .backoff import NoBackoff
 from .credentials import CredentialProvider, UsernamePasswordCredentialProvider
@@ -1312,12 +1312,9 @@ def __init__(
         if self.cache is not None and self._scheduler is not None:
             self._hc_cancel_event = threading.Event()
             self._hc_thread = self._scheduler.run_with_interval(
-                self._perform_health_check,
-                2,
-                self._hc_cancel_event
+                self._perform_health_check, 2, self._hc_cancel_event
             )
 
-
     def __repr__(self) -> (str, str):
         return (
             f"<{type(self).__module__}.{type(self).__name__}"

redis/scheduler.py

@@ -13,37 +13,36 @@ def __init__(self, polling_period: float = 0.1):
         self.polling_period = polling_period
 
     def run_with_interval(
-            self,
-            func: Callable[[threading.Event, ...], None],
-            interval: float,
-            cancel: threading.Event,
-            args: tuple = (),
+        self,
+        func: Callable[[threading.Event, ...], None],
+        interval: float,
+        cancel: threading.Event,
+        args: tuple = (),
     ) -> threading.Thread:
         """
         Run scheduled execution with given interval
         in a separate thread until cancel event won't be set.
         """
         done = threading.Event()
-        thread = threading.Thread(target=self._run_timer, args=(func, interval, (done, *args), done, cancel))
+        thread = threading.Thread(
+            target=self._run_timer, args=(func, interval, (done, *args), done, cancel)
+        )
         thread.start()
         return thread
 
     def _get_timer(
-            self,
-            func: Callable[[threading.Event, ...], None],
-            interval: float,
-            args: tuple
+        self, func: Callable[[threading.Event, ...], None], interval: float, args: tuple
     ) -> threading.Timer:
         timer = threading.Timer(interval=interval, function=func, args=args)
         return timer
 
     def _run_timer(
-            self,
-            func: Callable[[threading.Event, ...], None],
-            interval: float,
-            args: tuple,
-            done: threading.Event,
-            cancel: threading.Event
+        self,
+        func: Callable[[threading.Event, ...], None],
+        interval: float,
+        args: tuple,
+        done: threading.Event,
+        cancel: threading.Event,
     ):
         timer = self._get_timer(func, interval, args)
         timer.start()

tests/conftest.py

@@ -8,14 +8,24 @@
 from urllib.parse import urlparse
 
 import pytest
-from _pytest import unittest
-
 import redis
+from _pytest import unittest
 from packaging.version import Version
 from redis import Sentinel
 from redis.backoff import NoBackoff
-from redis.cache import CacheConfiguration, EvictionPolicy, CacheFactoryInterface, CacheInterface
-from redis.connection import Connection, SSLConnection, parse_url, ConnectionPool, ConnectionInterface
+from redis.cache import (
+    CacheConfiguration,
+    CacheFactoryInterface,
+    CacheInterface,
+    EvictionPolicy,
+)
+from redis.connection import (
+    Connection,
+    ConnectionInterface,
+    ConnectionPool,
+    SSLConnection,
+    parse_url,
+)
 from redis.exceptions import RedisClusterException
 from redis.retry import Retry
 from tests.ssl_utils import get_ssl_filename
@@ -544,9 +554,7 @@ def master_host(request):
 @pytest.fixture()
 def cache_conf() -> CacheConfiguration:
     return CacheConfiguration(
-        cache_size=100,
-        cache_ttl=20,
-        cache_eviction=EvictionPolicy.TTL
+        cache_size=100, cache_ttl=20, cache_eviction=EvictionPolicy.TTL
     )
 
 

tests/test_cache.py

@@ -4,7 +4,7 @@
 import pytest
 import redis
 from cachetools import LFUCache, LRUCache, TTLCache
-from redis.cache import CacheToolsAdapter, EvictionPolicy, CacheConfiguration
+from redis.cache import CacheConfiguration, CacheToolsAdapter, EvictionPolicy
 from redis.utils import HIREDIS_AVAILABLE
 from tests.conftest import _get_client, skip_if_resp_version
 
@@ -1176,4 +1176,4 @@ def test_is_exceeds_max_size(self, cache_conf: CacheConfiguration):
 
     def test_is_allowed_to_cache(self, cache_conf: CacheConfiguration):
         assert cache_conf.is_allowed_to_cache("GET")
-        assert not cache_conf.is_allowed_to_cache("SET")
+        assert not cache_conf.is_allowed_to_cache("SET")

tests/test_connection.py

@@ -4,20 +4,20 @@
 from unittest.mock import patch
 
 import pytest
-from cachetools import TTLCache, LRUCache
-
 import redis
+from cachetools import LRUCache, TTLCache
 from redis import ConnectionPool, Redis
 from redis._parsers import _HiredisParser, _RESP2Parser, _RESP3Parser
 from redis.backoff import NoBackoff
-from redis.cache import EvictionPolicy, CacheInterface, CacheToolsAdapter
+from redis.cache import CacheInterface, CacheToolsAdapter, EvictionPolicy
 from redis.connection import (
+    CacheProxyConnection,
     Connection,
     SSLConnection,
     UnixDomainSocketConnection,
-    parse_url, CacheProxyConnection,
+    parse_url,
 )
-from redis.exceptions import ConnectionError, InvalidResponse, TimeoutError, RedisError
+from redis.exceptions import ConnectionError, InvalidResponse, RedisError, TimeoutError
 from redis.retry import Retry
 from redis.utils import HIREDIS_AVAILABLE
 
@@ -353,48 +353,36 @@ def test_unix_socket_connection_failure():
 
 class TestUnitConnectionPool:
 
-    @pytest.mark.parametrize("max_conn", (-1, 'str'), ids=("non-positive", "wrong type"))
+    @pytest.mark.parametrize(
+        "max_conn", (-1, "str"), ids=("non-positive", "wrong type")
+    )
     def test_throws_error_on_incorrect_max_connections(self, max_conn):
         with pytest.raises(
-                ValueError,
-                match='"max_connections" must be a positive integer'
+            ValueError, match='"max_connections" must be a positive integer'
         ):
             ConnectionPool(
                 max_connections=max_conn,
             )
 
     def test_throws_error_on_cache_enable_in_resp2(self):
         with pytest.raises(
-                RedisError,
-                match="Client caching is only supported with RESP version 3"
+            RedisError, match="Client caching is only supported with RESP version 3"
         ):
-            ConnectionPool(
-                protocol=2,
-                use_cache=True
-            )
+            ConnectionPool(protocol=2, use_cache=True)
 
     def test_throws_error_on_incorrect_cache_implementation(self):
-        with pytest.raises(
-                ValueError,
-                match="Cache must implement CacheInterface"
-        ):
-            ConnectionPool(
-                protocol=3,
-                use_cache=True,
-                cache=TTLCache(100, 20)
-            )
+        with pytest.raises(ValueError, match="Cache must implement CacheInterface"):
+            ConnectionPool(protocol=3, use_cache=True, cache=TTLCache(100, 20))
 
     def test_returns_custom_cache_implementation(self, mock_cache):
-        connection_pool = ConnectionPool(
-            protocol=3,
-            use_cache=True,
-            cache=mock_cache
-        )
+        connection_pool = ConnectionPool(protocol=3, use_cache=True, cache=mock_cache)
 
         assert mock_cache == connection_pool.cache
         connection_pool.disconnect()
 
-    def test_creates_cache_with_custom_cache_factory(self, mock_cache_factory, mock_cache):
+    def test_creates_cache_with_custom_cache_factory(
+        self, mock_cache_factory, mock_cache
+    ):
         mock_cache_factory.get_cache.return_value = mock_cache
 
         connection_pool = ConnectionPool(
@@ -403,7 +391,7 @@ def test_creates_cache_with_custom_cache_factory(self, mock_cache_factory, mock_
             cache_size=100,
             cache_ttl=20,
             cache_eviction=EvictionPolicy.TTL,
-            cache_factory=mock_cache_factory
+            cache_factory=mock_cache_factory,
         )
 
         assert connection_pool.cache == mock_cache
@@ -415,7 +403,7 @@ def test_creates_cache_with_given_configuration(self, mock_cache):
             use_cache=True,
             cache_size=100,
             cache_ttl=20,
-            cache_eviction=EvictionPolicy.TTL
+            cache_eviction=EvictionPolicy.TTL,
         )
 
         assert isinstance(connection_pool.cache, CacheInterface)
@@ -424,10 +412,7 @@ def test_creates_cache_with_given_configuration(self, mock_cache):
         connection_pool.disconnect()
 
     def test_make_connection_proxy_connection_on_given_cache(self):
-        connection_pool = ConnectionPool(
-            protocol=3,
-            use_cache=True
-        )
+        connection_pool = ConnectionPool(protocol=3, use_cache=True)
 
         assert isinstance(connection_pool.make_connection(), CacheProxyConnection)
         connection_pool.disconnect()
@@ -436,16 +421,17 @@ def test_make_connection_proxy_connection_on_given_cache(self):
 class TestUnitCacheProxyConnection:
     def test_clears_cache_on_disconnect(self, mock_connection, cache_conf):
         cache = LRUCache(100)
-        cache['key'] = 'value'
-        assert cache['key'] == 'value'
+        cache["key"] = "value"
+        assert cache["key"] == "value"
 
         mock_connection.disconnect.return_value = None
-        mock_connection.retry = 'mock'
-        mock_connection.host = 'mock'
-        mock_connection.port = 'mock'
+        mock_connection.retry = "mock"
+        mock_connection.host = "mock"
+        mock_connection.port = "mock"
 
-        proxy_connection = CacheProxyConnection(mock_connection, CacheToolsAdapter(cache), cache_conf)
+        proxy_connection = CacheProxyConnection(
+            mock_connection, CacheToolsAdapter(cache), cache_conf
+        )
         proxy_connection.disconnect()
 
         assert cache.currsize == 0
-

tests/test_scheduler.py

@@ -2,7 +2,6 @@
 import time
 
 import pytest
-
 from redis.scheduler import Scheduler
 
 
@@ -15,10 +14,10 @@ class TestScheduler:
             (0.1, 2, (0, 0)),
         ],
         ids=[
-            'small polling period (0.001s)',
-            'large polling period (0.1s)',
-            'interval larger than timeout - no execution',
-        ]
+            "small polling period (0.001s)",
+            "large polling period (0.1s)",
+            "interval larger than timeout - no execution",
+        ],
     )
     def test_run_with_interval(self, polling_period, interval, expected_count):
         scheduler = Scheduler(polling_period=polling_period)
@@ -30,7 +29,9 @@ def callback(done: threading.Event):
             counter += 1
             done.set()
 
-        scheduler.run_with_interval(func=callback, interval=interval, cancel=cancel_event)
+        scheduler.run_with_interval(
+            func=callback, interval=interval, cancel=cancel_event
+        )
         time.sleep(1)
         cancel_event.set()
         cancel_event.wait()