# 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 neuroshard.protos import neuroshard_pb2 as neuroshard__pb2

GRPC_GENERATED_VERSION = '1.76.0'
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},'
        + ' but the generated code in neuroshard_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 NeuroShardServiceStub(object):
    """Service definition for Node-to-Node and Client-to-Node communication
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.StreamInference = channel.stream_stream(
                '/neuroshard.NeuroShardService/StreamInference',
                request_serializer=neuroshard__pb2.InferenceRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.InferenceResponse.FromString,
                _registered_method=True)
        self.UnaryInference = channel.unary_unary(
                '/neuroshard.NeuroShardService/UnaryInference',
                request_serializer=neuroshard__pb2.InferenceRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.InferenceResponse.FromString,
                _registered_method=True)
        self.GetWeights = channel.unary_unary(
                '/neuroshard.NeuroShardService/GetWeights',
                request_serializer=neuroshard__pb2.WeightRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.WeightResponse.FromString,
                _registered_method=True)
        self.GossipProof = channel.unary_unary(
                '/neuroshard.NeuroShardService/GossipProof',
                request_serializer=neuroshard__pb2.GossipProofRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.GossipProofResponse.FromString,
                _registered_method=True)
        self.GossipTransaction = channel.unary_unary(
                '/neuroshard.NeuroShardService/GossipTransaction',
                request_serializer=neuroshard__pb2.GossipTransactionRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.GossipTransactionResponse.FromString,
                _registered_method=True)
        self.GossipStake = channel.unary_unary(
                '/neuroshard.NeuroShardService/GossipStake',
                request_serializer=neuroshard__pb2.GossipStakeRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.GossipStakeResponse.FromString,
                _registered_method=True)
        self.RequestProofValidation = channel.unary_unary(
                '/neuroshard.NeuroShardService/RequestProofValidation',
                request_serializer=neuroshard__pb2.ProofValidationRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.ProofValidationResponse.FromString,
                _registered_method=True)
        self.GossipValidationVote = channel.unary_unary(
                '/neuroshard.NeuroShardService/GossipValidationVote',
                request_serializer=neuroshard__pb2.ValidationVoteRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.ValidationVoteResponse.FromString,
                _registered_method=True)
        self.GossipGradient = channel.unary_unary(
                '/neuroshard.NeuroShardService/GossipGradient',
                request_serializer=neuroshard__pb2.GossipGradientRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.GossipGradientResponse.FromString,
                _registered_method=True)
        self.GetCheckpoint = channel.unary_unary(
                '/neuroshard.NeuroShardService/GetCheckpoint',
                request_serializer=neuroshard__pb2.GetCheckpointRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.GetCheckpointResponse.FromString,
                _registered_method=True)
        self.GetCheckpointInfo = channel.unary_unary(
                '/neuroshard.NeuroShardService/GetCheckpointInfo',
                request_serializer=neuroshard__pb2.GetCheckpointInfoRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.GetCheckpointInfoResponse.FromString,
                _registered_method=True)
        self.PipelineForward = channel.unary_unary(
                '/neuroshard.NeuroShardService/PipelineForward',
                request_serializer=neuroshard__pb2.PipelineForwardRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.PipelineForwardResponse.FromString,
                _registered_method=True)
        self.PipelineBackward = channel.unary_unary(
                '/neuroshard.NeuroShardService/PipelineBackward',
                request_serializer=neuroshard__pb2.PipelineBackwardRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.PipelineBackwardResponse.FromString,
                _registered_method=True)
        self.GetShardInfo = channel.unary_unary(
                '/neuroshard.NeuroShardService/GetShardInfo',
                request_serializer=neuroshard__pb2.GetShardInfoRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.GetShardInfoResponse.FromString,
                _registered_method=True)
        self.GetShardChunk = channel.unary_unary(
                '/neuroshard.NeuroShardService/GetShardChunk',
                request_serializer=neuroshard__pb2.GetShardChunkRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.GetShardChunkResponse.FromString,
                _registered_method=True)
        self.DHTPing = channel.unary_unary(
                '/neuroshard.NeuroShardService/DHTPing',
                request_serializer=neuroshard__pb2.DHTPingRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.DHTPingResponse.FromString,
                _registered_method=True)
        self.DHTStore = channel.unary_unary(
                '/neuroshard.NeuroShardService/DHTStore',
                request_serializer=neuroshard__pb2.DHTStoreRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.DHTStoreResponse.FromString,
                _registered_method=True)
        self.DHTFindNode = channel.unary_unary(
                '/neuroshard.NeuroShardService/DHTFindNode',
                request_serializer=neuroshard__pb2.DHTFindNodeRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.DHTFindNodeResponse.FromString,
                _registered_method=True)
        self.DHTFindValue = channel.unary_unary(
                '/neuroshard.NeuroShardService/DHTFindValue',
                request_serializer=neuroshard__pb2.DHTFindValueRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.DHTFindValueResponse.FromString,
                _registered_method=True)
        self.TensorExchange = channel.unary_unary(
                '/neuroshard.NeuroShardService/TensorExchange',
                request_serializer=neuroshard__pb2.TensorExchangeRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.TensorExchangeResponse.FromString,
                _registered_method=True)
        self.SendPartialResult = channel.unary_unary(
                '/neuroshard.NeuroShardService/SendPartialResult',
                request_serializer=neuroshard__pb2.PartialResultRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.PartialResultResponse.FromString,
                _registered_method=True)
        self.AnnounceTensorShard = channel.unary_unary(
                '/neuroshard.NeuroShardService/AnnounceTensorShard',
                request_serializer=neuroshard__pb2.AnnounceShardRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.AnnounceShardResponse.FromString,
                _registered_method=True)
        self.FindTensorShardPeers = channel.unary_unary(
                '/neuroshard.NeuroShardService/FindTensorShardPeers',
                request_serializer=neuroshard__pb2.FindShardPeersRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.FindShardPeersResponse.FromString,
                _registered_method=True)
        self.ListModels = channel.unary_unary(
                '/neuroshard.NeuroShardService/ListModels',
                request_serializer=neuroshard__pb2.ListModelsRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.ListModelsResponse.FromString,
                _registered_method=True)
        self.GetModelStatus = channel.unary_unary(
                '/neuroshard.NeuroShardService/GetModelStatus',
                request_serializer=neuroshard__pb2.GetModelStatusRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.GetModelStatusResponse.FromString,
                _registered_method=True)
        self.SwarmForward = channel.unary_unary(
                '/neuroshard.NeuroShardService/SwarmForward',
                request_serializer=neuroshard__pb2.SwarmForwardRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.SwarmForwardResponse.FromString,
                _registered_method=True)
        self.GetSwarmStatus = channel.unary_unary(
                '/neuroshard.NeuroShardService/GetSwarmStatus',
                request_serializer=neuroshard__pb2.SwarmStatusRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.SwarmStatusResponse.FromString,
                _registered_method=True)
        self.UpdatePeerCapacity = channel.unary_unary(
                '/neuroshard.NeuroShardService/UpdatePeerCapacity',
                request_serializer=neuroshard__pb2.UpdatePeerCapacityRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.UpdatePeerCapacityResponse.FromString,
                _registered_method=True)
        self.AnnounceEpoch = channel.unary_unary(
                '/neuroshard.NeuroShardService/AnnounceEpoch',
                request_serializer=neuroshard__pb2.EpochAnnouncementRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.EpochAnnouncementResponse.FromString,
                _registered_method=True)
        self.GetEpoch = channel.unary_unary(
                '/neuroshard.NeuroShardService/GetEpoch',
                request_serializer=neuroshard__pb2.EpochRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.EpochResponse.FromString,
                _registered_method=True)
        self.GetLatestEpoch = channel.unary_unary(
                '/neuroshard.NeuroShardService/GetLatestEpoch',
                request_serializer=neuroshard__pb2.Empty.SerializeToString,
                response_deserializer=neuroshard__pb2.LatestEpochResponse.FromString,
                _registered_method=True)
        self.SpotCheckChallenge = channel.unary_unary(
                '/neuroshard.NeuroShardService/SpotCheckChallenge',
                request_serializer=neuroshard__pb2.SpotCheckChallengeRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.SpotCheckChallengeResponse.FromString,
                _registered_method=True)
        self.ExpertForward = channel.unary_unary(
                '/neuroshard.NeuroShardService/ExpertForward',
                request_serializer=neuroshard__pb2.ExpertForwardRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.ExpertForwardResponse.FromString,
                _registered_method=True)
        self.GetExpertStatus = channel.unary_unary(
                '/neuroshard.NeuroShardService/GetExpertStatus',
                request_serializer=neuroshard__pb2.ExpertStatusRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.ExpertStatusResponse.FromString,
                _registered_method=True)
        self.AnnounceExpert = channel.unary_unary(
                '/neuroshard.NeuroShardService/AnnounceExpert',
                request_serializer=neuroshard__pb2.AnnounceExpertRequest.SerializeToString,
                response_deserializer=neuroshard__pb2.AnnounceExpertResponse.FromString,
                _registered_method=True)


class NeuroShardServiceServicer(object):
    """Service definition for Node-to-Node and Client-to-Node communication
    """

    def StreamInference(self, request_iterator, context):
        """Streaming inference: Client/Node sends a stream of requests, receives a stream of tokens/updates
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UnaryInference(self, request, context):
        """Simple unary call for single-step (legacy/fallback)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetWeights(self, request, context):
        """Gossip weights for training
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GossipProof(self, request, context):
        """Gossip Proof of Uptime
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GossipTransaction(self, request, context):
        """Gossip Transaction
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GossipStake(self, request, context):
        """Gossip Stake Update
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RequestProofValidation(self, request, context):
        """Request Proof Validation from Validators
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GossipValidationVote(self, request, context):
        """Gossip Validation Vote
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GossipGradient(self, request, context):
        """--- Distributed Training RPCs ---

        Gossip gradients for distributed training
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetCheckpoint(self, request, context):
        """Request checkpoint from peer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetCheckpointInfo(self, request, context):
        """Get checkpoint info (version, hash) without downloading
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PipelineForward(self, request, context):
        """--- Pipeline Parallelism RPCs ---

        Forward hidden states through this node's layers
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PipelineBackward(self, request, context):
        """Backward pass: propagate gradients back to previous node
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetShardInfo(self, request, context):
        """Get shard info from this node
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetShardChunk(self, request, context):
        """--- Data Swarm RPCs (P2P Dataset) ---

        Request a chunk of a data shard
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DHTPing(self, request, context):
        """--- DHT RPCs ---
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DHTStore(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 DHTFindNode(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 DHTFindValue(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 TensorExchange(self, request, context):
        """--- Phase 4: Tensor Parallelism RPCs ---

        Exchange tensor chunks during ring all-reduce
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendPartialResult(self, request, context):
        """Send partial results for async aggregation
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AnnounceTensorShard(self, request, context):
        """Announce tensor shard availability
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FindTensorShardPeers(self, request, context):
        """Find peer shards for all-reduce coordination
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListModels(self, request, context):
        """--- Phase 4: Model Registry RPCs ---

        List available models in network
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetModelStatus(self, request, context):
        """Get status of a specific model
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SwarmForward(self, request, context):
        """--- Swarm Routing RPCs (Phase 2) ---

        Async activation forward (non-blocking, buffers locally)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetSwarmStatus(self, request, context):
        """Get swarm node status (buffer fill rates, capacity)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdatePeerCapacity(self, request, context):
        """Update peer capacity (TCP fallback for UDP heartbeat)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AnnounceEpoch(self, request, context):
        """--- Chained Epoch System RPCs ---

        Announce a finalized epoch to peers
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetEpoch(self, request, context):
        """Request a specific epoch from peer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetLatestEpoch(self, request, context):
        """Get latest finalized epoch ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SpotCheckChallenge(self, request, context):
        """Submit spot-check challenge for gradient commitment
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ExpertForward(self, request, context):
        """--- Mixture of Experts (MoE) RPCs ---

        Forward activations to a remote expert
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetExpertStatus(self, request, context):
        """Get expert status for routing decisions
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AnnounceExpert(self, request, context):
        """Announce expert availability to network
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_NeuroShardServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'StreamInference': grpc.stream_stream_rpc_method_handler(
                    servicer.StreamInference,
                    request_deserializer=neuroshard__pb2.InferenceRequest.FromString,
                    response_serializer=neuroshard__pb2.InferenceResponse.SerializeToString,
            ),
            'UnaryInference': grpc.unary_unary_rpc_method_handler(
                    servicer.UnaryInference,
                    request_deserializer=neuroshard__pb2.InferenceRequest.FromString,
                    response_serializer=neuroshard__pb2.InferenceResponse.SerializeToString,
            ),
            'GetWeights': grpc.unary_unary_rpc_method_handler(
                    servicer.GetWeights,
                    request_deserializer=neuroshard__pb2.WeightRequest.FromString,
                    response_serializer=neuroshard__pb2.WeightResponse.SerializeToString,
            ),
            'GossipProof': grpc.unary_unary_rpc_method_handler(
                    servicer.GossipProof,
                    request_deserializer=neuroshard__pb2.GossipProofRequest.FromString,
                    response_serializer=neuroshard__pb2.GossipProofResponse.SerializeToString,
            ),
            'GossipTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.GossipTransaction,
                    request_deserializer=neuroshard__pb2.GossipTransactionRequest.FromString,
                    response_serializer=neuroshard__pb2.GossipTransactionResponse.SerializeToString,
            ),
            'GossipStake': grpc.unary_unary_rpc_method_handler(
                    servicer.GossipStake,
                    request_deserializer=neuroshard__pb2.GossipStakeRequest.FromString,
                    response_serializer=neuroshard__pb2.GossipStakeResponse.SerializeToString,
            ),
            'RequestProofValidation': grpc.unary_unary_rpc_method_handler(
                    servicer.RequestProofValidation,
                    request_deserializer=neuroshard__pb2.ProofValidationRequest.FromString,
                    response_serializer=neuroshard__pb2.ProofValidationResponse.SerializeToString,
            ),
            'GossipValidationVote': grpc.unary_unary_rpc_method_handler(
                    servicer.GossipValidationVote,
                    request_deserializer=neuroshard__pb2.ValidationVoteRequest.FromString,
                    response_serializer=neuroshard__pb2.ValidationVoteResponse.SerializeToString,
            ),
            'GossipGradient': grpc.unary_unary_rpc_method_handler(
                    servicer.GossipGradient,
                    request_deserializer=neuroshard__pb2.GossipGradientRequest.FromString,
                    response_serializer=neuroshard__pb2.GossipGradientResponse.SerializeToString,
            ),
            'GetCheckpoint': grpc.unary_unary_rpc_method_handler(
                    servicer.GetCheckpoint,
                    request_deserializer=neuroshard__pb2.GetCheckpointRequest.FromString,
                    response_serializer=neuroshard__pb2.GetCheckpointResponse.SerializeToString,
            ),
            'GetCheckpointInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetCheckpointInfo,
                    request_deserializer=neuroshard__pb2.GetCheckpointInfoRequest.FromString,
                    response_serializer=neuroshard__pb2.GetCheckpointInfoResponse.SerializeToString,
            ),
            'PipelineForward': grpc.unary_unary_rpc_method_handler(
                    servicer.PipelineForward,
                    request_deserializer=neuroshard__pb2.PipelineForwardRequest.FromString,
                    response_serializer=neuroshard__pb2.PipelineForwardResponse.SerializeToString,
            ),
            'PipelineBackward': grpc.unary_unary_rpc_method_handler(
                    servicer.PipelineBackward,
                    request_deserializer=neuroshard__pb2.PipelineBackwardRequest.FromString,
                    response_serializer=neuroshard__pb2.PipelineBackwardResponse.SerializeToString,
            ),
            'GetShardInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetShardInfo,
                    request_deserializer=neuroshard__pb2.GetShardInfoRequest.FromString,
                    response_serializer=neuroshard__pb2.GetShardInfoResponse.SerializeToString,
            ),
            'GetShardChunk': grpc.unary_unary_rpc_method_handler(
                    servicer.GetShardChunk,
                    request_deserializer=neuroshard__pb2.GetShardChunkRequest.FromString,
                    response_serializer=neuroshard__pb2.GetShardChunkResponse.SerializeToString,
            ),
            'DHTPing': grpc.unary_unary_rpc_method_handler(
                    servicer.DHTPing,
                    request_deserializer=neuroshard__pb2.DHTPingRequest.FromString,
                    response_serializer=neuroshard__pb2.DHTPingResponse.SerializeToString,
            ),
            'DHTStore': grpc.unary_unary_rpc_method_handler(
                    servicer.DHTStore,
                    request_deserializer=neuroshard__pb2.DHTStoreRequest.FromString,
                    response_serializer=neuroshard__pb2.DHTStoreResponse.SerializeToString,
            ),
            'DHTFindNode': grpc.unary_unary_rpc_method_handler(
                    servicer.DHTFindNode,
                    request_deserializer=neuroshard__pb2.DHTFindNodeRequest.FromString,
                    response_serializer=neuroshard__pb2.DHTFindNodeResponse.SerializeToString,
            ),
            'DHTFindValue': grpc.unary_unary_rpc_method_handler(
                    servicer.DHTFindValue,
                    request_deserializer=neuroshard__pb2.DHTFindValueRequest.FromString,
                    response_serializer=neuroshard__pb2.DHTFindValueResponse.SerializeToString,
            ),
            'TensorExchange': grpc.unary_unary_rpc_method_handler(
                    servicer.TensorExchange,
                    request_deserializer=neuroshard__pb2.TensorExchangeRequest.FromString,
                    response_serializer=neuroshard__pb2.TensorExchangeResponse.SerializeToString,
            ),
            'SendPartialResult': grpc.unary_unary_rpc_method_handler(
                    servicer.SendPartialResult,
                    request_deserializer=neuroshard__pb2.PartialResultRequest.FromString,
                    response_serializer=neuroshard__pb2.PartialResultResponse.SerializeToString,
            ),
            'AnnounceTensorShard': grpc.unary_unary_rpc_method_handler(
                    servicer.AnnounceTensorShard,
                    request_deserializer=neuroshard__pb2.AnnounceShardRequest.FromString,
                    response_serializer=neuroshard__pb2.AnnounceShardResponse.SerializeToString,
            ),
            'FindTensorShardPeers': grpc.unary_unary_rpc_method_handler(
                    servicer.FindTensorShardPeers,
                    request_deserializer=neuroshard__pb2.FindShardPeersRequest.FromString,
                    response_serializer=neuroshard__pb2.FindShardPeersResponse.SerializeToString,
            ),
            'ListModels': grpc.unary_unary_rpc_method_handler(
                    servicer.ListModels,
                    request_deserializer=neuroshard__pb2.ListModelsRequest.FromString,
                    response_serializer=neuroshard__pb2.ListModelsResponse.SerializeToString,
            ),
            'GetModelStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetModelStatus,
                    request_deserializer=neuroshard__pb2.GetModelStatusRequest.FromString,
                    response_serializer=neuroshard__pb2.GetModelStatusResponse.SerializeToString,
            ),
            'SwarmForward': grpc.unary_unary_rpc_method_handler(
                    servicer.SwarmForward,
                    request_deserializer=neuroshard__pb2.SwarmForwardRequest.FromString,
                    response_serializer=neuroshard__pb2.SwarmForwardResponse.SerializeToString,
            ),
            'GetSwarmStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSwarmStatus,
                    request_deserializer=neuroshard__pb2.SwarmStatusRequest.FromString,
                    response_serializer=neuroshard__pb2.SwarmStatusResponse.SerializeToString,
            ),
            'UpdatePeerCapacity': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdatePeerCapacity,
                    request_deserializer=neuroshard__pb2.UpdatePeerCapacityRequest.FromString,
                    response_serializer=neuroshard__pb2.UpdatePeerCapacityResponse.SerializeToString,
            ),
            'AnnounceEpoch': grpc.unary_unary_rpc_method_handler(
                    servicer.AnnounceEpoch,
                    request_deserializer=neuroshard__pb2.EpochAnnouncementRequest.FromString,
                    response_serializer=neuroshard__pb2.EpochAnnouncementResponse.SerializeToString,
            ),
            'GetEpoch': grpc.unary_unary_rpc_method_handler(
                    servicer.GetEpoch,
                    request_deserializer=neuroshard__pb2.EpochRequest.FromString,
                    response_serializer=neuroshard__pb2.EpochResponse.SerializeToString,
            ),
            'GetLatestEpoch': grpc.unary_unary_rpc_method_handler(
                    servicer.GetLatestEpoch,
                    request_deserializer=neuroshard__pb2.Empty.FromString,
                    response_serializer=neuroshard__pb2.LatestEpochResponse.SerializeToString,
            ),
            'SpotCheckChallenge': grpc.unary_unary_rpc_method_handler(
                    servicer.SpotCheckChallenge,
                    request_deserializer=neuroshard__pb2.SpotCheckChallengeRequest.FromString,
                    response_serializer=neuroshard__pb2.SpotCheckChallengeResponse.SerializeToString,
            ),
            'ExpertForward': grpc.unary_unary_rpc_method_handler(
                    servicer.ExpertForward,
                    request_deserializer=neuroshard__pb2.ExpertForwardRequest.FromString,
                    response_serializer=neuroshard__pb2.ExpertForwardResponse.SerializeToString,
            ),
            'GetExpertStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetExpertStatus,
                    request_deserializer=neuroshard__pb2.ExpertStatusRequest.FromString,
                    response_serializer=neuroshard__pb2.ExpertStatusResponse.SerializeToString,
            ),
            'AnnounceExpert': grpc.unary_unary_rpc_method_handler(
                    servicer.AnnounceExpert,
                    request_deserializer=neuroshard__pb2.AnnounceExpertRequest.FromString,
                    response_serializer=neuroshard__pb2.AnnounceExpertResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'neuroshard.NeuroShardService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('neuroshard.NeuroShardService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class NeuroShardService(object):
    """Service definition for Node-to-Node and Client-to-Node communication
    """

    @staticmethod
    def StreamInference(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(
            request_iterator,
            target,
            '/neuroshard.NeuroShardService/StreamInference',
            neuroshard__pb2.InferenceRequest.SerializeToString,
            neuroshard__pb2.InferenceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UnaryInference(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,
            '/neuroshard.NeuroShardService/UnaryInference',
            neuroshard__pb2.InferenceRequest.SerializeToString,
            neuroshard__pb2.InferenceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetWeights(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,
            '/neuroshard.NeuroShardService/GetWeights',
            neuroshard__pb2.WeightRequest.SerializeToString,
            neuroshard__pb2.WeightResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GossipProof(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,
            '/neuroshard.NeuroShardService/GossipProof',
            neuroshard__pb2.GossipProofRequest.SerializeToString,
            neuroshard__pb2.GossipProofResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GossipTransaction(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,
            '/neuroshard.NeuroShardService/GossipTransaction',
            neuroshard__pb2.GossipTransactionRequest.SerializeToString,
            neuroshard__pb2.GossipTransactionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GossipStake(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,
            '/neuroshard.NeuroShardService/GossipStake',
            neuroshard__pb2.GossipStakeRequest.SerializeToString,
            neuroshard__pb2.GossipStakeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RequestProofValidation(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,
            '/neuroshard.NeuroShardService/RequestProofValidation',
            neuroshard__pb2.ProofValidationRequest.SerializeToString,
            neuroshard__pb2.ProofValidationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GossipValidationVote(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,
            '/neuroshard.NeuroShardService/GossipValidationVote',
            neuroshard__pb2.ValidationVoteRequest.SerializeToString,
            neuroshard__pb2.ValidationVoteResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GossipGradient(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,
            '/neuroshard.NeuroShardService/GossipGradient',
            neuroshard__pb2.GossipGradientRequest.SerializeToString,
            neuroshard__pb2.GossipGradientResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetCheckpoint(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,
            '/neuroshard.NeuroShardService/GetCheckpoint',
            neuroshard__pb2.GetCheckpointRequest.SerializeToString,
            neuroshard__pb2.GetCheckpointResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetCheckpointInfo(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,
            '/neuroshard.NeuroShardService/GetCheckpointInfo',
            neuroshard__pb2.GetCheckpointInfoRequest.SerializeToString,
            neuroshard__pb2.GetCheckpointInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PipelineForward(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,
            '/neuroshard.NeuroShardService/PipelineForward',
            neuroshard__pb2.PipelineForwardRequest.SerializeToString,
            neuroshard__pb2.PipelineForwardResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PipelineBackward(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,
            '/neuroshard.NeuroShardService/PipelineBackward',
            neuroshard__pb2.PipelineBackwardRequest.SerializeToString,
            neuroshard__pb2.PipelineBackwardResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetShardInfo(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,
            '/neuroshard.NeuroShardService/GetShardInfo',
            neuroshard__pb2.GetShardInfoRequest.SerializeToString,
            neuroshard__pb2.GetShardInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetShardChunk(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,
            '/neuroshard.NeuroShardService/GetShardChunk',
            neuroshard__pb2.GetShardChunkRequest.SerializeToString,
            neuroshard__pb2.GetShardChunkResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DHTPing(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,
            '/neuroshard.NeuroShardService/DHTPing',
            neuroshard__pb2.DHTPingRequest.SerializeToString,
            neuroshard__pb2.DHTPingResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DHTStore(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,
            '/neuroshard.NeuroShardService/DHTStore',
            neuroshard__pb2.DHTStoreRequest.SerializeToString,
            neuroshard__pb2.DHTStoreResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DHTFindNode(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,
            '/neuroshard.NeuroShardService/DHTFindNode',
            neuroshard__pb2.DHTFindNodeRequest.SerializeToString,
            neuroshard__pb2.DHTFindNodeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DHTFindValue(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,
            '/neuroshard.NeuroShardService/DHTFindValue',
            neuroshard__pb2.DHTFindValueRequest.SerializeToString,
            neuroshard__pb2.DHTFindValueResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TensorExchange(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,
            '/neuroshard.NeuroShardService/TensorExchange',
            neuroshard__pb2.TensorExchangeRequest.SerializeToString,
            neuroshard__pb2.TensorExchangeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SendPartialResult(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,
            '/neuroshard.NeuroShardService/SendPartialResult',
            neuroshard__pb2.PartialResultRequest.SerializeToString,
            neuroshard__pb2.PartialResultResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AnnounceTensorShard(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,
            '/neuroshard.NeuroShardService/AnnounceTensorShard',
            neuroshard__pb2.AnnounceShardRequest.SerializeToString,
            neuroshard__pb2.AnnounceShardResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FindTensorShardPeers(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,
            '/neuroshard.NeuroShardService/FindTensorShardPeers',
            neuroshard__pb2.FindShardPeersRequest.SerializeToString,
            neuroshard__pb2.FindShardPeersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListModels(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,
            '/neuroshard.NeuroShardService/ListModels',
            neuroshard__pb2.ListModelsRequest.SerializeToString,
            neuroshard__pb2.ListModelsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetModelStatus(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,
            '/neuroshard.NeuroShardService/GetModelStatus',
            neuroshard__pb2.GetModelStatusRequest.SerializeToString,
            neuroshard__pb2.GetModelStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SwarmForward(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,
            '/neuroshard.NeuroShardService/SwarmForward',
            neuroshard__pb2.SwarmForwardRequest.SerializeToString,
            neuroshard__pb2.SwarmForwardResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSwarmStatus(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,
            '/neuroshard.NeuroShardService/GetSwarmStatus',
            neuroshard__pb2.SwarmStatusRequest.SerializeToString,
            neuroshard__pb2.SwarmStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdatePeerCapacity(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,
            '/neuroshard.NeuroShardService/UpdatePeerCapacity',
            neuroshard__pb2.UpdatePeerCapacityRequest.SerializeToString,
            neuroshard__pb2.UpdatePeerCapacityResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AnnounceEpoch(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,
            '/neuroshard.NeuroShardService/AnnounceEpoch',
            neuroshard__pb2.EpochAnnouncementRequest.SerializeToString,
            neuroshard__pb2.EpochAnnouncementResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetEpoch(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,
            '/neuroshard.NeuroShardService/GetEpoch',
            neuroshard__pb2.EpochRequest.SerializeToString,
            neuroshard__pb2.EpochResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetLatestEpoch(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,
            '/neuroshard.NeuroShardService/GetLatestEpoch',
            neuroshard__pb2.Empty.SerializeToString,
            neuroshard__pb2.LatestEpochResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SpotCheckChallenge(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,
            '/neuroshard.NeuroShardService/SpotCheckChallenge',
            neuroshard__pb2.SpotCheckChallengeRequest.SerializeToString,
            neuroshard__pb2.SpotCheckChallengeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExpertForward(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,
            '/neuroshard.NeuroShardService/ExpertForward',
            neuroshard__pb2.ExpertForwardRequest.SerializeToString,
            neuroshard__pb2.ExpertForwardResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetExpertStatus(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,
            '/neuroshard.NeuroShardService/GetExpertStatus',
            neuroshard__pb2.ExpertStatusRequest.SerializeToString,
            neuroshard__pb2.ExpertStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AnnounceExpert(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,
            '/neuroshard.NeuroShardService/AnnounceExpert',
            neuroshard__pb2.AnnounceExpertRequest.SerializeToString,
            neuroshard__pb2.AnnounceExpertResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
