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

redis/connection.py

@@ -22,8 +22,10 @@ from redis.cache import (
 )
 
 from ._parsers import Encoder, _HiredisParser, _RESP2Parser, _RESP3Parser
+from .auth.token import TokenInterface
 from .backoff import NoBackoff
 from .credentials import CredentialProvider, UsernamePasswordCredentialProvider
+from .event import AfterConnectionReleasedEvent, EventDispatcher
 from .exceptions import (
     AuthenticationError,
     AuthenticationWrongNumberOfArgsError,
@@ -151,6 +153,10 @@ class ConnectionInterface:
     def set_parser(self, parser_class):
         pass
 
+    @abstractmethod
+    def get_protocol(self):
+        pass
+
     @abstractmethod
     def connect(self):
         pass
@@ -202,6 +208,14 @@ class ConnectionInterface:
     def handshake_metadata(self) -> Union[Dict[bytes, bytes], Dict[str, str]]:
         pass
 
+    @abstractmethod
+    def set_re_auth_token(self, token: TokenInterface):
+        pass
+
+    @abstractmethod
+    def re_auth(self):
+        pass
+
 
 class AbstractConnection(ConnectionInterface):
     "Manages communication to and from a Redis server"
@@ -229,6 +243,7 @@ class AbstractConnection(ConnectionInterface):
         credential_provider: Optional[CredentialProvider] = None,
         protocol: Optional[int] = 2,
         command_packer: Optional[Callable[[], None]] = None,
+        event_dispatcher: Optional[EventDispatcher] = None,
     ):
         """
         Initialize a new Connection.
@@ -244,6 +259,10 @@ class AbstractConnection(ConnectionInterface):
                 "1. 'password' and (optional) 'username'\n"
                 "2. 'credential_provider'"
             )
+        if event_dispatcher is None:
+            self._event_dispatcher = EventDispatcher()
+        else:
+            self._event_dispatcher = event_dispatcher
         self.pid = os.getpid()
         self.db = db
         self.client_name = client_name
@@ -283,6 +302,7 @@ class AbstractConnection(ConnectionInterface):
         self.set_parser(parser_class)
         self._connect_callbacks = []
         self._buffer_cutoff = 6000
+        self._re_auth_token: Optional[TokenInterface] = None
         try:
             p = int(protocol)
         except TypeError:
@@ -663,6 +683,19 @@ class AbstractConnection(ConnectionInterface):
     def handshake_metadata(self, value: Union[Dict[bytes, bytes], Dict[str, str]]):
         self._handshake_metadata = value
 
+    def set_re_auth_token(self, token: TokenInterface):
+        self._re_auth_token = token
+
+    def re_auth(self):
+        if self._re_auth_token is not None:
+            self.send_command(
+                "AUTH",
+                self._re_auth_token.try_get("oid"),
+                self._re_auth_token.get_value(),
+            )
+            self.read_response()
+            self._re_auth_token = None
+
 
 class Connection(AbstractConnection):
     "Manages TCP communication to and from a Redis server"
@@ -750,6 +783,7 @@ class CacheProxyConnection(ConnectionInterface):
         self.retry = self._conn.retry
         self.host = self._conn.host
         self.port = self._conn.port
+        self.credential_provider = conn.credential_provider
         self._pool_lock = pool_lock
         self._cache = cache
         self._cache_lock = threading.Lock()
@@ -933,6 +967,15 @@ class CacheProxyConnection(ConnectionInterface):
             else:
                 self._cache.delete_by_redis_keys(data[1])
 
+    def get_protocol(self):
+        return self._conn.get_protocol()
+
+    def set_re_auth_token(self, token: TokenInterface):
+        self._conn.set_re_auth_token(token)
+
+    def re_auth(self):
+        self._conn.re_auth()
+
 
 class SSLConnection(Connection):
     """Manages SSL connections to and from the Redis server(s).
@@ -1318,6 +1361,10 @@ class ConnectionPool:
         connection_kwargs.pop("cache", None)
         connection_kwargs.pop("cache_config", None)
 
+        self._event_dispatcher = self.connection_kwargs.get("event_dispatcher", None)
+        if self._event_dispatcher is None:
+            self._event_dispatcher = EventDispatcher()
+
         # a lock to protect the critical section in _checkpid().
         # this lock is acquired when the process id changes, such as
         # after a fork. during this time, multiple threads in the child
@@ -1475,6 +1522,9 @@ class ConnectionPool:
 
             if self.owns_connection(connection):
                 self._available_connections.append(connection)
+                self._event_dispatcher.dispatch(
+                    AfterConnectionReleasedEvent(connection)
+                )
             else:
                 # pool doesn't own this connection. do not add it back
                 # to the pool and decrement the count so that another
@@ -1517,6 +1567,29 @@ class ConnectionPool:
         for conn in self._in_use_connections:
             conn.retry = retry
 
+    def re_auth_callback(self, token: TokenInterface):
+        with self._lock:
+            for conn in self._available_connections:
+                conn.retry.call_with_retry(
+                    lambda: conn.send_command(
+                        "AUTH", token.try_get("oid"), token.get_value()
+                    ),
+                    lambda error: self._mock(error),
+                )
+                conn.retry.call_with_retry(
+                    lambda: conn.read_response(), lambda error: self._mock(error)
+                )
+            for conn in self._in_use_connections:
+                conn.set_re_auth_token(token)
+
+    async def _mock(self, error: RedisError):
+        """
+        Dummy functions, needs to be passed as error callback to retry object.
+        :param error:
+        :return:
+        """
+        pass
+
 
 class BlockingConnectionPool(ConnectionPool):
     """

redis/credentials.py

@@ -1,4 +1,8 @@
-from typing import Optional, Tuple, Union
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Callable, Optional, Tuple, Union
+
+logger = logging.getLogger(__name__)
 
 
 class CredentialProvider:
@@ -9,6 +13,38 @@ class CredentialProvider:
     def get_credentials(self) -> Union[Tuple[str], Tuple[str, str]]:
         raise NotImplementedError("get_credentials must be implemented")
 
+    async def get_credentials_async(self) -> Union[Tuple[str], Tuple[str, str]]:
+        logger.warning(
+            "This method is added for backward compatability. "
+            "Please override it in your implementation."
+        )
+        return self.get_credentials()
+
+
+class StreamingCredentialProvider(CredentialProvider, ABC):
+    """
+    Credential provider that streams credentials in the background.
+    """
+
+    @abstractmethod
+    def on_next(self, callback: Callable[[Any], None]):
+        """
+        Specifies the callback that should be invoked
+        when the next credentials will be retrieved.
+
+        :param callback: Callback with
+        :return:
+        """
+        pass
+
+    @abstractmethod
+    def on_error(self, callback: Callable[[Exception], None]):
+        pass
+
+    @abstractmethod
+    def is_streaming(self) -> bool:
+        pass
+
 
 class UsernamePasswordCredentialProvider(CredentialProvider):
     """
@@ -24,3 +60,6 @@ class UsernamePasswordCredentialProvider(CredentialProvider):
         if self.username:
             return self.username, self.password
         return (self.password,)
+
+    async def get_credentials_async(self) -> Union[Tuple[str], Tuple[str, str]]:
+        return self.get_credentials()

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-5.2.1.dist-info → redis-5.3.0b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis
-Version: 5.2.1
+Version: 5.3.0b3
 Summary: Python client for Redis database and key-value store
 Home-page: https://github.com/redis/redis-py
 Author: Redis Inc.

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

@@ -1,11 +1,12 @@
 redis/__init__.py,sha256=WlARnwwst8oaEyjXV5XTcmSGyEKVCn3S9N1MrHyJ8U8,2015
 redis/backoff.py,sha256=N2CZXkB3cdoHeMZ01r0zVry0bRKe8mk0ybi8hE7PvzU,3177
 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=MMDn5Qh6rcBx2sDFU4O_Jid5TdzhA3-91_sxzmOBWAM,61055
+redis/cluster.py,sha256=4UBn9HoGjKGUZ-ILROSVw-4I3Kg_9YW8r0X4COKwPsI,95882
+redis/connection.py,sha256=UXrGt2T_1ebCGnpTmIzafZRLiZyqMJi4LOsRFkaFVHU,64750
 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
@@ -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=xxifh7JrWJkSPpbem1qVXV6sCvAQRlq4VCYrkj84yvQ,61176
+redis/asyncio/cluster.py,sha256=c3dhOQjMUdXQO0WJCOn6-DTPxk-mbcgw52OpiSDrfG8,65243
+redis/asyncio/connection.py,sha256=w4yYr2Pzx_8Q7uJbeEyqZrjrqBpXaEZFYHZC5Zuv5HA,47203
 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.0b3.dist-info/LICENSE,sha256=pXslClvwPXr-VbdAYzE_Ktt7ANVGwKsUmok5gzP-PMg,1074
+redis-5.3.0b3.dist-info/METADATA,sha256=-wR2WJlqo5dVm6xSA2HiBdbI5Sawtc5hwKdce1OhOms,9140
+redis-5.3.0b3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+redis-5.3.0b3.dist-info/top_level.txt,sha256=OMAefszlde6ZoOtlM35AWzpRIrwtcqAMHGlRit-w2-4,6
+redis-5.3.0b3.dist-info/RECORD,,