def __init__(self, capability_name, preferred_provider):
validate_spec_name(capability_name)
if preferred_provider is not None:
validate_spec_name(preferred_provider)
self.name = capability_name
self.capability_name = capability_name
self.provider = preferred_provider
self.preferred_provider = preferred_provider
def __init__(self, capability_name, preferred_provider):
validate_spec_name(capability_name)
if preferred_provider is not None:
validate_spec_name(preferred_provider)
self.name = capability_name
self.capability_name = capability_name
self.provider = preferred_provider
self.preferred_provider = preferred_provider
def semantic_capability_interface_from_dict(spec, file_name='<dict>'):
"""Creates a SemanticCapabilityInterface instance from a dict version of the spec
:param string: Semantic Capability Interface spec
:type string: dict
:param file_name: Name of the file where this spec originated (defaults to '<dict>')
:type file_name: str
:returns: SemanticCapabilityInterface instance, populated with the provided spec
:rtype: :py:class:`SemanticCapabilityInterface`
:raises: :py:exc:`InvalidSemanticInterface` if the spec is not complete or has invalid entries
"""
if 'spec_type' not in spec:
raise InvalidSemanticInterface('No spec type specified', file_name)
if spec['spec_type'] != 'semantic_interface':
raise InvalidSemanticInterface("Invalid spec type, expected 'semantic_interface' got: '{0}'"
.format(spec['spec_type']), file_name)
if 'spec_version' not in spec:
raise InvalidSemanticInterface('No spec version specified', file_name)
spec_version = int(spec['spec_version'])
if spec_version != 1:
raise InvalidSemanticInterface("Invalid spec version: '{0}'".format(spec_version), file_name)
if 'name' not in spec:
raise InvalidSemanticInterface('No name specified', file_name)
name = spec['name']
if 'redefines' not in spec:
raise InvalidSemanticInterface("No redefined capability specified", file_name)
redefines = spec['redefines']
try:
if isinstance(redefines, __basestring):
validate_spec_name(redefines)
else:
raise InvalidSemanticInterface("Invalid redefines, must be a string", file_name)
except (ValueError, AssertionError) as exc:
raise InvalidSemanticInterface("Invalid spec name for redefines: " + str(exc), file_name)
global_namespace = spec.get('global_namespace', None)
description = spec.get('description', 'No description given.')
try:
semantic_capability_interface = SemanticCapabilityInterface(
name,
redefines,
spec_version,
description,
global_namespace
)
semantic_capability_interface.add_remappings_by_dict(spec.get('remappings', {}))
except (AssertionError, ValueError) as exc:
raise InvalidSemanticInterface(str(exc), file_name)
return semantic_capability_interface
def capability_provider_from_dict(spec, file_name='<dict>'):
"""Creates a CapabilityProvider instance from a dict version of the spec
:param string: Capability Provider spec
:type string: dict
:param file_name: Name of the file where this spec originated (defaults to '<dict>')
:type file_name: str
:returns: CapabilityProvider instance, populated with the provided spec
:rtype: :py:class:`CapabilityProvider`
:raises: :py:exc:`InvalidProvider` if the spec is not complete or has invalid entries
"""
if 'name' not in spec:
raise InvalidProvider('No name specified', file_name)
name = spec['name']
if 'spec_type' not in spec:
raise InvalidProvider('No spec type specified', file_name)
if spec['spec_type'] != 'provider':
raise InvalidProvider(
"Invalid spec type, expected 'provider' got: '{0}'".format(
spec['spec_type']), file_name)
if 'spec_version' not in spec:
raise InvalidProvider('No spec version specified', file_name)
spec_version = int(spec['spec_version'])
if spec_version != 1:
raise InvalidProvider(
"Invalid spec version: '{0}'".format(spec_version), file_name)
if 'implements' not in spec:
raise InvalidProvider("No implements specified", file_name)
implements = spec['implements']
try:
validate_spec_name(implements)
except (ValueError, AssertionError) as exc:
raise InvalidProvider("Invalid spec name for implements: " + str(exc),
file_name)
launch_file = spec.get('launch_file', None)
description = spec.get('description', 'No description given.')
remappings = spec.get('remappings', {})
if not isinstance(remappings, dict):
raise InvalidProvider(
"Invalid remappings section, expected dict got: '{0}'".format(
type(remappings)), file_name)
nodelet_manager = spec.get('nodelet_manager', None)
if not isinstance(nodelet_manager, (str, type(None))):
raise InvalidProvider(
"Invalid nodelet_manager, expected string got: '{0}'".format(
type(nodelet_manager)), file_name)
try:
capability_provider = CapabilityProvider(name, spec_version,
implements, launch_file,
description, remappings,
nodelet_manager)
except (AssertionError, ValueError) as e: # Catch remapping errors
raise InvalidProvider(str(e), file_name)
depends_on = spec.get('depends_on', {})
if isinstance(depends_on, str):
depends_on = [depends_on]
if isinstance(depends_on, (list, tuple)):
depends_on = dict([(x, {}) for x in depends_on])
if not isinstance(depends_on, dict):
raise InvalidProvider(
"Invalid depends_on section, expected dict got: '{0}'".format(
type(depends_on)), file_name)
valid_conditionals = ['provider']
for interface, conditions in depends_on.items():
if not isinstance(conditions, dict):
raise InvalidProvider(
"Invalid depends_on conditional section, expected dict got: '{0}'"
.format(type(conditions)), file_name)
for key in conditions:
if key not in valid_conditionals:
raise InvalidProvider(
"Invalid depends_on interface condition '{0}', should be one of: '{1}'"
.format(key, "', '".join(valid_conditionals)), file_name)
preferred_provider = conditions.get('provider', None)
capability_provider.add_depends_on(interface, preferred_provider)
return capability_provider
def test_validate_spec_name():
for name, exc_type, exc_regex in test_cases:
with assert_raises_regex(exc_type, exc_regex):
validate_spec_name(name)
def capability_provider_from_dict(spec, file_name='<dict>'):
"""Creates a CapabilityProvider instance from a dict version of the spec
:param string: Capability Provider spec
:type string: dict
:param file_name: Name of the file where this spec originated (defaults to '<dict>')
:type file_name: str
:returns: CapabilityProvider instance, populated with the provided spec
:rtype: :py:class:`CapabilityProvider`
:raises: :py:exc:`InvalidProvider` if the spec is not complete or has invalid entries
"""
if 'name' not in spec:
raise InvalidProvider('No name specified', file_name)
name = spec['name']
if 'spec_type' not in spec:
raise InvalidProvider('No spec type specified', file_name)
if spec['spec_type'] != 'provider':
raise InvalidProvider("Invalid spec type, expected 'provider' got: '{0}'".format(spec['spec_type']),
file_name)
if 'spec_version' not in spec:
raise InvalidProvider('No spec version specified', file_name)
spec_version = int(spec['spec_version'])
if spec_version != 1:
raise InvalidProvider("Invalid spec version: '{0}'".format(spec_version), file_name)
if 'implements' not in spec:
raise InvalidProvider("No implements specified", file_name)
implements = spec['implements']
try:
validate_spec_name(implements)
except (ValueError, AssertionError) as exc:
raise InvalidProvider("Invalid spec name for implements: " + str(exc), file_name)
launch_file = spec.get('launch_file', None)
description = spec.get('description', 'No description given.')
remappings = spec.get('remappings', {})
if not isinstance(remappings, dict):
raise InvalidProvider("Invalid remappings section, expected dict got: '{0}'".format(type(remappings)),
file_name)
nodelet_manager = spec.get('nodelet_manager', None)
if not isinstance(nodelet_manager, (str, type(None))):
raise InvalidProvider("Invalid nodelet_manager, expected string got: '{0}'".format(type(nodelet_manager)),
file_name)
try:
capability_provider = CapabilityProvider(name, spec_version, implements, launch_file,
description, remappings, nodelet_manager)
except (AssertionError, ValueError) as e: # Catch remapping errors
raise InvalidProvider(str(e), file_name)
depends_on = spec.get('depends_on', {})
if isinstance(depends_on, str):
depends_on = [depends_on]
if isinstance(depends_on, (list, tuple)):
depends_on = dict([(x, {}) for x in depends_on])
if not isinstance(depends_on, dict):
raise InvalidProvider("Invalid depends_on section, expected dict got: '{0}'".format(type(depends_on)),
file_name)
valid_conditionals = ['provider']
for interface, conditions in depends_on.iteritems():
if not isinstance(conditions, dict):
raise InvalidProvider("Invalid depends_on conditional section, expected dict got: '{0}'"
.format(type(conditions)), file_name)
for key in conditions:
if key not in valid_conditionals:
raise InvalidProvider("Invalid depends_on interface condition '{0}', should be one of: '{1}'"
.format(key, "', '".join(valid_conditionals)), file_name)
preferred_provider = conditions.get('provider', None)
capability_provider.add_depends_on(interface, preferred_provider)
return capability_provider
