Codestyle fixes

Author: vladvildanov

redis/asyncio/client.py

@@ -53,8 +53,13 @@
     list_or_args,
 )
 from redis.credentials import CredentialProvider
-from redis.event import EventDispatcher, AfterPooledConnectionsInstantiationEvent, ClientType, \
-    AfterSingleConnectionInstantiationEvent, AfterPubSubConnectionInstantiationEvent
+from redis.event import (
+    AfterPooledConnectionsInstantiationEvent,
+    AfterPubSubConnectionInstantiationEvent,
+    AfterSingleConnectionInstantiationEvent,
+    ClientType,
+    EventDispatcher,
+)
 from redis.exceptions import (
     ConnectionError,
     ExecAbortError,
@@ -323,19 +328,19 @@ def __init__(
             # This arg only used if no pool is passed in
             self.auto_close_connection_pool = auto_close_connection_pool
             connection_pool = ConnectionPool(**kwargs)
-            event_dispatcher.dispatch(AfterPooledConnectionsInstantiationEvent(
-                [connection_pool],
-                ClientType.ASYNC,
-                credential_provider
-            ))
+            event_dispatcher.dispatch(
+                AfterPooledConnectionsInstantiationEvent(
+                    [connection_pool], ClientType.ASYNC, credential_provider
+                )
+            )
         else:
             # If a pool is passed in, do not close it
             self.auto_close_connection_pool = False
-            event_dispatcher.dispatch(AfterPooledConnectionsInstantiationEvent(
-                [connection_pool],
-                ClientType.ASYNC,
-                credential_provider
-            ))
+            event_dispatcher.dispatch(
+                AfterPooledConnectionsInstantiationEvent(
+                    [connection_pool], ClientType.ASYNC, credential_provider
+                )
+            )
 
         self.connection_pool = connection_pool
         self._event_dispatcher = event_dispatcher
@@ -370,7 +375,9 @@ async def initialize(self: _RedisT) -> _RedisT:
                     self.connection = await self.connection_pool.get_connection("_")
 
             self._event_dispatcher.dispatch(
-                AfterSingleConnectionInstantiationEvent(self.connection, ClientType.ASYNC, self._single_conn_lock)
+                AfterSingleConnectionInstantiationEvent(
+                    self.connection, ClientType.ASYNC, self._single_conn_lock
+                )
             )
         return self
 
@@ -539,7 +546,9 @@ def pubsub(self, **kwargs) -> "PubSub":
         subscribe to channels and listen for messages that get published to
         them.
         """
-        return PubSub(self.connection_pool, event_dispatcher=self._event_dispatcher, **kwargs)
+        return PubSub(
+            self.connection_pool, event_dispatcher=self._event_dispatcher, **kwargs
+        )
 
     def monitor(self) -> "Monitor":
         return Monitor(self.connection_pool)
@@ -898,10 +907,7 @@ async def connect(self):
 
         self._event_dispatcher.dispatch(
             AfterPubSubConnectionInstantiationEvent(
-                self.connection,
-                self.connection_pool,
-                ClientType.ASYNC,
-                self._lock
+                self.connection, self.connection_pool, ClientType.ASYNC, self._lock
             )
         )
 

redis/asyncio/cluster.py

@@ -47,7 +47,11 @@
 from redis.commands import READ_COMMANDS, AsyncRedisClusterCommands
 from redis.crc import REDIS_CLUSTER_HASH_SLOTS, key_slot
 from redis.credentials import CredentialProvider
-from redis.event import EventDispatcher, AsyncAfterConnectionReleasedEvent, AfterAsyncClusterInstantiationEvent
+from redis.event import (
+    AfterAsyncClusterInstantiationEvent,
+    AsyncAfterConnectionReleasedEvent,
+    EventDispatcher,
+)
 from redis.exceptions import (
     AskError,
     BusyLoadingError,
@@ -60,10 +64,11 @@
     MaxConnectionsError,
     MovedError,
     RedisClusterException,
+    RedisError,
     ResponseError,
     SlotNotCoveredError,
     TimeoutError,
-    TryAgainError, RedisError,
+    TryAgainError,
 )
 from redis.typing import AnyKeyT, EncodableT, KeyT
 from redis.utils import (
@@ -1097,12 +1102,13 @@ async def re_auth_callback(self, token: TokenInterface):
         while self._free:
             conn = self._free.popleft()
             await conn.retry.call_with_retry(
-                lambda: conn.send_command('AUTH', token.try_get('oid'), token.get_value()),
-                lambda error: self._mock(error)
+                lambda: conn.send_command(
+                    "AUTH", token.try_get("oid"), token.get_value()
+                ),
+                lambda error: self._mock(error),
             )
             await conn.retry.call_with_retry(
-                lambda: conn.read_response(),
-                lambda error: self._mock(error)
+                lambda: conn.read_response(), lambda error: self._mock(error)
             )
             tmp_queue.append(conn)
 
@@ -1272,7 +1278,8 @@ async def initialize(self) -> None:
                     self._event_dispatcher.dispatch(
                         AfterAsyncClusterInstantiationEvent(
                             self.nodes_cache,
-                            self.connection_kwargs.get("credential_provider", None))
+                            self.connection_kwargs.get("credential_provider", None),
+                        )
                     )
                     cluster_slots = await startup_node.execute_command("CLUSTER SLOTS")
                 except ResponseError:

redis/asyncio/connection.py

@@ -29,7 +29,7 @@
 from urllib.parse import ParseResult, parse_qs, unquote, urlparse
 
 from ..auth.token import TokenInterface
-from ..event import EventDispatcher, AsyncAfterConnectionReleasedEvent
+from ..event import AsyncAfterConnectionReleasedEvent, EventDispatcher
 from ..utils import format_error_message
 
 # the functionality is available in 3.11.x but has a major issue before
@@ -42,7 +42,11 @@
 from redis.asyncio.retry import Retry
 from redis.backoff import NoBackoff
 from redis.connection import DEFAULT_RESP_VERSION
-from redis.credentials import CredentialProvider, UsernamePasswordCredentialProvider, StreamingCredentialProvider
+from redis.credentials import (
+    CredentialProvider,
+    StreamingCredentialProvider,
+    UsernamePasswordCredentialProvider,
+)
 from redis.exceptions import (
     AuthenticationError,
     AuthenticationWrongNumberOfArgsError,
@@ -151,7 +155,7 @@ def __init__(
         encoder_class: Type[Encoder] = Encoder,
         credential_provider: Optional[CredentialProvider] = None,
         protocol: Optional[int] = 2,
-        event_dispatcher: Optional[EventDispatcher] = EventDispatcher()
+        event_dispatcher: Optional[EventDispatcher] = EventDispatcher(),
     ):
         if (username or password) and credential_provider is not None:
             raise DataError(
@@ -678,9 +682,9 @@ def set_re_auth_token(self, token: TokenInterface):
     async def re_auth(self):
         if self._re_auth_token is not None:
             await self.send_command(
-                'AUTH',
-                self._re_auth_token.try_get('oid'),
-                self._re_auth_token.get_value()
+                "AUTH",
+                self._re_auth_token.try_get("oid"),
+                self._re_auth_token.get_value(),
             )
             await self.read_response()
             self._re_auth_token = None
@@ -1143,7 +1147,9 @@ async def release(self, connection: AbstractConnection):
         # not doing so is an error that will cause an exception here.
         self._in_use_connections.remove(connection)
         self._available_connections.append(connection)
-        await self._event_dispatcher.dispatch_async(AsyncAfterConnectionReleasedEvent(connection))
+        await self._event_dispatcher.dispatch_async(
+            AsyncAfterConnectionReleasedEvent(connection)
+        )
 
     async def disconnect(self, inuse_connections: bool = True):
         """
@@ -1181,12 +1187,13 @@ async def re_auth_callback(self, token: TokenInterface):
         async with self._lock:
             for conn in self._available_connections:
                 await conn.retry.call_with_retry(
-                    lambda: conn.send_command('AUTH', token.try_get('oid'), token.get_value()),
-                    lambda error: self._mock(error)
+                    lambda: conn.send_command(
+                        "AUTH", token.try_get("oid"), token.get_value()
+                    ),
+                    lambda error: self._mock(error),
                 )
                 await conn.retry.call_with_retry(
-                    lambda: conn.read_response(),
-                    lambda error: self._mock(error)
+                    lambda: conn.read_response(), lambda error: self._mock(error)
                 )
             for conn in self._in_use_connections:
                 conn.set_re_auth_token(token)

redis/auth/err.py

@@ -5,6 +5,7 @@ class RequestTokenErr(Exception):
     """
     Represents an exception during token request.
     """
+
     def __init__(self, *args):
         super().__init__(*args)
 
@@ -13,15 +14,18 @@ class InvalidTokenSchemaErr(Exception):
     """
     Represents an exception related to invalid token schema.
     """
+
     def __init__(self, missing_fields: Iterable[str] = []):
         super().__init__(
-            "Unexpected token schema. Following fields are missing: " + ", ".join(missing_fields)
+            "Unexpected token schema. Following fields are missing: "
+            + ", ".join(missing_fields)
         )
 
 
 class TokenRenewalErr(Exception):
     """
     Represents an exception during token renewal process.
     """
+
     def __init__(self, *args):
-        super().__init__(*args)
+        super().__init__(*args)

redis/auth/idp.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+
 from redis.auth.token import TokenInterface
 
 """
@@ -20,6 +21,7 @@ class IdentityProviderConfigInterface(ABC):
     """
     Configuration class that provides a configured identity provider.
     """
+
     @abstractmethod
     def get_provider(self) -> IdentityProviderInterface:
         pass

redis/auth/token.py

@@ -1,8 +1,7 @@
 from abc import ABC, abstractmethod
-
-import jwt
 from datetime import datetime, timezone
 
+import jwt
 from redis.auth.err import InvalidTokenSchemaErr
 
 
@@ -44,7 +43,9 @@ def get_ttl_ms(self) -> float:
 
 
 class SimpleToken(TokenInterface):
-    def __init__(self, value: str, expires_at_ms: float, received_at_ms: float, claims: dict) -> None:
+    def __init__(
+        self, value: str, expires_at_ms: float, received_at_ms: float, claims: dict
+    ) -> None:
         self.value = value
         self.expires_at = expires_at_ms
         self.received_at = received_at_ms
@@ -77,30 +78,34 @@ def get_received_at_ms(self) -> float:
 
 class JWToken(TokenInterface):
 
-    REQUIRED_FIELDS = {'exp'}
+    REQUIRED_FIELDS = {"exp"}
 
     def __init__(self, token: str):
         self._value = token
         self._decoded = jwt.decode(
             self._value,
             options={"verify_signature": False},
-            algorithms=[jwt.get_unverified_header(self._value).get('alg')]
+            algorithms=[jwt.get_unverified_header(self._value).get("alg")],
         )
         self._validate_token()
 
     def is_expired(self) -> bool:
-        exp = self._decoded['exp']
+        exp = self._decoded["exp"]
         if exp == -1:
             return False
 
-        return self._decoded['exp'] * 1000 <= datetime.now(timezone.utc).timestamp() * 1000
+        return (
+            self._decoded["exp"] * 1000 <= datetime.now(timezone.utc).timestamp() * 1000
+        )
 
     def ttl(self) -> float:
-        exp = self._decoded['exp']
+        exp = self._decoded["exp"]
         if exp == -1:
             return -1
 
-        return self._decoded['exp'] * 1000 - datetime.now(timezone.utc).timestamp() * 1000
+        return (
+            self._decoded["exp"] * 1000 - datetime.now(timezone.utc).timestamp() * 1000
+        )
 
     def try_get(self, key: str) -> str:
         return self._decoded.get(key)
@@ -109,7 +114,7 @@ def get_value(self) -> str:
         return self._value
 
     def get_expires_at_ms(self) -> float:
-        return float(self._decoded['exp'] * 1000)
+        return float(self._decoded["exp"] * 1000)
 
     def get_received_at_ms(self) -> float:
         return datetime.now(timezone.utc).timestamp() * 1000
@@ -118,4 +123,4 @@ def _validate_token(self):
         actual_fields = {x for x in self._decoded.keys()}
 
         if len(self.REQUIRED_FIELDS - actual_fields) != 0:
-            raise InvalidTokenSchemaErr(self.REQUIRED_FIELDS - actual_fields)
+            raise InvalidTokenSchemaErr(self.REQUIRED_FIELDS - actual_fields)