Add REPLICA aliases for deprecated SLAVE terminology in Sentinel (#3817)

Redis 5.0 deprecated SLAVE in favor of REPLICA. This adds aliases for
the Sentinel APIs to match the modern Redis terminology:

- ReplicaNotFoundError (alias for SlaveNotFoundError)
- Sentinel.replica_for() (alias for slave_for())
- Sentinel.discover_replicas() (alias for discover_slaves())
- Sentinel.filter_replicas() (alias for filter_slaves())
- SentinelConnectionPool.rotate_replicas() (alias for rotate_slaves())

Both sync and async implementations are updated.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: majiayu000

redis/asyncio/sentinel.py

@@ -27,6 +27,10 @@ class SlaveNotFoundError(ConnectionError):
     pass
 
 
+# Alias for REPLICA terminology (Redis 5.0+)
+ReplicaNotFoundError = SlaveNotFoundError
+
+
 class SentinelManagedConnection(Connection):
     def __init__(self, **kwargs):
         self.connection_pool = kwargs.pop("connection_pool")
@@ -166,6 +170,11 @@ async def rotate_slaves(self) -> AsyncIterator:
             pass
         raise SlaveNotFoundError(f"No slave found for {self.service_name!r}")
 
+    async def rotate_replicas(self) -> AsyncIterator:
+        """Round-robin replica balancer"""
+        async for replica in self.rotate_slaves():
+            yield replica
+
 
 class Sentinel(AsyncSentinelCommands):
     """
@@ -318,6 +327,12 @@ def filter_slaves(
             slaves_alive.append((slave["ip"], slave["port"]))
         return slaves_alive
 
+    def filter_replicas(
+        self, replicas: Iterable[Mapping]
+    ) -> Sequence[Tuple[EncodableT, EncodableT]]:
+        """Remove replicas that are in an ODOWN or SDOWN state"""
+        return self.filter_slaves(replicas)
+
     async def discover_slaves(
         self, service_name: str
     ) -> Sequence[Tuple[EncodableT, EncodableT]]:
@@ -332,6 +347,12 @@ async def discover_slaves(
                 return slaves
         return []
 
+    async def discover_replicas(
+        self, service_name: str
+    ) -> Sequence[Tuple[EncodableT, EncodableT]]:
+        """Returns a list of alive replicas for service ``service_name``"""
+        return await self.discover_slaves(service_name)
+
     def master_for(
         self,
         service_name: str,
@@ -402,3 +423,34 @@ def slave_for(
         connection_pool = connection_pool_class(service_name, self, **connection_kwargs)
         # The Redis object "owns" the pool
         return redis_class.from_pool(connection_pool)
+
+    def replica_for(
+        self,
+        service_name: str,
+        redis_class: Type[Redis] = Redis,
+        connection_pool_class: Type[SentinelConnectionPool] = SentinelConnectionPool,
+        **kwargs,
+    ):
+        """
+        Returns redis client instance for the ``service_name`` replica(s).
+
+        A SentinelConnectionPool class is used to retrieve the replica's
+        address before establishing a new connection.
+
+        By default clients will be a :py:class:`~redis.Redis` instance.
+        Specify a different class to the ``redis_class`` argument if you
+        desire something different.
+
+        The ``connection_pool_class`` specifies the connection pool to use.
+        The SentinelConnectionPool will be used by default.
+
+        All other keyword arguments are merged with any connection_kwargs
+        passed to this class and passed to the connection pool as keyword
+        arguments to be used to initialize Redis connections.
+        """
+        return self.slave_for(
+            service_name,
+            redis_class=redis_class,
+            connection_pool_class=connection_pool_class,
+            **kwargs,
+        )

redis/sentinel.py

@@ -21,6 +21,10 @@ class SlaveNotFoundError(ConnectionError):
     pass
 
 
+# Alias for REPLICA terminology (Redis 5.0+)
+ReplicaNotFoundError = SlaveNotFoundError
+
+
 class SentinelManagedConnection(Connection):
     def __init__(self, **kwargs):
         self.connection_pool = kwargs.pop("connection_pool")
@@ -198,6 +202,10 @@ def rotate_slaves(self):
         "Round-robin slave balancer"
         return self.proxy.rotate_slaves()
 
+    def rotate_replicas(self):
+        "Round-robin replica balancer"
+        return self.rotate_slaves()
+
 
 class Sentinel(SentinelCommands):
     """
@@ -343,6 +351,10 @@ def filter_slaves(self, slaves):
             slaves_alive.append((slave["ip"], slave["port"]))
         return slaves_alive
 
+    def filter_replicas(self, replicas):
+        "Remove replicas that are in an ODOWN or SDOWN state"
+        return self.filter_slaves(replicas)
+
     def discover_slaves(self, service_name):
         "Returns a list of alive slaves for service ``service_name``"
         for sentinel in self.sentinels:
@@ -355,6 +367,10 @@ def discover_slaves(self, service_name):
                 return slaves
         return []
 
+    def discover_replicas(self, service_name):
+        "Returns a list of alive replicas for service ``service_name``"
+        return self.discover_slaves(service_name)
+
     def master_for(
         self,
         service_name,
@@ -423,3 +439,34 @@ def slave_for(
         return redis_class.from_pool(
             connection_pool_class(service_name, self, **connection_kwargs)
         )
+
+    def replica_for(
+        self,
+        service_name,
+        redis_class=Redis,
+        connection_pool_class=SentinelConnectionPool,
+        **kwargs,
+    ):
+        """
+        Returns redis client instance for the ``service_name`` replica(s).
+
+        A SentinelConnectionPool class is used to retrieve the replica's
+        address before establishing a new connection.
+
+        By default clients will be a :py:class:`~redis.Redis` instance.
+        Specify a different class to the ``redis_class`` argument if you
+        desire something different.
+
+        The ``connection_pool_class`` specifies the connection pool to use.
+        The SentinelConnectionPool will be used by default.
+
+        All other keyword arguments are merged with any connection_kwargs
+        passed to this class and passed to the connection pool as keyword
+        arguments to be used to initialize Redis connections.
+        """
+        return self.slave_for(
+            service_name,
+            redis_class=redis_class,
+            connection_pool_class=connection_pool_class,
+            **kwargs,
+        )