chore: add documentation RI

Code functionality left unchanged, only added docs where missing

close: N25B-298

src/robot_interface/endpoints/main_receiver.py

@@ -6,26 +6,47 @@ from robot_interface.state import state
 from robot_interface.core.config import settings
 
 class MainReceiver(ReceiverBase):
+    """
+    The main receiver endpoint, responsible for handling ping and negotiation requests.
+
+    :param zmq_context: The ZeroMQ context to use.
+    :type zmq_context: zmq.Context
+
+    :param port: The port to use.
+    :type port: int
+    """
     def __init__(self, zmq_context, port=settings.agent_settings.main_receiver_port):
-        """
-        The main receiver endpoint, responsible for handling ping and negotiation requests.
-
-        :param zmq_context: The ZeroMQ context to use.
-        :type zmq_context: zmq.Context
-
-        :param port: The port to use.
-        :type port: int
-        """
         super(MainReceiver, self).__init__("main")
         self.create_socket(zmq_context, zmq.REP, port, bind=False)
 
     @staticmethod
     def _handle_ping(message):
-        """A simple ping endpoint. Returns the provided data."""
+        """
+        Handle a ping request.
+
+        Returns the provided data in a standardized response dictionary.
+
+        :param message: The ping request message.
+        :type message: dict
+
+        :return: A response dictionary containing the original data.
+        :rtype: dict[str, str | list[dict]]
+        """
         return {"endpoint": "ping", "data": message.get("data")}
 
     @staticmethod
     def _handle_port_negotiation(message):
+        """
+        Handle a port negotiation request.
+
+        Returns a list of all known endpoints and their descriptions.
+
+        :param message: The negotiation request message.
+        :type message: dict
+
+        :return: A response dictionary with endpoint descriptions as data.
+        :rtype: dict[str, list[dict]]
+        """
         endpoints = [socket.endpoint_description() for socket in state.sockets]
 
         return {"endpoint": "negotiate/ports", "data": endpoints}
@@ -33,13 +54,13 @@ class MainReceiver(ReceiverBase):
     @staticmethod
     def _handle_negotiation(message):
         """
-        Handle a negotiation request. Will respond with ports that can be used to connect to the robot.
+        Handle a negotiation request. Responds with ports that can be used to connect to the robot.
 
         :param message: The negotiation request message.
         :type message: dict
 
-        :return: A response dictionary with a 'ports' key containing a list of ports and their function.
-        :rtype: dict[str, list[dict]]
+        :return: A response dictionary with the negotiation result.
+        :rtype: dict[str, str | list[dict]]
         """
         # In the future, the sender could send information like the robot's IP address, etc.
 
@@ -49,6 +70,17 @@ class MainReceiver(ReceiverBase):
         return {"endpoint": "negotiate/error", "data": "The requested endpoint is not implemented."}
 
     def handle_message(self, message):
+        """
+        Main entry point for handling incoming messages.
+
+        Dispatches messages to the appropriate handler based on the endpoint.
+
+        :param message: The received message.
+        :type message: dict
+
+        :return: A response dictionary based on the requested endpoint.
+        :rtype: dict[str, str | list[dict]]
+        """
         if message["endpoint"] == "ping":
             return self._handle_ping(message)
         elif message["endpoint"].startswith("negotiate"):