Revert "implement parameter_client" (#958)

See discussion @ #956

Signed-off-by: Brian Chen <[email protected]>

rclpy/docs/source/api/parameters.rst

@@ -10,8 +10,3 @@ Parameter Service
 -----------------
 
 .. automodule:: rclpy.parameter_service
-
-Parameter Client
------------------
-
-.. automodule:: rclpy.parameter_client

rclpy/rclpy/__init__.py

@@ -43,7 +43,6 @@
 from typing import List
 from typing import Optional
 from typing import TYPE_CHECKING
-from typing import Union
 
 from rclpy.context import Context
 from rclpy.parameter import Parameter
@@ -142,7 +141,7 @@ def create_node(
     use_global_arguments: bool = True,
     enable_rosout: bool = True,
     start_parameter_services: bool = True,
-    parameter_overrides: Union[List[Parameter], None] = None,
+    parameter_overrides: List[Parameter] = None,
     allow_undeclared_parameters: bool = False,
     automatically_declare_parameters_from_overrides: bool = False
 ) -> 'Node':

rclpy/rclpy/parameter.py

@@ -14,14 +14,9 @@
 
 import array
 from enum import Enum
-from typing import Dict
-from typing import List
-from typing import Optional
 
 from rcl_interfaces.msg import Parameter as ParameterMsg
-from rcl_interfaces.msg import ParameterType
-from rcl_interfaces.msg import ParameterValue
-import yaml
+from rcl_interfaces.msg import ParameterType, ParameterValue
 
 PARAMETER_SEPARATOR_STRING = '.'
 
@@ -182,50 +177,6 @@ def to_parameter_msg(self):
         return ParameterMsg(name=self.name, value=self.get_parameter_value())
 
 
-def get_parameter_value(string_value: str) -> ParameterValue:
-    """
-    Guess the desired type of the parameter based on the string value.
-
-    :param string_value: The string value to be converted to a ParameterValue.
-    :return: The ParameterValue.
-    """
-    value = ParameterValue()
-    try:
-        yaml_value = yaml.safe_load(string_value)
-    except yaml.parser.ParserError:
-        yaml_value = string_value
-
-    if isinstance(yaml_value, bool):
-        value.type = ParameterType.PARAMETER_BOOL
-        value.bool_value = yaml_value
-    elif isinstance(yaml_value, int):
-        value.type = ParameterType.PARAMETER_INTEGER
-        value.integer_value = yaml_value
-    elif isinstance(yaml_value, float):
-        value.type = ParameterType.PARAMETER_DOUBLE
-        value.double_value = yaml_value
-    elif isinstance(yaml_value, list):
-        if all((isinstance(v, bool) for v in yaml_value)):
-            value.type = ParameterType.PARAMETER_BOOL_ARRAY
-            value.bool_array_value = yaml_value
-        elif all((isinstance(v, int) for v in yaml_value)):
-            value.type = ParameterType.PARAMETER_INTEGER_ARRAY
-            value.integer_array_value = yaml_value
-        elif all((isinstance(v, float) for v in yaml_value)):
-            value.type = ParameterType.PARAMETER_DOUBLE_ARRAY
-            value.double_array_value = yaml_value
-        elif all((isinstance(v, str) for v in yaml_value)):
-            value.type = ParameterType.PARAMETER_STRING_ARRAY
-            value.string_array_value = yaml_value
-        else:
-            value.type = ParameterType.PARAMETER_STRING
-            value.string_value = string_value
-    else:
-        value.type = ParameterType.PARAMETER_STRING
-        value.string_value = yaml_value
-    return value
-
-
 def parameter_value_to_python(parameter_value: ParameterValue):
     """
     Get the value for the Python builtin type from a rcl_interfaces/msg/ParameterValue object.
@@ -260,70 +211,3 @@ def parameter_value_to_python(parameter_value: ParameterValue):
         raise RuntimeError(f'unexpected parameter type {parameter_value.type}')
 
     return value
-
-
-def parameter_dict_from_yaml_file(
-    parameter_file: str,
-    use_wildcard: bool = False,
-    target_nodes: Optional[List[str]] = None,
-    namespace: str = ''
-) -> Dict[str, ParameterMsg]:
-    """
-    Build a dict of parameters from a YAML file formatted as per ``ros2 param dump``.
-
-    Will load all parameters if ``target_nodes`` is None
-
-    :param parameter_file: Path to the YAML file to load parameters from.
-    :param use_wildcard: Use wildcard matching for the target nodes.
-    :param target_nodes: List of nodes in the YAML file to load parameters from.
-    :param namespace: Namespace to prepend to all parameters.
-    :return: A dict of Parameter objects keyed by the parameter names
-    """
-    with open(parameter_file, 'r') as f:
-        param_file = yaml.safe_load(f)
-        param_keys = set()
-        param_dict = {}
-
-        if use_wildcard and '/**' in param_file:
-            param_keys.add('/**')
-        if target_nodes:
-            for n in target_nodes:
-                if n not in param_file.keys():
-                    raise RuntimeError(f'Param file does not contain parameters for {n},'
-                                       f'only for nodes: {list(param_file.keys())} ')
-                param_keys.add(n)
-        else:
-            param_keys = param_file.keys()
-
-        for n in param_keys:
-            value = param_file[n]
-            if type(value) != dict or 'ros__parameters' not in value:
-                raise RuntimeError('Invalid structure of parameter file for node {}'
-                                   'expected same format as provided by ros2 param dump'
-                                   .format(n))
-            param_dict.update(value['ros__parameters'])
-        return _unpack_parameter_dict(namespace, param_dict)
-
-
-def _unpack_parameter_dict(namespace, parameter_dict):
-    """
-    Flatten a parameter dictionary recursively.
-
-    :param namespace: The namespace to prepend to the parameter names.
-    :param parameter_dict: A dictionary of parameters keyed by the parameter names
-    :return: A dict of Parameter objects keyed by the parameter names
-    """
-    parameters: Dict[str, ParameterMsg] = {}
-    for param_name, param_value in parameter_dict.items():
-        full_param_name = namespace + param_name
-        # Unroll nested parameters
-        if type(param_value) == Dict:
-            parameters += _unpack_parameter_dict(
-                    namespace=full_param_name + PARAMETER_SEPARATOR_STRING,
-                    parameter_dict=param_value)
-        else:
-            parameter = ParameterMsg()
-            parameter.name = full_param_name
-            parameter.value = get_parameter_value(str(param_value))
-            parameters[full_param_name] = parameter
-    return parameters