Module hyveos_sdk.protocol.bridge_pb2_grpc

Client and server classes corresponding to protobuf-defined services.

Functions

def add_AppsServicer_to_server(servicer, server)

Expand source code

def add_AppsServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Deploy': grpc.unary_unary_rpc_method_handler(
                    servicer.Deploy,
                    request_deserializer=bridge__pb2.DeployAppRequest.FromString,
                    response_serializer=bridge__pb2.ID.SerializeToString,
            ),
            'ListRunning': grpc.unary_unary_rpc_method_handler(
                    servicer.ListRunning,
                    request_deserializer=bridge__pb2.ListRunningAppsRequest.FromString,
                    response_serializer=bridge__pb2.RunningApps.SerializeToString,
            ),
            'Stop': grpc.unary_unary_rpc_method_handler(
                    servicer.Stop,
                    request_deserializer=bridge__pb2.StopAppRequest.FromString,
                    response_serializer=bridge__pb2.Empty.SerializeToString,
            ),
            'GetOwnAppId': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOwnAppId,
                    request_deserializer=bridge__pb2.Empty.FromString,
                    response_serializer=bridge__pb2.ID.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'bridge.Apps', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('bridge.Apps', rpc_method_handlers)

def add_DebugServicer_to_server(servicer, server)

Expand source code

def add_DebugServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'SubscribeMeshTopology': grpc.unary_stream_rpc_method_handler(
                    servicer.SubscribeMeshTopology,
                    request_deserializer=bridge__pb2.Empty.FromString,
                    response_serializer=bridge__pb2.MeshTopologyEvent.SerializeToString,
            ),
            'SubscribeMessages': grpc.unary_stream_rpc_method_handler(
                    servicer.SubscribeMessages,
                    request_deserializer=bridge__pb2.Empty.FromString,
                    response_serializer=bridge__pb2.MessageDebugEvent.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'bridge.Debug', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('bridge.Debug', rpc_method_handlers)

def add_DiscoveryServicer_to_server(servicer, server)

Expand source code

def add_DiscoveryServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Provide': grpc.unary_unary_rpc_method_handler(
                    servicer.Provide,
                    request_deserializer=bridge__pb2.DHTKey.FromString,
                    response_serializer=bridge__pb2.Empty.SerializeToString,
            ),
            'GetProviders': grpc.unary_stream_rpc_method_handler(
                    servicer.GetProviders,
                    request_deserializer=bridge__pb2.DHTKey.FromString,
                    response_serializer=bridge__pb2.Peer.SerializeToString,
            ),
            'StopProviding': grpc.unary_unary_rpc_method_handler(
                    servicer.StopProviding,
                    request_deserializer=bridge__pb2.DHTKey.FromString,
                    response_serializer=bridge__pb2.Empty.SerializeToString,
            ),
            'GetOwnId': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOwnId,
                    request_deserializer=bridge__pb2.Empty.FromString,
                    response_serializer=bridge__pb2.Peer.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'bridge.Discovery', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('bridge.Discovery', rpc_method_handlers)

def add_FileTransferServicer_to_server(servicer, server)

Expand source code

def add_FileTransferServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Publish': grpc.unary_unary_rpc_method_handler(
                    servicer.Publish,
                    request_deserializer=bridge__pb2.FilePath.FromString,
                    response_serializer=bridge__pb2.CID.SerializeToString,
            ),
            'Get': grpc.unary_unary_rpc_method_handler(
                    servicer.Get,
                    request_deserializer=bridge__pb2.CID.FromString,
                    response_serializer=bridge__pb2.FilePath.SerializeToString,
            ),
            'GetWithProgress': grpc.unary_stream_rpc_method_handler(
                    servicer.GetWithProgress,
                    request_deserializer=bridge__pb2.CID.FromString,
                    response_serializer=bridge__pb2.DownloadEvent.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'bridge.FileTransfer', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('bridge.FileTransfer', rpc_method_handlers)

def add_KVServicer_to_server(servicer, server)

Expand source code

def add_KVServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'PutRecord': grpc.unary_unary_rpc_method_handler(
                    servicer.PutRecord,
                    request_deserializer=bridge__pb2.DHTRecord.FromString,
                    response_serializer=bridge__pb2.Empty.SerializeToString,
            ),
            'GetRecord': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRecord,
                    request_deserializer=bridge__pb2.DHTKey.FromString,
                    response_serializer=bridge__pb2.OptionalData.SerializeToString,
            ),
            'RemoveRecord': grpc.unary_unary_rpc_method_handler(
                    servicer.RemoveRecord,
                    request_deserializer=bridge__pb2.DHTKey.FromString,
                    response_serializer=bridge__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'bridge.KV', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('bridge.KV', rpc_method_handlers)

def add_LocalKVServicer_to_server(servicer, server)

Expand source code

def add_LocalKVServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Put': grpc.unary_unary_rpc_method_handler(
                    servicer.Put,
                    request_deserializer=bridge__pb2.LocalKVRecord.FromString,
                    response_serializer=bridge__pb2.OptionalData.SerializeToString,
            ),
            'Get': grpc.unary_unary_rpc_method_handler(
                    servicer.Get,
                    request_deserializer=bridge__pb2.LocalKVKey.FromString,
                    response_serializer=bridge__pb2.OptionalData.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'bridge.LocalKV', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('bridge.LocalKV', rpc_method_handlers)

def add_NeighboursServicer_to_server(servicer, server)

Expand source code

def add_NeighboursServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=bridge__pb2.Empty.FromString,
                    response_serializer=bridge__pb2.NeighbourEvent.SerializeToString,
            ),
            'Get': grpc.unary_unary_rpc_method_handler(
                    servicer.Get,
                    request_deserializer=bridge__pb2.Empty.FromString,
                    response_serializer=bridge__pb2.Peers.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'bridge.Neighbours', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('bridge.Neighbours', rpc_method_handlers)

def add_PubSubServicer_to_server(servicer, server)

Expand source code

def add_PubSubServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=bridge__pb2.Topic.FromString,
                    response_serializer=bridge__pb2.PubSubRecvMessage.SerializeToString,
            ),
            'Publish': grpc.unary_unary_rpc_method_handler(
                    servicer.Publish,
                    request_deserializer=bridge__pb2.PubSubMessage.FromString,
                    response_serializer=bridge__pb2.PubSubMessageID.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'bridge.PubSub', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('bridge.PubSub', rpc_method_handlers)

def add_ReqRespServicer_to_server(servicer, server)

Expand source code

def add_ReqRespServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Send': grpc.unary_unary_rpc_method_handler(
                    servicer.Send,
                    request_deserializer=bridge__pb2.SendRequest.FromString,
                    response_serializer=bridge__pb2.Response.SerializeToString,
            ),
            'Recv': grpc.unary_stream_rpc_method_handler(
                    servicer.Recv,
                    request_deserializer=bridge__pb2.OptionalTopicQuery.FromString,
                    response_serializer=bridge__pb2.RecvRequest.SerializeToString,
            ),
            'Respond': grpc.unary_unary_rpc_method_handler(
                    servicer.Respond,
                    request_deserializer=bridge__pb2.SendResponse.FromString,
                    response_serializer=bridge__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'bridge.ReqResp', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('bridge.ReqResp', rpc_method_handlers)

Classes

class Apps

Expand source code

class Apps(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def Deploy(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,
            '/bridge.Apps/Deploy',
            bridge__pb2.DeployAppRequest.SerializeToString,
            bridge__pb2.ID.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListRunning(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,
            '/bridge.Apps/ListRunning',
            bridge__pb2.ListRunningAppsRequest.SerializeToString,
            bridge__pb2.RunningApps.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Stop(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,
            '/bridge.Apps/Stop',
            bridge__pb2.StopAppRequest.SerializeToString,
            bridge__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetOwnAppId(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,
            '/bridge.Apps/GetOwnAppId',
            bridge__pb2.Empty.SerializeToString,
            bridge__pb2.ID.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

Missing associated documentation comment in .proto file.

Static methods

def Deploy(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Deploy(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,
        '/bridge.Apps/Deploy',
        bridge__pb2.DeployAppRequest.SerializeToString,
        bridge__pb2.ID.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def GetOwnAppId(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def GetOwnAppId(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,
        '/bridge.Apps/GetOwnAppId',
        bridge__pb2.Empty.SerializeToString,
        bridge__pb2.ID.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def ListRunning(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def ListRunning(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,
        '/bridge.Apps/ListRunning',
        bridge__pb2.ListRunningAppsRequest.SerializeToString,
        bridge__pb2.RunningApps.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def Stop(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Stop(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,
        '/bridge.Apps/Stop',
        bridge__pb2.StopAppRequest.SerializeToString,
        bridge__pb2.Empty.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

class AppsServicer

Expand source code

class AppsServicer(object):
    """Missing associated documentation comment in .proto file."""

    def Deploy(self, request, context):
        """Deploy an app to a peer and get the id of the deployed app
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListRunning(self, request, context):
        """List running apps on a peer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Stop(self, request, context):
        """Stop a running app on a peer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetOwnAppId(self, request, context):
        """Get the id of the current app
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

Missing associated documentation comment in .proto file.

Methods

def Deploy(self, request, context)

Expand source code

def Deploy(self, request, context):
    """Deploy an app to a peer and get the id of the deployed app
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Deploy an app to a peer and get the id of the deployed app

def GetOwnAppId(self, request, context)

Expand source code

def GetOwnAppId(self, request, context):
    """Get the id of the current app
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Get the id of the current app

def ListRunning(self, request, context)

Expand source code

def ListRunning(self, request, context):
    """List running apps on a peer
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

List running apps on a peer

def Stop(self, request, context)

Expand source code

def Stop(self, request, context):
    """Stop a running app on a peer
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Stop a running app on a peer

class AppsStub (channel)

Expand source code

class AppsStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.Deploy = channel.unary_unary(
                '/bridge.Apps/Deploy',
                request_serializer=bridge__pb2.DeployAppRequest.SerializeToString,
                response_deserializer=bridge__pb2.ID.FromString,
                _registered_method=True)
        self.ListRunning = channel.unary_unary(
                '/bridge.Apps/ListRunning',
                request_serializer=bridge__pb2.ListRunningAppsRequest.SerializeToString,
                response_deserializer=bridge__pb2.RunningApps.FromString,
                _registered_method=True)
        self.Stop = channel.unary_unary(
                '/bridge.Apps/Stop',
                request_serializer=bridge__pb2.StopAppRequest.SerializeToString,
                response_deserializer=bridge__pb2.Empty.FromString,
                _registered_method=True)
        self.GetOwnAppId = channel.unary_unary(
                '/bridge.Apps/GetOwnAppId',
                request_serializer=bridge__pb2.Empty.SerializeToString,
                response_deserializer=bridge__pb2.ID.FromString,
                _registered_method=True)

Missing associated documentation comment in .proto file.

Constructor.

Args

channel

A grpc.Channel.

class Debug

Expand source code

class Debug(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def SubscribeMeshTopology(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/bridge.Debug/SubscribeMeshTopology',
            bridge__pb2.Empty.SerializeToString,
            bridge__pb2.MeshTopologyEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SubscribeMessages(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/bridge.Debug/SubscribeMessages',
            bridge__pb2.Empty.SerializeToString,
            bridge__pb2.MessageDebugEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

Missing associated documentation comment in .proto file.

Static methods

def SubscribeMeshTopology(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def SubscribeMeshTopology(request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None):
    return grpc.experimental.unary_stream(
        request,
        target,
        '/bridge.Debug/SubscribeMeshTopology',
        bridge__pb2.Empty.SerializeToString,
        bridge__pb2.MeshTopologyEvent.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def SubscribeMessages(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def SubscribeMessages(request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None):
    return grpc.experimental.unary_stream(
        request,
        target,
        '/bridge.Debug/SubscribeMessages',
        bridge__pb2.Empty.SerializeToString,
        bridge__pb2.MessageDebugEvent.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

class DebugServicer

Expand source code

class DebugServicer(object):
    """Missing associated documentation comment in .proto file."""

    def SubscribeMeshTopology(self, request, context):
        """Subscribe to mesh topology events to get notified when the mesh topology
        changes
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SubscribeMessages(self, request, context):
        """Subscribe to message debug events to get notified when messages are sent
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

Missing associated documentation comment in .proto file.

Methods

def SubscribeMeshTopology(self, request, context)

Expand source code

def SubscribeMeshTopology(self, request, context):
    """Subscribe to mesh topology events to get notified when the mesh topology
    changes
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Subscribe to mesh topology events to get notified when the mesh topology changes

def SubscribeMessages(self, request, context)

Expand source code

def SubscribeMessages(self, request, context):
    """Subscribe to message debug events to get notified when messages are sent
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Subscribe to message debug events to get notified when messages are sent

class DebugStub (channel)

Expand source code

class DebugStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.SubscribeMeshTopology = channel.unary_stream(
                '/bridge.Debug/SubscribeMeshTopology',
                request_serializer=bridge__pb2.Empty.SerializeToString,
                response_deserializer=bridge__pb2.MeshTopologyEvent.FromString,
                _registered_method=True)
        self.SubscribeMessages = channel.unary_stream(
                '/bridge.Debug/SubscribeMessages',
                request_serializer=bridge__pb2.Empty.SerializeToString,
                response_deserializer=bridge__pb2.MessageDebugEvent.FromString,
                _registered_method=True)

Missing associated documentation comment in .proto file.

Constructor.

Args

channel

A grpc.Channel.

class Discovery

Expand source code

class Discovery(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def Provide(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,
            '/bridge.Discovery/Provide',
            bridge__pb2.DHTKey.SerializeToString,
            bridge__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetProviders(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/bridge.Discovery/GetProviders',
            bridge__pb2.DHTKey.SerializeToString,
            bridge__pb2.Peer.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StopProviding(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,
            '/bridge.Discovery/StopProviding',
            bridge__pb2.DHTKey.SerializeToString,
            bridge__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetOwnId(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,
            '/bridge.Discovery/GetOwnId',
            bridge__pb2.Empty.SerializeToString,
            bridge__pb2.Peer.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

Missing associated documentation comment in .proto file.

Static methods

def GetOwnId(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def GetOwnId(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,
        '/bridge.Discovery/GetOwnId',
        bridge__pb2.Empty.SerializeToString,
        bridge__pb2.Peer.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def GetProviders(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def GetProviders(request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None):
    return grpc.experimental.unary_stream(
        request,
        target,
        '/bridge.Discovery/GetProviders',
        bridge__pb2.DHTKey.SerializeToString,
        bridge__pb2.Peer.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def Provide(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Provide(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,
        '/bridge.Discovery/Provide',
        bridge__pb2.DHTKey.SerializeToString,
        bridge__pb2.Empty.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def StopProviding(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def StopProviding(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,
        '/bridge.Discovery/StopProviding',
        bridge__pb2.DHTKey.SerializeToString,
        bridge__pb2.Empty.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

class DiscoveryServicer

Expand source code

class DiscoveryServicer(object):
    """Missing associated documentation comment in .proto file."""

    def Provide(self, request, context):
        """Mark the current runtime as a provider for a discovery key
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetProviders(self, request, context):
        """Get the providers of a discovery key
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StopProviding(self, request, context):
        """Stop providing a discovery key.
        This only has local effects and only affects other hyveOS nodes once the
        providers records expire.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetOwnId(self, request, context):
        """Get the peer id of the current runtime
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

Missing associated documentation comment in .proto file.

Methods

def GetOwnId(self, request, context)

Expand source code

def GetOwnId(self, request, context):
    """Get the peer id of the current runtime
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Get the peer id of the current runtime

def GetProviders(self, request, context)

Expand source code

def GetProviders(self, request, context):
    """Get the providers of a discovery key
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Get the providers of a discovery key

def Provide(self, request, context)

Expand source code

def Provide(self, request, context):
    """Mark the current runtime as a provider for a discovery key
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Mark the current runtime as a provider for a discovery key

def StopProviding(self, request, context)

Expand source code

def StopProviding(self, request, context):
    """Stop providing a discovery key.
    This only has local effects and only affects other hyveOS nodes once the
    providers records expire.
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Stop providing a discovery key. This only has local effects and only affects other hyveOS nodes once the providers records expire.

class DiscoveryStub (channel)

Expand source code

class DiscoveryStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.Provide = channel.unary_unary(
                '/bridge.Discovery/Provide',
                request_serializer=bridge__pb2.DHTKey.SerializeToString,
                response_deserializer=bridge__pb2.Empty.FromString,
                _registered_method=True)
        self.GetProviders = channel.unary_stream(
                '/bridge.Discovery/GetProviders',
                request_serializer=bridge__pb2.DHTKey.SerializeToString,
                response_deserializer=bridge__pb2.Peer.FromString,
                _registered_method=True)
        self.StopProviding = channel.unary_unary(
                '/bridge.Discovery/StopProviding',
                request_serializer=bridge__pb2.DHTKey.SerializeToString,
                response_deserializer=bridge__pb2.Empty.FromString,
                _registered_method=True)
        self.GetOwnId = channel.unary_unary(
                '/bridge.Discovery/GetOwnId',
                request_serializer=bridge__pb2.Empty.SerializeToString,
                response_deserializer=bridge__pb2.Peer.FromString,
                _registered_method=True)

Missing associated documentation comment in .proto file.

Constructor.

Args

channel

A grpc.Channel.

class FileTransfer

Expand source code

class FileTransfer(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def Publish(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/bridge.FileTransfer/Publish',
            bridge__pb2.FilePath.SerializeToString,
            bridge__pb2.CID.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Get(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/bridge.FileTransfer/Get',
            bridge__pb2.CID.SerializeToString,
            bridge__pb2.FilePath.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetWithProgress(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/bridge.FileTransfer/GetWithProgress',
            bridge__pb2.CID.SerializeToString,
            bridge__pb2.DownloadEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

Missing associated documentation comment in .proto file.

Static methods

def Get(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Get(request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None):
    return grpc.experimental.unary_unary(
        request,
        target,
        '/bridge.FileTransfer/Get',
        bridge__pb2.CID.SerializeToString,
        bridge__pb2.FilePath.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def GetWithProgress(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def GetWithProgress(request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None):
    return grpc.experimental.unary_stream(
        request,
        target,
        '/bridge.FileTransfer/GetWithProgress',
        bridge__pb2.CID.SerializeToString,
        bridge__pb2.DownloadEvent.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def Publish(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Publish(request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None):
    return grpc.experimental.unary_unary(
        request,
        target,
        '/bridge.FileTransfer/Publish',
        bridge__pb2.FilePath.SerializeToString,
        bridge__pb2.CID.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

class FileTransferServicer

Expand source code

class FileTransferServicer(object):
    """Missing associated documentation comment in .proto file."""

    def Publish(self, request, context):
        """Publish a file in the runtime and get the cid of the file
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Get(self, request, context):
        """Request a file with a cid from the runtime
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetWithProgress(self, request, context):
        """Request a file with a cid from the runtime and get notified about the
        download progress
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

Missing associated documentation comment in .proto file.

Methods

def Get(self, request, context)

Expand source code

def Get(self, request, context):
    """Request a file with a cid from the runtime
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Request a file with a cid from the runtime

def GetWithProgress(self, request, context)

Expand source code

def GetWithProgress(self, request, context):
    """Request a file with a cid from the runtime and get notified about the
    download progress
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Request a file with a cid from the runtime and get notified about the download progress

def Publish(self, request, context)

Expand source code

def Publish(self, request, context):
    """Publish a file in the runtime and get the cid of the file
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Publish a file in the runtime and get the cid of the file

class FileTransferStub (channel)

Expand source code

class FileTransferStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.Publish = channel.unary_unary(
                '/bridge.FileTransfer/Publish',
                request_serializer=bridge__pb2.FilePath.SerializeToString,
                response_deserializer=bridge__pb2.CID.FromString,
                _registered_method=True)
        self.Get = channel.unary_unary(
                '/bridge.FileTransfer/Get',
                request_serializer=bridge__pb2.CID.SerializeToString,
                response_deserializer=bridge__pb2.FilePath.FromString,
                _registered_method=True)
        self.GetWithProgress = channel.unary_stream(
                '/bridge.FileTransfer/GetWithProgress',
                request_serializer=bridge__pb2.CID.SerializeToString,
                response_deserializer=bridge__pb2.DownloadEvent.FromString,
                _registered_method=True)

Missing associated documentation comment in .proto file.

Constructor.

Args

channel

A grpc.Channel.

class KV

Expand source code

class KV(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def PutRecord(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,
            '/bridge.KV/PutRecord',
            bridge__pb2.DHTRecord.SerializeToString,
            bridge__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetRecord(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,
            '/bridge.KV/GetRecord',
            bridge__pb2.DHTKey.SerializeToString,
            bridge__pb2.OptionalData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RemoveRecord(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,
            '/bridge.KV/RemoveRecord',
            bridge__pb2.DHTKey.SerializeToString,
            bridge__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

Missing associated documentation comment in .proto file.

Static methods

def GetRecord(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def GetRecord(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,
        '/bridge.KV/GetRecord',
        bridge__pb2.DHTKey.SerializeToString,
        bridge__pb2.OptionalData.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def PutRecord(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def PutRecord(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,
        '/bridge.KV/PutRecord',
        bridge__pb2.DHTRecord.SerializeToString,
        bridge__pb2.Empty.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def RemoveRecord(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def RemoveRecord(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,
        '/bridge.KV/RemoveRecord',
        bridge__pb2.DHTKey.SerializeToString,
        bridge__pb2.Empty.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

class KVServicer

Expand source code

class KVServicer(object):
    """Missing associated documentation comment in .proto file."""

    def PutRecord(self, request, context):
        """Put a record into the global key-value store
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetRecord(self, request, context):
        """Get a record from the global key-value store.
        The value of the record will be empty if the key is not found.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RemoveRecord(self, request, context):
        """Remove a record from the global key-value store.
        This only has local effects and only affects the key-value store once the
        records expire.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

Missing associated documentation comment in .proto file.

Methods

def GetRecord(self, request, context)

Expand source code

def GetRecord(self, request, context):
    """Get a record from the global key-value store.
    The value of the record will be empty if the key is not found.
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Get a record from the global key-value store. The value of the record will be empty if the key is not found.

def PutRecord(self, request, context)

Expand source code

def PutRecord(self, request, context):
    """Put a record into the global key-value store
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Put a record into the global key-value store

def RemoveRecord(self, request, context)

Expand source code

def RemoveRecord(self, request, context):
    """Remove a record from the global key-value store.
    This only has local effects and only affects the key-value store once the
    records expire.
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Remove a record from the global key-value store. This only has local effects and only affects the key-value store once the records expire.

class KVStub (channel)

Expand source code

class KVStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.PutRecord = channel.unary_unary(
                '/bridge.KV/PutRecord',
                request_serializer=bridge__pb2.DHTRecord.SerializeToString,
                response_deserializer=bridge__pb2.Empty.FromString,
                _registered_method=True)
        self.GetRecord = channel.unary_unary(
                '/bridge.KV/GetRecord',
                request_serializer=bridge__pb2.DHTKey.SerializeToString,
                response_deserializer=bridge__pb2.OptionalData.FromString,
                _registered_method=True)
        self.RemoveRecord = channel.unary_unary(
                '/bridge.KV/RemoveRecord',
                request_serializer=bridge__pb2.DHTKey.SerializeToString,
                response_deserializer=bridge__pb2.Empty.FromString,
                _registered_method=True)

Missing associated documentation comment in .proto file.

Constructor.

Args

channel

A grpc.Channel.

class LocalKV

Expand source code

class LocalKV(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def Put(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,
            '/bridge.LocalKV/Put',
            bridge__pb2.LocalKVRecord.SerializeToString,
            bridge__pb2.OptionalData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Get(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/bridge.LocalKV/Get',
            bridge__pb2.LocalKVKey.SerializeToString,
            bridge__pb2.OptionalData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

Missing associated documentation comment in .proto file.

Static methods

def Get(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Get(request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None):
    return grpc.experimental.unary_unary(
        request,
        target,
        '/bridge.LocalKV/Get',
        bridge__pb2.LocalKVKey.SerializeToString,
        bridge__pb2.OptionalData.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def Put(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Put(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,
        '/bridge.LocalKV/Put',
        bridge__pb2.LocalKVRecord.SerializeToString,
        bridge__pb2.OptionalData.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

class LocalKVServicer

Expand source code

class LocalKVServicer(object):
    """Missing associated documentation comment in .proto file."""

    def Put(self, request, context):
        """Put a record into the local key-value store and get the previous value if
        it exists. This only has local effects but will be persisted across
        restarts.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Get(self, request, context):
        """Get a record from the local key-value store.
        This will not return records from other hyveOS nodes.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

Missing associated documentation comment in .proto file.

Methods

def Get(self, request, context)

Expand source code

def Get(self, request, context):
    """Get a record from the local key-value store.
    This will not return records from other hyveOS nodes.
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Get a record from the local key-value store. This will not return records from other hyveOS nodes.

def Put(self, request, context)

Expand source code

def Put(self, request, context):
    """Put a record into the local key-value store and get the previous value if
    it exists. This only has local effects but will be persisted across
    restarts.
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Put a record into the local key-value store and get the previous value if it exists. This only has local effects but will be persisted across restarts.

class LocalKVStub (channel)

Expand source code

class LocalKVStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.Put = channel.unary_unary(
                '/bridge.LocalKV/Put',
                request_serializer=bridge__pb2.LocalKVRecord.SerializeToString,
                response_deserializer=bridge__pb2.OptionalData.FromString,
                _registered_method=True)
        self.Get = channel.unary_unary(
                '/bridge.LocalKV/Get',
                request_serializer=bridge__pb2.LocalKVKey.SerializeToString,
                response_deserializer=bridge__pb2.OptionalData.FromString,
                _registered_method=True)

Missing associated documentation comment in .proto file.

Constructor.

Args

channel

A grpc.Channel.

class Neighbours

Expand source code

class Neighbours(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/bridge.Neighbours/Subscribe',
            bridge__pb2.Empty.SerializeToString,
            bridge__pb2.NeighbourEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Get(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/bridge.Neighbours/Get',
            bridge__pb2.Empty.SerializeToString,
            bridge__pb2.Peers.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

Missing associated documentation comment in .proto file.

Static methods

def Get(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Get(request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None):
    return grpc.experimental.unary_unary(
        request,
        target,
        '/bridge.Neighbours/Get',
        bridge__pb2.Empty.SerializeToString,
        bridge__pb2.Peers.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def Subscribe(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Subscribe(request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None):
    return grpc.experimental.unary_stream(
        request,
        target,
        '/bridge.Neighbours/Subscribe',
        bridge__pb2.Empty.SerializeToString,
        bridge__pb2.NeighbourEvent.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

class NeighboursServicer

Expand source code

class NeighboursServicer(object):
    """Missing associated documentation comment in .proto file."""

    def Subscribe(self, request, context):
        """Subscribe to neighbour discovery events to get notified when new neighbour
        peers are discovered or lost
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Get(self, request, context):
        """Get the neighbours of the current runtime
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

Missing associated documentation comment in .proto file.

Methods

def Get(self, request, context)

Expand source code

def Get(self, request, context):
    """Get the neighbours of the current runtime
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Get the neighbours of the current runtime

def Subscribe(self, request, context)

Expand source code

def Subscribe(self, request, context):
    """Subscribe to neighbour discovery events to get notified when new neighbour
    peers are discovered or lost
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Subscribe to neighbour discovery events to get notified when new neighbour peers are discovered or lost

class NeighboursStub (channel)

Expand source code

class NeighboursStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/bridge.Neighbours/Subscribe',
                request_serializer=bridge__pb2.Empty.SerializeToString,
                response_deserializer=bridge__pb2.NeighbourEvent.FromString,
                _registered_method=True)
        self.Get = channel.unary_unary(
                '/bridge.Neighbours/Get',
                request_serializer=bridge__pb2.Empty.SerializeToString,
                response_deserializer=bridge__pb2.Peers.FromString,
                _registered_method=True)

Missing associated documentation comment in .proto file.

Constructor.

Args

channel

A grpc.Channel.

class PubSub

Expand source code

class PubSub(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/bridge.PubSub/Subscribe',
            bridge__pb2.Topic.SerializeToString,
            bridge__pb2.PubSubRecvMessage.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Publish(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/bridge.PubSub/Publish',
            bridge__pb2.PubSubMessage.SerializeToString,
            bridge__pb2.PubSubMessageID.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

Missing associated documentation comment in .proto file.

Static methods

def Publish(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Publish(request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None):
    return grpc.experimental.unary_unary(
        request,
        target,
        '/bridge.PubSub/Publish',
        bridge__pb2.PubSubMessage.SerializeToString,
        bridge__pb2.PubSubMessageID.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def Subscribe(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Subscribe(request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None):
    return grpc.experimental.unary_stream(
        request,
        target,
        '/bridge.PubSub/Subscribe',
        bridge__pb2.Topic.SerializeToString,
        bridge__pb2.PubSubRecvMessage.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

class PubSubServicer

Expand source code

class PubSubServicer(object):
    """Missing associated documentation comment in .proto file."""

    def Subscribe(self, request, context):
        """Subscribe to a pub-sub topic to receive messages published in that topic
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Publish(self, request, context):
        """Publish a message in a pub-sub topic
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

Missing associated documentation comment in .proto file.

Methods

def Publish(self, request, context)

Expand source code

def Publish(self, request, context):
    """Publish a message in a pub-sub topic
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Publish a message in a pub-sub topic

def Subscribe(self, request, context)

Expand source code

def Subscribe(self, request, context):
    """Subscribe to a pub-sub topic to receive messages published in that topic
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Subscribe to a pub-sub topic to receive messages published in that topic

class PubSubStub (channel)

Expand source code

class PubSubStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/bridge.PubSub/Subscribe',
                request_serializer=bridge__pb2.Topic.SerializeToString,
                response_deserializer=bridge__pb2.PubSubRecvMessage.FromString,
                _registered_method=True)
        self.Publish = channel.unary_unary(
                '/bridge.PubSub/Publish',
                request_serializer=bridge__pb2.PubSubMessage.SerializeToString,
                response_deserializer=bridge__pb2.PubSubMessageID.FromString,
                _registered_method=True)

Missing associated documentation comment in .proto file.

Constructor.

Args

channel

A grpc.Channel.

class ReqResp

Expand source code

class ReqResp(object):
    """----- SERVICES -----

    """

    @staticmethod
    def Send(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,
            '/bridge.ReqResp/Send',
            bridge__pb2.SendRequest.SerializeToString,
            bridge__pb2.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Recv(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/bridge.ReqResp/Recv',
            bridge__pb2.OptionalTopicQuery.SerializeToString,
            bridge__pb2.RecvRequest.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Respond(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,
            '/bridge.ReqResp/Respond',
            bridge__pb2.SendResponse.SerializeToString,
            bridge__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

----- SERVICES -----

Static methods

def Recv(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Recv(request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None):
    return grpc.experimental.unary_stream(
        request,
        target,
        '/bridge.ReqResp/Recv',
        bridge__pb2.OptionalTopicQuery.SerializeToString,
        bridge__pb2.RecvRequest.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def Respond(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Respond(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,
        '/bridge.ReqResp/Respond',
        bridge__pb2.SendResponse.SerializeToString,
        bridge__pb2.Empty.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

def Send(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None)

Expand source code

@staticmethod
def Send(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,
        '/bridge.ReqResp/Send',
        bridge__pb2.SendRequest.SerializeToString,
        bridge__pb2.Response.FromString,
        options,
        channel_credentials,
        insecure,
        call_credentials,
        compression,
        wait_for_ready,
        timeout,
        metadata,
        _registered_method=True)

class ReqRespServicer

Expand source code

class ReqRespServicer(object):
    """----- SERVICES -----

    """

    def Send(self, request, context):
        """Send a request with an optional topic to a peer and wait for a response
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Recv(self, request, context):
        """Receive requests from peers that either have no topic or have a topic that
        has been subscribed to
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Respond(self, request, context):
        """Respond to a request received from Recv
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

----- SERVICES -----

Methods

def Recv(self, request, context)

Expand source code

def Recv(self, request, context):
    """Receive requests from peers that either have no topic or have a topic that
    has been subscribed to
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Receive requests from peers that either have no topic or have a topic that has been subscribed to

def Respond(self, request, context)

Expand source code

def Respond(self, request, context):
    """Respond to a request received from Recv
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Respond to a request received from Recv

def Send(self, request, context)

Expand source code

def Send(self, request, context):
    """Send a request with an optional topic to a peer and wait for a response
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

Send a request with an optional topic to a peer and wait for a response

class ReqRespStub (channel)

Expand source code

class ReqRespStub(object):
    """----- SERVICES -----

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Send = channel.unary_unary(
                '/bridge.ReqResp/Send',
                request_serializer=bridge__pb2.SendRequest.SerializeToString,
                response_deserializer=bridge__pb2.Response.FromString,
                _registered_method=True)
        self.Recv = channel.unary_stream(
                '/bridge.ReqResp/Recv',
                request_serializer=bridge__pb2.OptionalTopicQuery.SerializeToString,
                response_deserializer=bridge__pb2.RecvRequest.FromString,
                _registered_method=True)
        self.Respond = channel.unary_unary(
                '/bridge.ReqResp/Respond',
                request_serializer=bridge__pb2.SendResponse.SerializeToString,
                response_deserializer=bridge__pb2.Empty.FromString,
                _registered_method=True)

----- SERVICES -----

Constructor.

Args

channel

A grpc.Channel.