def _arg_tag(self, tag, context, ros_config, verbose=True):
"""
Process an <arg> tag.
"""
try:
self._check_attrs(tag, context, ros_config, XmlLoader.ARG_ATTRS)
(name, ) = self.reqd_attrs(tag, context, ('name', ))
value, default, doc = self.opt_attrs(tag, context,
('value', 'default', 'doc'))
if value is not None and default is not None:
raise XmlParseException(
"<arg> tag must have one and only one of value/default.")
context.add_arg(name, value=value, default=default, doc=doc)
except substitution_args.ArgException as e:
raise XmlParseException(
"arg '%s' is not defined. \n\nArg xml is %s" %
(e, tag.toxml()))
except ResourceNotFound as e:
raise ResourceNotFound(
"The following package was not found in {}: {}".format(
tag.toxml(), e))
except Exception as e:
raise XmlParseException(
"Invalid <arg> tag: %s. \n\nArg xml is %s" % (e, tag.toxml()))
def get_rosdep_view(self, view_key, verbose=False):
"""
Get a :class:`RosdepView` associated with *view_key*. Views
can be queries to resolve rosdep keys to definitions.
:param view_key: Name of rosdep view (e.g. ROS stack name), ``str``
:raises: :exc:`RosdepConflict` if view cannot be created due
to conflict rosdep definitions.
:raises: :exc:`rospkg.ResourceNotFound` if *view_key* cannot be located
:raises: :exc:`RosdepInternalError`
"""
if view_key in self._view_cache:
return self._view_cache[view_key]
# lazy-init
self._load_view_dependencies(view_key, self.loader)
# use dependencies to create view
try:
dependencies = self.rosdep_db.get_view_dependencies(view_key)
except KeyError as e:
# convert to ResourceNotFound. This should be decoupled
# in the future
raise ResourceNotFound(str(e.args[0]))
# load views in order
view = self.create_rosdep_view(view_key, dependencies + [view_key], verbose=verbose)
self._view_cache[view_key] = view
return view
def test_ResourceNotFound():
from rospkg import ResourceNotFound
r = ResourceNotFound('blah')
assert 'blah' == str(r)
assert r.ros_paths is None
s = str(r)
assert 'None' not in s
assert 'blah' in s
r = ResourceNotFound('blah', ['ros_root', 'ros_package_path'])
assert 'blah' == str(r.args[0])
assert ['ros_root', 'ros_package_path'] == r.ros_paths
s = str(r)
print(s)
assert 'blah' in s
assert 'ros_root' in s
assert 'ros_package_path' in s
def __init__(
self,
dev_name: str,
hw_server_name: str = None,
emotion_core_data_descriptor_json: str = None,
perception_concept_descriptor_json: str = None,
):
"""
Parameters
----------
dev_name : str
[description]
hw_server_name : str, optional
If not specified, the HW server will not be used, by default None
emotion_core_data_descriptor_json : str, optional
If not specified, the data_descriptor server will not be used, by default None
perception_concept_descriptor_json : str, optional
If not specified, the perception_concept_descriptor server will not be used, by default None
Raises
------
ResourceNotFound
[description]
"""
self.name = dev_name
self.hw_server_name = hw_server_name
self.client_hw_lock = threading.Lock()
try:
self.schema_path = RosPack().get_path('aliveos_msgs') + "/json"
except ResourceNotFound:
raise ResourceNotFound("Cannot find the aliveos_msgs package")
self.data_dsc_json = None
if emotion_core_data_descriptor_json:
self.data_dsc_json = json_to_dict(
in_json=emotion_core_data_descriptor_json,
in_schema=
f"{self.schema_path}/emotion-core-data-descriptor.json")
self.p_concept_json = None
if perception_concept_descriptor_json:
self.p_concept_json = json_to_dict(
in_json=perception_concept_descriptor_json,
in_schema=
f"{self.schema_path}/perception-concept-descriptor.json")
# ros clients
self.client_hw = None
self.client_emotion_core_data_descriptor = None
self.client_perception_concept_decriptor = None
# ros subscribers
self.subscriber_to_cmd = None
# ros publishers
self.publisher_of_sensor_data = None
def __init__(self,
name="GenericMindNode",
concept_files: list = None,
node_type=node_types.GENERIC_NODE):
self.name = name
self.node_type = node_type
self.sensor_cb_thread = None
self.current_emotion_params = None
self.current_perception_concept = None
self.current_perception_concept_mod = None
# Command concepts
self.concept_files = concept_files
# Clients
self.clt_command_concept = None
self.clt_command_concept_dsc = None
self.clt_emotion_core_write = None
# Subscribers
self.sub_perception_concept = None
self.sub_emotion_params = None
try:
self.schema_path = RosPack().get_path('aliveos_msgs') + "/json"
except ResourceNotFound:
raise ResourceNotFound("Cannot find the aliveos_msgs package")
