Client

def __init__(self, researcher: ResearcherCredentials):
    """Create channels and stubs

    Args:
        researcher: An instance of ResearcherCredentials
    """
    self._researcher = researcher

    self._channels = {}
    self._stubs = {}
    self._stub_types = [
        _StubType.LISTENER_TASK_STUB,
        _StubType.SENDER_TASK_STUB,
        _StubType.SENDER_FEEDBACK_STUB,
    ]
    for st in self._stub_types:
        self._channels[st]: grpc.aio.Channel = None
        self._stubs[st]: ResearcherServiceStub = None

    # lock for accessing channels and stubs
    self._channels_stubs_lock = asyncio.Lock()

def __init__(
    self, node_id: str, researcher: ResearcherCredentials, update_id_map: Awaitable
) -> None:
    """Class constructor

    Args:
        node_id: unique ID of this node (connection client)
        researcher: the researcher to which the node connects (connection server)
        update_id_map: awaitable to call when updating the researcher ID, needs proper prototype
    """
    self._id = None
    self._researcher = researcher
    self._channels = Channels(researcher)

    self._task_listener = TaskListener(
        channels=self._channels,
        node_id=node_id,
        on_status_change=self._on_status_change,
        update_id=self._update_id,
    )

    self._sender = Sender(
        channels=self._channels, on_status_change=self._on_status_change
    )

    # TODO: use `self._status` for finer gRPC agent handling.
    # Currently, the (tentative) status is maintained but not used
    self._status = ClientStatus.DISCONNECTED
    # lock for accessing self._status
    self._status_lock = asyncio.Lock()

    self._update_id_map = update_id_map
    self._tasks = []

def __init__(self, channels: Channels) -> None:
    """Constructs task listener channels

    Args:
        channels: Keeps channels and stubs.
    """
    self._channels = channels
    self._retry_on_error = False

def __init__(
    self,
    channels: Channels,
    on_status_change: Awaitable,
) -> None:
    """Class constructor.

    Args:
        channels: RPC channels and stubs to be used for polling tasks from researcher
        on_status_change: Callback awaitable to run for changing node agent status
    """
    super().__init__(channels)

    self._queue = asyncio.Queue()
    self._on_status_change = on_status_change
    self._retry_count = 0
    self._retry_item = None
    self._stub_type = _StubType.NO_STUB
    self._retry_on_error = True

def __init__(
    self,
    channels: Channels,
    node_id: str,
    on_status_change: Awaitable,
    update_id: Awaitable,
) -> None:
    """Class constructor.

    Args:
        channels: RPC channels and stubs to be used for polling tasks from researcher
        node_id: unique ID for this node
        on_status_change: Callback awaitable to run for changing node agent status
        update_id: Callback function to run updating peer researcher ID
    """
    super().__init__(channels)

    self._node_id = node_id
    self._on_status_change = on_status_change
    self._update_id = update_id
    self._retry_count = 0