nexaroa 0.0.111__py3-none-any.whl

protos/neuroshard_pb2_grpc.py

@@ -0,0 +1,1298 @@
+# 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 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)
+
+
+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 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,
+            ),
+    }
+    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)