redis 5.2.1__py3-none-any.whl → 5.3.0__py3-none-any.whl

redis/event.py

@@ -0,0 +1,394 @@
+import asyncio
+import threading
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import List, Optional, Union
+
+from redis.auth.token import TokenInterface
+from redis.credentials import CredentialProvider, StreamingCredentialProvider
+
+
+class EventListenerInterface(ABC):
+    """
+    Represents a listener for given event object.
+    """
+
+    @abstractmethod
+    def listen(self, event: object):
+        pass
+
+
+class AsyncEventListenerInterface(ABC):
+    """
+    Represents an async listener for given event object.
+    """
+
+    @abstractmethod
+    async def listen(self, event: object):
+        pass
+
+
+class EventDispatcherInterface(ABC):
+    """
+    Represents a dispatcher that dispatches events to listeners
+    associated with given event.
+    """
+
+    @abstractmethod
+    def dispatch(self, event: object):
+        pass
+
+    @abstractmethod
+    async def dispatch_async(self, event: object):
+        pass
+
+
+class EventException(Exception):
+    """
+    Exception wrapper that adds an event object into exception context.
+    """
+
+    def __init__(self, exception: Exception, event: object):
+        self.exception = exception
+        self.event = event
+        super().__init__(exception)
+
+
+class EventDispatcher(EventDispatcherInterface):
+    # TODO: Make dispatcher to accept external mappings.
+    def __init__(self):
+        """
+        Mapping should be extended for any new events or listeners to be added.
+        """
+        self._event_listeners_mapping = {
+            AfterConnectionReleasedEvent: [
+                ReAuthConnectionListener(),
+            ],
+            AfterPooledConnectionsInstantiationEvent: [
+                RegisterReAuthForPooledConnections()
+            ],
+            AfterSingleConnectionInstantiationEvent: [
+                RegisterReAuthForSingleConnection()
+            ],
+            AfterPubSubConnectionInstantiationEvent: [RegisterReAuthForPubSub()],
+            AfterAsyncClusterInstantiationEvent: [RegisterReAuthForAsyncClusterNodes()],
+            AsyncAfterConnectionReleasedEvent: [
+                AsyncReAuthConnectionListener(),
+            ],
+        }
+
+    def dispatch(self, event: object):
+        listeners = self._event_listeners_mapping.get(type(event))
+
+        for listener in listeners:
+            listener.listen(event)
+
+    async def dispatch_async(self, event: object):
+        listeners = self._event_listeners_mapping.get(type(event))
+
+        for listener in listeners:
+            await listener.listen(event)
+
+
+class AfterConnectionReleasedEvent:
+    """
+    Event that will be fired before each command execution.
+    """
+
+    def __init__(self, connection):
+        self._connection = connection
+
+    @property
+    def connection(self):
+        return self._connection
+
+
+class AsyncAfterConnectionReleasedEvent(AfterConnectionReleasedEvent):
+    pass
+
+
+class ClientType(Enum):
+    SYNC = ("sync",)
+    ASYNC = ("async",)
+
+
+class AfterPooledConnectionsInstantiationEvent:
+    """
+    Event that will be fired after pooled connection instances was created.
+    """
+
+    def __init__(
+        self,
+        connection_pools: List,
+        client_type: ClientType,
+        credential_provider: Optional[CredentialProvider] = None,
+    ):
+        self._connection_pools = connection_pools
+        self._client_type = client_type
+        self._credential_provider = credential_provider
+
+    @property
+    def connection_pools(self):
+        return self._connection_pools
+
+    @property
+    def client_type(self) -> ClientType:
+        return self._client_type
+
+    @property
+    def credential_provider(self) -> Union[CredentialProvider, None]:
+        return self._credential_provider
+
+
+class AfterSingleConnectionInstantiationEvent:
+    """
+    Event that will be fired after single connection instances was created.
+
+    :param connection_lock: For sync client thread-lock should be provided,
+    for async asyncio.Lock
+    """
+
+    def __init__(
+        self,
+        connection,
+        client_type: ClientType,
+        connection_lock: Union[threading.Lock, asyncio.Lock],
+    ):
+        self._connection = connection
+        self._client_type = client_type
+        self._connection_lock = connection_lock
+
+    @property
+    def connection(self):
+        return self._connection
+
+    @property
+    def client_type(self) -> ClientType:
+        return self._client_type
+
+    @property
+    def connection_lock(self) -> Union[threading.Lock, asyncio.Lock]:
+        return self._connection_lock
+
+
+class AfterPubSubConnectionInstantiationEvent:
+    def __init__(
+        self,
+        pubsub_connection,
+        connection_pool,
+        client_type: ClientType,
+        connection_lock: Union[threading.Lock, asyncio.Lock],
+    ):
+        self._pubsub_connection = pubsub_connection
+        self._connection_pool = connection_pool
+        self._client_type = client_type
+        self._connection_lock = connection_lock
+
+    @property
+    def pubsub_connection(self):
+        return self._pubsub_connection
+
+    @property
+    def connection_pool(self):
+        return self._connection_pool
+
+    @property
+    def client_type(self) -> ClientType:
+        return self._client_type
+
+    @property
+    def connection_lock(self) -> Union[threading.Lock, asyncio.Lock]:
+        return self._connection_lock
+
+
+class AfterAsyncClusterInstantiationEvent:
+    """
+    Event that will be fired after async cluster instance was created.
+
+    Async cluster doesn't use connection pools,
+    instead ClusterNode object manages connections.
+    """
+
+    def __init__(
+        self,
+        nodes: dict,
+        credential_provider: Optional[CredentialProvider] = None,
+    ):
+        self._nodes = nodes
+        self._credential_provider = credential_provider
+
+    @property
+    def nodes(self) -> dict:
+        return self._nodes
+
+    @property
+    def credential_provider(self) -> Union[CredentialProvider, None]:
+        return self._credential_provider
+
+
+class ReAuthConnectionListener(EventListenerInterface):
+    """
+    Listener that performs re-authentication of given connection.
+    """
+
+    def listen(self, event: AfterConnectionReleasedEvent):
+        event.connection.re_auth()
+
+
+class AsyncReAuthConnectionListener(AsyncEventListenerInterface):
+    """
+    Async listener that performs re-authentication of given connection.
+    """
+
+    async def listen(self, event: AsyncAfterConnectionReleasedEvent):
+        await event.connection.re_auth()
+
+
+class RegisterReAuthForPooledConnections(EventListenerInterface):
+    """
+    Listener that registers a re-authentication callback for pooled connections.
+    Required by :class:`StreamingCredentialProvider`.
+    """
+
+    def __init__(self):
+        self._event = None
+
+    def listen(self, event: AfterPooledConnectionsInstantiationEvent):
+        if isinstance(event.credential_provider, StreamingCredentialProvider):
+            self._event = event
+
+            if event.client_type == ClientType.SYNC:
+                event.credential_provider.on_next(self._re_auth)
+                event.credential_provider.on_error(self._raise_on_error)
+            else:
+                event.credential_provider.on_next(self._re_auth_async)
+                event.credential_provider.on_error(self._raise_on_error_async)
+
+    def _re_auth(self, token):
+        for pool in self._event.connection_pools:
+            pool.re_auth_callback(token)
+
+    async def _re_auth_async(self, token):
+        for pool in self._event.connection_pools:
+            await pool.re_auth_callback(token)
+
+    def _raise_on_error(self, error: Exception):
+        raise EventException(error, self._event)
+
+    async def _raise_on_error_async(self, error: Exception):
+        raise EventException(error, self._event)
+
+
+class RegisterReAuthForSingleConnection(EventListenerInterface):
+    """
+    Listener that registers a re-authentication callback for single connection.
+    Required by :class:`StreamingCredentialProvider`.
+    """
+
+    def __init__(self):
+        self._event = None
+
+    def listen(self, event: AfterSingleConnectionInstantiationEvent):
+        if isinstance(
+            event.connection.credential_provider, StreamingCredentialProvider
+        ):
+            self._event = event
+
+            if event.client_type == ClientType.SYNC:
+                event.connection.credential_provider.on_next(self._re_auth)
+                event.connection.credential_provider.on_error(self._raise_on_error)
+            else:
+                event.connection.credential_provider.on_next(self._re_auth_async)
+                event.connection.credential_provider.on_error(
+                    self._raise_on_error_async
+                )
+
+    def _re_auth(self, token):
+        with self._event.connection_lock:
+            self._event.connection.send_command(
+                "AUTH", token.try_get("oid"), token.get_value()
+            )
+            self._event.connection.read_response()
+
+    async def _re_auth_async(self, token):
+        async with self._event.connection_lock:
+            await self._event.connection.send_command(
+                "AUTH", token.try_get("oid"), token.get_value()
+            )
+            await self._event.connection.read_response()
+
+    def _raise_on_error(self, error: Exception):
+        raise EventException(error, self._event)
+
+    async def _raise_on_error_async(self, error: Exception):
+        raise EventException(error, self._event)
+
+
+class RegisterReAuthForAsyncClusterNodes(EventListenerInterface):
+    def __init__(self):
+        self._event = None
+
+    def listen(self, event: AfterAsyncClusterInstantiationEvent):
+        if isinstance(event.credential_provider, StreamingCredentialProvider):
+            self._event = event
+            event.credential_provider.on_next(self._re_auth)
+            event.credential_provider.on_error(self._raise_on_error)
+
+    async def _re_auth(self, token: TokenInterface):
+        for key in self._event.nodes:
+            await self._event.nodes[key].re_auth_callback(token)
+
+    async def _raise_on_error(self, error: Exception):
+        raise EventException(error, self._event)
+
+
+class RegisterReAuthForPubSub(EventListenerInterface):
+    def __init__(self):
+        self._connection = None
+        self._connection_pool = None
+        self._client_type = None
+        self._connection_lock = None
+        self._event = None
+
+    def listen(self, event: AfterPubSubConnectionInstantiationEvent):
+        if isinstance(
+            event.pubsub_connection.credential_provider, StreamingCredentialProvider
+        ) and event.pubsub_connection.get_protocol() in [3, "3"]:
+            self._event = event
+            self._connection = event.pubsub_connection
+            self._connection_pool = event.connection_pool
+            self._client_type = event.client_type
+            self._connection_lock = event.connection_lock
+
+            if self._client_type == ClientType.SYNC:
+                self._connection.credential_provider.on_next(self._re_auth)
+                self._connection.credential_provider.on_error(self._raise_on_error)
+            else:
+                self._connection.credential_provider.on_next(self._re_auth_async)
+                self._connection.credential_provider.on_error(
+                    self._raise_on_error_async
+                )
+
+    def _re_auth(self, token: TokenInterface):
+        with self._connection_lock:
+            self._connection.send_command(
+                "AUTH", token.try_get("oid"), token.get_value()
+            )
+            self._connection.read_response()
+
+        self._connection_pool.re_auth_callback(token)
+
+    async def _re_auth_async(self, token: TokenInterface):
+        async with self._connection_lock:
+            await self._connection.send_command(
+                "AUTH", token.try_get("oid"), token.get_value()
+            )
+            await self._connection.read_response()
+
+        await self._connection_pool.re_auth_callback(token)
+
+    def _raise_on_error(self, error: Exception):
+        raise EventException(error, self._event)
+
+    async def _raise_on_error_async(self, error: Exception):
+        raise EventException(error, self._event)

redis/typing.py

@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 
 
 Number = Union[int, float]
-EncodedT = Union[bytes, memoryview]
+EncodedT = Union[bytes, bytearray, memoryview]
 DecodedT = Union[str, int, float]
 EncodableT = Union[EncodedT, DecodedT]
 AbsExpiryT = Union[int, datetime]

redis/utils.py

@@ -122,6 +122,71 @@ def deprecated_function(reason="", version="", name=None):
     return decorator
 
 
+def warn_deprecated_arg_usage(
+    arg_name: Union[list, str],
+    function_name: str,
+    reason: str = "",
+    version: str = "",
+    stacklevel: int = 2,
+):
+    import warnings
+
+    msg = (
+        f"Call to '{function_name}' function with deprecated"
+        f" usage of input argument/s '{arg_name}'."
+    )
+    if reason:
+        msg += f" ({reason})"
+    if version:
+        msg += f" -- Deprecated since version {version}."
+    warnings.warn(msg, category=DeprecationWarning, stacklevel=stacklevel)
+
+
+def deprecated_args(
+    args_to_warn: list = ["*"],
+    allowed_args: list = [],
+    reason: str = "",
+    version: str = "",
+):
+    """
+    Decorator to mark specified args of a function as deprecated.
+    If '*' is in args_to_warn, all arguments will be marked as deprecated.
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # Get function argument names
+            arg_names = func.__code__.co_varnames[: func.__code__.co_argcount]
+
+            provided_args = dict(zip(arg_names, args))
+            provided_args.update(kwargs)
+
+            provided_args.pop("self", None)
+            for allowed_arg in allowed_args:
+                provided_args.pop(allowed_arg, None)
+
+            for arg in args_to_warn:
+                if arg == "*" and len(provided_args) > 0:
+                    warn_deprecated_arg_usage(
+                        list(provided_args.keys()),
+                        func.__name__,
+                        reason,
+                        version,
+                        stacklevel=3,
+                    )
+                elif arg in provided_args:
+                    warn_deprecated_arg_usage(
+                        arg, func.__name__, reason, version, stacklevel=3
+                    )
+
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
 def _set_info_logger():
     """
     Set up a logger that log info logs to stdout.

{redis-5.2.1.dist-info → redis-5.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis
-Version: 5.2.1
+Version: 5.3.0
 Summary: Python client for Redis database and key-value store
 Home-page: https://github.com/redis/redis-py
 Author: Redis Inc.
@@ -30,6 +30,7 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: PyJWT~=2.9.0
 Requires-Dist: async-timeout>=4.0.3; python_full_version < "3.11.3"
 Provides-Extra: hiredis
 Requires-Dist: hiredis>=3.0.0; extra == "hiredis"

{redis-5.2.1.dist-info → redis-5.3.0.dist-info}/RECORD

@@ -1,19 +1,20 @@
 redis/__init__.py,sha256=WlARnwwst8oaEyjXV5XTcmSGyEKVCn3S9N1MrHyJ8U8,2015
-redis/backoff.py,sha256=N2CZXkB3cdoHeMZ01r0zVry0bRKe8mk0ybi8hE7PvzU,3177
+redis/backoff.py,sha256=d22h74LEatJiFd_5o8HvFW3biFBotYOFZHddHt45ydc,3663
 redis/cache.py,sha256=68rJDNogvNwgdgBel6zSX9QziL11qsKIMhmvQvHvznM,9549
-redis/client.py,sha256=HbcVPvRKOA8Hd6zeMmmU7eAJ9xkSX9oqLR0ZW7r5AHI,59101
-redis/cluster.py,sha256=ECId2H3NdWmxktcHWRk1lWHFgRMipdj143i26xaNhaU,94317
-redis/connection.py,sha256=xjd9mfHGR6s0EoF80Rz1EWdzA8aBkYLI2XDhL4UGdhI,62323
+redis/client.py,sha256=5KynKSwVK7YPKWwOItEfNpJsVlu_oSchm2lNc_xJnVc,61733
+redis/cluster.py,sha256=YzGkte85bSJOYeqs_WESFam_gtaWgEZ6CijPIdldVis,99287
+redis/connection.py,sha256=sZiKny4EQ8BtReUYtB4zBQ5D3Tk0SOjbjD3j56jrb0g,65270
 redis/crc.py,sha256=Z3kXFtkY2LdgefnQMud1xr4vG5UYvA9LCMqNMX1ywu4,729
-redis/credentials.py,sha256=6VvFeReFp6vernGIWlIVOm8OmbNgoFYdd1wgsjZTnlk,738
+redis/credentials.py,sha256=GOnO3-LSW34efHaIrUbS742Mw8l70mRzF6UrKiKZsMY,1828
+redis/event.py,sha256=urOK241IdgmCQ3fq7GqXRstZ2vcXRV14bBBMdN3latk,12129
 redis/exceptions.py,sha256=OmOGoS9EPInuTZPJT0BuDeIYuYrtRGEUT_Pu6NtEQNI,5211
 redis/lock.py,sha256=3JOC3AmYJ10zbq0blOtV4uNwuEhw4K7xuJ6nM-qv5Ig,11976
 redis/ocsp.py,sha256=4b1s43x-DJ859zRKtwGTIbNys_dyGv5YyOdWnOvigyM,11451
 redis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 redis/retry.py,sha256=JiIDxeD890vgi_me8pwypO1LixwhU0Fv3A5NEay8SAY,2206
 redis/sentinel.py,sha256=ya1aPeAvUcY9qXMSpV_wA3081vUqkIqcyXG9SqAvU88,14661
-redis/typing.py,sha256=skQl2VuyL7fPpg2BRDlGYMmwDQ2BLwwxxR8u_V1Kbm4,2138
-redis/utils.py,sha256=oTonIc6DbbB-ZT-mL14ChhcFk2y4qnK3UNORMKPj2oI,4787
+redis/typing.py,sha256=k7F_3Vtsexeb7mUl6txlwrY1veGDLEhtcHe9FwIJOOo,2149
+redis/utils.py,sha256=ErCe0V4nMTWTfeCI1Pg6X3WZeuxG0E-AirsI1AYaGF4,6664
 redis/_parsers/__init__.py,sha256=qkfgV2X9iyvQAvbLdSelwgz0dCk9SGAosCvuZC9-qDc,550
 redis/_parsers/base.py,sha256=0j3qIhLjQZOzYGc4n1IesNegckomVhvDsEZD6-yb3Ns,7475
 redis/_parsers/commands.py,sha256=pmR4hl4u93UvCmeDgePHFc6pWDr4slrKEvCsdMmtj_M,11052
@@ -24,13 +25,18 @@ redis/_parsers/resp2.py,sha256=f22kH-_ZP2iNtOn6xOe65MSy_fJpu8OEn1u_hgeeojI,4813
 redis/_parsers/resp3.py,sha256=jHtL1LYJegJ_LiNTsjzIvS-kZyNR58jZ_YV4cRfwuN0,11127
 redis/_parsers/socket.py,sha256=CKD8QW_wFSNlIZzxlbNduaGpiv0I8wBcsGuAIojDfJg,5403
 redis/asyncio/__init__.py,sha256=uoDD8XYVi0Kj6mcufYwLDUTQXmBRx7a0bhKF9stZr7I,1489
-redis/asyncio/client.py,sha256=WIkebQoxn8GUMv2UmhQ4s81Cal6INwMc5mUohfNSTRk,59630
-redis/asyncio/cluster.py,sha256=qgBglEl7410K5M1CJxPH1-G3Mv2ed-S134uSJ2mmxng,63177
-redis/asyncio/connection.py,sha256=sErywuQxjauJVB5rx2P1AsEKD0T2Z9sTyfzF2ekrIp8,45061
+redis/asyncio/client.py,sha256=Ef2yknTMQrTJ0bvi3-4payHGsDqU0cRZLytHrPxHNuE,61016
+redis/asyncio/cluster.py,sha256=4uV8uTRDFeAY25BbgagX1ykwnPLMuXzOtxzUH5SC8Q0,66922
+redis/asyncio/connection.py,sha256=NKzj0LNn27ZR9A4sh3KtOiPuKkFwujc9dTegodHaHAo,47512
 redis/asyncio/lock.py,sha256=lLasXEO2E1CskhX5ZZoaSGpmwZP1Q782R3HAUNG3wD4,11967
 redis/asyncio/retry.py,sha256=SnPPOlo5gcyIFtkC4DY7HFvmDgUaILsJ3DeHioogdB8,2219
 redis/asyncio/sentinel.py,sha256=QBpsrdlhZlFqENy_rK1IuasSicox55_xSvP_IywbhbQ,14293
 redis/asyncio/utils.py,sha256=Yxc5YQumhLjtDDwCS4mgxI6yy2Z21AzLlFxVbxCohic,704
+redis/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+redis/auth/err.py,sha256=WYkbuDIzwp1S-eAvsya6QMlO6g9QIXbzMITOsTWX0xk,694
+redis/auth/idp.py,sha256=IMDIIb9q72vbIwtFN8vPdaAKZVTdh0HuC5uj5ufqmw4,631
+redis/auth/token.py,sha256=DslJx_wN8yPcrmcF-Ui8E5emcamP6OUwi9PTGSvsXQw,3125
+redis/auth/token_manager.py,sha256=ShBsYXiBZBJBOMB_Y-pXfLwEOAmc9s1okaCECinNZ7g,12018
 redis/commands/__init__.py,sha256=cTUH-MGvaLYS0WuoytyqtN1wniw2A1KbkUXcpvOSY3I,576
 redis/commands/cluster.py,sha256=BBHSyXfl3OETIJs4JC5DrcfzqgF2Kt4WMEcd0WMILOU,31598
 redis/commands/core.py,sha256=YlCzD44YJnFzdEKIFDBloPh1ivgHKcFMZsxPzamE9JM,238528
@@ -69,8 +75,8 @@ redis/commands/timeseries/__init__.py,sha256=gkz6wshEzzQQryBOnrAqqQzttS-AHfXmuN_
 redis/commands/timeseries/commands.py,sha256=8Z2BEyP23qTYCJR_e9zdG11yWmIDwGBMO2PJNLtK2BA,47147
 redis/commands/timeseries/info.py,sha256=meZYdu7IV9KaUWMKZs9qW4vo3Q9MwhdY-EBtKQzls5o,3223
 redis/commands/timeseries/utils.py,sha256=NLwSOS5Dz9N8dYQSzEyBIvrItOWwfQ0xgDj8un6x3dU,1319
-redis-5.2.1.dist-info/LICENSE,sha256=pXslClvwPXr-VbdAYzE_Ktt7ANVGwKsUmok5gzP-PMg,1074
-redis-5.2.1.dist-info/METADATA,sha256=BPiJh0sxEzBec911KAZAZ0fbCI4gF46NBvYbMV0Xeco,9138
-redis-5.2.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-redis-5.2.1.dist-info/top_level.txt,sha256=OMAefszlde6ZoOtlM35AWzpRIrwtcqAMHGlRit-w2-4,6
-redis-5.2.1.dist-info/RECORD,,
+redis-5.3.0.dist-info/LICENSE,sha256=pXslClvwPXr-VbdAYzE_Ktt7ANVGwKsUmok5gzP-PMg,1074
+redis-5.3.0.dist-info/METADATA,sha256=ql3ziX3Hi71hXv26oLIMfFNqOCfAMtA8izDvb-NHQvI,9166
+redis-5.3.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+redis-5.3.0.dist-info/top_level.txt,sha256=OMAefszlde6ZoOtlM35AWzpRIrwtcqAMHGlRit-w2-4,6
+redis-5.3.0.dist-info/RECORD,,