pre-commit changes

Author: URJala

ur_robot_driver/CMakeLists.txt

@@ -148,7 +148,7 @@ target_link_libraries(trajectory_until_node PUBLIC
   ${std_msgs_TARGETS}
   rclcpp_action::rclcpp_action
   ${ur_msgs_TARGETS}
-  )
+)
 
 install(
   TARGETS

ur_robot_driver/doc/trajectory_until_node.rst

@@ -19,4 +19,4 @@ Implementation details
 """"""""""""""""""""""
 Upon instantiation of the node, the internal trajectory action client will connect to an action named ``motion_controller/follow_joint_trajectory``.
 This action does not exist, but upon launch of the driver, the node is remapped to connect to the ``initial_joint_controller``, default is ``scaled_joint_trajectory_controller``.
-If you wish to use the node with another motion controller use the launch argument ``initial_joint_controller:=<your_motion_controller>`` when launching the driver.
+If you wish to use the node with another motion controller use the launch argument ``initial_joint_controller:=<your_motion_controller>`` when launching the driver.

ur_robot_driver/include/ur_robot_driver/trajectory_until_node.hpp

@@ -55,7 +55,6 @@
 #include <ur_msgs/action/trajectory_until.hpp>
 #include <control_msgs/action/follow_joint_trajectory.hpp>
 
-
 namespace ur_robot_driver
 {
 class TrajectoryUntilNode : public rclcpp::Node
@@ -77,16 +76,14 @@ class TrajectoryUntilNode : public rclcpp::Node
 
   std::shared_ptr<rclcpp_action::ServerGoalHandle<ur_msgs::action::TrajectoryUntil>> server_goal_handle_;
 
-  template<class ActionType, class ClientType>
+  template <class ActionType, class ClientType>
   void send_until_goal(std::shared_ptr<const ur_msgs::action::TrajectoryUntil::Goal> goal);
 
-  template<class T>
-  void
-  until_response_callback(const typename rclcpp_action::ClientGoalHandle<T>::SharedPtr& goal_handle);
+  template <class T>
+  void until_response_callback(const typename rclcpp_action::ClientGoalHandle<T>::SharedPtr& goal_handle);
 
-  template<class T>
-  void
-  until_result_callback(const typename rclcpp_action::ClientGoalHandle<T>::WrappedResult& result);
+  template <class T>
+  void until_result_callback(const typename rclcpp_action::ClientGoalHandle<T>::WrappedResult& result);
 
   void cancel_until_goal();
 

ur_robot_driver/launch/ur_control.launch.py

@@ -164,8 +164,11 @@ def launch_setup(context):
         name="trajectory_until_node",
         output="screen",
         remappings=[
-            ('/motion_controller/follow_joint_trajectory', f'/{initial_joint_controller.perform(context)}/follow_joint_trajectory'),
-            ]
+            (
+                "/motion_controller/follow_joint_trajectory",
+                f"/{initial_joint_controller.perform(context)}/follow_joint_trajectory",
+            ),
+        ],
     )
 
     # Spawn controllers

ur_robot_driver/src/trajectory_until_node.cpp

@@ -96,9 +96,9 @@ bool TrajectoryUntilNode::assign_until_action_client(std::shared_ptr<const Traje
   switch (type) {
     case TrajectoryUntil::Goal::TOOL_CONTACT:
       until_action_client_variant = rclcpp_action::create_client<TCAction>(this,
-                                                                     "/tool_contact_controller/"
-                                                                     "detect_tool_contact",
-                                                                     clients_callback_group);
+                                                                           "/tool_contact_controller/"
+                                                                           "detect_tool_contact",
+                                                                           clients_callback_group);
       break;
 
     default:
@@ -118,7 +118,7 @@ rclcpp_action::GoalResponse TrajectoryUntilNode::goal_received_callback(
     return rclcpp_action::GoalResponse::REJECT;
   }
 
-  if(!assign_until_action_client(goal)){
+  if (!assign_until_action_client(goal)) {
     RCLCPP_ERROR(this->get_logger(), "Until type not defined, double check the types in the action "
                                      "definition.");
     return rclcpp_action::GoalResponse::REJECT;
@@ -129,17 +129,16 @@ rclcpp_action::GoalResponse TrajectoryUntilNode::goal_received_callback(
   }
 
   // Check until action server, send action goal to until-controller and wait for it to be accepted.
-  if(std::holds_alternative<TCClient>(until_action_client_variant)){
+  if (std::holds_alternative<TCClient>(until_action_client_variant)) {
     if (!std::get<TCClient>(until_action_client_variant)->wait_for_action_server(std::chrono::seconds(1))) {
       RCLCPP_ERROR(this->get_logger(), "Until action server not available.");
       return rclcpp_action::GoalResponse::REJECT;
     }
     send_until_goal<TCAction, TCClient>(goal);
-  }
-  else{
+  } else {
     throw std::runtime_error("Until type not implemented. This should not happen.");
   }
-  
+
   // If it is not accepted within 1 seconds, it is
   // assumed to be rejected.
   std::unique_lock<std::mutex> until_lock(mutex_until);
@@ -204,19 +203,19 @@ void TrajectoryUntilNode::send_trajectory_goal(std::shared_ptr<const TrajectoryU
 }
 
 // Send the until goal, using the relevant fields supplied from the action server.
-template<class ActionType, class ClientType>
+template <class ActionType, class ClientType>
 void TrajectoryUntilNode::send_until_goal(std::shared_ptr<const TrajectoryUntil::Goal> /* goal */)
 {
-  // Setup goal 
+  // Setup goal
   auto goal_msg = typename ActionType::Goal();
   auto send_goal_options = typename rclcpp_action::Client<ActionType>::SendGoalOptions();
   send_goal_options.goal_response_callback =
-    std::bind(&TrajectoryUntilNode::until_response_callback<ActionType>, this, std::placeholders::_1);
+      std::bind(&TrajectoryUntilNode::until_response_callback<ActionType>, this, std::placeholders::_1);
   send_goal_options.result_callback =
-    std::bind(&TrajectoryUntilNode::until_result_callback<ActionType>, this, std::placeholders::_1);
+      std::bind(&TrajectoryUntilNode::until_result_callback<ActionType>, this, std::placeholders::_1);
 
   // Send goal
-  std::get<ClientType>(until_action_client_variant) -> async_send_goal(goal_msg, send_goal_options);
+  std::get<ClientType>(until_action_client_variant)->async_send_goal(goal_msg, send_goal_options);
 }
 
 void TrajectoryUntilNode::trajectory_response_callback(
@@ -235,7 +234,7 @@ void TrajectoryUntilNode::trajectory_response_callback(
   cv_trajectory_.notify_one();
 }
 
-template<class T>
+template <class T>
 void TrajectoryUntilNode::until_response_callback(
     const typename rclcpp_action::ClientGoalHandle<T>::SharedPtr& goal_handle)
 {
@@ -263,7 +262,7 @@ void TrajectoryUntilNode::trajectory_feedback_callback(
     prealloc_fb->error = feedback->error;
     prealloc_fb->header = feedback->header;
     prealloc_fb->joint_names = feedback->joint_names;
-    if(server_goal_handle_){
+    if (server_goal_handle_) {
       server_goal_handle_->publish_feedback(prealloc_fb);
     }
   }
@@ -278,8 +277,9 @@ void TrajectoryUntilNode::trajectory_result_callback(
   report_goal(result);
 }
 
-template<class T>
-void TrajectoryUntilNode::until_result_callback(const typename rclcpp_action::ClientGoalHandle<T>::WrappedResult& result)
+template <class T>
+void TrajectoryUntilNode::until_result_callback(
+    const typename rclcpp_action::ClientGoalHandle<T>::WrappedResult& result)
 {
   RCLCPP_INFO(this->get_logger(), "Until result received.");
   current_until_goal_handle_.reset();
@@ -345,8 +345,9 @@ void TrajectoryUntilNode::report_goal(UntilResult result)
         break;
 
       default:
-        prealloc_res->error_string += "Unknown result code received from until action, this should not happen. Aborting "
-                                     "goal.";
+        prealloc_res->error_string += "Unknown result code received from until action, this should not happen. "
+                                      "Aborting "
+                                      "goal.";
         server_goal_handle_->abort(prealloc_res);
 
         break;
@@ -380,10 +381,10 @@ void TrajectoryUntilNode::reset_node()
 }
 
 // Cancel the action contained in the variant, regardless of what type it is.
-void TrajectoryUntilNode::cancel_until_goal(){
-  std::visit([this](const auto& until_client) {
-      until_client->async_cancel_goal(current_until_goal_handle_);
-    }, until_action_client_variant);
+void TrajectoryUntilNode::cancel_until_goal()
+{
+  std::visit([this](const auto& until_client) { until_client->async_cancel_goal(current_until_goal_handle_); },
+             until_action_client_variant);
 }
 
 }  // namespace ur_robot_driver

ur_robot_driver/test/integration_test_trajectory_until.py

@@ -31,7 +31,6 @@
 import sys
 import time
 import unittest
-import logging
 
 import pytest
 
@@ -41,7 +40,6 @@
 
 from controller_manager_msgs.srv import SwitchController
 from ur_msgs.action import TrajectoryUntil
-from action_msgs.msg import GoalStatus
 from action_msgs.srv import CancelGoal_Response
 from trajectory_msgs.msg import JointTrajectory, JointTrajectoryPoint
 from builtin_interfaces.msg import Duration
@@ -64,7 +62,9 @@
     [("", "scaled_joint_trajectory_controller"), ("my_ur_", "passthrough_trajectory_controller")],
 )
 def generate_test_description(tf_prefix, initial_joint_controller):
-    return generate_driver_test_description(tf_prefix=tf_prefix, initial_joint_controller=initial_joint_controller)
+    return generate_driver_test_description(
+        tf_prefix=tf_prefix, initial_joint_controller=initial_joint_controller
+    )
 
 
 class RobotDriverTest(unittest.TestCase):
@@ -119,7 +119,9 @@ def test_trajectory_with_tool_contact_no_trigger_succeeds(self, tf_prefix):
             )
             for i in range(len(self.test_traj["waypts"]))
         ]
-        goal_handle = self._trajectory_until_interface.send_goal(trajectory=trajectory, until_type=TrajectoryUntil.Goal.TOOL_CONTACT)
+        goal_handle = self._trajectory_until_interface.send_goal(
+            trajectory=trajectory, until_type=TrajectoryUntil.Goal.TOOL_CONTACT
+        )
         self.assertTrue(goal_handle.accepted)
         if goal_handle.accepted:
             result = self._trajectory_until_interface.get_result(
@@ -133,7 +135,7 @@ def test_trajectory_with_tool_contact_no_trigger_succeeds(self, tf_prefix):
                 deactivate_controllers=["tool_contact_controller"],
             ).ok
         )
-    
+
     def test_trajectory_until_can_cancel(self, tf_prefix):
         self.assertTrue(
             self._controller_manager_interface.switch_controller(
@@ -150,7 +152,9 @@ def test_trajectory_until_can_cancel(self, tf_prefix):
             )
             for i in range(len(self.test_traj["waypts"]))
         ]
-        goal_handle = self._trajectory_until_interface.send_goal(trajectory=trajectory, until_type=TrajectoryUntil.Goal.TOOL_CONTACT)
+        goal_handle = self._trajectory_until_interface.send_goal(
+            trajectory=trajectory, until_type=TrajectoryUntil.Goal.TOOL_CONTACT
+        )
         self.assertTrue(goal_handle.accepted)
         time.sleep(2)
         result = self._trajectory_until_interface.cancel_goal(goal_handle)
@@ -162,4 +166,3 @@ def test_trajectory_until_can_cancel(self, tf_prefix):
                 deactivate_controllers=["tool_contact_controller"],
             ).ok
         )
-