Merge branch 'ros2' into dependabot/github_actions/actions/upload-artifact-7

Author: bjsowa

.github/workflows/ci.yml

@@ -28,9 +28,7 @@ jobs:
         include:
           # Test supported ROS 2 distributions
           # https://docs.ros.org/en/rolling/Releases.html
-          # NOTE: Humble and Jazzy do not work on the `ros2` branch, so they are tested in their own branches.
-          - ros: kilted
-            os: ubuntu-24.04
+          # NOTE: Humble, Jazzy and Kilted do not work on the `ros2` branch, so they are tested in their own branches.
           - ros: rolling
             os: ubuntu-24.04
 

rosbridge_library/package.xml

@@ -26,6 +26,7 @@ ROS action, like subscribe, publish, call service, and interact with params.
   <exec_depend>python3-ujson</exec_depend>
   <exec_depend>rcl_interfaces</exec_depend>
   <exec_depend>rclpy</exec_depend>
+  <exec_depend>rosidl_pycommon</exec_depend>
 
   <test_depend>action_msgs</test_depend>
   <test_depend>ament_cmake_mypy</test_depend>

rosbridge_library/src/rosbridge_library/capabilities/advertise_action.py

@@ -33,11 +33,11 @@
 from __future__ import annotations
 
 import fnmatch
-from typing import TYPE_CHECKING, Generic, cast
+from typing import TYPE_CHECKING, Any, Generic, cast
 
 from action_msgs.msg import GoalStatus
 from rclpy.action import ActionServer
-from rclpy.action.server import CancelResponse, ServerGoalHandle
+from rclpy.action.server import CancelResponse
 from rclpy.callback_groups import ReentrantCallbackGroup
 from rclpy.task import Future
 
@@ -47,23 +47,29 @@
 from rosbridge_library.internal.type_support import (
     ROSActionFeedbackT,
     ROSActionGoalT,
+    ROSActionImplT,
     ROSActionResultT,
     ROSMessage,
 )
 
 if TYPE_CHECKING:
+    from rclpy.action.server import ServerGoalHandle
+
     from rosbridge_library.protocol import Protocol
 
 
-class AdvertisedActionHandler(Generic[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT]):
+class AdvertisedActionHandler(
+    Generic[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT, ROSActionImplT]
+):
     id_counter = 1
 
     def __init__(
         self, action_name: str, action_type: str, protocol: Protocol, sleep_time: float = 0.001
     ) -> None:
         self.goal_futures: dict[str, Future[ROSActionResultT]] = {}
         self.goal_handles: dict[
-            str, ServerGoalHandle[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT]
+            str,
+            ServerGoalHandle[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT, ROSActionImplT],
         ] = {}
         self.goal_statuses: dict[str, int] = {}
 
@@ -72,15 +78,15 @@ def __init__(
         self.protocol = protocol
         self.sleep_time = sleep_time
         # setup the action
-        self.action_server: ActionServer[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT] = (
-            ActionServer(
-                protocol.node_handle,
-                get_action_class(action_type),
-                action_name,
-                self.execute_callback,  # type: ignore[arg-type]  # rclpy type hint does not support coroutines
-                cancel_callback=self.cancel_callback,  # type: ignore[arg-type]  # rclpy type hint is incorrect
-                callback_group=ReentrantCallbackGroup(),  # https://github.com/ros2/rclpy/issues/834#issuecomment-961331870
-            )
+        self.action_server = ActionServer[
+            ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT, ROSActionImplT
+        ](
+            protocol.node_handle,
+            get_action_class(action_type),
+            action_name,
+            self.execute_callback,  # type: ignore[arg-type]  # rclpy type hint does not support coroutines
+            cancel_callback=self.cancel_callback,  # type: ignore[arg-type]  # rclpy type hint is incorrect
+            callback_group=ReentrantCallbackGroup(),  # https://github.com/ros2/rclpy/issues/834#issuecomment-961331870
         )
 
     def next_id(self) -> int:
@@ -89,7 +95,10 @@ def next_id(self) -> int:
         return next_id_value
 
     async def execute_callback(
-        self, goal: ServerGoalHandle[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT]
+        self,
+        goal: ServerGoalHandle[
+            ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT, ROSActionImplT
+        ],
     ) -> ROSActionResultT:
         """
         Execute action goal.
@@ -143,7 +152,10 @@ def done_callback(fut: Future[ROSActionResultT]) -> None:
             del self.goal_handles[goal_id]
 
     def cancel_callback(
-        self, goal: ServerGoalHandle[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT]
+        self,
+        goal: ServerGoalHandle[
+            ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT, ROSActionImplT
+        ],
     ) -> CancelResponse:
         """
         Cancel action goal.
@@ -270,8 +282,8 @@ def advertise_action(self, message: dict) -> None:
 
         # setup and store the action information
         action_type: str = message["type"]
-        action_handler: AdvertisedActionHandler[ROSMessage, ROSMessage, ROSMessage] = (
-            AdvertisedActionHandler(action_name, action_type, self.protocol)
+        action_handler = AdvertisedActionHandler[ROSMessage, ROSMessage, ROSMessage, Any](
+            action_name, action_type, self.protocol
         )
         self.protocol.external_action_list[action_name] = action_handler
         self.protocol.log("info", f"Advertised action {action_name}")

rosbridge_library/src/rosbridge_library/capabilities/send_action_goal.py

@@ -134,7 +134,7 @@ def send_action_goal(self, message: dict) -> None:
         f_cb = partial(self._feedback, cid, action) if message.get("feedback", False) else None
 
         # Run action client handler in the same thread.
-        client_handler: ActionClientHandler[ROSMessage, ROSMessage, ROSMessage] = (
+        client_handler: ActionClientHandler[ROSMessage, ROSMessage, ROSMessage, Any] = (
             ActionClientHandler(
                 trim_action_name(action),
                 action_type,

rosbridge_library/src/rosbridge_library/internal/actions.py

@@ -49,6 +49,7 @@
 from rosbridge_library.internal.type_support import (
     ROSActionFeedbackT,
     ROSActionGoalT,
+    ROSActionImplT,
     ROSActionResultT,
 )
 
@@ -69,7 +70,9 @@ def __init__(self, action_name: str) -> None:
         Exception.__init__(self, f"Action {action_name} does not exist")
 
 
-class ActionClientHandler(Thread, Generic[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT]):
+class ActionClientHandler(
+    Thread, Generic[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT, ROSActionImplT]
+):
     def __init__(
         self,
         action: str,
@@ -104,9 +107,9 @@ def __init__(
         self.error = error_callback
         self.feedback = feedback_callback
         self.node_handle = node_handle
-        self.send_goal_helper: SendGoal[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT] = (
-            SendGoal()
-        )
+        self.send_goal_helper = SendGoal[
+            ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT, ROSActionImplT
+        ]()
 
     def run(self) -> None:
         try:
@@ -143,7 +146,7 @@ def args_to_action_goal_instance(inst: ROSMessage, args: list | dict[str, Any] |
     populate_instance(msg, inst)
 
 
-class SendGoal(Generic[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT]):
+class SendGoal(Generic[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT, ROSActionImplT]):
     """Helper class to send action goals."""
 
     result: GetResultServiceResponse[ROSActionResultT] | Exception | None = None
@@ -152,15 +155,19 @@ def __init__(self, server_timeout_time: float = 1.0, sleep_time: float = 0.001)
         self.server_timeout_time = server_timeout_time
         self.sleep_time = sleep_time
         self.goal_handle: (
-            ClientGoalHandle[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT] | None
+            ClientGoalHandle[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT, ROSActionImplT]
+            | None
         ) = None
         self.goal_canceled = False
 
     def get_result_cb(self, future: Future[GetResultServiceResponse[ROSActionResultT]]) -> None:
         self.result = future.result()
 
     def goal_response_cb(
-        self, future: Future[ClientGoalHandle[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT]]
+        self,
+        future: Future[
+            ClientGoalHandle[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT, ROSActionImplT]
+        ],
     ) -> None:
         self.goal_handle = future.result()
         assert self.goal_handle is not None
@@ -193,7 +200,7 @@ def send_goal(
         args_to_action_goal_instance(inst, args)
 
         self.result = None
-        client: ActionClient[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT] = ActionClient(
+        client = ActionClient[ROSActionGoalT, ROSActionResultT, ROSActionFeedbackT, ROSActionImplT](
             node_handle, action_class, action_name
         )
         if not client.wait_for_server(timeout_sec=self.server_timeout_time):

rosbridge_library/src/rosbridge_library/internal/type_support.py

@@ -32,37 +32,13 @@
 
 from __future__ import annotations
 
-from typing import Protocol, TypeVar, runtime_checkable
+from typing import Any, TypeAlias, TypeVar
 
+from rosidl_pycommon.interface_base_classes import BaseAction, BaseImpl, BaseMessage, BaseService
 
-@runtime_checkable
-class ROSMessage(Protocol):
-    """Protocol for ROS message types."""
-
-    __slots__: list[str]
-    _fields_and_field_types: dict[str, str]
-
-    def get_fields_and_field_types(self) -> dict[str, str]:
-        """Return a dictionary of field names to field types."""
-
-
-@runtime_checkable
-class ROSService(Protocol):
-    """Protocol for ROS service types."""
-
-    Request: type[ROSMessage]
-    Response: type[ROSMessage]
-    Event: type[ROSMessage]
-
-
-@runtime_checkable
-class ROSAction(Protocol):
-    """Protocol for ROS action types."""
-
-    Goal: type[ROSMessage]
-    Result: type[ROSMessage]
-    Feedback: type[ROSMessage]
-
+ROSMessage: TypeAlias = BaseMessage
+ROSService: TypeAlias = BaseService
+ROSAction: TypeAlias = BaseAction
 
 # Type variables for ROS types
 ROSMessageT = TypeVar("ROSMessageT", bound=ROSMessage)
@@ -73,3 +49,4 @@ class ROSAction(Protocol):
 ROSActionGoalT = TypeVar("ROSActionGoalT", bound=ROSMessage)
 ROSActionResultT = TypeVar("ROSActionResultT", bound=ROSMessage)
 ROSActionFeedbackT = TypeVar("ROSActionFeedbackT", bound=ROSMessage)
+ROSActionImplT = TypeVar("ROSActionImplT", bound=BaseImpl[Any, Any, Any])

rosbridge_library/test/internal/actions/test_actions.py

@@ -33,20 +33,15 @@ def __init__(self, executor: Executor) -> None:
         self.executor = executor
         self.node = Node("action_tester")
         self.executor.add_node(self.node)
-        self.action_server: ActionServer[Fibonacci_Goal, Fibonacci_Result, Fibonacci_Feedback] = (
-            ActionServer(
-                self.node,
-                Fibonacci,
-                "get_fibonacci_sequence",
-                self.execute_callback,
-            )
+        self.action_server = ActionServer(
+            self.node, Fibonacci, "get_fibonacci_sequence", self.execute_callback
         )
 
     def __del__(self) -> None:
         self.executor.remove_node(self.node)
 
     def execute_callback(
-        self, goal: ServerGoalHandle[Fibonacci_Goal, Fibonacci_Result, Fibonacci_Feedback]
+        self, goal: ServerGoalHandle[Fibonacci_Goal, Fibonacci_Result, Fibonacci_Feedback, Any]
     ) -> Fibonacci_Result:
         self.goal = goal
         feedback_msg = Fibonacci.Feedback()
@@ -164,11 +159,7 @@ def get_result_callback(future: Future[GetResultServiceResponse[Fibonacci_Result
             received["msg"] = response.result
 
         # First, call the action the 'proper' way
-        client: ActionClient[Fibonacci_Goal, Fibonacci_Result, Fibonacci_Feedback] = ActionClient(
-            self.node,
-            Fibonacci,
-            "get_fibonacci_sequence",
-        )
+        client = ActionClient(self.node, Fibonacci, "get_fibonacci_sequence")
         client.wait_for_server()
         goal = Fibonacci.Goal()
         goal.order = 5