AS: creating final node

test/ros_osc/build/.built_by

@@ -0,0 +1 @@
+colcon

test/ros_osc/install/.colcon_install_layout

@@ -0,0 +1 @@
+isolated

test/ros_osc/install/_local_setup_util_ps1.py

@@ -0,0 +1,407 @@
+# Copyright 2016-2019 Dirk Thomas
+# Licensed under the Apache License, Version 2.0
+
+import argparse
+from collections import OrderedDict
+import os
+from pathlib import Path
+import sys
+
+
+FORMAT_STR_COMMENT_LINE = '# {comment}'
+FORMAT_STR_SET_ENV_VAR = 'Set-Item -Path "Env:{name}" -Value "{value}"'
+FORMAT_STR_USE_ENV_VAR = '$env:{name}'
+FORMAT_STR_INVOKE_SCRIPT = '_colcon_prefix_powershell_source_script "{script_path}"'  # noqa: E501
+FORMAT_STR_REMOVE_LEADING_SEPARATOR = ''  # noqa: E501
+FORMAT_STR_REMOVE_TRAILING_SEPARATOR = ''  # noqa: E501
+
+DSV_TYPE_APPEND_NON_DUPLICATE = 'append-non-duplicate'
+DSV_TYPE_PREPEND_NON_DUPLICATE = 'prepend-non-duplicate'
+DSV_TYPE_PREPEND_NON_DUPLICATE_IF_EXISTS = 'prepend-non-duplicate-if-exists'
+DSV_TYPE_SET = 'set'
+DSV_TYPE_SET_IF_UNSET = 'set-if-unset'
+DSV_TYPE_SOURCE = 'source'
+
+
+def main(argv=sys.argv[1:]):  # noqa: D103
+    parser = argparse.ArgumentParser(
+        description='Output shell commands for the packages in topological '
+                    'order')
+    parser.add_argument(
+        'primary_extension',
+        help='The file extension of the primary shell')
+    parser.add_argument(
+        'additional_extension', nargs='?',
+        help='The additional file extension to be considered')
+    parser.add_argument(
+        '--merged-install', action='store_true',
+        help='All install prefixes are merged into a single location')
+    args = parser.parse_args(argv)
+
+    packages = get_packages(Path(__file__).parent, args.merged_install)
+
+    ordered_packages = order_packages(packages)
+    for pkg_name in ordered_packages:
+        if _include_comments():
+            print(
+                FORMAT_STR_COMMENT_LINE.format_map(
+                    {'comment': 'Package: ' + pkg_name}))
+        prefix = os.path.abspath(os.path.dirname(__file__))
+        if not args.merged_install:
+            prefix = os.path.join(prefix, pkg_name)
+        for line in get_commands(
+            pkg_name, prefix, args.primary_extension,
+            args.additional_extension
+        ):
+            print(line)
+
+    for line in _remove_ending_separators():
+        print(line)
+
+
+def get_packages(prefix_path, merged_install):
+    """
+    Find packages based on colcon-specific files created during installation.
+
+    :param Path prefix_path: The install prefix path of all packages
+    :param bool merged_install: The flag if the packages are all installed
+      directly in the prefix or if each package is installed in a subdirectory
+      named after the package
+    :returns: A mapping from the package name to the set of runtime
+      dependencies
+    :rtype: dict
+    """
+    packages = {}
+    # since importing colcon_core isn't feasible here the following constant
+    # must match colcon_core.location.get_relative_package_index_path()
+    subdirectory = 'share/colcon-core/packages'
+    if merged_install:
+        # return if workspace is empty
+        if not (prefix_path / subdirectory).is_dir():
+            return packages
+        # find all files in the subdirectory
+        for p in (prefix_path / subdirectory).iterdir():
+            if not p.is_file():
+                continue
+            if p.name.startswith('.'):
+                continue
+            add_package_runtime_dependencies(p, packages)
+    else:
+        # for each subdirectory look for the package specific file
+        for p in prefix_path.iterdir():
+            if not p.is_dir():
+                continue
+            if p.name.startswith('.'):
+                continue
+            p = p / subdirectory / p.name
+            if p.is_file():
+                add_package_runtime_dependencies(p, packages)
+
+    # remove unknown dependencies
+    pkg_names = set(packages.keys())
+    for k in packages.keys():
+        packages[k] = {d for d in packages[k] if d in pkg_names}
+
+    return packages
+
+
+def add_package_runtime_dependencies(path, packages):
+    """
+    Check the path and if it exists extract the packages runtime dependencies.
+
+    :param Path path: The resource file containing the runtime dependencies
+    :param dict packages: A mapping from package names to the sets of runtime
+      dependencies to add to
+    """
+    content = path.read_text()
+    dependencies = set(content.split(os.pathsep) if content else [])
+    packages[path.name] = dependencies
+
+
+def order_packages(packages):
+    """
+    Order packages topologically.
+
+    :param dict packages: A mapping from package name to the set of runtime
+      dependencies
+    :returns: The package names
+    :rtype: list
+    """
+    # select packages with no dependencies in alphabetical order
+    to_be_ordered = list(packages.keys())
+    ordered = []
+    while to_be_ordered:
+        pkg_names_without_deps = [
+            name for name in to_be_ordered if not packages[name]]
+        if not pkg_names_without_deps:
+            reduce_cycle_set(packages)
+            raise RuntimeError(
+                'Circular dependency between: ' + ', '.join(sorted(packages)))
+        pkg_names_without_deps.sort()
+        pkg_name = pkg_names_without_deps[0]
+        to_be_ordered.remove(pkg_name)
+        ordered.append(pkg_name)
+        # remove item from dependency lists
+        for k in list(packages.keys()):
+            if pkg_name in packages[k]:
+                packages[k].remove(pkg_name)
+    return ordered
+
+
+def reduce_cycle_set(packages):
+    """
+    Reduce the set of packages to the ones part of the circular dependency.
+
+    :param dict packages: A mapping from package name to the set of runtime
+      dependencies which is modified in place
+    """
+    last_depended = None
+    while len(packages) > 0:
+        # get all remaining dependencies
+        depended = set()
+        for pkg_name, dependencies in packages.items():
+            depended = depended.union(dependencies)
+        # remove all packages which are not dependent on
+        for name in list(packages.keys()):
+            if name not in depended:
+                del packages[name]
+        if last_depended:
+            # if remaining packages haven't changed return them
+            if last_depended == depended:
+                return packages.keys()
+        # otherwise reduce again
+        last_depended = depended
+
+
+def _include_comments():
+    # skipping comment lines when COLCON_TRACE is not set speeds up the
+    # processing especially on Windows
+    return bool(os.environ.get('COLCON_TRACE'))
+
+
+def get_commands(pkg_name, prefix, primary_extension, additional_extension):
+    commands = []
+    package_dsv_path = os.path.join(prefix, 'share', pkg_name, 'package.dsv')
+    if os.path.exists(package_dsv_path):
+        commands += process_dsv_file(
+            package_dsv_path, prefix, primary_extension, additional_extension)
+    return commands
+
+
+def process_dsv_file(
+    dsv_path, prefix, primary_extension=None, additional_extension=None
+):
+    commands = []
+    if _include_comments():
+        commands.append(FORMAT_STR_COMMENT_LINE.format_map({'comment': dsv_path}))
+    with open(dsv_path, 'r') as h:
+        content = h.read()
+    lines = content.splitlines()
+
+    basenames = OrderedDict()
+    for i, line in enumerate(lines):
+        # skip over empty or whitespace-only lines
+        if not line.strip():
+            continue
+        # skip over comments
+        if line.startswith('#'):
+            continue
+        try:
+            type_, remainder = line.split(';', 1)
+        except ValueError:
+            raise RuntimeError(
+                "Line %d in '%s' doesn't contain a semicolon separating the "
+                'type from the arguments' % (i + 1, dsv_path))
+        if type_ != DSV_TYPE_SOURCE:
+            # handle non-source lines
+            try:
+                commands += handle_dsv_types_except_source(
+                    type_, remainder, prefix)
+            except RuntimeError as e:
+                raise RuntimeError(
+                    "Line %d in '%s' %s" % (i + 1, dsv_path, e)) from e
+        else:
+            # group remaining source lines by basename
+            path_without_ext, ext = os.path.splitext(remainder)
+            if path_without_ext not in basenames:
+                basenames[path_without_ext] = set()
+            assert ext.startswith('.')
+            ext = ext[1:]
+            if ext in (primary_extension, additional_extension):
+                basenames[path_without_ext].add(ext)
+
+    # add the dsv extension to each basename if the file exists
+    for basename, extensions in basenames.items():
+        if not os.path.isabs(basename):
+            basename = os.path.join(prefix, basename)
+        if os.path.exists(basename + '.dsv'):
+            extensions.add('dsv')
+
+    for basename, extensions in basenames.items():
+        if not os.path.isabs(basename):
+            basename = os.path.join(prefix, basename)
+        if 'dsv' in extensions:
+            # process dsv files recursively
+            commands += process_dsv_file(
+                basename + '.dsv', prefix, primary_extension=primary_extension,
+                additional_extension=additional_extension)
+        elif primary_extension in extensions and len(extensions) == 1:
+            # source primary-only files
+            commands += [
+                FORMAT_STR_INVOKE_SCRIPT.format_map({
+                    'prefix': prefix,
+                    'script_path': basename + '.' + primary_extension})]
+        elif additional_extension in extensions:
+            # source non-primary files
+            commands += [
+                FORMAT_STR_INVOKE_SCRIPT.format_map({
+                    'prefix': prefix,
+                    'script_path': basename + '.' + additional_extension})]
+
+    return commands
+
+
+def handle_dsv_types_except_source(type_, remainder, prefix):
+    commands = []
+    if type_ in (DSV_TYPE_SET, DSV_TYPE_SET_IF_UNSET):
+        try:
+            env_name, value = remainder.split(';', 1)
+        except ValueError:
+            raise RuntimeError(
+                "doesn't contain a semicolon separating the environment name "
+                'from the value')
+        try_prefixed_value = os.path.join(prefix, value) if value else prefix
+        if os.path.exists(try_prefixed_value):
+            value = try_prefixed_value
+        if type_ == DSV_TYPE_SET:
+            commands += _set(env_name, value)
+        elif type_ == DSV_TYPE_SET_IF_UNSET:
+            commands += _set_if_unset(env_name, value)
+        else:
+            assert False
+    elif type_ in (
+        DSV_TYPE_APPEND_NON_DUPLICATE,
+        DSV_TYPE_PREPEND_NON_DUPLICATE,
+        DSV_TYPE_PREPEND_NON_DUPLICATE_IF_EXISTS
+    ):
+        try:
+            env_name_and_values = remainder.split(';')
+        except ValueError:
+            raise RuntimeError(
+                "doesn't contain a semicolon separating the environment name "
+                'from the values')
+        env_name = env_name_and_values[0]
+        values = env_name_and_values[1:]
+        for value in values:
+            if not value:
+                value = prefix
+            elif not os.path.isabs(value):
+                value = os.path.join(prefix, value)
+            if (
+                type_ == DSV_TYPE_PREPEND_NON_DUPLICATE_IF_EXISTS and
+                not os.path.exists(value)
+            ):
+                comment = f'skip extending {env_name} with not existing ' \
+                    f'path: {value}'
+                if _include_comments():
+                    commands.append(
+                        FORMAT_STR_COMMENT_LINE.format_map({'comment': comment}))
+            elif type_ == DSV_TYPE_APPEND_NON_DUPLICATE:
+                commands += _append_unique_value(env_name, value)
+            else:
+                commands += _prepend_unique_value(env_name, value)
+    else:
+        raise RuntimeError(
+            'contains an unknown environment hook type: ' + type_)
+    return commands
+
+
+env_state = {}
+
+
+def _append_unique_value(name, value):
+    global env_state
+    if name not in env_state:
+        if os.environ.get(name):
+            env_state[name] = set(os.environ[name].split(os.pathsep))
+        else:
+            env_state[name] = set()
+    # append even if the variable has not been set yet, in case a shell script sets the
+    # same variable without the knowledge of this Python script.
+    # later _remove_ending_separators() will cleanup any unintentional leading separator
+    extend = FORMAT_STR_USE_ENV_VAR.format_map({'name': name}) + os.pathsep
+    line = FORMAT_STR_SET_ENV_VAR.format_map(
+        {'name': name, 'value': extend + value})
+    if value not in env_state[name]:
+        env_state[name].add(value)
+    else:
+        if not _include_comments():
+            return []
+        line = FORMAT_STR_COMMENT_LINE.format_map({'comment': line})
+    return [line]
+
+
+def _prepend_unique_value(name, value):
+    global env_state
+    if name not in env_state:
+        if os.environ.get(name):
+            env_state[name] = set(os.environ[name].split(os.pathsep))
+        else:
+            env_state[name] = set()
+    # prepend even if the variable has not been set yet, in case a shell script sets the
+    # same variable without the knowledge of this Python script.
+    # later _remove_ending_separators() will cleanup any unintentional trailing separator
+    extend = os.pathsep + FORMAT_STR_USE_ENV_VAR.format_map({'name': name})
+    line = FORMAT_STR_SET_ENV_VAR.format_map(
+        {'name': name, 'value': value + extend})
+    if value not in env_state[name]:
+        env_state[name].add(value)
+    else:
+        if not _include_comments():
+            return []
+        line = FORMAT_STR_COMMENT_LINE.format_map({'comment': line})
+    return [line]
+
+
+# generate commands for removing prepended underscores
+def _remove_ending_separators():
+    # do nothing if the shell extension does not implement the logic
+    if FORMAT_STR_REMOVE_TRAILING_SEPARATOR is None:
+        return []
+
+    global env_state
+    commands = []
+    for name in env_state:
+        # skip variables that already had values before this script started prepending
+        if name in os.environ:
+            continue
+        commands += [
+            FORMAT_STR_REMOVE_LEADING_SEPARATOR.format_map({'name': name}),
+            FORMAT_STR_REMOVE_TRAILING_SEPARATOR.format_map({'name': name})]
+    return commands
+
+
+def _set(name, value):
+    global env_state
+    env_state[name] = value
+    line = FORMAT_STR_SET_ENV_VAR.format_map(
+        {'name': name, 'value': value})
+    return [line]
+
+
+def _set_if_unset(name, value):
+    global env_state
+    line = FORMAT_STR_SET_ENV_VAR.format_map(
+        {'name': name, 'value': value})
+    if env_state.get(name, os.environ.get(name)):
+        line = FORMAT_STR_COMMENT_LINE.format_map({'comment': line})
+    return [line]
+
+
+if __name__ == '__main__':  # pragma: no cover
+    try:
+        rc = main()
+    except RuntimeError as e:
+        print(str(e), file=sys.stderr)
+        rc = 1
+    sys.exit(rc)

test/ros_osc/install/_local_setup_util_sh.py

@@ -0,0 +1,407 @@
+# Copyright 2016-2019 Dirk Thomas
+# Licensed under the Apache License, Version 2.0
+
+import argparse
+from collections import OrderedDict
+import os
+from pathlib import Path
+import sys
+
+
+FORMAT_STR_COMMENT_LINE = '# {comment}'
+FORMAT_STR_SET_ENV_VAR = 'export {name}="{value}"'
+FORMAT_STR_USE_ENV_VAR = '${name}'
+FORMAT_STR_INVOKE_SCRIPT = 'COLCON_CURRENT_PREFIX="{prefix}" _colcon_prefix_sh_source_script "{script_path}"'  # noqa: E501
+FORMAT_STR_REMOVE_LEADING_SEPARATOR = 'if [ "$(echo -n ${name} | head -c 1)" = ":" ]; then export {name}=${{{name}#?}} ; fi'  # noqa: E501
+FORMAT_STR_REMOVE_TRAILING_SEPARATOR = 'if [ "$(echo -n ${name} | tail -c 1)" = ":" ]; then export {name}=${{{name}%?}} ; fi'  # noqa: E501
+
+DSV_TYPE_APPEND_NON_DUPLICATE = 'append-non-duplicate'
+DSV_TYPE_PREPEND_NON_DUPLICATE = 'prepend-non-duplicate'
+DSV_TYPE_PREPEND_NON_DUPLICATE_IF_EXISTS = 'prepend-non-duplicate-if-exists'
+DSV_TYPE_SET = 'set'
+DSV_TYPE_SET_IF_UNSET = 'set-if-unset'
+DSV_TYPE_SOURCE = 'source'
+
+
+def main(argv=sys.argv[1:]):  # noqa: D103
+    parser = argparse.ArgumentParser(
+        description='Output shell commands for the packages in topological '
+                    'order')
+    parser.add_argument(
+        'primary_extension',
+        help='The file extension of the primary shell')
+    parser.add_argument(
+        'additional_extension', nargs='?',
+        help='The additional file extension to be considered')
+    parser.add_argument(
+        '--merged-install', action='store_true',
+        help='All install prefixes are merged into a single location')
+    args = parser.parse_args(argv)
+
+    packages = get_packages(Path(__file__).parent, args.merged_install)
+
+    ordered_packages = order_packages(packages)
+    for pkg_name in ordered_packages:
+        if _include_comments():
+            print(
+                FORMAT_STR_COMMENT_LINE.format_map(
+                    {'comment': 'Package: ' + pkg_name}))
+        prefix = os.path.abspath(os.path.dirname(__file__))
+        if not args.merged_install:
+            prefix = os.path.join(prefix, pkg_name)
+        for line in get_commands(
+            pkg_name, prefix, args.primary_extension,
+            args.additional_extension
+        ):
+            print(line)
+
+    for line in _remove_ending_separators():
+        print(line)
+
+
+def get_packages(prefix_path, merged_install):
+    """
+    Find packages based on colcon-specific files created during installation.
+
+    :param Path prefix_path: The install prefix path of all packages
+    :param bool merged_install: The flag if the packages are all installed
+      directly in the prefix or if each package is installed in a subdirectory
+      named after the package
+    :returns: A mapping from the package name to the set of runtime
+      dependencies
+    :rtype: dict
+    """
+    packages = {}
+    # since importing colcon_core isn't feasible here the following constant
+    # must match colcon_core.location.get_relative_package_index_path()
+    subdirectory = 'share/colcon-core/packages'
+    if merged_install:
+        # return if workspace is empty
+        if not (prefix_path / subdirectory).is_dir():
+            return packages
+        # find all files in the subdirectory
+        for p in (prefix_path / subdirectory).iterdir():
+            if not p.is_file():
+                continue
+            if p.name.startswith('.'):
+                continue
+            add_package_runtime_dependencies(p, packages)
+    else:
+        # for each subdirectory look for the package specific file
+        for p in prefix_path.iterdir():
+            if not p.is_dir():
+                continue
+            if p.name.startswith('.'):
+                continue
+            p = p / subdirectory / p.name
+            if p.is_file():
+                add_package_runtime_dependencies(p, packages)
+
+    # remove unknown dependencies
+    pkg_names = set(packages.keys())
+    for k in packages.keys():
+        packages[k] = {d for d in packages[k] if d in pkg_names}
+
+    return packages
+
+
+def add_package_runtime_dependencies(path, packages):
+    """
+    Check the path and if it exists extract the packages runtime dependencies.
+
+    :param Path path: The resource file containing the runtime dependencies
+    :param dict packages: A mapping from package names to the sets of runtime
+      dependencies to add to
+    """
+    content = path.read_text()
+    dependencies = set(content.split(os.pathsep) if content else [])
+    packages[path.name] = dependencies
+
+
+def order_packages(packages):
+    """
+    Order packages topologically.
+
+    :param dict packages: A mapping from package name to the set of runtime
+      dependencies
+    :returns: The package names
+    :rtype: list
+    """
+    # select packages with no dependencies in alphabetical order
+    to_be_ordered = list(packages.keys())
+    ordered = []
+    while to_be_ordered:
+        pkg_names_without_deps = [
+            name for name in to_be_ordered if not packages[name]]
+        if not pkg_names_without_deps:
+            reduce_cycle_set(packages)
+            raise RuntimeError(
+                'Circular dependency between: ' + ', '.join(sorted(packages)))
+        pkg_names_without_deps.sort()
+        pkg_name = pkg_names_without_deps[0]
+        to_be_ordered.remove(pkg_name)
+        ordered.append(pkg_name)
+        # remove item from dependency lists
+        for k in list(packages.keys()):
+            if pkg_name in packages[k]:
+                packages[k].remove(pkg_name)
+    return ordered
+
+
+def reduce_cycle_set(packages):
+    """
+    Reduce the set of packages to the ones part of the circular dependency.
+
+    :param dict packages: A mapping from package name to the set of runtime
+      dependencies which is modified in place
+    """
+    last_depended = None
+    while len(packages) > 0:
+        # get all remaining dependencies
+        depended = set()
+        for pkg_name, dependencies in packages.items():
+            depended = depended.union(dependencies)
+        # remove all packages which are not dependent on
+        for name in list(packages.keys()):
+            if name not in depended:
+                del packages[name]
+        if last_depended:
+            # if remaining packages haven't changed return them
+            if last_depended == depended:
+                return packages.keys()
+        # otherwise reduce again
+        last_depended = depended
+
+
+def _include_comments():
+    # skipping comment lines when COLCON_TRACE is not set speeds up the
+    # processing especially on Windows
+    return bool(os.environ.get('COLCON_TRACE'))
+
+
+def get_commands(pkg_name, prefix, primary_extension, additional_extension):
+    commands = []
+    package_dsv_path = os.path.join(prefix, 'share', pkg_name, 'package.dsv')
+    if os.path.exists(package_dsv_path):
+        commands += process_dsv_file(
+            package_dsv_path, prefix, primary_extension, additional_extension)
+    return commands
+
+
+def process_dsv_file(
+    dsv_path, prefix, primary_extension=None, additional_extension=None
+):
+    commands = []
+    if _include_comments():
+        commands.append(FORMAT_STR_COMMENT_LINE.format_map({'comment': dsv_path}))
+    with open(dsv_path, 'r') as h:
+        content = h.read()
+    lines = content.splitlines()
+
+    basenames = OrderedDict()
+    for i, line in enumerate(lines):
+        # skip over empty or whitespace-only lines
+        if not line.strip():
+            continue
+        # skip over comments
+        if line.startswith('#'):
+            continue
+        try:
+            type_, remainder = line.split(';', 1)
+        except ValueError:
+            raise RuntimeError(
+                "Line %d in '%s' doesn't contain a semicolon separating the "
+                'type from the arguments' % (i + 1, dsv_path))
+        if type_ != DSV_TYPE_SOURCE:
+            # handle non-source lines
+            try:
+                commands += handle_dsv_types_except_source(
+                    type_, remainder, prefix)
+            except RuntimeError as e:
+                raise RuntimeError(
+                    "Line %d in '%s' %s" % (i + 1, dsv_path, e)) from e
+        else:
+            # group remaining source lines by basename
+            path_without_ext, ext = os.path.splitext(remainder)
+            if path_without_ext not in basenames:
+                basenames[path_without_ext] = set()
+            assert ext.startswith('.')
+            ext = ext[1:]
+            if ext in (primary_extension, additional_extension):
+                basenames[path_without_ext].add(ext)
+
+    # add the dsv extension to each basename if the file exists
+    for basename, extensions in basenames.items():
+        if not os.path.isabs(basename):
+            basename = os.path.join(prefix, basename)
+        if os.path.exists(basename + '.dsv'):
+            extensions.add('dsv')
+
+    for basename, extensions in basenames.items():
+        if not os.path.isabs(basename):
+            basename = os.path.join(prefix, basename)
+        if 'dsv' in extensions:
+            # process dsv files recursively
+            commands += process_dsv_file(
+                basename + '.dsv', prefix, primary_extension=primary_extension,
+                additional_extension=additional_extension)
+        elif primary_extension in extensions and len(extensions) == 1:
+            # source primary-only files
+            commands += [
+                FORMAT_STR_INVOKE_SCRIPT.format_map({
+                    'prefix': prefix,
+                    'script_path': basename + '.' + primary_extension})]
+        elif additional_extension in extensions:
+            # source non-primary files
+            commands += [
+                FORMAT_STR_INVOKE_SCRIPT.format_map({
+                    'prefix': prefix,
+                    'script_path': basename + '.' + additional_extension})]
+
+    return commands
+
+
+def handle_dsv_types_except_source(type_, remainder, prefix):
+    commands = []
+    if type_ in (DSV_TYPE_SET, DSV_TYPE_SET_IF_UNSET):
+        try:
+            env_name, value = remainder.split(';', 1)
+        except ValueError:
+            raise RuntimeError(
+                "doesn't contain a semicolon separating the environment name "
+                'from the value')
+        try_prefixed_value = os.path.join(prefix, value) if value else prefix
+        if os.path.exists(try_prefixed_value):
+            value = try_prefixed_value
+        if type_ == DSV_TYPE_SET:
+            commands += _set(env_name, value)
+        elif type_ == DSV_TYPE_SET_IF_UNSET:
+            commands += _set_if_unset(env_name, value)
+        else:
+            assert False
+    elif type_ in (
+        DSV_TYPE_APPEND_NON_DUPLICATE,
+        DSV_TYPE_PREPEND_NON_DUPLICATE,
+        DSV_TYPE_PREPEND_NON_DUPLICATE_IF_EXISTS
+    ):
+        try:
+            env_name_and_values = remainder.split(';')
+        except ValueError:
+            raise RuntimeError(
+                "doesn't contain a semicolon separating the environment name "
+                'from the values')
+        env_name = env_name_and_values[0]
+        values = env_name_and_values[1:]
+        for value in values:
+            if not value:
+                value = prefix
+            elif not os.path.isabs(value):
+                value = os.path.join(prefix, value)
+            if (
+                type_ == DSV_TYPE_PREPEND_NON_DUPLICATE_IF_EXISTS and
+                not os.path.exists(value)
+            ):
+                comment = f'skip extending {env_name} with not existing ' \
+                    f'path: {value}'
+                if _include_comments():
+                    commands.append(
+                        FORMAT_STR_COMMENT_LINE.format_map({'comment': comment}))
+            elif type_ == DSV_TYPE_APPEND_NON_DUPLICATE:
+                commands += _append_unique_value(env_name, value)
+            else:
+                commands += _prepend_unique_value(env_name, value)
+    else:
+        raise RuntimeError(
+            'contains an unknown environment hook type: ' + type_)
+    return commands
+
+
+env_state = {}
+
+
+def _append_unique_value(name, value):
+    global env_state
+    if name not in env_state:
+        if os.environ.get(name):
+            env_state[name] = set(os.environ[name].split(os.pathsep))
+        else:
+            env_state[name] = set()
+    # append even if the variable has not been set yet, in case a shell script sets the
+    # same variable without the knowledge of this Python script.
+    # later _remove_ending_separators() will cleanup any unintentional leading separator
+    extend = FORMAT_STR_USE_ENV_VAR.format_map({'name': name}) + os.pathsep
+    line = FORMAT_STR_SET_ENV_VAR.format_map(
+        {'name': name, 'value': extend + value})
+    if value not in env_state[name]:
+        env_state[name].add(value)
+    else:
+        if not _include_comments():
+            return []
+        line = FORMAT_STR_COMMENT_LINE.format_map({'comment': line})
+    return [line]
+
+
+def _prepend_unique_value(name, value):
+    global env_state
+    if name not in env_state:
+        if os.environ.get(name):
+            env_state[name] = set(os.environ[name].split(os.pathsep))
+        else:
+            env_state[name] = set()
+    # prepend even if the variable has not been set yet, in case a shell script sets the
+    # same variable without the knowledge of this Python script.
+    # later _remove_ending_separators() will cleanup any unintentional trailing separator
+    extend = os.pathsep + FORMAT_STR_USE_ENV_VAR.format_map({'name': name})
+    line = FORMAT_STR_SET_ENV_VAR.format_map(
+        {'name': name, 'value': value + extend})
+    if value not in env_state[name]:
+        env_state[name].add(value)
+    else:
+        if not _include_comments():
+            return []
+        line = FORMAT_STR_COMMENT_LINE.format_map({'comment': line})
+    return [line]
+
+
+# generate commands for removing prepended underscores
+def _remove_ending_separators():
+    # do nothing if the shell extension does not implement the logic
+    if FORMAT_STR_REMOVE_TRAILING_SEPARATOR is None:
+        return []
+
+    global env_state
+    commands = []
+    for name in env_state:
+        # skip variables that already had values before this script started prepending
+        if name in os.environ:
+            continue
+        commands += [
+            FORMAT_STR_REMOVE_LEADING_SEPARATOR.format_map({'name': name}),
+            FORMAT_STR_REMOVE_TRAILING_SEPARATOR.format_map({'name': name})]
+    return commands
+
+
+def _set(name, value):
+    global env_state
+    env_state[name] = value
+    line = FORMAT_STR_SET_ENV_VAR.format_map(
+        {'name': name, 'value': value})
+    return [line]
+
+
+def _set_if_unset(name, value):
+    global env_state
+    line = FORMAT_STR_SET_ENV_VAR.format_map(
+        {'name': name, 'value': value})
+    if env_state.get(name, os.environ.get(name)):
+        line = FORMAT_STR_COMMENT_LINE.format_map({'comment': line})
+    return [line]
+
+
+if __name__ == '__main__':  # pragma: no cover
+    try:
+        rc = main()
+    except RuntimeError as e:
+        print(str(e), file=sys.stderr)
+        rc = 1
+    sys.exit(rc)

test/ros_osc/install/local_setup.bash

@@ -0,0 +1,121 @@
+# generated from colcon_bash/shell/template/prefix.bash.em
+
+# This script extends the environment with all packages contained in this
+# prefix path.
+
+# a bash script is able to determine its own path if necessary
+if [ -z "$COLCON_CURRENT_PREFIX" ]; then
+  _colcon_prefix_bash_COLCON_CURRENT_PREFIX="$(builtin cd "`dirname "${BASH_SOURCE[0]}"`" > /dev/null && pwd)"
+else
+  _colcon_prefix_bash_COLCON_CURRENT_PREFIX="$COLCON_CURRENT_PREFIX"
+fi
+
+# function to prepend a value to a variable
+# which uses colons as separators
+# duplicates as well as trailing separators are avoided
+# first argument: the name of the result variable
+# second argument: the value to be prepended
+_colcon_prefix_bash_prepend_unique_value() {
+  # arguments
+  _listname="$1"
+  _value="$2"
+
+  # get values from variable
+  eval _values=\"\$$_listname\"
+  # backup the field separator
+  _colcon_prefix_bash_prepend_unique_value_IFS="$IFS"
+  IFS=":"
+  # start with the new value
+  _all_values="$_value"
+  _contained_value=""
+  # iterate over existing values in the variable
+  for _item in $_values; do
+    # ignore empty strings
+    if [ -z "$_item" ]; then
+      continue
+    fi
+    # ignore duplicates of _value
+    if [ "$_item" = "$_value" ]; then
+      _contained_value=1
+      continue
+    fi
+    # keep non-duplicate values
+    _all_values="$_all_values:$_item"
+  done
+  unset _item
+  if [ -z "$_contained_value" ]; then
+    if [ -n "$COLCON_TRACE" ]; then
+      if [ "$_all_values" = "$_value" ]; then
+        echo "export $_listname=$_value"
+      else
+        echo "export $_listname=$_value:\$$_listname"
+      fi
+    fi
+  fi
+  unset _contained_value
+  # restore the field separator
+  IFS="$_colcon_prefix_bash_prepend_unique_value_IFS"
+  unset _colcon_prefix_bash_prepend_unique_value_IFS
+  # export the updated variable
+  eval export $_listname=\"$_all_values\"
+  unset _all_values
+  unset _values
+
+  unset _value
+  unset _listname
+}
+
+# add this prefix to the COLCON_PREFIX_PATH
+_colcon_prefix_bash_prepend_unique_value COLCON_PREFIX_PATH "$_colcon_prefix_bash_COLCON_CURRENT_PREFIX"
+unset _colcon_prefix_bash_prepend_unique_value
+
+# check environment variable for custom Python executable
+if [ -n "$COLCON_PYTHON_EXECUTABLE" ]; then
+  if [ ! -f "$COLCON_PYTHON_EXECUTABLE" ]; then
+    echo "error: COLCON_PYTHON_EXECUTABLE '$COLCON_PYTHON_EXECUTABLE' doesn't exist"
+    return 1
+  fi
+  _colcon_python_executable="$COLCON_PYTHON_EXECUTABLE"
+else
+  # try the Python executable known at configure time
+  _colcon_python_executable="/usr/bin/python3"
+  # if it doesn't exist try a fall back
+  if [ ! -f "$_colcon_python_executable" ]; then
+    if ! /usr/bin/env python3 --version > /dev/null 2> /dev/null; then
+      echo "error: unable to find python3 executable"
+      return 1
+    fi
+    _colcon_python_executable=`/usr/bin/env python3 -c "import sys; print(sys.executable)"`
+  fi
+fi
+
+# function to source another script with conditional trace output
+# first argument: the path of the script
+_colcon_prefix_sh_source_script() {
+  if [ -f "$1" ]; then
+    if [ -n "$COLCON_TRACE" ]; then
+      echo "# . \"$1\""
+    fi
+    . "$1"
+  else
+    echo "not found: \"$1\"" 1>&2
+  fi
+}
+
+# get all commands in topological order
+_colcon_ordered_commands="$($_colcon_python_executable "$_colcon_prefix_bash_COLCON_CURRENT_PREFIX/_local_setup_util_sh.py" sh bash)"
+unset _colcon_python_executable
+if [ -n "$COLCON_TRACE" ]; then
+  echo "$(declare -f _colcon_prefix_sh_source_script)"
+  echo "# Execute generated script:"
+  echo "# <<<"
+  echo "${_colcon_ordered_commands}"
+  echo "# >>>"
+  echo "unset _colcon_prefix_sh_source_script"
+fi
+eval "${_colcon_ordered_commands}"
+unset _colcon_ordered_commands
+
+unset _colcon_prefix_sh_source_script
+
+unset _colcon_prefix_bash_COLCON_CURRENT_PREFIX

test/ros_osc/install/local_setup.ps1

@@ -0,0 +1,55 @@
+# generated from colcon_powershell/shell/template/prefix.ps1.em
+
+# This script extends the environment with all packages contained in this
+# prefix path.
+
+# check environment variable for custom Python executable
+if ($env:COLCON_PYTHON_EXECUTABLE) {
+  if (!(Test-Path "$env:COLCON_PYTHON_EXECUTABLE" -PathType Leaf)) {
+    echo "error: COLCON_PYTHON_EXECUTABLE '$env:COLCON_PYTHON_EXECUTABLE' doesn't exist"
+    exit 1
+  }
+  $_colcon_python_executable="$env:COLCON_PYTHON_EXECUTABLE"
+} else {
+  # use the Python executable known at configure time
+  $_colcon_python_executable="/usr/bin/python3"
+  # if it doesn't exist try a fall back
+  if (!(Test-Path "$_colcon_python_executable" -PathType Leaf)) {
+    if (!(Get-Command "python3" -ErrorAction SilentlyContinue)) {
+      echo "error: unable to find python3 executable"
+      exit 1
+    }
+    $_colcon_python_executable="python3"
+  }
+}
+
+# function to source another script with conditional trace output
+# first argument: the path of the script
+function _colcon_prefix_powershell_source_script {
+  param (
+    $_colcon_prefix_powershell_source_script_param
+  )
+  # source script with conditional trace output
+  if (Test-Path $_colcon_prefix_powershell_source_script_param) {
+    if ($env:COLCON_TRACE) {
+      echo ". '$_colcon_prefix_powershell_source_script_param'"
+    }
+    . "$_colcon_prefix_powershell_source_script_param"
+  } else {
+    Write-Error "not found: '$_colcon_prefix_powershell_source_script_param'"
+  }
+}
+
+# get all commands in topological order
+$_colcon_ordered_commands = & "$_colcon_python_executable" "$(Split-Path $PSCommandPath -Parent)/_local_setup_util_ps1.py" ps1
+
+# execute all commands in topological order
+if ($env:COLCON_TRACE) {
+  echo "Execute generated script:"
+  echo "<<<"
+  $_colcon_ordered_commands.Split([Environment]::NewLine, [StringSplitOptions]::RemoveEmptyEntries) | Write-Output
+  echo ">>>"
+}
+if ($_colcon_ordered_commands) {
+  $_colcon_ordered_commands.Split([Environment]::NewLine, [StringSplitOptions]::RemoveEmptyEntries) | Invoke-Expression
+}

test/ros_osc/install/local_setup.sh

@@ -0,0 +1,137 @@
+# generated from colcon_core/shell/template/prefix.sh.em
+
+# This script extends the environment with all packages contained in this
+# prefix path.
+
+# since a plain shell script can't determine its own path when being sourced
+# either use the provided COLCON_CURRENT_PREFIX
+# or fall back to the build time prefix (if it exists)
+_colcon_prefix_sh_COLCON_CURRENT_PREFIX="/BA/ros_osc/install"
+if [ -z "$COLCON_CURRENT_PREFIX" ]; then
+  if [ ! -d "$_colcon_prefix_sh_COLCON_CURRENT_PREFIX" ]; then
+    echo "The build time path \"$_colcon_prefix_sh_COLCON_CURRENT_PREFIX\" doesn't exist. Either source a script for a different shell or set the environment variable \"COLCON_CURRENT_PREFIX\" explicitly." 1>&2
+    unset _colcon_prefix_sh_COLCON_CURRENT_PREFIX
+    return 1
+  fi
+else
+  _colcon_prefix_sh_COLCON_CURRENT_PREFIX="$COLCON_CURRENT_PREFIX"
+fi
+
+# function to prepend a value to a variable
+# which uses colons as separators
+# duplicates as well as trailing separators are avoided
+# first argument: the name of the result variable
+# second argument: the value to be prepended
+_colcon_prefix_sh_prepend_unique_value() {
+  # arguments
+  _listname="$1"
+  _value="$2"
+
+  # get values from variable
+  eval _values=\"\$$_listname\"
+  # backup the field separator
+  _colcon_prefix_sh_prepend_unique_value_IFS="$IFS"
+  IFS=":"
+  # start with the new value
+  _all_values="$_value"
+  _contained_value=""
+  # iterate over existing values in the variable
+  for _item in $_values; do
+    # ignore empty strings
+    if [ -z "$_item" ]; then
+      continue
+    fi
+    # ignore duplicates of _value
+    if [ "$_item" = "$_value" ]; then
+      _contained_value=1
+      continue
+    fi
+    # keep non-duplicate values
+    _all_values="$_all_values:$_item"
+  done
+  unset _item
+  if [ -z "$_contained_value" ]; then
+    if [ -n "$COLCON_TRACE" ]; then
+      if [ "$_all_values" = "$_value" ]; then
+        echo "export $_listname=$_value"
+      else
+        echo "export $_listname=$_value:\$$_listname"
+      fi
+    fi
+  fi
+  unset _contained_value
+  # restore the field separator
+  IFS="$_colcon_prefix_sh_prepend_unique_value_IFS"
+  unset _colcon_prefix_sh_prepend_unique_value_IFS
+  # export the updated variable
+  eval export $_listname=\"$_all_values\"
+  unset _all_values
+  unset _values
+
+  unset _value
+  unset _listname
+}
+
+# add this prefix to the COLCON_PREFIX_PATH
+_colcon_prefix_sh_prepend_unique_value COLCON_PREFIX_PATH "$_colcon_prefix_sh_COLCON_CURRENT_PREFIX"
+unset _colcon_prefix_sh_prepend_unique_value
+
+# check environment variable for custom Python executable
+if [ -n "$COLCON_PYTHON_EXECUTABLE" ]; then
+  if [ ! -f "$COLCON_PYTHON_EXECUTABLE" ]; then
+    echo "error: COLCON_PYTHON_EXECUTABLE '$COLCON_PYTHON_EXECUTABLE' doesn't exist"
+    return 1
+  fi
+  _colcon_python_executable="$COLCON_PYTHON_EXECUTABLE"
+else
+  # try the Python executable known at configure time
+  _colcon_python_executable="/usr/bin/python3"
+  # if it doesn't exist try a fall back
+  if [ ! -f "$_colcon_python_executable" ]; then
+    if ! /usr/bin/env python3 --version > /dev/null 2> /dev/null; then
+      echo "error: unable to find python3 executable"
+      return 1
+    fi
+    _colcon_python_executable=`/usr/bin/env python3 -c "import sys; print(sys.executable)"`
+  fi
+fi
+
+# function to source another script with conditional trace output
+# first argument: the path of the script
+_colcon_prefix_sh_source_script() {
+  if [ -f "$1" ]; then
+    if [ -n "$COLCON_TRACE" ]; then
+      echo "# . \"$1\""
+    fi
+    . "$1"
+  else
+    echo "not found: \"$1\"" 1>&2
+  fi
+}
+
+# get all commands in topological order
+_colcon_ordered_commands="$($_colcon_python_executable "$_colcon_prefix_sh_COLCON_CURRENT_PREFIX/_local_setup_util_sh.py" sh)"
+unset _colcon_python_executable
+if [ -n "$COLCON_TRACE" ]; then
+  echo "_colcon_prefix_sh_source_script() {
+    if [ -f \"\$1\" ]; then
+      if [ -n \"\$COLCON_TRACE\" ]; then
+        echo \"# . \\\"\$1\\\"\"
+      fi
+      . \"\$1\"
+    else
+      echo \"not found: \\\"\$1\\\"\" 1>&2
+    fi
+  }"
+  echo "# Execute generated script:"
+  echo "# <<<"
+  echo "${_colcon_ordered_commands}"
+  echo "# >>>"
+  echo "unset _colcon_prefix_sh_source_script"
+fi
+eval "${_colcon_ordered_commands}"
+unset _colcon_ordered_commands
+
+unset _colcon_prefix_sh_source_script
+
+unset _colcon_prefix_sh_COLCON_CURRENT_PREFIX

test/ros_osc/install/local_setup.zsh

@@ -0,0 +1,134 @@
+# generated from colcon_zsh/shell/template/prefix.zsh.em
+
+# This script extends the environment with all packages contained in this
+# prefix path.
+
+# a zsh script is able to determine its own path if necessary
+if [ -z "$COLCON_CURRENT_PREFIX" ]; then
+  _colcon_prefix_zsh_COLCON_CURRENT_PREFIX="$(builtin cd -q "`dirname "${(%):-%N}"`" > /dev/null && pwd)"
+else
+  _colcon_prefix_zsh_COLCON_CURRENT_PREFIX="$COLCON_CURRENT_PREFIX"
+fi
+
+# function to convert array-like strings into arrays
+# to workaround SH_WORD_SPLIT not being set
+_colcon_prefix_zsh_convert_to_array() {
+  local _listname=$1
+  local _dollar="$"
+  local _split="{="
+  local _to_array="(\"$_dollar$_split$_listname}\")"
+  eval $_listname=$_to_array
+}
+
+# function to prepend a value to a variable
+# which uses colons as separators
+# duplicates as well as trailing separators are avoided
+# first argument: the name of the result variable
+# second argument: the value to be prepended
+_colcon_prefix_zsh_prepend_unique_value() {
+  # arguments
+  _listname="$1"
+  _value="$2"
+
+  # get values from variable
+  eval _values=\"\$$_listname\"
+  # backup the field separator
+  _colcon_prefix_zsh_prepend_unique_value_IFS="$IFS"
+  IFS=":"
+  # start with the new value
+  _all_values="$_value"
+  _contained_value=""
+  # workaround SH_WORD_SPLIT not being set
+  _colcon_prefix_zsh_convert_to_array _values
+  # iterate over existing values in the variable
+  for _item in $_values; do
+    # ignore empty strings
+    if [ -z "$_item" ]; then
+      continue
+    fi
+    # ignore duplicates of _value
+    if [ "$_item" = "$_value" ]; then
+      _contained_value=1
+      continue
+    fi
+    # keep non-duplicate values
+    _all_values="$_all_values:$_item"
+  done
+  unset _item
+  if [ -z "$_contained_value" ]; then
+    if [ -n "$COLCON_TRACE" ]; then
+      if [ "$_all_values" = "$_value" ]; then
+        echo "export $_listname=$_value"
+      else
+        echo "export $_listname=$_value:\$$_listname"
+      fi
+    fi
+  fi
+  unset _contained_value
+  # restore the field separator
+  IFS="$_colcon_prefix_zsh_prepend_unique_value_IFS"
+  unset _colcon_prefix_zsh_prepend_unique_value_IFS
+  # export the updated variable
+  eval export $_listname=\"$_all_values\"
+  unset _all_values
+  unset _values
+
+  unset _value
+  unset _listname
+}
+
+# add this prefix to the COLCON_PREFIX_PATH
+_colcon_prefix_zsh_prepend_unique_value COLCON_PREFIX_PATH "$_colcon_prefix_zsh_COLCON_CURRENT_PREFIX"
+unset _colcon_prefix_zsh_prepend_unique_value
+unset _colcon_prefix_zsh_convert_to_array
+
+# check environment variable for custom Python executable
+if [ -n "$COLCON_PYTHON_EXECUTABLE" ]; then
+  if [ ! -f "$COLCON_PYTHON_EXECUTABLE" ]; then
+    echo "error: COLCON_PYTHON_EXECUTABLE '$COLCON_PYTHON_EXECUTABLE' doesn't exist"
+    return 1
+  fi
+  _colcon_python_executable="$COLCON_PYTHON_EXECUTABLE"
+else
+  # try the Python executable known at configure time
+  _colcon_python_executable="/usr/bin/python3"
+  # if it doesn't exist try a fall back
+  if [ ! -f "$_colcon_python_executable" ]; then
+    if ! /usr/bin/env python3 --version > /dev/null 2> /dev/null; then
+      echo "error: unable to find python3 executable"
+      return 1
+    fi
+    _colcon_python_executable=`/usr/bin/env python3 -c "import sys; print(sys.executable)"`
+  fi
+fi
+
+# function to source another script with conditional trace output
+# first argument: the path of the script
+_colcon_prefix_sh_source_script() {
+  if [ -f "$1" ]; then
+    if [ -n "$COLCON_TRACE" ]; then
+      echo "# . \"$1\""
+    fi
+    . "$1"
+  else
+    echo "not found: \"$1\"" 1>&2
+  fi
+}
+
+# get all commands in topological order
+_colcon_ordered_commands="$($_colcon_python_executable "$_colcon_prefix_zsh_COLCON_CURRENT_PREFIX/_local_setup_util_sh.py" sh zsh)"
+unset _colcon_python_executable
+if [ -n "$COLCON_TRACE" ]; then
+  echo "$(declare -f _colcon_prefix_sh_source_script)"
+  echo "# Execute generated script:"
+  echo "# <<<"
+  echo "${_colcon_ordered_commands}"
+  echo "# >>>"
+  echo "unset _colcon_prefix_sh_source_script"
+fi
+eval "${_colcon_ordered_commands}"
+unset _colcon_ordered_commands
+
+unset _colcon_prefix_sh_source_script
+
+unset _colcon_prefix_zsh_COLCON_CURRENT_PREFIX

test/ros_osc/install/setup.bash

@@ -0,0 +1,26 @@
+# generated from colcon_bash/shell/template/prefix_chain.bash.em
+
+# This script extends the environment with the environment of other prefix
+# paths which were sourced when this file was generated as well as all packages
+# contained in this prefix path.
+
+# function to source another script with conditional trace output
+# first argument: the path of the script
+_colcon_prefix_chain_bash_source_script() {
+  if [ -f "$1" ]; then
+    if [ -n "$COLCON_TRACE" ]; then
+      echo "# . \"$1\""
+    fi
+    . "$1"
+  else
+    echo "not found: \"$1\"" 1>&2
+  fi
+}
+
+# source this prefix
+# setting COLCON_CURRENT_PREFIX avoids determining the prefix in the sourced script
+COLCON_CURRENT_PREFIX="$(builtin cd "`dirname "${BASH_SOURCE[0]}"`" > /dev/null && pwd)"
+_colcon_prefix_chain_bash_source_script "$COLCON_CURRENT_PREFIX/local_setup.bash"
+
+unset COLCON_CURRENT_PREFIX
+unset _colcon_prefix_chain_bash_source_script

test/ros_osc/install/setup.ps1

@@ -0,0 +1,26 @@
+# generated from colcon_powershell/shell/template/prefix_chain.ps1.em
+
+# This script extends the environment with the environment of other prefix
+# paths which were sourced when this file was generated as well as all packages
+# contained in this prefix path.
+
+# function to source another script with conditional trace output
+# first argument: the path of the script
+function _colcon_prefix_chain_powershell_source_script {
+  param (
+    $_colcon_prefix_chain_powershell_source_script_param
+  )
+  # source script with conditional trace output
+  if (Test-Path $_colcon_prefix_chain_powershell_source_script_param) {
+    if ($env:COLCON_TRACE) {
+      echo ". '$_colcon_prefix_chain_powershell_source_script_param'"
+    }
+    . "$_colcon_prefix_chain_powershell_source_script_param"
+  } else {
+    Write-Error "not found: '$_colcon_prefix_chain_powershell_source_script_param'"
+  }
+}
+
+# source this prefix
+$env:COLCON_CURRENT_PREFIX=(Split-Path $PSCommandPath -Parent)
+_colcon_prefix_chain_powershell_source_script "$env:COLCON_CURRENT_PREFIX\local_setup.ps1"

test/ros_osc/install/setup.sh

@@ -0,0 +1,39 @@
+# generated from colcon_core/shell/template/prefix_chain.sh.em
+
+# This script extends the environment with the environment of other prefix
+# paths which were sourced when this file was generated as well as all packages
+# contained in this prefix path.
+
+# since a plain shell script can't determine its own path when being sourced
+# either use the provided COLCON_CURRENT_PREFIX
+# or fall back to the build time prefix (if it exists)
+_colcon_prefix_chain_sh_COLCON_CURRENT_PREFIX=/BA/ros_osc/install
+if [ ! -z "$COLCON_CURRENT_PREFIX" ]; then
+  _colcon_prefix_chain_sh_COLCON_CURRENT_PREFIX="$COLCON_CURRENT_PREFIX"
+elif [ ! -d "$_colcon_prefix_chain_sh_COLCON_CURRENT_PREFIX" ]; then
+  echo "The build time path \"$_colcon_prefix_chain_sh_COLCON_CURRENT_PREFIX\" doesn't exist. Either source a script for a different shell or set the environment variable \"COLCON_CURRENT_PREFIX\" explicitly." 1>&2
+  unset _colcon_prefix_chain_sh_COLCON_CURRENT_PREFIX
+  return 1
+fi
+
+# function to source another script with conditional trace output
+# first argument: the path of the script
+_colcon_prefix_chain_sh_source_script() {
+  if [ -f "$1" ]; then
+    if [ -n "$COLCON_TRACE" ]; then
+      echo "# . \"$1\""
+    fi
+    . "$1"
+  else
+    echo "not found: \"$1\"" 1>&2
+  fi
+}
+
+# source this prefix
+# setting COLCON_CURRENT_PREFIX avoids relying on the build time prefix of the sourced script
+COLCON_CURRENT_PREFIX="$_colcon_prefix_chain_sh_COLCON_CURRENT_PREFIX"
+_colcon_prefix_chain_sh_source_script "$COLCON_CURRENT_PREFIX/local_setup.sh"
+
+unset _colcon_prefix_chain_sh_COLCON_CURRENT_PREFIX
+unset _colcon_prefix_chain_sh_source_script
+unset COLCON_CURRENT_PREFIX

test/ros_osc/install/setup.zsh

@@ -0,0 +1,26 @@
+# generated from colcon_zsh/shell/template/prefix_chain.zsh.em
+
+# This script extends the environment with the environment of other prefix
+# paths which were sourced when this file was generated as well as all packages
+# contained in this prefix path.
+
+# function to source another script with conditional trace output
+# first argument: the path of the script
+_colcon_prefix_chain_zsh_source_script() {
+  if [ -f "$1" ]; then
+    if [ -n "$COLCON_TRACE" ]; then
+      echo "# . \"$1\""
+    fi
+    . "$1"
+  else
+    echo "not found: \"$1\"" 1>&2
+  fi
+}
+
+# source this prefix
+# setting COLCON_CURRENT_PREFIX avoids determining the prefix in the sourced script
+COLCON_CURRENT_PREFIX="$(builtin cd -q "`dirname "${(%):-%N}"`" > /dev/null && pwd)"
+_colcon_prefix_chain_zsh_source_script "$COLCON_CURRENT_PREFIX/local_setup.zsh"
+
+unset COLCON_CURRENT_PREFIX
+unset _colcon_prefix_chain_zsh_source_script

test/ros_osc/joint_control/joint_angles_client.py

@@ -0,0 +1,9 @@
+from pythonosc.udp_client import SimpleUDPClient
+
+ip = "127.0.0.1"
+port = 8000
+
+client = SimpleUDPClient(ip, port)
+
+# Send joint updates
+client.send_message("/joint_angles", [0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

test/ros_osc/joint_control/joint_angles_server.py

@@ -0,0 +1,117 @@
+import rclpy
+from rclpy.node import Node
+from rclpy.executors import SingleThreadedExecutor
+from trajectory_msgs.msg import JointTrajectory, JointTrajectoryPoint
+from sensor_msgs.msg import JointState
+from pythonosc.dispatcher import Dispatcher
+from pythonosc.osc_server import BlockingOSCUDPServer
+import time
+
+class JointStateReader(Node):
+    """Node to read joint names from the /joint_states topic."""
+    def __init__(self):
+        super().__init__('JointStateReader')
+        self.sub = self.create_subscription(JointState, 'joint_states', self.sub_callback, 1)
+        self.joint_names = []
+        self.got_msg = False
+    
+    def sub_callback(self, msg):
+        """Callback to read joint names from the first received message."""
+        if not self.joint_names:
+            self.got_msg = True
+            self.joint_names = list(msg.name)
+
+def get_joint_names():
+    """get joint names using an existing ROS2 context and ensure proper cleanup."""
+    #rclpy.init()
+    node = JointStateReader()
+    executor = SingleThreadedExecutor()
+    executor.add_node(node)
+
+    while not node.got_msg:
+        executor.spin_once(timeout_sec=0)
+
+    joint_list = node.joint_names
+
+    node.destroy_node()  # destroy the node
+    #rclpy.shutdown()  # Shutdown
+
+    return joint_list  # Return the joint names
+
+class ScaledJointTrajectoryPublisher(Node):
+    """Node to publish joint trajectories based on OSC messages."""
+    def __init__(self, joint_names):
+        super().__init__('scaled_joint_trajectory_publisher')
+        
+        # ROS2 Publisher
+        self.publisher = self.create_publisher(
+            JointTrajectory, 
+            '/scaled_joint_trajectory_controller/joint_trajectory', 
+            10
+        )
+
+        # Use dynamically retrieved joint names
+        self.joint_names = joint_names
+
+        # Store received joint positions
+        self.joint_positions = [0.0] * len(self.joint_names)
+
+        # OSC Server Setup
+        self.osc_ip = "0.0.0.0"
+        self.osc_port = 8000
+        self.dispatcher = Dispatcher()
+
+        # Register OSC handlers dynamically
+        for joint in self.joint_names:
+            self.dispatcher.map(f"/joint/{joint}", self.osc_joint_handler)
+
+        self.get_logger().info("Scaled Joint Trajectory Publisher Ready")
+
+    def osc_joint_handler(self, address, *args):
+        """Handles incoming OSC messages for joint positions."""
+        joint_name = address.split("/")[-1]  # Extract joint name
+        if joint_name in self.joint_names:
+            index = self.joint_names.index(joint_name)
+            self.joint_positions[index] = args[0]  # Update joint position
+            self.get_logger().info(f"Updated {joint_name} to {args[0]}")
+        
+        # Publish the trajectory whenever a joint update is received
+        self.send_trajectory(self.joint_positions)
+
+    def send_trajectory(self, joint_positions, duration=2.0):
+        """Publish a joint trajectory command to move the UR10e."""
+        msg = JointTrajectory()
+        msg.joint_names = self.joint_names
+
+        point = JointTrajectoryPoint()
+        point.positions = joint_positions  # Updated joint positions
+        point.time_from_start.sec = int(duration)  # Duration in seconds
+        #point.time_from_start.nanosec = int((duration - int(duration)) * 1e9)  # Nanoseconds
+
+        msg.points.append(point)
+        self.publisher.publish(msg)
+        self.get_logger().info(f"Published Joint Trajectory: {joint_positions}")
+
+def main():
+    """Main function to get joint names and start the ROS 2 & OSC system."""
+    rclpy.init()
+    joints = get_joint_names()
+    #print(joints)
+    node = ScaledJointTrajectoryPublisher(joints)
+
+    # Setup OSC Server
+    server = BlockingOSCUDPServer((node.osc_ip, node.osc_port), node.dispatcher)
+    
+    # Run both ROS 2 and OSC Server together
+    try:
+        while rclpy.ok():
+            server.handle_request()  # Handle one OSC request at a time
+            rclpy.spin_once(node, timeout_sec=0.1)  # Process ROS callbacks
+    except KeyboardInterrupt:
+        print("")
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+if __name__ == '__main__':
+    main()

test/ros_osc/joint_info/osc4py3/osc_joint_states_pub.py

@@ -0,0 +1,92 @@
+import rclpy
+from rclpy.node import Node
+from sensor_msgs.msg import JointState
+from osc4py3.as_eventloop import *
+from osc4py3 import oscbuildparse
+
+class JointStateOSC(Node):
+    def __init__(self):
+        super().__init__('joint_states_osc')
+
+        # Create a ROS 2 subscriber to /joint_states topic
+        self.subscription = self.create_subscription(
+            JointState,
+            '/joint_states',
+            self.joint_states_callback,
+            1  # Queue size
+        )
+
+        # Open Sound Control (OSC) Client settings
+        self.osc_ip = "127.0.0.1"   # Replace with the target IP
+        self.osc_port = 8000        # Replace with the target port
+
+        # Start the OSC system
+        osc_startup()
+
+        # Make client channels to send packets
+        osc_udp_client(self.osc_ip, self.osc_port, "osc_client")
+
+    def joint_states_callback(self, msg):
+        """Callback function to handle incoming joint states."""
+        header = msg.header
+        joint_names = msg.name
+        joint_positions = msg.position
+        joint_velocity = msg.velocity
+        joint_effort = msg.effort
+
+        joint_names_str = "\n- ".join(joint_names)
+        joint_positions_str = "\n- ".join(map(str, joint_positions))
+        joint_velocity_str = "\n- ".join(map(str, joint_velocity))
+        joint_effort_str = "\n- ".join(map(str, joint_effort))
+
+        info = f"""
+---
+header:
+    stamp:
+        sec: {header.stamp.sec}
+        nanosec: {header.stamp.nanosec}
+name:
+- {joint_names_str}
+position:
+- {joint_positions_str}
+velocity:
+- {joint_velocity_str}
+effort:
+- {joint_effort_str}
+---"""
+
+        # Send the info message
+        msg = oscbuildparse.OSCMessage("/joint_states", None, [info])
+        osc_send(msg, "osc_client")
+        osc_process()
+        #print(f"Publishing: {info}")
+
+
+        # Send each joint state as an OSC message
+        for i, name in enumerate(joint_names):
+            #msg_sec = oscbuildparse.OSCMessage(f"/joint_states/header/sec", None, [header.stamp.sec])
+            #msg_nanosec = oscbuildparse.OSCMessage(f"/joint_states/header/nanosec", None, [header.stamp.nanosec])
+            msg_position = oscbuildparse.OSCMessage(f"/joint_states/{name}/position", None, [joint_positions[i]])
+            msg_velocity = oscbuildparse.OSCMessage(f"/joint_states/{name}/velocity", None, [joint_velocity[i]])
+            msg_effort = oscbuildparse.OSCMessage(f"/joint_states/{name}/effort", None, [joint_effort[i]])
+
+            bun = oscbuildparse.OSCBundle(oscbuildparse.unixtime2timetag(header.stamp.sec + header.stamp.nanosec), [msg_position, msg_velocity, msg_effort])
+            #bun = oscbuildparse.OSCBundle(oscbuildparse.OSC_IMMEDIATELY , [msg_position, msg_velocity, msg_effort])
+            osc_send(bun, "osc_client")
+            osc_process()
+            #print(f"OSC bundle sent for joint {name}")
+
+def main():
+    rclpy.init()
+    node = JointStateOSC()
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+        osc_terminate()
+
+if __name__ == '__main__':
+    main()

test/ros_osc/joint_info/osc4py3/osc_joint_states_sub.py

@@ -0,0 +1,41 @@
+from osc4py3.as_eventloop import *
+from osc4py3 import oscmethod as osm
+from osc4py3 import oscbuildparse
+import time
+
+def joint_states_handler(*args):
+    """Handler function to process incoming joint states."""
+    print(f"Received message")
+    for arg in args:
+        print(arg)
+
+def main():
+    ip = "0.0.0.0"  # IP address to listen on
+    port = 8000       # Port to listen on
+
+    # Start the OSC system
+    osc_startup()
+
+    # Make server channels to receive packets
+    osc_udp_server(ip, port, "osc_server")
+
+    # Associate Python functions with message address patterns
+    osc_method("/joint_states", joint_states_handler, argscheme=osm.OSCARG_MESSAGE)
+
+    print(f"Listening for OSC messages on {ip}:{port}...")
+
+    try:
+        # Run the event loop
+        while True:
+            osc_process()  # Process OSC messages
+            time.sleep(0.01)  # Sleep to avoid high CPU usage
+
+    except KeyboardInterrupt:
+        print("")
+
+    finally:
+        # Properly close the system
+        osc_terminate()
+
+if __name__ == "__main__":
+    main()

test/ros_osc/joint_info/osc4py3/tcp_cart_pos.py

@@ -0,0 +1,62 @@
+import rclpy
+from rclpy.node import Node
+from sensor_msgs.msg import JointState
+from osc4py3.as_eventloop import *
+from osc4py3 import oscbuildparse
+import roboticstoolbox as rtb
+
+class JointStateOSC(Node):
+    def __init__(self):
+        super().__init__('joint_states_osc')
+
+        # Create a ROS 2 subscriber to /joint_states topic
+        self.subscription = self.create_subscription(
+            JointState,
+            '/joint_states',
+            self.joint_states_callback,
+            1  # Queue size
+        )
+
+        # Open Sound Control (OSC) Client settings
+        self.osc_ip = "127.0.0.1"   # Replace with the target IP
+        self.osc_port = 8000        # Replace with the target port
+
+        # Start the OSC system
+        osc_startup()
+
+        # Make client channels to send packets
+        osc_udp_client(self.osc_ip, self.osc_port, "osc_client")
+
+        # Load the robot model
+        self.robot = rtb.ERobot.URDF('BA/robot.urdf')
+
+    def joint_states_callback(self, msg):
+        """Callback function to handle incoming joint states."""
+        header = msg.header
+        joint_names = msg.name
+        joint_positions = msg.position
+
+        # Compute the forward kinematics to get the TCP position
+        tcp_pos = self.robot.fkine(joint_positions).t
+
+        # Prepare the OSC message with the TCP position
+        msg = oscbuildparse.OSCMessage("/tcp_position", None, tcp_pos.tolist())
+        osc_send(msg, "osc_client")
+        osc_process()
+        print(f"Published TCP position: {tcp_pos}")
+
+def main():
+    rclpy.init()
+    node = JointStateOSC()
+
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+        osc_terminate()
+
+if __name__ == '__main__':
+    main()

test/ros_osc/joint_info/pythonosc/bundles/bundle_server_test.py

@@ -0,0 +1,26 @@
+from pythonosc import dispatcher
+from pythonosc import osc_server
+import time
+
+def joint_handler(address, *args):
+    print(args)
+    time.sleep(0.3)
+
+def main():
+    ip = "0.0.0.0"  # Listen on all network interfaces
+    port = 5005    # Must match the sender's port in `joint_state_osc.py`
+
+    # Create dispatcher and register callback
+    disp = dispatcher.Dispatcher()
+    #disp.map("/joint_states", joint_handler)
+    disp.map("/SYNC", joint_handler)
+
+    server = osc_server.ThreadingOSCUDPServer((ip, port), disp) # Start OSC server
+    
+    try:
+        server.serve_forever()  # Keep server running
+    except KeyboardInterrupt:
+        print("")
+
+if __name__ == "__main__":
+    main()

test/ros_osc/joint_info/pythonosc/bundles/bundle_timetag.py

@@ -0,0 +1,30 @@
+from pythonosc import dispatcher
+from pythonosc import osc_server
+from pythonosc.osc_bundle import OscBundle
+from pythonosc.osc_message import OscMessage
+
+def joint_handler(address, *args):
+    if isinstance(args[0], OscBundle):
+        bundle = args[0]
+        print(f"Received OSC bundle with timestamp: {bundle.timestamp}")
+        for element in bundle.bundle_elements:
+            if isinstance(element, OscMessage):
+                print(f"Message: {element.address}, Args: {element.params}")
+
+def main():
+    ip = "0.0.0.0"  # Listen on all network interfaces
+    port = 5005    # Must match the sender's port in `joint_state_osc.py`
+
+    # Create dispatcher and register callback
+    disp = dispatcher.Dispatcher()
+    disp.map("/joint_states/*", joint_handler)
+
+    server = osc_server.ThreadingOSCUDPServer((ip, port), disp) # Start OSC server
+    
+    try:
+        server.serve_forever()  # Keep server running
+    except KeyboardInterrupt:
+        print("")
+
+if __name__ == "__main__":
+    main()

test/ros_osc/joint_info/pythonosc/bundles/different_lib.py

@@ -0,0 +1,38 @@
+# Import needed modules from osc4py3
+import osc4py3.as_eventloop 
+from osc4py3 import oscmethod as osm
+
+def handlerfunction(*args):
+    for arg in args:
+        print(arg)
+    pass
+"""
+def handlerfunction2(address, s, x, y):
+    # Will receive message address, and message data flattened in s, x, y
+    print(f's: {s}')
+    print(f'x: {x}')
+    print(f'y: {y}')
+    pass
+"""
+# Start the system.
+osc_startup()
+
+# Make server channels to receive packets.
+osc_udp_server("0.0.0.0", 5005, "aservername")
+osc_udp_server("0.0.0.0", 5005, "anotherserver")
+
+# Associate Python functions with message address patterns, using default
+# argument scheme OSCARG_DATAUNPACK.
+osc_method("SYNC", handlerfunction)
+# Too, but request the message address pattern before in argscheme
+#osc_method("SYNC", handlerfunction2, argscheme=osm.OSCARG_ADDRESS + osm.OSCARG_DATAUNPACK)
+
+# Periodically call osc4py3 processing method in your event loop.
+finished = False
+while not finished:
+    # …
+    osc_process()
+    # …
+
+# Properly close the system.
+osc_terminate()

test/ros_osc/joint_info/pythonosc/bundles/joint_states_bundle.py

@@ -0,0 +1,75 @@
+import rclpy
+from rclpy.node import Node
+from sensor_msgs.msg import JointState
+from pythonosc.udp_client import SimpleUDPClient
+from pythonosc import osc_bundle_builder
+from pythonosc import osc_message_builder
+
+class JointStateOSC(Node):
+    def __init__(self):
+        super().__init__('joint_states_osc')
+
+        # Create a ROS 2 subscriber to /joint_states topic
+        self.subscription = self.create_subscription(
+            JointState,
+            '/joint_states',
+            self.joint_states_callback,
+            1  # Queue size
+        )
+
+        self.osc_ip = "127.0.0.1"   # target IP
+        self.osc_port = 5005        # target port
+        self.osc_client = SimpleUDPClient(self.osc_ip, self.osc_port)
+
+    def joint_states_callback(self, msg):
+        """Callback function to handle incoming joint states."""
+        header = msg.header
+        #print(f"Received joint states at {header.stamp.sec}.{header.stamp.nanosec}")
+        joint_names = msg.name
+        joint_positions = msg.position
+        joint_velocity = msg.velocity
+        joint_effort = msg.effort
+
+
+        bundle = osc_bundle_builder.OscBundleBuilder(timestamp=header.stamp.sec + header.stamp.nanosec * 1e-9)
+        #bundle = osc_bundle_builder.OscBundleBuilder(osc_bundle_builder.IMMEDIATELY)
+
+        names = osc_message_builder.OscMessageBuilder(address="/joint_states/names")
+        names.add_arg([str(name) for name in joint_names])
+        positions = osc_message_builder.OscMessageBuilder(address="/joint_states/positions")
+        positions.add_arg([float(pos) for pos in joint_positions])
+        velocity = osc_message_builder.OscMessageBuilder(address="/joint_states/velocity")
+        velocity.add_arg([float(vel) for vel in joint_velocity])
+        effort = osc_message_builder.OscMessageBuilder(address="/joint_states/effort")
+        effort.add_arg([float(eff) for eff in joint_effort])
+
+        bundle.add_content(names.build())
+        bundle.add_content(positions.build())
+        bundle.add_content(velocity.build())
+        bundle.add_content(effort.build())
+
+        info = osc_message_builder.OscMessageBuilder(address="/joint_states")
+        info.add_arg("joint names:")
+        info.add_arg([str(name) for name in joint_names])
+        info.add_arg("joint positions:")
+        info.add_arg([float(pos) for pos in joint_positions])
+        info.add_arg("joint velocity:")
+        info.add_arg([float(vel) for vel in joint_velocity])
+        info.add_arg("joint effort:")
+        info.add_arg([float(eff) for eff in joint_effort])
+
+        bundle.add_content(info.build())
+
+        self.osc_client.send(bundle.build())
+
+def main():
+    try: 
+        rclpy.init()
+        node = JointStateOSC()
+        rclpy.spin(node)
+    except KeyboardInterrupt: print("")
+        #node.destroy_node()
+        #rclpy.shutdown()
+
+if __name__ == '__main__':
+    main()

test/ros_osc/joint_info/pythonosc/bundles/read_bundle.py

@@ -0,0 +1,28 @@
+import argparse
+from pythonosc import dispatcher, osc_server
+from pythonosc.osc_bundle import OscBundle
+from pythonosc.osc_message import OscMessage
+
+def bundle_handler(address, *args):
+    for arg in args:
+        if isinstance(arg, OscBundle):
+            print(f"Received OSC bundle with timestamp: {arg.timestamp}")
+            for element in arg.bundle_elements:
+                if isinstance(element, OscMessage):
+                    print(f"Message: {element.address}, Args: {element.params}")
+
+def main():
+    parser = argparse.ArgumentParser(description="OSC Bundle Receiver")
+    parser.add_argument("--ip", default="127.0.0.1", help="The IP address to listen on")
+    parser.add_argument("--port", type=int, default=5005, help="The port to listen on")
+    args = parser.parse_args()
+
+    disp = dispatcher.Dispatcher()
+    disp.set_default_handler(bundle_handler)
+
+    server = osc_server.ThreadingOSCUDPServer((args.ip, args.port), disp)
+    print(f"Listening for OSC bundles on {args.ip}:{args.port}...")
+    server.serve_forever()
+
+if __name__ == "__main__":
+    main()

test/ros_osc/joint_info/pythonosc/bundles/send_bundle_test.py

@@ -0,0 +1,36 @@
+from pythonosc import osc_bundle_builder
+from pythonosc import osc_message_builder
+import argparse
+import time
+from pythonosc import udp_client
+
+
+if __name__ == "__main__":
+  parser = argparse.ArgumentParser()
+  parser.add_argument("--ip", default="127.0.0.1",
+      help="The ip of the OSC server")
+  parser.add_argument("--port", type=int, default=5005,
+      help="The port the OSC server is listening on")
+  args = parser.parse_args()
+
+  client = udp_client.SimpleUDPClient(args.ip, args.port)
+
+bundle = osc_bundle_builder.OscBundleBuilder(timestamp=time.time() + 10)
+msg = osc_message_builder.OscMessageBuilder(address="/SYNC")
+msg.add_arg(4.0)
+# Add 4 messages in the bundle, each with more arguments.
+bundle.add_content(msg.build())
+msg.add_arg(2)
+bundle.add_content(msg.build())
+msg.add_arg("value")
+bundle.add_content(msg.build())
+
+sub_bundle = bundle.build()
+# Now add the same bundle inside itself.
+bundle.add_content(sub_bundle)
+# The bundle has 5 elements in total now.
+
+bundle = bundle.build()
+while True:# You can now send it via a client with the `.send()` method:
+    client.send(bundle)
+    time.sleep(1)

test/ros_osc/joint_info/pythonosc/default_handler.py

@@ -0,0 +1,20 @@
+from pythonosc.dispatcher import Dispatcher
+from pythonosc.osc_server import BlockingOSCUDPServer
+
+# Fallback handler: will catch any OSC address not explicitly mapped
+def default_handler(address, *args):
+    print(f"[RECEIVED] Address: {address}, Args: {args}")
+
+def main():
+    ip = "0.0.0.0"   # Listen on all interfaces
+    port = 5005      # Set to the same port as the sender
+
+    dispatcher = Dispatcher()
+    dispatcher.set_default_handler(default_handler)
+
+    server = BlockingOSCUDPServer((ip, port), dispatcher)
+    print(f"Listening for OSC messages on {ip}:{port}...")
+    server.serve_forever()
+
+if __name__ == "__main__":
+    main()

test/ros_osc/joint_info/pythonosc/joint_names_reader.py

@@ -0,0 +1,42 @@
+import rclpy
+from rclpy.node import Node
+from sensor_msgs.msg import JointState
+from rclpy.executors import SingleThreadedExecutor
+
+class JointStateReader(Node):
+    def __init__(self):
+        super().__init__('JointStateReader')
+        self.sub = self.create_subscription(JointState, 'joint_states', self.sub_callback, 1)
+        self.joint_names = []
+        self.got_msg = False
+    
+    def sub_callback(self, msg):
+        """Callback to read joint names from the first received message."""
+        if not self.joint_names:
+            self.got_msg=True
+            self.joint_names = list(msg.name)
+
+def joint_names():
+    """Fetch joint names using an existing ROS2 context and ensure proper cleanup."""
+    rclpy.init()
+    node = JointStateReader()
+    executor = SingleThreadedExecutor()
+    executor.add_node(node)
+    while not node.got_msg:
+        executor.spin_once(timeout_sec=0)
+    joint_list = node.joint_names  # Store names before shutting down
+
+    node.destroy_node()  # Properly destroy the node
+    rclpy.shutdown()  # Shutdown ROS2 context to free memory
+
+    return joint_list  # Return the joint names safely
+
+def main():
+    """Main function to fetch and print joint names."""
+    joints = joint_names()
+    
+    for i, joint_name in enumerate(joints, start=1):
+        print(f"Joint No. {i}: {joint_name}")
+
+if __name__ == '__main__':
+    main()

test/ros_osc/joint_info/pythonosc/joint_state_overview.py

@@ -0,0 +1,43 @@
+from pythonosc import dispatcher
+from pythonosc import osc_server
+import time
+
+last_received = time.time()
+
+def joint_handler(address, *args):
+    global last_received
+    now = time.time()
+    
+    if now - last_received > 0.1:  # Limit updates to every 100ms
+        last_received = now
+        if args:
+            print(args[0])
+
+"""
+def joint_handler(address, *args):
+    if args:
+        print(args[0])
+        gc.collect()  # Force garbage collection
+"""
+        
+def main():
+    ip = "0.0.0.0"  # Listen on all network interfaces
+    port = 8000     # Must match the sender's port in `joint_state_osc.py`
+
+    # Create dispatcher and register callback
+    disp = dispatcher.Dispatcher()
+    disp.map("/joint_states", joint_handler)  # Listen for all joint messages
+
+    # Start OSC server
+    server = osc_server.ThreadingOSCUDPServer((ip, port), disp)
+    
+    try:
+        #server.serve_forever()  # Keep server running
+        while True:
+            server.handle_request()  # Process one request at a time
+
+    except KeyboardInterrupt:
+        print("")
+
+if __name__ == "__main__":
+    main()

test/ros_osc/joint_info/pythonosc/joint_state_overview_osc4py3.py

@@ -0,0 +1,43 @@
+from osc4py3.as_eventloop import *
+from osc4py3.oscmethod import *
+import time
+
+last_received = time.time()
+
+def joint_handler(address, info):
+    global last_received
+    now = time.time()
+    
+    if now - last_received > 0.1 and address == "/joint_states":  # Limit updates to every 100ms
+        last_received = now
+        if info:
+            print(info)
+
+def main():
+    ip = "127.0.0.1" # "0.0.0.0" Listen on all network interfaces
+    port = 8000     # Must match the sender's port in `joint_state_osc.py`
+
+    # Start the system
+    osc_startup()
+
+    # Make server channels to receive packets
+    osc_udp_server(ip, port, "joint_state_server")
+
+    # Associate Python functions with message address patterns
+    osc_method("/joint_states", joint_handler, argscheme=OSCARG_ADDRESS + OSCARG_DATAUNPACK)
+
+    try:
+        # Run the event loop
+        while True:
+            osc_process()  # Process OSC messages
+            time.sleep(0.01)  # Sleep to avoid high CPU usage
+
+    except KeyboardInterrupt:
+        print("")
+
+    finally:
+        # Properly close the system
+        osc_terminate()
+
+if __name__ == "__main__":
+    main()

test/ros_osc/joint_info/pythonosc/joint_state_reader.py

@@ -0,0 +1,23 @@
+from pythonosc import dispatcher
+from pythonosc import osc_server
+
+def joint_handler(address, *args):
+    print(f"{address} -> {args[0]}")
+
+def main():
+    ip = "0.0.0.0"  # Listen on all network interfaces
+    port = 5005     # Must match the sender's port in `joint_state_osc.py`
+
+    # Create dispatcher and register callback
+    disp = dispatcher.Dispatcher()
+    disp.map("/joint_states/shoulder_lift_joint/*", joint_handler)
+
+    server = osc_server.ThreadingOSCUDPServer((ip, port), disp) # Start OSC server
+    
+    try:
+        server.serve_forever()  # Keep server running
+    except KeyboardInterrupt:
+        print("")
+
+if __name__ == "__main__":
+    main()

test/ros_osc/joint_info/pythonosc/osc_joint_states_pub.py

@@ -0,0 +1,74 @@
+import rclpy
+from rclpy.node import Node
+from sensor_msgs.msg import JointState
+from pythonosc.udp_client import SimpleUDPClient
+
+class JointStateOSC(Node):
+    def __init__(self):
+        super().__init__('joint_states_osc')
+
+        # Create a ROS 2 subscriber to /joint_states topic
+        self.subscription = self.create_subscription(
+            JointState,
+            '/joint_states',
+            self.joint_states_callback,
+            1  # Queue size
+        )
+
+        # Open Sound Control (OSC) Client settings
+        self.osc_ip = "127.0.0.1"   # Replace with the target IP
+        self.osc_port = 8000        # Replace with the target port
+        self.osc_client = SimpleUDPClient(self.osc_ip, self.osc_port)
+
+    def joint_states_callback(self, msg):
+        """Callback function to handle incoming joint states."""
+        header = msg.header
+        joint_names = msg.name
+        joint_positions = msg.position
+        joint_velocity = msg.velocity
+        joint_effort = msg.effort
+
+        joint_names_str = "\n- ".join(joint_names)
+        joint_positions_str = "\n- ".join(map(str, joint_positions))
+        joint_velocity_str = "\n- ".join(map(str, joint_velocity))
+        joint_effort_str = "\n- ".join(map(str, joint_effort))
+
+        info = f"""
+---
+header:
+    stamp:
+        sec: {header.stamp.sec}
+        nanosec: {header.stamp.nanosec}
+name:
+- {joint_names_str}
+position:
+- {joint_positions_str}
+velocity:
+- {joint_velocity_str}
+effort:
+- {joint_effort_str}
+---"""
+
+        self.osc_client.send_message(f"/joint_states", info)
+
+        # Send each joint state as an OSC message
+        for i, name in enumerate(joint_names):
+
+            self.osc_client.send_message(f"/joint_states/header/sec", header.stamp.sec) # Publish Time (sec)
+            self.osc_client.send_message(f"/joint_states/header/nanosec", header.stamp.nanosec) # Publish Time (nanosec)
+
+            self.osc_client.send_message(f"/joint_states/{name}/position", joint_positions[i]) # Publish position
+
+            self.osc_client.send_message(f"/joint_states/{name}/velocity", joint_velocity[i])  # Publish velocity
+
+            self.osc_client.send_message(f"/joint_states/{name}/effort", joint_effort[i])      # Publish effort
+
+def main():
+    rclpy.init()
+    node = JointStateOSC()
+    rclpy.spin(node)
+    node.destroy_node()
+    rclpy.shutdown()
+
+if __name__ == '__main__':
+    main()

test/ros_osc/log/build_2025-03-14_09-46-22/events.log

@@ -0,0 +1,2 @@
+[0.000000] (-) TimerEvent: {}
+[0.000953] (-) EventReactorShutdown: {}

test/ros_osc/log/build_2025-03-14_09-46-22/logger_all.log

@@ -0,0 +1,146 @@
+[0.099s] DEBUG:colcon:Command line arguments: ['/usr/bin/colcon', 'build', '--symlink-install']
+[0.100s] DEBUG:colcon:Parsed command line arguments: Namespace(log_base=None, log_level=None, verb_name='build', build_base='build', install_base='install', merge_install=False, symlink_install=True, test_result_base=None, continue_on_error=False, executor='parallel', parallel_workers=8, event_handlers=None, ignore_user_meta=False, metas=['./colcon.meta'], base_paths=['.'], packages_ignore=None, packages_ignore_regex=None, paths=None, packages_up_to=None, packages_up_to_regex=None, packages_above=None, packages_above_and_dependencies=None, packages_above_depth=None, packages_select_by_dep=None, packages_skip_by_dep=None, packages_skip_up_to=None, packages_select_build_failed=False, packages_skip_build_finished=False, packages_select_test_failures=False, packages_skip_test_passed=False, packages_select=None, packages_skip=None, packages_select_regex=None, packages_skip_regex=None, packages_start=None, packages_end=None, cmake_args=None, cmake_target=None, cmake_target_skip_unavailable=False, cmake_clean_cache=False, cmake_clean_first=False, cmake_force_configure=False, ament_cmake_args=None, catkin_cmake_args=None, catkin_skip_building_tests=False, mixin_files=None, mixin=None, verb_parser=<colcon_mixin.mixin.mixin_argument.MixinArgumentDecorator object at 0x7ffffe3b3880>, verb_extension=<colcon_core.verb.build.BuildVerb object at 0x7ffffe2f07c0>, main=<bound method BuildVerb.main of <colcon_core.verb.build.BuildVerb object at 0x7ffffe2f07c0>>, mixin_verb=('build',))
+[0.183s] Level 1:colcon.colcon_core.package_discovery:discover_packages(colcon_meta) check parameters
+[0.184s] INFO:colcon.colcon_metadata.package_discovery.colcon_meta:Using configuration from '/root/.colcon/metadata/default/Gazebo.meta'
+[0.184s] INFO:colcon.colcon_metadata.package_discovery.colcon_meta:Using configuration from '/root/.colcon/metadata/default/fastrtps.meta'
+[0.184s] Level 1:colcon.colcon_core.package_discovery:discover_packages(recursive) check parameters
+[0.184s] Level 1:colcon.colcon_core.package_discovery:discover_packages(ignore) check parameters
+[0.184s] Level 1:colcon.colcon_core.package_discovery:discover_packages(path) check parameters
+[0.184s] Level 1:colcon.colcon_core.package_discovery:discover_packages(colcon_meta) discover
+[0.185s] Level 1:colcon.colcon_core.package_discovery:discover_packages(recursive) discover
+[0.185s] INFO:colcon.colcon_core.package_discovery:Crawling recursively for packages in '/BA/ros_osc'
+[0.185s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extensions ['ignore', 'ignore_ament_install']
+[0.185s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'ignore'
+[0.185s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'ignore_ament_install'
+[0.185s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extensions ['colcon_pkg']
+[0.185s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'colcon_pkg'
+[0.186s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extensions ['colcon_meta']
+[0.186s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'colcon_meta'
+[0.186s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extensions ['ros']
+[0.186s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'ros'
+[0.196s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extensions ['cmake', 'python']
+[0.196s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'cmake'
+[0.196s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'python'
+[0.196s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extensions ['python_setup_py']
+[0.197s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'python_setup_py'
+[0.197s] Level 1:colcon.colcon_core.package_identification:_identify(build) by extensions ['ignore', 'ignore_ament_install']
+[0.197s] Level 1:colcon.colcon_core.package_identification:_identify(build) by extension 'ignore'
+[0.197s] Level 1:colcon.colcon_core.package_identification:_identify(build) ignored
+[0.197s] Level 1:colcon.colcon_core.package_identification:_identify(install) by extensions ['ignore', 'ignore_ament_install']
+[0.197s] Level 1:colcon.colcon_core.package_identification:_identify(install) by extension 'ignore'
+[0.197s] Level 1:colcon.colcon_core.package_identification:_identify(install) ignored
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extensions ['ignore', 'ignore_ament_install']
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'ignore'
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'ignore_ament_install'
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extensions ['colcon_pkg']
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'colcon_pkg'
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extensions ['colcon_meta']
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'colcon_meta'
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extensions ['ros']
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'ros'
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extensions ['cmake', 'python']
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'cmake'
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'python'
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extensions ['python_setup_py']
+[0.198s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'python_setup_py'
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extensions ['ignore', 'ignore_ament_install']
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'ignore'
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'ignore_ament_install'
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extensions ['colcon_pkg']
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'colcon_pkg'
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extensions ['colcon_meta']
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'colcon_meta'
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extensions ['ros']
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'ros'
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extensions ['cmake', 'python']
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'cmake'
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'python'
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extensions ['python_setup_py']
+[0.199s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'python_setup_py'
+[0.200s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extensions ['ignore', 'ignore_ament_install']
+[0.200s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'ignore'
+[0.200s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'ignore_ament_install'
+[0.200s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extensions ['colcon_pkg']
+[0.200s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'colcon_pkg'
+[0.200s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extensions ['colcon_meta']
+[0.200s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'colcon_meta'
+[0.200s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extensions ['ros']
+[0.200s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'ros'
+[0.200s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extensions ['cmake', 'python']
+[0.200s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'cmake'
+[0.201s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'python'
+[0.201s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extensions ['python_setup_py']
+[0.201s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'python_setup_py'
+[0.201s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extensions ['ignore', 'ignore_ament_install']
+[0.201s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'ignore'
+[0.201s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'ignore_ament_install'
+[0.201s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extensions ['colcon_pkg']
+[0.201s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'colcon_pkg'
+[0.201s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extensions ['colcon_meta']
+[0.201s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'colcon_meta'
+[0.201s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extensions ['ros']
+[0.202s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'ros'
+[0.202s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extensions ['cmake', 'python']
+[0.202s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'cmake'
+[0.202s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'python'
+[0.202s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extensions ['python_setup_py']
+[0.202s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'python_setup_py'
+[0.202s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extensions ['ignore', 'ignore_ament_install']
+[0.202s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'ignore'
+[0.202s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'ignore_ament_install'
+[0.202s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extensions ['colcon_pkg']
+[0.202s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'colcon_pkg'
+[0.203s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extensions ['colcon_meta']
+[0.203s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'colcon_meta'
+[0.203s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extensions ['ros']
+[0.203s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'ros'
+[0.203s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extensions ['cmake', 'python']
+[0.203s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'cmake'
+[0.203s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'python'
+[0.203s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extensions ['python_setup_py']
+[0.203s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'python_setup_py'
+[0.203s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extensions ['ignore', 'ignore_ament_install']
+[0.203s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'ignore'
+[0.204s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'ignore_ament_install'
+[0.204s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extensions ['colcon_pkg']
+[0.204s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'colcon_pkg'
+[0.204s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extensions ['colcon_meta']
+[0.204s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'colcon_meta'
+[0.204s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extensions ['ros']
+[0.204s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'ros'
+[0.204s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extensions ['cmake', 'python']
+[0.204s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'cmake'
+[0.204s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'python'
+[0.204s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extensions ['python_setup_py']
+[0.204s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'python_setup_py'
+[0.205s] Level 1:colcon.colcon_core.package_identification:_identify(log) by extensions ['ignore', 'ignore_ament_install']
+[0.205s] Level 1:colcon.colcon_core.package_identification:_identify(log) by extension 'ignore'
+[0.205s] Level 1:colcon.colcon_core.package_identification:_identify(log) ignored
+[0.205s] Level 1:colcon.colcon_core.package_discovery:discover_packages(recursive) using defaults
+[0.205s] Level 1:colcon.colcon_core.package_discovery:discover_packages(ignore) discover
+[0.205s] Level 1:colcon.colcon_core.package_discovery:discover_packages(ignore) using defaults
+[0.205s] Level 1:colcon.colcon_core.package_discovery:discover_packages(path) discover
+[0.205s] Level 1:colcon.colcon_core.package_discovery:discover_packages(path) using defaults
+[0.220s] INFO:colcon.colcon_core.executor:Executing jobs using 'parallel' executor
+[0.224s] DEBUG:colcon.colcon_parallel_executor.executor.parallel:run_until_complete
+[0.225s] DEBUG:colcon.colcon_parallel_executor.executor.parallel:closing loop
+[0.225s] DEBUG:colcon.colcon_parallel_executor.executor.parallel:loop closed
+[0.225s] DEBUG:colcon.colcon_parallel_executor.executor.parallel:run_until_complete finished with '0'
+[0.226s] DEBUG:colcon.colcon_core.event_reactor:joining thread
+[0.237s] INFO:colcon.colcon_core.plugin_system:Skipping extension 'colcon_notification.desktop_notification.notify_send': Could not find 'notify-send'
+[0.237s] INFO:colcon.colcon_core.plugin_system:Skipping extension 'colcon_notification.desktop_notification.terminal_notifier': Not used on non-Darwin systems
+[0.237s] INFO:colcon.colcon_core.plugin_system:Skipping extension 'colcon_notification.desktop_notification.win32': Not used on non-Windows systems
+[0.237s] INFO:colcon.colcon_notification.desktop_notification:Sending desktop notification using 'notify2'
+[0.238s] DEBUG:colcon.colcon_notification.desktop_notification.notify2:Failed to initialize notify2: org.freedesktop.DBus.Error.NotSupported: Unable to autolaunch a dbus-daemon without a $DISPLAY for X11
+[0.239s] DEBUG:colcon.colcon_core.event_reactor:joined thread
+[0.242s] INFO:colcon.colcon_core.plugin_system:Skipping extension 'colcon_core.shell.bat': Not used on non-Windows systems
+[0.242s] INFO:colcon.colcon_core.shell:Creating prefix script '/BA/ros_osc/install/local_setup.ps1'
+[0.244s] INFO:colcon.colcon_core.shell:Creating prefix util module '/BA/ros_osc/install/_local_setup_util_ps1.py'
+[0.245s] INFO:colcon.colcon_core.shell:Creating prefix chain script '/BA/ros_osc/install/setup.ps1'
+[0.247s] INFO:colcon.colcon_core.shell:Creating prefix script '/BA/ros_osc/install/local_setup.sh'
+[0.248s] INFO:colcon.colcon_core.shell:Creating prefix util module '/BA/ros_osc/install/_local_setup_util_sh.py'
+[0.248s] INFO:colcon.colcon_core.shell:Creating prefix chain script '/BA/ros_osc/install/setup.sh'
+[0.249s] INFO:colcon.colcon_core.shell:Creating prefix script '/BA/ros_osc/install/local_setup.bash'
+[0.250s] INFO:colcon.colcon_core.shell:Creating prefix chain script '/BA/ros_osc/install/setup.bash'
+[0.251s] INFO:colcon.colcon_core.shell:Creating prefix script '/BA/ros_osc/install/local_setup.zsh'
+[0.251s] INFO:colcon.colcon_core.shell:Creating prefix chain script '/BA/ros_osc/install/setup.zsh'

test/ros_osc/log/latest

@@ -0,0 +1 @@
+latest_test

test/ros_osc/log/latest_build

@@ -0,0 +1 @@
+build_2025-03-14_09-46-22

test/ros_osc/log/latest_test

@@ -0,0 +1 @@
+test_2025-03-14_09-46-33

test/ros_osc/log/test_2025-03-14_09-46-33/events.log

@@ -0,0 +1,2 @@
+[0.000000] (-) TimerEvent: {}
+[0.000901] (-) EventReactorShutdown: {}

test/ros_osc/log/test_2025-03-14_09-46-33/logger_all.log

@@ -0,0 +1,135 @@
+[0.137s] DEBUG:colcon:Command line arguments: ['/usr/bin/colcon', 'test']
+[0.138s] DEBUG:colcon:Parsed command line arguments: Namespace(log_base=None, log_level=None, verb_name='test', build_base='build', install_base='install', merge_install=False, test_result_base=None, retest_until_fail=0, retest_until_pass=0, abort_on_error=False, return_code_on_test_failure=False, executor='parallel', parallel_workers=8, event_handlers=None, ignore_user_meta=False, metas=['./colcon.meta'], base_paths=['.'], packages_ignore=None, packages_ignore_regex=None, paths=None, packages_up_to=None, packages_up_to_regex=None, packages_above=None, packages_above_and_dependencies=None, packages_above_depth=None, packages_select_by_dep=None, packages_skip_by_dep=None, packages_skip_up_to=None, packages_select_build_failed=False, packages_skip_build_finished=False, packages_select_test_failures=False, packages_skip_test_passed=False, packages_select=None, packages_skip=None, packages_select_regex=None, packages_skip_regex=None, packages_start=None, packages_end=None, ctest_args=None, python_testing=None, pytest_args=None, pytest_with_coverage=False, unittest_args=None, mixin_files=None, mixin=None, verb_parser=<colcon_mixin.mixin.mixin_argument.MixinArgumentDecorator object at 0x7ffffe1f0940>, verb_extension=<colcon_core.verb.test.TestVerb object at 0x7ffffe2f0790>, main=<bound method TestVerb.main of <colcon_core.verb.test.TestVerb object at 0x7ffffe2f0790>>, mixin_verb=('test',))
+[0.204s] Level 1:colcon.colcon_core.package_discovery:discover_packages(colcon_meta) check parameters
+[0.204s] INFO:colcon.colcon_metadata.package_discovery.colcon_meta:Using configuration from '/root/.colcon/metadata/default/Gazebo.meta'
+[0.204s] INFO:colcon.colcon_metadata.package_discovery.colcon_meta:Using configuration from '/root/.colcon/metadata/default/fastrtps.meta'
+[0.205s] Level 1:colcon.colcon_core.package_discovery:discover_packages(recursive) check parameters
+[0.205s] Level 1:colcon.colcon_core.package_discovery:discover_packages(ignore) check parameters
+[0.205s] Level 1:colcon.colcon_core.package_discovery:discover_packages(path) check parameters
+[0.205s] Level 1:colcon.colcon_core.package_discovery:discover_packages(colcon_meta) discover
+[0.205s] Level 1:colcon.colcon_core.package_discovery:discover_packages(recursive) discover
+[0.205s] INFO:colcon.colcon_core.package_discovery:Crawling recursively for packages in '/BA/ros_osc'
+[0.205s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extensions ['ignore', 'ignore_ament_install']
+[0.206s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'ignore'
+[0.206s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'ignore_ament_install'
+[0.206s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extensions ['colcon_pkg']
+[0.206s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'colcon_pkg'
+[0.206s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extensions ['colcon_meta']
+[0.206s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'colcon_meta'
+[0.206s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extensions ['ros']
+[0.206s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'ros'
+[0.213s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extensions ['cmake', 'python']
+[0.213s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'cmake'
+[0.213s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'python'
+[0.213s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extensions ['python_setup_py']
+[0.213s] Level 1:colcon.colcon_core.package_identification:_identify(.) by extension 'python_setup_py'
+[0.213s] Level 1:colcon.colcon_core.package_identification:_identify(build) by extensions ['ignore', 'ignore_ament_install']
+[0.214s] Level 1:colcon.colcon_core.package_identification:_identify(build) by extension 'ignore'
+[0.214s] Level 1:colcon.colcon_core.package_identification:_identify(build) ignored
+[0.214s] Level 1:colcon.colcon_core.package_identification:_identify(install) by extensions ['ignore', 'ignore_ament_install']
+[0.214s] Level 1:colcon.colcon_core.package_identification:_identify(install) by extension 'ignore'
+[0.214s] Level 1:colcon.colcon_core.package_identification:_identify(install) ignored
+[0.215s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extensions ['ignore', 'ignore_ament_install']
+[0.215s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'ignore'
+[0.215s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'ignore_ament_install'
+[0.215s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extensions ['colcon_pkg']
+[0.215s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'colcon_pkg'
+[0.215s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extensions ['colcon_meta']
+[0.215s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'colcon_meta'
+[0.215s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extensions ['ros']
+[0.216s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'ros'
+[0.216s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extensions ['cmake', 'python']
+[0.216s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'cmake'
+[0.216s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'python'
+[0.216s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extensions ['python_setup_py']
+[0.216s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control) by extension 'python_setup_py'
+[0.216s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extensions ['ignore', 'ignore_ament_install']
+[0.216s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'ignore'
+[0.217s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'ignore_ament_install'
+[0.217s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extensions ['colcon_pkg']
+[0.217s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'colcon_pkg'
+[0.217s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extensions ['colcon_meta']
+[0.217s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'colcon_meta'
+[0.217s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extensions ['ros']
+[0.217s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'ros'
+[0.217s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extensions ['cmake', 'python']
+[0.217s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'cmake'
+[0.217s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'python'
+[0.217s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extensions ['python_setup_py']
+[0.218s] Level 1:colcon.colcon_core.package_identification:_identify(joint_control/__pycache__) by extension 'python_setup_py'
+[0.218s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extensions ['ignore', 'ignore_ament_install']
+[0.218s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'ignore'
+[0.218s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'ignore_ament_install'
+[0.218s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extensions ['colcon_pkg']
+[0.218s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'colcon_pkg'
+[0.218s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extensions ['colcon_meta']
+[0.218s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'colcon_meta'
+[0.218s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extensions ['ros']
+[0.218s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'ros'
+[0.219s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extensions ['cmake', 'python']
+[0.219s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'cmake'
+[0.219s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'python'
+[0.219s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extensions ['python_setup_py']
+[0.219s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info) by extension 'python_setup_py'
+[0.219s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extensions ['ignore', 'ignore_ament_install']
+[0.219s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'ignore'
+[0.219s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'ignore_ament_install'
+[0.220s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extensions ['colcon_pkg']
+[0.220s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'colcon_pkg'
+[0.220s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extensions ['colcon_meta']
+[0.220s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'colcon_meta'
+[0.220s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extensions ['ros']
+[0.220s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'ros'
+[0.220s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extensions ['cmake', 'python']
+[0.220s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'cmake'
+[0.220s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'python'
+[0.220s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extensions ['python_setup_py']
+[0.220s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/osc4py3) by extension 'python_setup_py'
+[0.221s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extensions ['ignore', 'ignore_ament_install']
+[0.221s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'ignore'
+[0.221s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'ignore_ament_install'
+[0.221s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extensions ['colcon_pkg']
+[0.221s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'colcon_pkg'
+[0.221s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extensions ['colcon_meta']
+[0.221s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'colcon_meta'
+[0.221s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extensions ['ros']
+[0.221s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'ros'
+[0.222s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extensions ['cmake', 'python']
+[0.222s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'cmake'
+[0.222s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'python'
+[0.222s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extensions ['python_setup_py']
+[0.222s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc) by extension 'python_setup_py'
+[0.222s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extensions ['ignore', 'ignore_ament_install']
+[0.222s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'ignore'
+[0.222s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'ignore_ament_install'
+[0.222s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extensions ['colcon_pkg']
+[0.222s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'colcon_pkg'
+[0.223s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extensions ['colcon_meta']
+[0.223s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'colcon_meta'
+[0.223s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extensions ['ros']
+[0.223s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'ros'
+[0.223s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extensions ['cmake', 'python']
+[0.223s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'cmake'
+[0.223s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'python'
+[0.223s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extensions ['python_setup_py']
+[0.223s] Level 1:colcon.colcon_core.package_identification:_identify(joint_info/pythonosc/bundles) by extension 'python_setup_py'
+[0.224s] Level 1:colcon.colcon_core.package_identification:_identify(log) by extensions ['ignore', 'ignore_ament_install']
+[0.224s] Level 1:colcon.colcon_core.package_identification:_identify(log) by extension 'ignore'
+[0.224s] Level 1:colcon.colcon_core.package_identification:_identify(log) ignored
+[0.224s] Level 1:colcon.colcon_core.package_discovery:discover_packages(recursive) using defaults
+[0.224s] Level 1:colcon.colcon_core.package_discovery:discover_packages(ignore) discover
+[0.224s] Level 1:colcon.colcon_core.package_discovery:discover_packages(ignore) using defaults
+[0.224s] Level 1:colcon.colcon_core.package_discovery:discover_packages(path) discover
+[0.224s] Level 1:colcon.colcon_core.package_discovery:discover_packages(path) using defaults
+[0.226s] INFO:colcon.colcon_core.executor:Executing jobs using 'parallel' executor
+[0.228s] DEBUG:colcon.colcon_parallel_executor.executor.parallel:run_until_complete
+[0.229s] DEBUG:colcon.colcon_parallel_executor.executor.parallel:closing loop
+[0.229s] DEBUG:colcon.colcon_parallel_executor.executor.parallel:loop closed
+[0.229s] DEBUG:colcon.colcon_parallel_executor.executor.parallel:run_until_complete finished with '0'
+[0.230s] DEBUG:colcon.colcon_core.event_reactor:joining thread
+[0.234s] INFO:colcon.colcon_core.plugin_system:Skipping extension 'colcon_notification.desktop_notification.notify_send': Could not find 'notify-send'
+[0.234s] INFO:colcon.colcon_core.plugin_system:Skipping extension 'colcon_notification.desktop_notification.terminal_notifier': Not used on non-Darwin systems
+[0.234s] INFO:colcon.colcon_core.plugin_system:Skipping extension 'colcon_notification.desktop_notification.win32': Not used on non-Windows systems
+[0.234s] INFO:colcon.colcon_notification.desktop_notification:Sending desktop notification using 'notify2'
+[0.236s] DEBUG:colcon.colcon_notification.desktop_notification.notify2:Failed to initialize notify2: org.freedesktop.DBus.Error.NotSupported: Unable to autolaunch a dbus-daemon without a $DISPLAY for X11
+[0.236s] DEBUG:colcon.colcon_core.event_reactor:joined thread