def generate_launch_description(): executable = "executable" if ROS_DISTRO == ROS_DISTRO_FOXY else "node_executable" pkg_share = get_package_share_directory("tennis_court") gazebo_ros_share = get_package_share_directory("gazebo_ros") # Gazebo Server gzserver_launch_file = os.path.join(gazebo_ros_share, "launch", "gzserver.launch.py") world_file = os.path.join(pkg_share, "worlds", "court.world") gzserver_launch = IncludeLaunchDescription( PythonLaunchDescriptionSource(gzserver_launch_file), launch_arguments={ "world": world_file, "verbose": "false", "pause": LaunchConfiguration("paused") }.items()) # Gazebo Client gzclient_launch_file = os.path.join(gazebo_ros_share, "launch", "gzclient.launch.py") gzclient_launch = IncludeLaunchDescription( PythonLaunchDescriptionSource(gzclient_launch_file), condition=IfCondition(LaunchConfiguration("gui"))) static_tf_node = Node(package="tf2_ros", arguments=[ "0", "0", "8", "3.14159", "1.57079", "3.14159", "map", "zenith_camera_link" ], **{executable: "static_transform_publisher"}) # Ball Manager ball_manager_node = Node(package="tennis_court", condition=IfCondition( LaunchConfiguration("manager")), parameters=[{ "use_sim_time": True }], output="screen", emulate_tty=True, **{executable: "ball_manager.py"}) # Rviz rviz_config_file = os.path.join(pkg_share, "config", "config.rviz") rviz_node = Node(package="rviz2", arguments=["-d", rviz_config_file], condition=IfCondition(LaunchConfiguration("rviz")), parameters=[{ "use_sim_time": True }], **{executable: "rviz2"}) return LaunchDescription([ DeclareLaunchArgument(name="gui", default_value="true"), DeclareLaunchArgument(name="paused", default_value="false"), DeclareLaunchArgument(name="rviz", default_value="false"), DeclareLaunchArgument(name="manager", default_value="true"), gzserver_launch, gzclient_launch, static_tf_node, ball_manager_node, rviz_node ])
def generate_launch_description(): """Launch euclidean cluster and ray ground classifier nodes.""" # euclidean cluster parameter file definition. vlp16_lexus_cluster_file_path = os.path.join( get_package_share_directory('euclidean_cluster_nodes'), 'param', 'vlp16_lexus_cluster.param.yaml') euclidean_cluster_param_file = launch.substitutions.LaunchConfiguration( 'params', default=[vlp16_lexus_cluster_file_path]) # ray ground classifier parameter file definition. vlp16_lexus_ray_ground_file_path = os.path.join( get_package_share_directory('ray_ground_classifier_nodes'), 'param', 'vlp16_lexus.param.yaml') ray_ground_param_file = launch.substitutions.LaunchConfiguration( 'params', default=[vlp16_lexus_ray_ground_file_path]) # euclidean cluster node execution definition. euclidean_cluster_node_runner = launch_ros.actions.Node( package='euclidean_cluster_nodes', node_executable='euclidean_cluster_node_exe', parameters=[euclidean_cluster_param_file], remappings=[("points_clustered", "cluster_points")]) # ros1 bridge runner definition. ray_ground_runner = launch_ros.actions.Node( package='ray_ground_classifier_nodes', node_executable='ray_ground_classifier_cloud_node_exe', parameters=[ray_ground_param_file], remappings=[("points_in", "lidar_front/points_filtered")]) return launch.LaunchDescription( [euclidean_cluster_node_runner, ray_ground_runner])
def test_get_package_share_directory(): set_ament_prefix_path(['prefix1', 'prefix2']) def get_package_share_directory_test(package_name, expect_prefix): full_share_dir = get_package_share_directory(package_name) left_over, dirname = os.path.split(full_share_dir) assert dirname == package_name, "Expected package name '{}'".format( package_name) left_over, dirname = os.path.split(left_over) assert dirname == 'share', "Expected 'share'" left_over, dirname = os.path.split(left_over) assert dirname == expect_prefix, "Expected '{}'".format(expect_prefix) get_package_share_directory_test('foo', 'prefix1') # found in both prefix1 and prefix2, but prefix1 is ahead on the APP get_package_share_directory_test('bar', 'prefix1') get_package_share_directory_test('baz', 'prefix2') try: get_package_share_directory('does_not_exist') except PackageNotFoundError: pass except Exception as exc: assert False, 'Expected PackageNotFoundError, got: {}'.format( type(exc))
def setUpClass(cls): cls.robot = urdf.Robot.from_xml_file( get_package_share_directory("march_description") + "/urdf/march6.urdf") cls.gait_directory = os.path.join( get_package_share_directory(VALID_PACKAGE), VALID_DIRECTORY) cls.gait_selection = GaitSelection(gait_package=VALID_PACKAGE, directory=VALID_DIRECTORY, robot=cls.robot)
def generate_launch_description(): map_data_prefix = get_package_share_directory('autoware_auto_avp_demo') # map_provider parameter file definition ndt_map_provider_file_path = os.path.join(map_data_prefix, "param", "map_publisher.param.yaml") map_provider_param_file = LaunchConfiguration( "params", default=[ndt_map_provider_file_path]) # map provide map file arguments map_yaml_file_path = os.path.join( map_data_prefix, "data/autonomoustuff_parking_lot_lgsvl.yaml") map_pcd_file_path = os.path.join( map_data_prefix, "data/autonomoustuff_parking_lot_lgsvl.pcd") map_yaml_file_param = DeclareLaunchArgument( 'map_yaml_file_arg', default_value=map_yaml_file_path, description='Map YAML file describing map origin') map_pcd_file_param = DeclareLaunchArgument( 'map_pcd_file_arg', default_value=map_pcd_file_path, description='Map PCD file containing 3D point cloud data') # map_provide node execution definition map_provider_node_runner = launch_ros.actions.Node( package="ndt_nodes", node_executable="ndt_map_publisher_exe", node_namespace="localization", parameters=[ map_provider_param_file, { "map_yaml_file": LaunchConfiguration('map_yaml_file_arg') }, { "map_pcd_file": LaunchConfiguration('map_pcd_file_arg') } ]) # map downsampler paramter file definition ndt_map_downsampler_file_path = os.path.join( get_package_share_directory('ndt_nodes'), 'param', 'pcl_map_voxel_grid_downsample.param.yaml') map_downsampler_param_file = launch.substitutions.LaunchConfiguration( 'params', default=[ndt_map_downsampler_file_path]) # map downsample node execution definition map_downsampler_node_runner = launch_ros.actions.Node( package='voxel_grid_nodes', node_executable='voxel_grid_node_exe', parameters=[map_downsampler_param_file], remappings=[("points_in", "viz_ndt_map"), ("points_downsampled", "viz_ndt_map_downsampled")]) # require a map file location return launch.LaunchDescription([ map_yaml_file_param, map_pcd_file_param, map_provider_node_runner, map_downsampler_node_runner ])
def generate_test_description(ready_fn): PORT = lidar_integration.get_open_port() # The nodes under test: velodyne_block_node = launch_ros.actions.Node( package="velodyne_node", node_executable="velodyne_cloud_node_exe", node_name="vlp16_test_node", node_namespace="lidar_front", parameters=[ os.path.join( ament_index_python.get_package_share_directory("velodyne_node"), "vlp16_test.param.yaml" ), { "port": PORT, } ] ) point_cloud_filter_transform_node = launch_ros.actions.Node( package="point_cloud_filter_transform_nodes", node_executable="point_cloud_filter_transform_node_exe", node_name="point_cloud_filter_transform_node", node_namespace="lidar_front", parameters=[ os.path.join( ament_index_python.get_package_share_directory( "point_cloud_filter_transform_nodes"), "param", "test.param.yaml" ), { "expected_num_ground_subscribers": 1, "expected_num_nonground_subscribers": 1, } ], remappings=[("points_in", "points_raw")] ) filtered_points_checker = lidar_integration.make_pcl_checker( topic="points_filtered", size=16930, period=100, period_tolerance=1.0 ) return lidar_integration.get_lidar_launch_description( test_nodes=[velodyne_block_node, point_cloud_filter_transform_node], checkers=[filtered_points_checker], other_actions=[ launch.actions.OpaqueFunction(function=lambda context: ready_fn()) ], port=PORT )
def setUp(self): self.robot = urdf.Robot.from_xml_file( get_package_share_directory("march_description") + "/urdf/march6.urdf" ) self.gait_directory = os.path.join( get_package_share_directory(TEST_PACKAGE), TEST_DIRECTORY ) self.gait_selection = GaitSelection( gait_package=TEST_PACKAGE, directory=TEST_DIRECTORY, robot=self.robot ) self.load_realsense_gaits()
def generate_launch_description(): default_vehicle_characteristics_param = os.path.join( get_package_share_directory('simple_planning_simulator'), 'param/vehicle_characteristics.param.param.yaml') vehicle_characteristics_param = DeclareLaunchArgument( 'vehicle_characteristics_param_file', default_value=default_vehicle_characteristics_param, description='Path to config file for vehicle characteristics' ) simple_planning_simulator_node = launch_ros.actions.Node( package='simple_planning_simulator', executable='simple_planning_simulator_exe', name='simple_planning_simulator', namespace='simulation', output='screen', parameters=[ "{}/param/simple_planning_simulator_default.param.yaml".format( ament_index_python.get_package_share_directory( "simple_planning_simulator" ) ), LaunchConfiguration('vehicle_characteristics_param_file'), ], remappings=[ ('input/vehicle_control_command', '/vehicle/vehicle_command'), ('input/ackermann_control_command', '/control/command/control_cmd'), ('input/gear_command', '/control/command/gear_cmd'), ('input/trajectory', '/planning/scenario_planning/trajectory'), ('output/twist', '/vehicle/status/velocity_status'), ('output/odometry', '/localization/kinematic_state'), ('output/steering', '/vehicle/status/steering_status'), ('output/gear_report', '/vehicle/status/gear_status'), ('output/control_mode_report', '/vehicle/status/control_mode'), ('/initialpose', '/initialpose'), ] ) map_to_odom_tf_publisher = launch_ros.actions.Node( package='tf2_ros', executable='static_transform_publisher', name='static_map_to_odom_tf_publisher', output='screen', arguments=['0.0', '0.0', '0.0', '0', '0', '0', 'map', 'odom']) ld = launch.LaunchDescription([ vehicle_characteristics_param, simple_planning_simulator_node, map_to_odom_tf_publisher ]) return ld
def generate_test_description(ready_fn): # The node under test and the checker node that will pass/fail our tests: test_topic = "veloyne_cloud_node_test_topic" velodyne_cloud_node = launch_ros.actions.LifecycleNode( package="velodyne_node", node_executable="velodyne_cloud_node_exe", node_name="vlp16_driver_node", node_namespace="lidar_front", parameters=[ "{}/param/vlp16_test.param.yaml".format( ament_index_python.get_package_share_directory("velodyne_node") ), { "cloud_size": 500, "topic": test_topic } ], arguments=["--model", "vlp16"] ) context = {'vel_node': velodyne_cloud_node} return launch.LaunchDescription([ ROSSpecificLaunchStartup(), velodyne_cloud_node, # Need to keep the launch alive by having an alive process launch_testing.util.KeepAliveProc(), # Start tests right away - no need to wait for anything launch.actions.OpaqueFunction(function=lambda context: ready_fn())] ), context
def setUp(self): self.gait_name = "walk" self.robot = urdf.Robot.from_xml_file( get_package_share_directory("march_description") + "/urdf/march6.urdf") self.resources_folder = os.path.join( get_package_share_directory("march_utility"), "test", "resources") self.default_yaml = os.path.join(self.resources_folder, "default.yaml") with open(self.default_yaml, "r") as default_yaml_file: default_config = yaml.load(default_yaml_file, Loader=yaml.SafeLoader) self.gait_version_map = default_config["gaits"] self.gait = Gait.from_file(self.gait_name, self.resources_folder, self.robot, self.gait_version_map)
def generate_launch_description(): params_file = LaunchConfiguration( 'params', default=[ThisLaunchFileDir(), '/launch_params.yaml']) # make sure the dbc file gets installed with the launch file dbc_file_path = get_package_share_directory('raptor_dbw_can') + \ "/launch/New_Eagle_DBW_3.3.388.dbc" return LaunchDescription([ Node( package='raptor_dbw_can', executable='raptor_dbw_can_node', output='screen', namespace='raptor_dbw_interface', parameters=[{ "dbw_dbc_file": dbc_file_path }], remappings=[ ('/raptor_dbw_interface/can_rx', '/can_rx_tx/can_tx'), ('/raptor_dbw_interface/can_tx', '/can_rx_tx/can_rx'), ], ), LifecycleNode(package='kvaser_interface', node_executable='kvaser_can_bridge', node_name="kvaser_interface", output='screen', namespace='', parameters=[params_file]), ])
def __init__(self, node: Node, gui, urdf_path=None, foot_link_names=[], terrain_height=0, field=False, robot="wolfgang"): super().__init__(node) # load simuation params load_parameter_file( node=node, node_name=self.node.get_name(), parameter_file=get_package_share_directory('wolfgang_pybullet_sim') + '/config/config.yaml', use_wildcard=True) self.gui = gui self.sim: Simulation = Simulation(gui, urdf_path=urdf_path, foot_link_names=foot_link_names, terrain_height=terrain_height, field=field, robot=robot) self.sim_interface: ROSInterface = ROSInterface( self.node, self.sim, declare_parameters=False)
def generate_test_description(): robot_information_node = IncludeLaunchDescription( PythonLaunchDescriptionSource( os.path.join( get_package_share_directory("march_robot_information"), "launch", "robot_information.launch.py", )), launch_arguments=[("joint_names", "[test_joint1, test_joint2, test_joint3]")], ) safety_node = Node( package="march_safety", executable="march_safety_node", name="safety_node", namespace="march", output="screen", parameters=[ { "input_device_connection_timeout": INPUT_DEVICE_CONNECTION_TIMEOUT }, { "use_sim_time": False }, ], ) return ( LaunchDescription([ robot_information_node, safety_node, ReadyToTest(), ]), {}, )
def generate_test_description(ready_fn): PORT = lidar_integration.get_open_port() # The node under test and the checker node that will pass/fail our tests: test_topic = "veloyne_cloud_node_test_topic" velodyne_cloud_node = launch_ros.actions.LifecycleNode( package="velodyne_node", node_executable="velodyne_cloud_node_exe", node_name="vlp16_driver_node", node_namespace="lidar_front", parameters=[ "{}/param/vlp16_test.param.yaml".format( ament_index_python.get_package_share_directory( "velodyne_node")), { "port": PORT, "cloud_size": 10700, "expected_num_subscribers": 1, } ], remappings=[("points_raw", test_topic)], arguments=["--model", "vlp16"]) pcl_checker = lidar_integration.make_pcl_checker( topic=test_topic, size=10700, period=50, ) return lidar_integration.get_lidar_launch_description( test_nodes=[velodyne_cloud_node], checkers=[pcl_checker], other_actions=[ launch.actions.OpaqueFunction(function=lambda context: ready_fn()) ], port=PORT)
def generate_launch_description(): return LaunchDescription([ DeclareLaunchArgument( name="config_path", default_value=os.path.join( get_package_share_directory("march_safety"), "config", "safety_settings.yaml", ), description="Path to the configuration for the safety settings", ), DeclareLaunchArgument( name="use_sim_time", default_value="true", description="Whether to use simulation time", ), Node( package="march_safety", executable="march_safety_node", name="safety_node", namespace="march", output="screen", parameters=[ LaunchConfiguration("config_path"), { "use_sim_time": LaunchConfiguration("use_sim_time") }, ], # If this node exits, the entire system is shutdown # This is the ROS2 equivalent of required:=true # See: https://ubuntu.com/blog/ros2-launch-required-nodes on_exit=Shutdown(), ), ])
def generate_launch_description(): config = DeclareLaunchArgument( 'yaml', default_value=join(get_package_share_directory('unbag2'), 'cfg', 'unbag2.yml'), description= 'path to the config file, by default the one stored in this package.') files = DeclareLaunchArgument( 'files', default_value='', description= 'string containing a list of all files/directories to try to read as ' 'bag files') config_param = LaunchConfiguration('yaml') files_param = LaunchConfiguration('files') return LaunchDescription([ files, config, LogInfo(msg=["Un-Bagging files: ", files_param]), Node(package='unbag2', executable='unbag2', output='screen', name='unbag2', parameters=[config_param, { 'files': files_param }]) ])
def generate_launch_description(): params_file = LaunchConfiguration( 'params', default=[ThisLaunchFileDir(), '/launch_params.yaml']) # make sure the dbc file gets installed with the launch file dbc_file_path = get_package_share_directory('raptor_dbw_can') + \ '/launch/New_Eagle_DBW_3.4.dbc' return LaunchDescription( [ Node( package='raptor_dbw_can', executable='raptor_dbw_can_node', output='screen', namespace='raptor_dbw_interface', parameters=[ {'dbw_dbc_file': dbc_file_path}, params_file ], ), Node( package='kvaser_interface', executable='kvaser_can_bridge', output='screen', namespace='raptor_dbw_interface', parameters=[params_file]), ])
def get_filename(url, use_protocol=True): mod_url = url if url.find(PACKAGE_PREFIX) == 0: mod_url = url[len(PACKAGE_PREFIX):] pos = mod_url.find('/') if pos == -1: raise Exception( 'Could not parse package:// format into file:// format for ' + url) package = mod_url[0:pos] mod_url = mod_url[pos:] package_path = get_package_share_directory(package) if use_protocol: protocol = 'file://' else: protocol = '' if sys.platform.startswith('win'): path_without_protocol = package_path + mod_url path_without_protocol = '/' + path_without_protocol.replace( '/', '\\') mod_url = protocol + path_without_protocol else: mod_url = protocol + package_path + mod_url return mod_url
def generate_test_description(ready_fn): # The node under test and the checker node that will pass/fail our tests: test_topic = "veloyne_cloud_node_test_topic" node = launch_ros.actions.Node( package="voxel_grid_nodes", node_executable="voxel_grid_node_exe", node_name="voxel_grid_cloud_node", parameters=[ "{}/param/vlp16_lexus_centroid.param.yaml".format( ament_index_python.get_package_share_directory( "voxel_grid_nodes") )], remappings=[ ("points_in", test_topic) ]) ld, context = lidar_integration.get_point_cloud_mutation_launch_description( test_nodes=[node], checkers=[], # TODO we only check that node does not crash for now topic=test_topic, other_actions=[ launch.actions.OpaqueFunction(function=lambda context: ready_fn()) ]) return ld, context
def init(node: Node): node.get_logger().info("Starting localization handler") global_params_dict = get_parameters_from_other_node( node, "parameter_blackboard", ["field_length", "team_id"]) global_params = [("field_length", global_params_dict["field_length"]), ("team_id", global_params_dict["team_id"])] node.declare_parameters(parameters=global_params, namespace="") blackboard = LocalizationBlackboard(node) dirname = get_package_share_directory("bitbots_localization_handler") node.get_logger().info(dirname) dsd = DSD(blackboard, "debug/dsd/localization", node) dsd.register_actions(os.path.join(dirname, 'actions')) dsd.register_decisions(os.path.join(dirname, 'decisions')) dsd.load_behavior(os.path.join(dirname, 'localization.dsd')) node.create_subscription(PoseWithCovarianceStamped, "pose_with_covariance", blackboard._callback_pose, 1) node.create_subscription(GameState, "gamestate", blackboard.gamestate.gamestate_callback, 1) node.create_subscription(RobotControlState, "robot_state", blackboard._callback_robot_control_state, 1) return dsd
def generate(self, package_name, interface_files, include_paths, output_path): package_share_path = \ pathlib.Path(get_package_share_directory('rosidl_generator_cpp')) templates_path = package_share_path / 'resource' # Normalize interface definition format to .idl idl_interface_files = [] non_idl_interface_files = [] for path in interface_files: if not path.endswith('.idl'): non_idl_interface_files.append(path) else: idl_interface_files.append(path) if non_idl_interface_files: idl_interface_files.extend( translate( package_name=package_name, interface_files=non_idl_interface_files, include_paths=include_paths, output_format='idl', output_path=output_path / 'tmp', )) # Generate code with legacy_generator_arguments_file( package_name=package_name, interface_files=idl_interface_files, include_paths=include_paths, templates_path=templates_path, output_path=output_path) as path_to_arguments_file: return generate_cpp(path_to_arguments_file)
def generate_test_description(ready_fn): # The node under test and the checker node that will pass/fail our tests: state_estimation_node = launch_ros.actions.Node( package="state_estimation_node", node_executable="state_estimation_node_exe", node_name="state_estimation_node", node_namespace="state_estimation_namespace", parameters=[ "{}/param/state_estimation_node_test.param.yaml".format( ament_index_python.get_package_share_directory( "state_estimation_node") ), {"output_frequency": 30.0} ] ) context = {'state_node': state_estimation_node} return launch.LaunchDescription([ ROSSpecificLaunchStartup(), state_estimation_node, # Need to keep the launch alive by having an alive process launch_testing.util.KeepAliveProc(), # Start tests right away - no need to wait for anything launch.actions.OpaqueFunction(function=lambda context: ready_fn())] ), context
def generate_test_description(): robot_information_node = IncludeLaunchDescription( PythonLaunchDescriptionSource( os.path.join( get_package_share_directory("march_robot_information"), "launch", "robot_information.launch.py", ) ), launch_arguments=[("joint_names", f"[{','.join(JOINT_NAMES)}]")], ) safety_node = Node( package="march_safety", executable="march_safety_node", name="safety_node", namespace="march", output="screen", parameters=[CONFIG_PATH, {"use_sim_time": False}], ) return ( LaunchDescription( [ robot_information_node, safety_node, ReadyToTest(), ] ), {}, )
def setUpClass(cls): rclpy.init() cls.robot = urdf.Robot.from_xml_file( get_package_share_directory("march_description") + "/urdf/march4.urdf" ) cls.stand_position = StaticEdgePosition( (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8) )
def get_package_share_directory_test(package_name, expect_prefix): full_share_dir = get_package_share_directory(package_name) left_over, dirname = os.path.split(full_share_dir) assert dirname == package_name, f"Expected package name '{package_name}'" left_over, dirname = os.path.split(left_over) assert dirname == 'share', "Expected 'share'" left_over, dirname = os.path.split(left_over) assert dirname == expect_prefix, f"Expected '{expect_prefix}'"
def set_param_to_file(node, param, package, file): path = get_package_share_directory(package) with open(path + file, 'r') as file: file_content = file.read() node.set_parameters([ rclpy.parameter.Parameter(param, rclpy.Parameter.Type.DOUBLE, file_content) ])
def get_param_file(package_name, file_name): """Helper function to get param file""" file_path = os.path.join( get_package_share_directory(package_name), 'param', file_name) return launch.substitutions.LaunchConfiguration( 'params', default=[file_path])
def generate(self, package_name, interface_files, include_paths, output_path): generated_files = [] package_share_path = \ get_package_share_directory('rosidl_typesupport_c') templates_path = os.path.join(package_share_path, 'resource') # Normalize interface definition format to .idl idl_interface_files = [] non_idl_interface_files = [] for path in interface_files: if not path.endswith('.idl'): non_idl_interface_files.append(path) else: idl_interface_files.append(path) if non_idl_interface_files: idl_interface_files.extend( translate( package_name=package_name, interface_files=non_idl_interface_files, include_paths=include_paths, output_format='idl', output_path=output_path / 'tmp', )) # Generate visibility control file visibility_control_file_template_path = \ 'rosidl_typesupport_c__visibility_control.h.in' visibility_control_file_template_path = \ templates_path / visibility_control_file_template_path visibility_control_file_path = \ 'rosidl_typesupport_c__visibility_control.h' visibility_control_file_path = \ output_path / 'msg' / visibility_control_file_path generate_visibility_control_file( package_name=package_name, template_path=visibility_control_file_template_path, output_path=visibility_control_file_path) generated_files.append(visibility_control_file_path) # Generate typesupport code typesupport_implementations = list( get_resources('rosidl_typesupport_c')) with legacy_generator_arguments_file( package_name=package_name, interface_files=idl_interface_files, include_paths=include_paths, templates_path=templates_path, output_path=output_path) as path_to_arguments_file: generated_files.extend( generate_c(path_to_arguments_file, typesupport_implementations)) return generated_files
def main(): parser = argparse.ArgumentParser() parser.add_argument("--destination", required=True, help="Absolute path to new package (without package name)." "e.g., ~/autoware_ws/src") parser.add_argument("--pkg-name", required=True, help="Name of the new package") parser.add_argument("--maintainer", required=True, help="Name of maintainer (for package.xml)") parser.add_argument("--email", required=True, help="Email of the maintainer (for package.xml)") parser.add_argument("--description", required=True, help="Description of package (for package.xml)") args = parser.parse_args() dest = os.path.join(args.destination, args.pkg_name) # Copy the template package to the desired location template_pkg_dir = os.path.join( get_package_share_directory('autoware_auto_create_pkg'), 'template') copy(template_pkg_dir, dest) # Remove COLCON_IGNORE try: os.remove(os.path.join(dest, 'COLCON_IGNORE')) except FileNotFoundError: pass # Find and replace all hello_world and HELLO_WORLD with pkg_name and PKG_NAME for root, _, files in os.walk(dest): for filename in files: if filename == 'package.xml': find_and_replace(os.path.join(root, filename), args.pkg_name, args.email, description=args.description, maintainer=args.maintainer) else: find_and_replace(os.path.join(root, filename), args.pkg_name, args.email) if 'hello_world' in filename: new_filename = filename.replace('hello_world', args.pkg_name) os.rename(os.path.join(root, filename), os.path.join(root, new_filename)) # Rename directories for root, dirs, _ in os.walk(dest): for dirname in dirs: if 'hello_world' in dirname: new_dirname = dirname.replace('hello_world', args.pkg_name) os.rename(os.path.join(root, dirname), os.path.join(root, new_dirname)) print("Package {} has been generated in {}.".format(args.pkg_name, args.destination)) return 0
def load_yaml(package_name, file_path): package_path = get_package_share_directory(package_name) absolute_file_path = os.path.join(package_path, file_path) try: with open(absolute_file_path, "r") as file: return yaml.safe_load(file) except EnvironmentError: # parent of IOError, OSError *and* WindowsError where available return None