# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
import warnings

from . import redis_service_pb2 as redis__service__pb2

GRPC_GENERATED_VERSION = '1.75.1'
GRPC_VERSION = grpc.__version__
_version_not_supported = False

try:
    from grpc._utilities import first_version_is_lower
    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    raise RuntimeError(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + f' but the generated code in redis_service_pb2_grpc.py depends on'
        + f' grpcio>={GRPC_GENERATED_VERSION}.'
        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
    )


class RedisServiceStub(object):
    """========================================
    Redis 缓存服务
    ========================================
    这是一个统一的缓存服务，为所有后端服务提供缓存和会话管理能力
    支持：
    - 用户和组织级别的命名空间隔离
    - String、Hash、List、Set、Sorted Set 操作
    - 分布式锁
    - Pub/Sub 消息
    - 过期时间管理
    - 批量操作

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.Set = channel.unary_unary(
                '/isa.redis.RedisService/Set',
                request_serializer=redis__service__pb2.SetRequest.SerializeToString,
                response_deserializer=redis__service__pb2.SetResponse.FromString,
                _registered_method=True)
        self.Get = channel.unary_unary(
                '/isa.redis.RedisService/Get',
                request_serializer=redis__service__pb2.GetRequest.SerializeToString,
                response_deserializer=redis__service__pb2.GetResponse.FromString,
                _registered_method=True)
        self.GetMultiple = channel.unary_unary(
                '/isa.redis.RedisService/GetMultiple',
                request_serializer=redis__service__pb2.GetMultipleRequest.SerializeToString,
                response_deserializer=redis__service__pb2.GetMultipleResponse.FromString,
                _registered_method=True)
        self.SetWithExpiration = channel.unary_unary(
                '/isa.redis.RedisService/SetWithExpiration',
                request_serializer=redis__service__pb2.SetWithExpirationRequest.SerializeToString,
                response_deserializer=redis__service__pb2.SetResponse.FromString,
                _registered_method=True)
        self.Increment = channel.unary_unary(
                '/isa.redis.RedisService/Increment',
                request_serializer=redis__service__pb2.IncrementRequest.SerializeToString,
                response_deserializer=redis__service__pb2.IncrementResponse.FromString,
                _registered_method=True)
        self.Decrement = channel.unary_unary(
                '/isa.redis.RedisService/Decrement',
                request_serializer=redis__service__pb2.DecrementRequest.SerializeToString,
                response_deserializer=redis__service__pb2.DecrementResponse.FromString,
                _registered_method=True)
        self.Append = channel.unary_unary(
                '/isa.redis.RedisService/Append',
                request_serializer=redis__service__pb2.AppendRequest.SerializeToString,
                response_deserializer=redis__service__pb2.AppendResponse.FromString,
                _registered_method=True)
        self.Delete = channel.unary_unary(
                '/isa.redis.RedisService/Delete',
                request_serializer=redis__service__pb2.DeleteRequest.SerializeToString,
                response_deserializer=redis__service__pb2.DeleteResponse.FromString,
                _registered_method=True)
        self.DeleteMultiple = channel.unary_unary(
                '/isa.redis.RedisService/DeleteMultiple',
                request_serializer=redis__service__pb2.DeleteMultipleRequest.SerializeToString,
                response_deserializer=redis__service__pb2.DeleteResponse.FromString,
                _registered_method=True)
        self.Exists = channel.unary_unary(
                '/isa.redis.RedisService/Exists',
                request_serializer=redis__service__pb2.ExistsRequest.SerializeToString,
                response_deserializer=redis__service__pb2.ExistsResponse.FromString,
                _registered_method=True)
        self.Expire = channel.unary_unary(
                '/isa.redis.RedisService/Expire',
                request_serializer=redis__service__pb2.ExpireRequest.SerializeToString,
                response_deserializer=redis__service__pb2.ExpireResponse.FromString,
                _registered_method=True)
        self.GetTTL = channel.unary_unary(
                '/isa.redis.RedisService/GetTTL',
                request_serializer=redis__service__pb2.GetTTLRequest.SerializeToString,
                response_deserializer=redis__service__pb2.GetTTLResponse.FromString,
                _registered_method=True)
        self.Rename = channel.unary_unary(
                '/isa.redis.RedisService/Rename',
                request_serializer=redis__service__pb2.RenameRequest.SerializeToString,
                response_deserializer=redis__service__pb2.RenameResponse.FromString,
                _registered_method=True)
        self.ListKeys = channel.unary_unary(
                '/isa.redis.RedisService/ListKeys',
                request_serializer=redis__service__pb2.ListKeysRequest.SerializeToString,
                response_deserializer=redis__service__pb2.ListKeysResponse.FromString,
                _registered_method=True)
        self.HSet = channel.unary_unary(
                '/isa.redis.RedisService/HSet',
                request_serializer=redis__service__pb2.HSetRequest.SerializeToString,
                response_deserializer=redis__service__pb2.HSetResponse.FromString,
                _registered_method=True)
        self.HGet = channel.unary_unary(
                '/isa.redis.RedisService/HGet',
                request_serializer=redis__service__pb2.HGetRequest.SerializeToString,
                response_deserializer=redis__service__pb2.HGetResponse.FromString,
                _registered_method=True)
        self.HGetAll = channel.unary_unary(
                '/isa.redis.RedisService/HGetAll',
                request_serializer=redis__service__pb2.HGetAllRequest.SerializeToString,
                response_deserializer=redis__service__pb2.HGetAllResponse.FromString,
                _registered_method=True)
        self.HDelete = channel.unary_unary(
                '/isa.redis.RedisService/HDelete',
                request_serializer=redis__service__pb2.HDeleteRequest.SerializeToString,
                response_deserializer=redis__service__pb2.HDeleteResponse.FromString,
                _registered_method=True)
        self.HExists = channel.unary_unary(
                '/isa.redis.RedisService/HExists',
                request_serializer=redis__service__pb2.HExistsRequest.SerializeToString,
                response_deserializer=redis__service__pb2.HExistsResponse.FromString,
                _registered_method=True)
        self.HKeys = channel.unary_unary(
                '/isa.redis.RedisService/HKeys',
                request_serializer=redis__service__pb2.HKeysRequest.SerializeToString,
                response_deserializer=redis__service__pb2.HKeysResponse.FromString,
                _registered_method=True)
        self.HValues = channel.unary_unary(
                '/isa.redis.RedisService/HValues',
                request_serializer=redis__service__pb2.HValuesRequest.SerializeToString,
                response_deserializer=redis__service__pb2.HValuesResponse.FromString,
                _registered_method=True)
        self.HIncrement = channel.unary_unary(
                '/isa.redis.RedisService/HIncrement',
                request_serializer=redis__service__pb2.HIncrementRequest.SerializeToString,
                response_deserializer=redis__service__pb2.HIncrementResponse.FromString,
                _registered_method=True)
        self.LPush = channel.unary_unary(
                '/isa.redis.RedisService/LPush',
                request_serializer=redis__service__pb2.LPushRequest.SerializeToString,
                response_deserializer=redis__service__pb2.LPushResponse.FromString,
                _registered_method=True)
        self.RPush = channel.unary_unary(
                '/isa.redis.RedisService/RPush',
                request_serializer=redis__service__pb2.RPushRequest.SerializeToString,
                response_deserializer=redis__service__pb2.RPushResponse.FromString,
                _registered_method=True)
        self.LPop = channel.unary_unary(
                '/isa.redis.RedisService/LPop',
                request_serializer=redis__service__pb2.LPopRequest.SerializeToString,
                response_deserializer=redis__service__pb2.LPopResponse.FromString,
                _registered_method=True)
        self.RPop = channel.unary_unary(
                '/isa.redis.RedisService/RPop',
                request_serializer=redis__service__pb2.RPopRequest.SerializeToString,
                response_deserializer=redis__service__pb2.RPopResponse.FromString,
                _registered_method=True)
        self.LRange = channel.unary_unary(
                '/isa.redis.RedisService/LRange',
                request_serializer=redis__service__pb2.LRangeRequest.SerializeToString,
                response_deserializer=redis__service__pb2.LRangeResponse.FromString,
                _registered_method=True)
        self.LLen = channel.unary_unary(
                '/isa.redis.RedisService/LLen',
                request_serializer=redis__service__pb2.LLenRequest.SerializeToString,
                response_deserializer=redis__service__pb2.LLenResponse.FromString,
                _registered_method=True)
        self.LIndex = channel.unary_unary(
                '/isa.redis.RedisService/LIndex',
                request_serializer=redis__service__pb2.LIndexRequest.SerializeToString,
                response_deserializer=redis__service__pb2.LIndexResponse.FromString,
                _registered_method=True)
        self.LTrim = channel.unary_unary(
                '/isa.redis.RedisService/LTrim',
                request_serializer=redis__service__pb2.LTrimRequest.SerializeToString,
                response_deserializer=redis__service__pb2.LTrimResponse.FromString,
                _registered_method=True)
        self.SAdd = channel.unary_unary(
                '/isa.redis.RedisService/SAdd',
                request_serializer=redis__service__pb2.SAddRequest.SerializeToString,
                response_deserializer=redis__service__pb2.SAddResponse.FromString,
                _registered_method=True)
        self.SRemove = channel.unary_unary(
                '/isa.redis.RedisService/SRemove',
                request_serializer=redis__service__pb2.SRemoveRequest.SerializeToString,
                response_deserializer=redis__service__pb2.SRemoveResponse.FromString,
                _registered_method=True)
        self.SMembers = channel.unary_unary(
                '/isa.redis.RedisService/SMembers',
                request_serializer=redis__service__pb2.SMembersRequest.SerializeToString,
                response_deserializer=redis__service__pb2.SMembersResponse.FromString,
                _registered_method=True)
        self.SIsMember = channel.unary_unary(
                '/isa.redis.RedisService/SIsMember',
                request_serializer=redis__service__pb2.SIsMemberRequest.SerializeToString,
                response_deserializer=redis__service__pb2.SIsMemberResponse.FromString,
                _registered_method=True)
        self.SCard = channel.unary_unary(
                '/isa.redis.RedisService/SCard',
                request_serializer=redis__service__pb2.SCardRequest.SerializeToString,
                response_deserializer=redis__service__pb2.SCardResponse.FromString,
                _registered_method=True)
        self.SUnion = channel.unary_unary(
                '/isa.redis.RedisService/SUnion',
                request_serializer=redis__service__pb2.SUnionRequest.SerializeToString,
                response_deserializer=redis__service__pb2.SUnionResponse.FromString,
                _registered_method=True)
        self.SInter = channel.unary_unary(
                '/isa.redis.RedisService/SInter',
                request_serializer=redis__service__pb2.SInterRequest.SerializeToString,
                response_deserializer=redis__service__pb2.SInterResponse.FromString,
                _registered_method=True)
        self.SDiff = channel.unary_unary(
                '/isa.redis.RedisService/SDiff',
                request_serializer=redis__service__pb2.SDiffRequest.SerializeToString,
                response_deserializer=redis__service__pb2.SDiffResponse.FromString,
                _registered_method=True)
        self.ZAdd = channel.unary_unary(
                '/isa.redis.RedisService/ZAdd',
                request_serializer=redis__service__pb2.ZAddRequest.SerializeToString,
                response_deserializer=redis__service__pb2.ZAddResponse.FromString,
                _registered_method=True)
        self.ZRemove = channel.unary_unary(
                '/isa.redis.RedisService/ZRemove',
                request_serializer=redis__service__pb2.ZRemoveRequest.SerializeToString,
                response_deserializer=redis__service__pb2.ZRemoveResponse.FromString,
                _registered_method=True)
        self.ZRange = channel.unary_unary(
                '/isa.redis.RedisService/ZRange',
                request_serializer=redis__service__pb2.ZRangeRequest.SerializeToString,
                response_deserializer=redis__service__pb2.ZRangeResponse.FromString,
                _registered_method=True)
        self.ZRangeByScore = channel.unary_unary(
                '/isa.redis.RedisService/ZRangeByScore',
                request_serializer=redis__service__pb2.ZRangeByScoreRequest.SerializeToString,
                response_deserializer=redis__service__pb2.ZRangeByScoreResponse.FromString,
                _registered_method=True)
        self.ZRank = channel.unary_unary(
                '/isa.redis.RedisService/ZRank',
                request_serializer=redis__service__pb2.ZRankRequest.SerializeToString,
                response_deserializer=redis__service__pb2.ZRankResponse.FromString,
                _registered_method=True)
        self.ZScore = channel.unary_unary(
                '/isa.redis.RedisService/ZScore',
                request_serializer=redis__service__pb2.ZScoreRequest.SerializeToString,
                response_deserializer=redis__service__pb2.ZScoreResponse.FromString,
                _registered_method=True)
        self.ZCard = channel.unary_unary(
                '/isa.redis.RedisService/ZCard',
                request_serializer=redis__service__pb2.ZCardRequest.SerializeToString,
                response_deserializer=redis__service__pb2.ZCardResponse.FromString,
                _registered_method=True)
        self.ZIncrement = channel.unary_unary(
                '/isa.redis.RedisService/ZIncrement',
                request_serializer=redis__service__pb2.ZIncrementRequest.SerializeToString,
                response_deserializer=redis__service__pb2.ZIncrementResponse.FromString,
                _registered_method=True)
        self.AcquireLock = channel.unary_unary(
                '/isa.redis.RedisService/AcquireLock',
                request_serializer=redis__service__pb2.AcquireLockRequest.SerializeToString,
                response_deserializer=redis__service__pb2.AcquireLockResponse.FromString,
                _registered_method=True)
        self.ReleaseLock = channel.unary_unary(
                '/isa.redis.RedisService/ReleaseLock',
                request_serializer=redis__service__pb2.ReleaseLockRequest.SerializeToString,
                response_deserializer=redis__service__pb2.ReleaseLockResponse.FromString,
                _registered_method=True)
        self.RenewLock = channel.unary_unary(
                '/isa.redis.RedisService/RenewLock',
                request_serializer=redis__service__pb2.RenewLockRequest.SerializeToString,
                response_deserializer=redis__service__pb2.RenewLockResponse.FromString,
                _registered_method=True)
        self.Publish = channel.unary_unary(
                '/isa.redis.RedisService/Publish',
                request_serializer=redis__service__pb2.PublishRequest.SerializeToString,
                response_deserializer=redis__service__pb2.PublishResponse.FromString,
                _registered_method=True)
        self.Subscribe = channel.unary_stream(
                '/isa.redis.RedisService/Subscribe',
                request_serializer=redis__service__pb2.SubscribeRequest.SerializeToString,
                response_deserializer=redis__service__pb2.MessageResponse.FromString,
                _registered_method=True)
        self.Unsubscribe = channel.unary_unary(
                '/isa.redis.RedisService/Unsubscribe',
                request_serializer=redis__service__pb2.UnsubscribeRequest.SerializeToString,
                response_deserializer=redis__service__pb2.UnsubscribeResponse.FromString,
                _registered_method=True)
        self.ExecuteBatch = channel.unary_unary(
                '/isa.redis.RedisService/ExecuteBatch',
                request_serializer=redis__service__pb2.RedisBatchRequest.SerializeToString,
                response_deserializer=redis__service__pb2.RedisBatchResponse.FromString,
                _registered_method=True)
        self.CreateSession = channel.unary_unary(
                '/isa.redis.RedisService/CreateSession',
                request_serializer=redis__service__pb2.CreateSessionRequest.SerializeToString,
                response_deserializer=redis__service__pb2.CreateSessionResponse.FromString,
                _registered_method=True)
        self.GetSession = channel.unary_unary(
                '/isa.redis.RedisService/GetSession',
                request_serializer=redis__service__pb2.GetSessionRequest.SerializeToString,
                response_deserializer=redis__service__pb2.GetSessionResponse.FromString,
                _registered_method=True)
        self.UpdateSession = channel.unary_unary(
                '/isa.redis.RedisService/UpdateSession',
                request_serializer=redis__service__pb2.UpdateSessionRequest.SerializeToString,
                response_deserializer=redis__service__pb2.UpdateSessionResponse.FromString,
                _registered_method=True)
        self.DeleteSession = channel.unary_unary(
                '/isa.redis.RedisService/DeleteSession',
                request_serializer=redis__service__pb2.DeleteSessionRequest.SerializeToString,
                response_deserializer=redis__service__pb2.DeleteSessionResponse.FromString,
                _registered_method=True)
        self.ListSessions = channel.unary_unary(
                '/isa.redis.RedisService/ListSessions',
                request_serializer=redis__service__pb2.ListSessionsRequest.SerializeToString,
                response_deserializer=redis__service__pb2.ListSessionsResponse.FromString,
                _registered_method=True)
        self.GetStatistics = channel.unary_unary(
                '/isa.redis.RedisService/GetStatistics',
                request_serializer=redis__service__pb2.GetStatisticsRequest.SerializeToString,
                response_deserializer=redis__service__pb2.GetStatisticsResponse.FromString,
                _registered_method=True)
        self.GetKeyInfo = channel.unary_unary(
                '/isa.redis.RedisService/GetKeyInfo',
                request_serializer=redis__service__pb2.GetKeyInfoRequest.SerializeToString,
                response_deserializer=redis__service__pb2.GetKeyInfoResponse.FromString,
                _registered_method=True)
        self.HealthCheck = channel.unary_unary(
                '/isa.redis.RedisService/HealthCheck',
                request_serializer=redis__service__pb2.RedisHealthCheckRequest.SerializeToString,
                response_deserializer=redis__service__pb2.RedisHealthCheckResponse.FromString,
                _registered_method=True)


class RedisServiceServicer(object):
    """========================================
    Redis 缓存服务
    ========================================
    这是一个统一的缓存服务，为所有后端服务提供缓存和会话管理能力
    支持：
    - 用户和组织级别的命名空间隔离
    - String、Hash、List、Set、Sorted Set 操作
    - 分布式锁
    - Pub/Sub 消息
    - 过期时间管理
    - 批量操作

    """

    def Set(self, request, context):
        """========== 字符串操作 (String Operations) ==========
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Get(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetMultiple(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetWithExpiration(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Increment(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Decrement(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Append(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Delete(self, request, context):
        """========== 键操作 (Key Operations) ==========
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteMultiple(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Exists(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Expire(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetTTL(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Rename(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListKeys(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HSet(self, request, context):
        """========== 哈希操作 (Hash Operations) ==========
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HGet(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HGetAll(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HDelete(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HExists(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HKeys(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HValues(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HIncrement(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LPush(self, request, context):
        """========== 列表操作 (List Operations) ==========
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RPush(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LPop(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RPop(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LRange(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LLen(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LIndex(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LTrim(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SAdd(self, request, context):
        """========== 集合操作 (Set Operations) ==========
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SRemove(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SMembers(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SIsMember(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SCard(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SUnion(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SInter(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SDiff(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ZAdd(self, request, context):
        """========== 有序集合操作 (Sorted Set Operations) ==========
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ZRemove(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ZRange(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ZRangeByScore(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ZRank(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ZScore(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ZCard(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ZIncrement(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AcquireLock(self, request, context):
        """========== 分布式锁 (Distributed Lock) ==========
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReleaseLock(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RenewLock(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Publish(self, request, context):
        """========== Pub/Sub ==========
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Subscribe(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Unsubscribe(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ExecuteBatch(self, request, context):
        """========== 批量操作 (Batch Operations) ==========
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateSession(self, request, context):
        """========== 会话管理 (Session Management) ==========
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetSession(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdateSession(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteSession(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListSessions(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetStatistics(self, request, context):
        """========== 统计和监控 ==========
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetKeyInfo(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HealthCheck(self, request, context):
        """========== 健康检查 ==========
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_RedisServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Set': grpc.unary_unary_rpc_method_handler(
                    servicer.Set,
                    request_deserializer=redis__service__pb2.SetRequest.FromString,
                    response_serializer=redis__service__pb2.SetResponse.SerializeToString,
            ),
            'Get': grpc.unary_unary_rpc_method_handler(
                    servicer.Get,
                    request_deserializer=redis__service__pb2.GetRequest.FromString,
                    response_serializer=redis__service__pb2.GetResponse.SerializeToString,
            ),
            'GetMultiple': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMultiple,
                    request_deserializer=redis__service__pb2.GetMultipleRequest.FromString,
                    response_serializer=redis__service__pb2.GetMultipleResponse.SerializeToString,
            ),
            'SetWithExpiration': grpc.unary_unary_rpc_method_handler(
                    servicer.SetWithExpiration,
                    request_deserializer=redis__service__pb2.SetWithExpirationRequest.FromString,
                    response_serializer=redis__service__pb2.SetResponse.SerializeToString,
            ),
            'Increment': grpc.unary_unary_rpc_method_handler(
                    servicer.Increment,
                    request_deserializer=redis__service__pb2.IncrementRequest.FromString,
                    response_serializer=redis__service__pb2.IncrementResponse.SerializeToString,
            ),
            'Decrement': grpc.unary_unary_rpc_method_handler(
                    servicer.Decrement,
                    request_deserializer=redis__service__pb2.DecrementRequest.FromString,
                    response_serializer=redis__service__pb2.DecrementResponse.SerializeToString,
            ),
            'Append': grpc.unary_unary_rpc_method_handler(
                    servicer.Append,
                    request_deserializer=redis__service__pb2.AppendRequest.FromString,
                    response_serializer=redis__service__pb2.AppendResponse.SerializeToString,
            ),
            'Delete': grpc.unary_unary_rpc_method_handler(
                    servicer.Delete,
                    request_deserializer=redis__service__pb2.DeleteRequest.FromString,
                    response_serializer=redis__service__pb2.DeleteResponse.SerializeToString,
            ),
            'DeleteMultiple': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteMultiple,
                    request_deserializer=redis__service__pb2.DeleteMultipleRequest.FromString,
                    response_serializer=redis__service__pb2.DeleteResponse.SerializeToString,
            ),
            'Exists': grpc.unary_unary_rpc_method_handler(
                    servicer.Exists,
                    request_deserializer=redis__service__pb2.ExistsRequest.FromString,
                    response_serializer=redis__service__pb2.ExistsResponse.SerializeToString,
            ),
            'Expire': grpc.unary_unary_rpc_method_handler(
                    servicer.Expire,
                    request_deserializer=redis__service__pb2.ExpireRequest.FromString,
                    response_serializer=redis__service__pb2.ExpireResponse.SerializeToString,
            ),
            'GetTTL': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTTL,
                    request_deserializer=redis__service__pb2.GetTTLRequest.FromString,
                    response_serializer=redis__service__pb2.GetTTLResponse.SerializeToString,
            ),
            'Rename': grpc.unary_unary_rpc_method_handler(
                    servicer.Rename,
                    request_deserializer=redis__service__pb2.RenameRequest.FromString,
                    response_serializer=redis__service__pb2.RenameResponse.SerializeToString,
            ),
            'ListKeys': grpc.unary_unary_rpc_method_handler(
                    servicer.ListKeys,
                    request_deserializer=redis__service__pb2.ListKeysRequest.FromString,
                    response_serializer=redis__service__pb2.ListKeysResponse.SerializeToString,
            ),
            'HSet': grpc.unary_unary_rpc_method_handler(
                    servicer.HSet,
                    request_deserializer=redis__service__pb2.HSetRequest.FromString,
                    response_serializer=redis__service__pb2.HSetResponse.SerializeToString,
            ),
            'HGet': grpc.unary_unary_rpc_method_handler(
                    servicer.HGet,
                    request_deserializer=redis__service__pb2.HGetRequest.FromString,
                    response_serializer=redis__service__pb2.HGetResponse.SerializeToString,
            ),
            'HGetAll': grpc.unary_unary_rpc_method_handler(
                    servicer.HGetAll,
                    request_deserializer=redis__service__pb2.HGetAllRequest.FromString,
                    response_serializer=redis__service__pb2.HGetAllResponse.SerializeToString,
            ),
            'HDelete': grpc.unary_unary_rpc_method_handler(
                    servicer.HDelete,
                    request_deserializer=redis__service__pb2.HDeleteRequest.FromString,
                    response_serializer=redis__service__pb2.HDeleteResponse.SerializeToString,
            ),
            'HExists': grpc.unary_unary_rpc_method_handler(
                    servicer.HExists,
                    request_deserializer=redis__service__pb2.HExistsRequest.FromString,
                    response_serializer=redis__service__pb2.HExistsResponse.SerializeToString,
            ),
            'HKeys': grpc.unary_unary_rpc_method_handler(
                    servicer.HKeys,
                    request_deserializer=redis__service__pb2.HKeysRequest.FromString,
                    response_serializer=redis__service__pb2.HKeysResponse.SerializeToString,
            ),
            'HValues': grpc.unary_unary_rpc_method_handler(
                    servicer.HValues,
                    request_deserializer=redis__service__pb2.HValuesRequest.FromString,
                    response_serializer=redis__service__pb2.HValuesResponse.SerializeToString,
            ),
            'HIncrement': grpc.unary_unary_rpc_method_handler(
                    servicer.HIncrement,
                    request_deserializer=redis__service__pb2.HIncrementRequest.FromString,
                    response_serializer=redis__service__pb2.HIncrementResponse.SerializeToString,
            ),
            'LPush': grpc.unary_unary_rpc_method_handler(
                    servicer.LPush,
                    request_deserializer=redis__service__pb2.LPushRequest.FromString,
                    response_serializer=redis__service__pb2.LPushResponse.SerializeToString,
            ),
            'RPush': grpc.unary_unary_rpc_method_handler(
                    servicer.RPush,
                    request_deserializer=redis__service__pb2.RPushRequest.FromString,
                    response_serializer=redis__service__pb2.RPushResponse.SerializeToString,
            ),
            'LPop': grpc.unary_unary_rpc_method_handler(
                    servicer.LPop,
                    request_deserializer=redis__service__pb2.LPopRequest.FromString,
                    response_serializer=redis__service__pb2.LPopResponse.SerializeToString,
            ),
            'RPop': grpc.unary_unary_rpc_method_handler(
                    servicer.RPop,
                    request_deserializer=redis__service__pb2.RPopRequest.FromString,
                    response_serializer=redis__service__pb2.RPopResponse.SerializeToString,
            ),
            'LRange': grpc.unary_unary_rpc_method_handler(
                    servicer.LRange,
                    request_deserializer=redis__service__pb2.LRangeRequest.FromString,
                    response_serializer=redis__service__pb2.LRangeResponse.SerializeToString,
            ),
            'LLen': grpc.unary_unary_rpc_method_handler(
                    servicer.LLen,
                    request_deserializer=redis__service__pb2.LLenRequest.FromString,
                    response_serializer=redis__service__pb2.LLenResponse.SerializeToString,
            ),
            'LIndex': grpc.unary_unary_rpc_method_handler(
                    servicer.LIndex,
                    request_deserializer=redis__service__pb2.LIndexRequest.FromString,
                    response_serializer=redis__service__pb2.LIndexResponse.SerializeToString,
            ),
            'LTrim': grpc.unary_unary_rpc_method_handler(
                    servicer.LTrim,
                    request_deserializer=redis__service__pb2.LTrimRequest.FromString,
                    response_serializer=redis__service__pb2.LTrimResponse.SerializeToString,
            ),
            'SAdd': grpc.unary_unary_rpc_method_handler(
                    servicer.SAdd,
                    request_deserializer=redis__service__pb2.SAddRequest.FromString,
                    response_serializer=redis__service__pb2.SAddResponse.SerializeToString,
            ),
            'SRemove': grpc.unary_unary_rpc_method_handler(
                    servicer.SRemove,
                    request_deserializer=redis__service__pb2.SRemoveRequest.FromString,
                    response_serializer=redis__service__pb2.SRemoveResponse.SerializeToString,
            ),
            'SMembers': grpc.unary_unary_rpc_method_handler(
                    servicer.SMembers,
                    request_deserializer=redis__service__pb2.SMembersRequest.FromString,
                    response_serializer=redis__service__pb2.SMembersResponse.SerializeToString,
            ),
            'SIsMember': grpc.unary_unary_rpc_method_handler(
                    servicer.SIsMember,
                    request_deserializer=redis__service__pb2.SIsMemberRequest.FromString,
                    response_serializer=redis__service__pb2.SIsMemberResponse.SerializeToString,
            ),
            'SCard': grpc.unary_unary_rpc_method_handler(
                    servicer.SCard,
                    request_deserializer=redis__service__pb2.SCardRequest.FromString,
                    response_serializer=redis__service__pb2.SCardResponse.SerializeToString,
            ),
            'SUnion': grpc.unary_unary_rpc_method_handler(
                    servicer.SUnion,
                    request_deserializer=redis__service__pb2.SUnionRequest.FromString,
                    response_serializer=redis__service__pb2.SUnionResponse.SerializeToString,
            ),
            'SInter': grpc.unary_unary_rpc_method_handler(
                    servicer.SInter,
                    request_deserializer=redis__service__pb2.SInterRequest.FromString,
                    response_serializer=redis__service__pb2.SInterResponse.SerializeToString,
            ),
            'SDiff': grpc.unary_unary_rpc_method_handler(
                    servicer.SDiff,
                    request_deserializer=redis__service__pb2.SDiffRequest.FromString,
                    response_serializer=redis__service__pb2.SDiffResponse.SerializeToString,
            ),
            'ZAdd': grpc.unary_unary_rpc_method_handler(
                    servicer.ZAdd,
                    request_deserializer=redis__service__pb2.ZAddRequest.FromString,
                    response_serializer=redis__service__pb2.ZAddResponse.SerializeToString,
            ),
            'ZRemove': grpc.unary_unary_rpc_method_handler(
                    servicer.ZRemove,
                    request_deserializer=redis__service__pb2.ZRemoveRequest.FromString,
                    response_serializer=redis__service__pb2.ZRemoveResponse.SerializeToString,
            ),
            'ZRange': grpc.unary_unary_rpc_method_handler(
                    servicer.ZRange,
                    request_deserializer=redis__service__pb2.ZRangeRequest.FromString,
                    response_serializer=redis__service__pb2.ZRangeResponse.SerializeToString,
            ),
            'ZRangeByScore': grpc.unary_unary_rpc_method_handler(
                    servicer.ZRangeByScore,
                    request_deserializer=redis__service__pb2.ZRangeByScoreRequest.FromString,
                    response_serializer=redis__service__pb2.ZRangeByScoreResponse.SerializeToString,
            ),
            'ZRank': grpc.unary_unary_rpc_method_handler(
                    servicer.ZRank,
                    request_deserializer=redis__service__pb2.ZRankRequest.FromString,
                    response_serializer=redis__service__pb2.ZRankResponse.SerializeToString,
            ),
            'ZScore': grpc.unary_unary_rpc_method_handler(
                    servicer.ZScore,
                    request_deserializer=redis__service__pb2.ZScoreRequest.FromString,
                    response_serializer=redis__service__pb2.ZScoreResponse.SerializeToString,
            ),
            'ZCard': grpc.unary_unary_rpc_method_handler(
                    servicer.ZCard,
                    request_deserializer=redis__service__pb2.ZCardRequest.FromString,
                    response_serializer=redis__service__pb2.ZCardResponse.SerializeToString,
            ),
            'ZIncrement': grpc.unary_unary_rpc_method_handler(
                    servicer.ZIncrement,
                    request_deserializer=redis__service__pb2.ZIncrementRequest.FromString,
                    response_serializer=redis__service__pb2.ZIncrementResponse.SerializeToString,
            ),
            'AcquireLock': grpc.unary_unary_rpc_method_handler(
                    servicer.AcquireLock,
                    request_deserializer=redis__service__pb2.AcquireLockRequest.FromString,
                    response_serializer=redis__service__pb2.AcquireLockResponse.SerializeToString,
            ),
            'ReleaseLock': grpc.unary_unary_rpc_method_handler(
                    servicer.ReleaseLock,
                    request_deserializer=redis__service__pb2.ReleaseLockRequest.FromString,
                    response_serializer=redis__service__pb2.ReleaseLockResponse.SerializeToString,
            ),
            'RenewLock': grpc.unary_unary_rpc_method_handler(
                    servicer.RenewLock,
                    request_deserializer=redis__service__pb2.RenewLockRequest.FromString,
                    response_serializer=redis__service__pb2.RenewLockResponse.SerializeToString,
            ),
            'Publish': grpc.unary_unary_rpc_method_handler(
                    servicer.Publish,
                    request_deserializer=redis__service__pb2.PublishRequest.FromString,
                    response_serializer=redis__service__pb2.PublishResponse.SerializeToString,
            ),
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=redis__service__pb2.SubscribeRequest.FromString,
                    response_serializer=redis__service__pb2.MessageResponse.SerializeToString,
            ),
            'Unsubscribe': grpc.unary_unary_rpc_method_handler(
                    servicer.Unsubscribe,
                    request_deserializer=redis__service__pb2.UnsubscribeRequest.FromString,
                    response_serializer=redis__service__pb2.UnsubscribeResponse.SerializeToString,
            ),
            'ExecuteBatch': grpc.unary_unary_rpc_method_handler(
                    servicer.ExecuteBatch,
                    request_deserializer=redis__service__pb2.RedisBatchRequest.FromString,
                    response_serializer=redis__service__pb2.RedisBatchResponse.SerializeToString,
            ),
            'CreateSession': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateSession,
                    request_deserializer=redis__service__pb2.CreateSessionRequest.FromString,
                    response_serializer=redis__service__pb2.CreateSessionResponse.SerializeToString,
            ),
            'GetSession': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSession,
                    request_deserializer=redis__service__pb2.GetSessionRequest.FromString,
                    response_serializer=redis__service__pb2.GetSessionResponse.SerializeToString,
            ),
            'UpdateSession': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateSession,
                    request_deserializer=redis__service__pb2.UpdateSessionRequest.FromString,
                    response_serializer=redis__service__pb2.UpdateSessionResponse.SerializeToString,
            ),
            'DeleteSession': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteSession,
                    request_deserializer=redis__service__pb2.DeleteSessionRequest.FromString,
                    response_serializer=redis__service__pb2.DeleteSessionResponse.SerializeToString,
            ),
            'ListSessions': grpc.unary_unary_rpc_method_handler(
                    servicer.ListSessions,
                    request_deserializer=redis__service__pb2.ListSessionsRequest.FromString,
                    response_serializer=redis__service__pb2.ListSessionsResponse.SerializeToString,
            ),
            'GetStatistics': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStatistics,
                    request_deserializer=redis__service__pb2.GetStatisticsRequest.FromString,
                    response_serializer=redis__service__pb2.GetStatisticsResponse.SerializeToString,
            ),
            'GetKeyInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetKeyInfo,
                    request_deserializer=redis__service__pb2.GetKeyInfoRequest.FromString,
                    response_serializer=redis__service__pb2.GetKeyInfoResponse.SerializeToString,
            ),
            'HealthCheck': grpc.unary_unary_rpc_method_handler(
                    servicer.HealthCheck,
                    request_deserializer=redis__service__pb2.RedisHealthCheckRequest.FromString,
                    response_serializer=redis__service__pb2.RedisHealthCheckResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'isa.redis.RedisService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('isa.redis.RedisService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class RedisService(object):
    """========================================
    Redis 缓存服务
    ========================================
    这是一个统一的缓存服务，为所有后端服务提供缓存和会话管理能力
    支持：
    - 用户和组织级别的命名空间隔离
    - String、Hash、List、Set、Sorted Set 操作
    - 分布式锁
    - Pub/Sub 消息
    - 过期时间管理
    - 批量操作

    """

    @staticmethod
    def Set(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/Set',
            redis__service__pb2.SetRequest.SerializeToString,
            redis__service__pb2.SetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Get(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/Get',
            redis__service__pb2.GetRequest.SerializeToString,
            redis__service__pb2.GetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMultiple(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/GetMultiple',
            redis__service__pb2.GetMultipleRequest.SerializeToString,
            redis__service__pb2.GetMultipleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetWithExpiration(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/SetWithExpiration',
            redis__service__pb2.SetWithExpirationRequest.SerializeToString,
            redis__service__pb2.SetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Increment(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/Increment',
            redis__service__pb2.IncrementRequest.SerializeToString,
            redis__service__pb2.IncrementResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Decrement(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/Decrement',
            redis__service__pb2.DecrementRequest.SerializeToString,
            redis__service__pb2.DecrementResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Append(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/Append',
            redis__service__pb2.AppendRequest.SerializeToString,
            redis__service__pb2.AppendResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Delete(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/Delete',
            redis__service__pb2.DeleteRequest.SerializeToString,
            redis__service__pb2.DeleteResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteMultiple(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/DeleteMultiple',
            redis__service__pb2.DeleteMultipleRequest.SerializeToString,
            redis__service__pb2.DeleteResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Exists(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/Exists',
            redis__service__pb2.ExistsRequest.SerializeToString,
            redis__service__pb2.ExistsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Expire(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/Expire',
            redis__service__pb2.ExpireRequest.SerializeToString,
            redis__service__pb2.ExpireResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTTL(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/GetTTL',
            redis__service__pb2.GetTTLRequest.SerializeToString,
            redis__service__pb2.GetTTLResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Rename(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/Rename',
            redis__service__pb2.RenameRequest.SerializeToString,
            redis__service__pb2.RenameResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListKeys(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/ListKeys',
            redis__service__pb2.ListKeysRequest.SerializeToString,
            redis__service__pb2.ListKeysResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HSet(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/HSet',
            redis__service__pb2.HSetRequest.SerializeToString,
            redis__service__pb2.HSetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HGet(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/HGet',
            redis__service__pb2.HGetRequest.SerializeToString,
            redis__service__pb2.HGetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HGetAll(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/HGetAll',
            redis__service__pb2.HGetAllRequest.SerializeToString,
            redis__service__pb2.HGetAllResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HDelete(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/HDelete',
            redis__service__pb2.HDeleteRequest.SerializeToString,
            redis__service__pb2.HDeleteResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HExists(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/HExists',
            redis__service__pb2.HExistsRequest.SerializeToString,
            redis__service__pb2.HExistsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HKeys(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/HKeys',
            redis__service__pb2.HKeysRequest.SerializeToString,
            redis__service__pb2.HKeysResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HValues(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/HValues',
            redis__service__pb2.HValuesRequest.SerializeToString,
            redis__service__pb2.HValuesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HIncrement(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/HIncrement',
            redis__service__pb2.HIncrementRequest.SerializeToString,
            redis__service__pb2.HIncrementResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def LPush(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/LPush',
            redis__service__pb2.LPushRequest.SerializeToString,
            redis__service__pb2.LPushResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RPush(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/RPush',
            redis__service__pb2.RPushRequest.SerializeToString,
            redis__service__pb2.RPushResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def LPop(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/LPop',
            redis__service__pb2.LPopRequest.SerializeToString,
            redis__service__pb2.LPopResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RPop(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/RPop',
            redis__service__pb2.RPopRequest.SerializeToString,
            redis__service__pb2.RPopResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def LRange(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/LRange',
            redis__service__pb2.LRangeRequest.SerializeToString,
            redis__service__pb2.LRangeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def LLen(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/LLen',
            redis__service__pb2.LLenRequest.SerializeToString,
            redis__service__pb2.LLenResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def LIndex(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/LIndex',
            redis__service__pb2.LIndexRequest.SerializeToString,
            redis__service__pb2.LIndexResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def LTrim(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/LTrim',
            redis__service__pb2.LTrimRequest.SerializeToString,
            redis__service__pb2.LTrimResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SAdd(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/SAdd',
            redis__service__pb2.SAddRequest.SerializeToString,
            redis__service__pb2.SAddResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SRemove(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/SRemove',
            redis__service__pb2.SRemoveRequest.SerializeToString,
            redis__service__pb2.SRemoveResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SMembers(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/SMembers',
            redis__service__pb2.SMembersRequest.SerializeToString,
            redis__service__pb2.SMembersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SIsMember(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/SIsMember',
            redis__service__pb2.SIsMemberRequest.SerializeToString,
            redis__service__pb2.SIsMemberResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SCard(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/SCard',
            redis__service__pb2.SCardRequest.SerializeToString,
            redis__service__pb2.SCardResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SUnion(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/SUnion',
            redis__service__pb2.SUnionRequest.SerializeToString,
            redis__service__pb2.SUnionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SInter(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/SInter',
            redis__service__pb2.SInterRequest.SerializeToString,
            redis__service__pb2.SInterResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SDiff(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/SDiff',
            redis__service__pb2.SDiffRequest.SerializeToString,
            redis__service__pb2.SDiffResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ZAdd(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/ZAdd',
            redis__service__pb2.ZAddRequest.SerializeToString,
            redis__service__pb2.ZAddResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ZRemove(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/ZRemove',
            redis__service__pb2.ZRemoveRequest.SerializeToString,
            redis__service__pb2.ZRemoveResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ZRange(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/ZRange',
            redis__service__pb2.ZRangeRequest.SerializeToString,
            redis__service__pb2.ZRangeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ZRangeByScore(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/ZRangeByScore',
            redis__service__pb2.ZRangeByScoreRequest.SerializeToString,
            redis__service__pb2.ZRangeByScoreResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ZRank(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/ZRank',
            redis__service__pb2.ZRankRequest.SerializeToString,
            redis__service__pb2.ZRankResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ZScore(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/ZScore',
            redis__service__pb2.ZScoreRequest.SerializeToString,
            redis__service__pb2.ZScoreResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ZCard(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/ZCard',
            redis__service__pb2.ZCardRequest.SerializeToString,
            redis__service__pb2.ZCardResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ZIncrement(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/ZIncrement',
            redis__service__pb2.ZIncrementRequest.SerializeToString,
            redis__service__pb2.ZIncrementResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AcquireLock(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/AcquireLock',
            redis__service__pb2.AcquireLockRequest.SerializeToString,
            redis__service__pb2.AcquireLockResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ReleaseLock(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/ReleaseLock',
            redis__service__pb2.ReleaseLockRequest.SerializeToString,
            redis__service__pb2.ReleaseLockResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RenewLock(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/RenewLock',
            redis__service__pb2.RenewLockRequest.SerializeToString,
            redis__service__pb2.RenewLockResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Publish(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/Publish',
            redis__service__pb2.PublishRequest.SerializeToString,
            redis__service__pb2.PublishResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/isa.redis.RedisService/Subscribe',
            redis__service__pb2.SubscribeRequest.SerializeToString,
            redis__service__pb2.MessageResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Unsubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/Unsubscribe',
            redis__service__pb2.UnsubscribeRequest.SerializeToString,
            redis__service__pb2.UnsubscribeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExecuteBatch(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/ExecuteBatch',
            redis__service__pb2.RedisBatchRequest.SerializeToString,
            redis__service__pb2.RedisBatchResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateSession(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/CreateSession',
            redis__service__pb2.CreateSessionRequest.SerializeToString,
            redis__service__pb2.CreateSessionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSession(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/GetSession',
            redis__service__pb2.GetSessionRequest.SerializeToString,
            redis__service__pb2.GetSessionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateSession(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/UpdateSession',
            redis__service__pb2.UpdateSessionRequest.SerializeToString,
            redis__service__pb2.UpdateSessionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteSession(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/DeleteSession',
            redis__service__pb2.DeleteSessionRequest.SerializeToString,
            redis__service__pb2.DeleteSessionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListSessions(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/ListSessions',
            redis__service__pb2.ListSessionsRequest.SerializeToString,
            redis__service__pb2.ListSessionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStatistics(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/GetStatistics',
            redis__service__pb2.GetStatisticsRequest.SerializeToString,
            redis__service__pb2.GetStatisticsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetKeyInfo(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/GetKeyInfo',
            redis__service__pb2.GetKeyInfoRequest.SerializeToString,
            redis__service__pb2.GetKeyInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HealthCheck(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/isa.redis.RedisService/HealthCheck',
            redis__service__pb2.RedisHealthCheckRequest.SerializeToString,
            redis__service__pb2.RedisHealthCheckResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
