Codestyle changes

Author: vladvildanov

redis/asyncio/cluster.py

@@ -2254,7 +2254,7 @@ async def _reinitialize_on_error(self, error):
                 await self._pipe.cluster_client.nodes_manager.initialize()
                 self.reinitialize_counter = 0
             else:
-                if type(error) == MovedError:
+                if type(error) is MovedError:
                     self._pipe.cluster_client.nodes_manager.update_moved_exception(
                         error
                     )

redis/asyncio/http/http_client.py

@@ -1,8 +1,9 @@
 import asyncio
 from abc import ABC, abstractmethod
 from concurrent.futures import ThreadPoolExecutor
-from typing import Optional, Mapping, Union, Any
-from redis.http.http_client import HttpResponse, HttpClient
+from typing import Any, Mapping, Optional, Union
+
+from redis.http.http_client import HttpClient, HttpResponse
 
 DEFAULT_USER_AGENT = "HttpClient/1.0 (+https://example.invalid)"
 DEFAULT_TIMEOUT = 30.0

redis/asyncio/multidb/client.py

@@ -1,18 +1,19 @@
 import asyncio
 import logging
-from typing import Callable, Optional, Coroutine, Any, List, Union, Awaitable
+from typing import Any, Awaitable, Callable, Coroutine, List, Optional, Union
 
-from redis.asyncio.client import PubSubHandler
+from redis.asyncio.client import PSWorkerThreadExcHandlerT, PubSubHandler
 from redis.asyncio.multidb.command_executor import DefaultCommandExecutor
+from redis.asyncio.multidb.config import DEFAULT_GRACE_PERIOD, MultiDbConfig
 from redis.asyncio.multidb.database import AsyncDatabase, Databases
 from redis.asyncio.multidb.failure_detector import AsyncFailureDetector
 from redis.asyncio.multidb.healthcheck import HealthCheck, HealthCheckPolicy
-from redis.multidb.circuit import State as CBState, CircuitBreaker
-from redis.asyncio.multidb.config import MultiDbConfig, DEFAULT_GRACE_PERIOD
 from redis.background import BackgroundScheduler
-from redis.commands import AsyncRedisModuleCommands, AsyncCoreCommands
+from redis.commands import AsyncCoreCommands, AsyncRedisModuleCommands
+from redis.multidb.circuit import CircuitBreaker
+from redis.multidb.circuit import State as CBState
 from redis.multidb.exception import NoValidDatabaseException, UnhealthyDatabaseException
-from redis.typing import KeyT, EncodableT, ChannelT
+from redis.typing import ChannelT, EncodableT, KeyT
 
 logger = logging.getLogger(__name__)
 

redis/asyncio/multidb/command_executor.py

@@ -1,29 +1,29 @@
 from abc import abstractmethod
 from asyncio import iscoroutinefunction
 from datetime import datetime
-from typing import List, Optional, Callable, Any, Union, Awaitable
+from typing import Any, Awaitable, Callable, List, Optional, Union
 
 from redis.asyncio import RedisCluster
-from redis.asyncio.client import PubSub, Pipeline
-from redis.asyncio.multidb.database import Databases, AsyncDatabase, Database
+from redis.asyncio.client import Pipeline, PubSub
+from redis.asyncio.multidb.database import AsyncDatabase, Database, Databases
 from redis.asyncio.multidb.event import (
     AsyncActiveDatabaseChanged,
+    CloseConnectionOnActiveDatabaseChanged,
     RegisterCommandFailure,
     ResubscribeOnActiveDatabaseChanged,
-    CloseConnectionOnActiveDatabaseChanged,
 )
 from redis.asyncio.multidb.failover import (
-    AsyncFailoverStrategy,
-    FailoverStrategyExecutor,
-    DefaultFailoverStrategyExecutor,
     DEFAULT_FAILOVER_ATTEMPTS,
     DEFAULT_FAILOVER_DELAY,
+    AsyncFailoverStrategy,
+    DefaultFailoverStrategyExecutor,
+    FailoverStrategyExecutor,
 )
 from redis.asyncio.multidb.failure_detector import AsyncFailureDetector
-from redis.multidb.circuit import State as CBState
 from redis.asyncio.retry import Retry
-from redis.event import EventDispatcherInterface, AsyncOnCommandsFailEvent
-from redis.multidb.command_executor import CommandExecutor, BaseCommandExecutor
+from redis.event import AsyncOnCommandsFailEvent, EventDispatcherInterface
+from redis.multidb.circuit import State as CBState
+from redis.multidb.command_executor import BaseCommandExecutor, CommandExecutor
 from redis.multidb.config import DEFAULT_AUTO_FALLBACK_INTERVAL
 from redis.typing import KeyT
 

redis/asyncio/multidb/config.py

@@ -1,43 +1,43 @@
 from dataclasses import dataclass, field
-from typing import Optional, List, Type, Union
+from typing import List, Optional, Type, Union
 
 import pybreaker
 
 from redis.asyncio import ConnectionPool, Redis, RedisCluster
-from redis.asyncio.multidb.database import Databases, Database
+from redis.asyncio.multidb.database import Database, Databases
 from redis.asyncio.multidb.failover import (
+    DEFAULT_FAILOVER_ATTEMPTS,
+    DEFAULT_FAILOVER_DELAY,
     AsyncFailoverStrategy,
     WeightBasedFailoverStrategy,
-    DEFAULT_FAILOVER_DELAY,
-    DEFAULT_FAILOVER_ATTEMPTS,
 )
 from redis.asyncio.multidb.failure_detector import (
     AsyncFailureDetector,
     FailureDetectorAsyncWrapper,
 )
 from redis.asyncio.multidb.healthcheck import (
-    HealthCheck,
-    EchoHealthCheck,
+    DEFAULT_HEALTH_CHECK_DELAY,
     DEFAULT_HEALTH_CHECK_INTERVAL,
+    DEFAULT_HEALTH_CHECK_POLICY,
     DEFAULT_HEALTH_CHECK_PROBES,
-    DEFAULT_HEALTH_CHECK_DELAY,
+    EchoHealthCheck,
+    HealthCheck,
     HealthCheckPolicies,
-    DEFAULT_HEALTH_CHECK_POLICY,
 )
 from redis.asyncio.retry import Retry
 from redis.backoff import ExponentialWithJitterBackoff, NoBackoff
 from redis.data_structure import WeightedList
-from redis.event import EventDispatcherInterface, EventDispatcher
+from redis.event import EventDispatcher, EventDispatcherInterface
 from redis.multidb.circuit import (
+    DEFAULT_GRACE_PERIOD,
     CircuitBreaker,
     PBCircuitBreakerAdapter,
-    DEFAULT_GRACE_PERIOD,
 )
 from redis.multidb.failure_detector import (
-    CommandFailureDetector,
-    DEFAULT_MIN_NUM_FAILURES,
     DEFAULT_FAILURE_RATE_THRESHOLD,
     DEFAULT_FAILURES_DETECTION_WINDOW,
+    DEFAULT_MIN_NUM_FAILURES,
+    CommandFailureDetector,
 )
 
 DEFAULT_AUTO_FALLBACK_INTERVAL = 120

redis/asyncio/multidb/database.py

@@ -1,5 +1,5 @@
 from abc import abstractmethod
-from typing import Union, Optional
+from typing import Optional, Union
 
 from redis.asyncio import Redis, RedisCluster
 from redis.data_structure import WeightedList

redis/asyncio/multidb/failover.py

@@ -1,9 +1,9 @@
 import time
-from abc import abstractmethod, ABC
+from abc import ABC, abstractmethod
 
 from redis.asyncio.multidb.database import AsyncDatabase, Databases
-from redis.multidb.circuit import State as CBState
 from redis.data_structure import WeightedList
+from redis.multidb.circuit import State as CBState
 from redis.multidb.exception import (
     NoValidDatabaseException,
     TemporaryUnavailableException,

redis/asyncio/multidb/healthcheck.py

@@ -2,15 +2,14 @@
 import logging
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import Optional, Tuple, Union, List
-
+from typing import List, Optional, Tuple, Union
 
 from redis.asyncio import Redis
-from redis.asyncio.http.http_client import AsyncHTTPClientWrapper, DEFAULT_TIMEOUT
-from redis.retry import Retry
+from redis.asyncio.http.http_client import DEFAULT_TIMEOUT, AsyncHTTPClientWrapper
 from redis.backoff import NoBackoff
 from redis.http.http_client import HttpClient
 from redis.multidb.exception import UnhealthyDatabaseException
+from redis.retry import Retry
 
 DEFAULT_HEALTH_CHECK_PROBES = 3
 DEFAULT_HEALTH_CHECK_INTERVAL = 5
@@ -85,7 +84,7 @@ async def execute(self, health_checks: List[HealthCheck], database) -> bool:
                     if not await health_check.check_health(database):
                         return False
                 except Exception as e:
-                    raise UnhealthyDatabaseException(f"Unhealthy database", database, e)
+                    raise UnhealthyDatabaseException("Unhealthy database", database, e)
 
                 if attempt < self.health_check_probes - 1:
                     await asyncio.sleep(self._health_check_delay)
@@ -117,7 +116,7 @@ async def execute(self, health_checks: List[HealthCheck], database) -> bool:
                     allowed_unsuccessful_probes -= 1
                     if allowed_unsuccessful_probes <= 0:
                         raise UnhealthyDatabaseException(
-                            f"Unhealthy database", database, e
+                            "Unhealthy database", database, e
                         )
 
                 if attempt < self.health_check_probes - 1:
@@ -148,7 +147,7 @@ async def execute(self, health_checks: List[HealthCheck], database) -> bool:
                         is_healthy = False
                 except Exception as e:
                     exception = UnhealthyDatabaseException(
-                        f"Unhealthy database", database, e
+                        "Unhealthy database", database, e
                     )
 
                 if attempt < self.health_check_probes - 1:

redis/background.py

@@ -1,6 +1,6 @@
 import asyncio
 import threading
-from typing import Callable, Coroutine, Any
+from typing import Any, Callable, Coroutine
 
 
 class BackgroundScheduler:

redis/cluster.py

@@ -3165,7 +3165,7 @@ def _reinitialize_on_error(self, error):
                 self._nodes_manager.initialize()
                 self.reinitialize_counter = 0
             else:
-                if type(error) == MovedError:
+                if type(error) is MovedError:
                     self._nodes_manager.update_moved_exception(error)
 
         self._executing = False