Rename parameter options

rclpy/rclpy/__init__.py

@@ -111,9 +111,9 @@ def create_node(
     namespace: str = None,
     use_global_arguments: bool = True,
     start_parameter_services: bool = True,
-    initial_parameters: List[Parameter] = None,
+    parameter_overrides: List[Parameter] = None,
     allow_undeclared_parameters: bool = False,
-    automatically_declare_initial_parameters: bool = True
+    automatically_declare_parameters_from_overrides: bool = True
 ) -> 'Node':
     """
     Create an instance of :class:`.Node`.
@@ -127,10 +127,12 @@ def create_node(
     :param use_global_arguments: ``False`` if the node should ignore process-wide command line
         arguments.
     :param start_parameter_services: ``False`` if the node should not create parameter services.
-    :param initial_parameters: A list of :class:`.Parameter` to be set during node creation.
-    :param allow_undeclared_parameters: True if undeclared parameters are allowed, False otherwise.
-    :param automatically_declare_initial_parameters: True if initial parameters have to be declared
-        upon node creation, false otherwise.
+    :param parameter_overrides: A list of :class:`.Parameter` which are used to override the
+        initial values of parameters declared on this node.
+     :param allow_undeclared_parameters: True if undeclared parameters are allowed, False otherwise.
+        This option doesn't affect `parameter_overrides`.
+    :param automatically_declare_parameters_from_overrides: If True, the "parameter overrides" will
+        be used to implicitly declare parameters on the node during creation.
     :return: An instance of the newly created node.
     """
     # imported locally to avoid loading extensions on module import
@@ -139,9 +141,11 @@ def create_node(
         node_name, context=context, cli_args=cli_args, namespace=namespace,
         use_global_arguments=use_global_arguments,
         start_parameter_services=start_parameter_services,
-        initial_parameters=initial_parameters,
+        parameter_overrides=parameter_overrides,
         allow_undeclared_parameters=allow_undeclared_parameters,
-        automatically_declare_initial_parameters=automatically_declare_initial_parameters)
+        automatically_declare_parameters_from_overrides=(
+            automatically_declare_parameters_from_overrides
+        ))
 
 
 def spin_once(node: 'Node', *, executor: 'Executor' = None, timeout_sec: float = None) -> None:

rclpy/rclpy/node.py

@@ -96,9 +96,9 @@ def __init__(
         namespace: str = None,
         use_global_arguments: bool = True,
         start_parameter_services: bool = True,
-        initial_parameters: List[Parameter] = None,
+        parameter_overrides: List[Parameter] = None,
         allow_undeclared_parameters: bool = False,
-        automatically_declare_initial_parameters: bool = False
+        automatically_declare_parameters_from_overrides: bool = False
     ) -> None:
         """
         Constructor.
@@ -113,11 +113,12 @@ def __init__(
             args.
         :param start_parameter_services: ``False`` if the node should not create parameter
             services.
-        :param initial_parameters: A list of parameters to be set during node creation.
+        :param parameter_overrides: A list of overrides for initial values for parameters declared
+            on the node.
         :param allow_undeclared_parameters: True if undeclared parameters are allowed.
             This flag affects the behavior of parameter-related operations.
-        :param automatically_declare_initial_parameters: True if initial parameters have to be
-            declared upon node creation, false otherwise.
+        :param automatically_declare_parameters_from_overrides: If True, the "parameter overrides"
+            will be used to implicitly declare parameters on the node during creation.
         """
         self.__handle = None
         self._context = get_default_context() if context is None else context
@@ -132,7 +133,7 @@ def __init__(
         self._default_callback_group = MutuallyExclusiveCallbackGroup()
         self._parameters_callback = None
         self._allow_undeclared_parameters = allow_undeclared_parameters
-        self._initial_parameters = {}
+        self._parameter_overrides = {}
         self._descriptors = {}
 
         namespace = namespace or ''
@@ -166,14 +167,14 @@ def __init__(
             ParameterEvent, 'parameter_events', qos_profile_parameter_events)
 
         with self.handle as capsule:
-            self._initial_parameters = _rclpy.rclpy_get_node_parameters(Parameter, capsule)
+            self._parameter_overrides = _rclpy.rclpy_get_node_parameters(Parameter, capsule)
         # Combine parameters from params files with those from the node constructor and
         # use the set_parameters_atomically API so a parameter event is published.
-        if initial_parameters is not None:
-            self._initial_parameters.update({p.name: p for p in initial_parameters})
+        if parameter_overrides is not None:
+            self._parameter_overrides.update({p.name: p for p in parameter_overrides})
 
-        if automatically_declare_initial_parameters:
-            self._parameters.update(self._initial_parameters)
+        if automatically_declare_parameters_from_overrides:
+            self._parameters.update(self._parameter_overrides)
             self._descriptors.update({p: ParameterDescriptor() for p in self._parameters})
 
         if start_parameter_services:
@@ -359,10 +360,10 @@ def declare_parameters(
                         'is not a str.'.format_map(locals())
                     )
 
-                # Get value from initial parameters, of from tuple if it doesn't exist.
-                if name in self._initial_parameters:
-                    type_ = self._initial_parameters[name].type_
-                    value = self._initial_parameters[name].value
+                # Get value from parameter overrides, of from tuple if it doesn't exist.
+                if name in self._parameter_overrides:
+                    type_ = self._parameter_overrides[name].type_
+                    value = self._parameter_overrides[name].value
                 else:
                     # This raises a TypeError if it's not possible to get a type from the tuple.
                     type_ = Parameter.Type.from_parameter_value(parameter_tuple[1])

rclpy/test/test_node.py

@@ -383,12 +383,12 @@ def setUp(self):
             TEST_NODE,
             namespace=TEST_NAMESPACE,
             context=self.context,
-            initial_parameters=[
+            parameter_overrides=[
                 Parameter('initial_foo', Parameter.Type.INTEGER, 4321),
                 Parameter('initial_bar', Parameter.Type.STRING, 'init_param'),
                 Parameter('initial_baz', Parameter.Type.DOUBLE, 3.14)
             ],
-            automatically_declare_initial_parameters=False
+            automatically_declare_parameters_from_overrides=False
         )
 
     @classmethod