Declaring static type paramaters no longer matches rclcpp functionaility and always raises an exception

[gstorer]

Operating System:

Ubuntu 24

ROS version or commit hash:

Jazzy

Client library (if applicable):

rclpy

Steps to reproduce issue

I have noticed this issue when upgrading our code base from Humble to Jazzy.

When declaring a static typed parameter in rclpy, it is no longer possible to supply a value at run time, a default value must be specified.

The following code runs fine in Humble but raises an exception in Jazzy when called as follows:
python3 test_node.py --ros-args --param my_string_param:=test_value

import rclpy
from rclpy.node import Node
from rcl_interfaces.msg import ParameterDescriptor, ParameterType


class SimpleParameterNode(Node):
    def __init__(self):
        super().__init__('simple_parameter_node')
        
        # Declare a string parameter without a default value using a descriptor to set its type
        string_descriptor = ParameterDescriptor(
            type=ParameterType.PARAMETER_STRING,
            description='A required string parameter'
        )
    
        self.my_param = self.declare_parameter(
            'my_string_param',
            descriptor=string_descriptor
        )
            
        # Print the parameter value
        self.get_logger().info(f'Received parameter: {repr(self.my_param.value)}')

def main(args=None):
    rclpy.init(args=args)
    node = SimpleParameterNode()
    
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        rclpy.shutdown()


if __name__ == '__main__':
    main()

The exception raised is:
ValueError: Cannot declare a statically typed parameter with default value of type PARAMETER_NOT_SET

Expected behavior

The behavior should match rclcpp. If a static typed parameter is declared without a default, it must be supplied when running the node or an exception is raised.

Actual behavior

rclpy always raises an exception for a static parameter without a default, even if it is supplied at runtime.

Additional information

This appears to be the pull request were the issue was introduced: #1216 . In it @haianos correctly identifies some user stories where it will be an issue. Note that before this pull request rclpy behavior didn't match rclcpp either, instead it never raised an exception. However, this didn't prevent my code from working.

For an example of the use of static typed parameters without defaults from within the ros2 org (in C++) see: https://github.com/ros2/openrobotics_darknet_ros/blob/6c741578d55b19ffb9a120b79cb8a78c7b60fbd6/src/detector_node.cpp#L98

[fujitatomoya]

The behavior should match rclcpp.

is this true? it generates the exceptions::UninitializedStaticallyTypedParameterException, right here in jazzy branch.

https://github.com/ros2/rclcpp/blob/8266f85bc81041d823baac1f955acd32e6be9cfd/rclcpp/include/rclcpp/node_impl.hpp#L282

[gstorer]

Yes, the vast majority of our code is C++ and this is the pattern we exclusively use to ensure that configuration is only in one place. The exception is only raised if the parameter is not provided at runtime.

This (admittedly slightly older) pull request makes it clear that static types without a default are intended to be a valid use:
ros2/rclcpp#1522

The following C++ code demonstrates this and runs as I described with Jazzy.
This produces no errors:
ros2 run simple_parameter_node simple_parameter_node --ros-args --param my_string_param:=test_value
This raises an rclcpp::exceptions::UninitializedStaticallyTypedParameterException:
ros2 run simple_parameter_node simple_parameter_node

#include "rclcpp/rclcpp.hpp"
#include "rcl_interfaces/msg/parameter_descriptor.hpp"
#include "rcl_interfaces/msg/parameter_type.hpp"

class SimpleParameterNode : public rclcpp::Node
{
public:
    SimpleParameterNode() : Node("simple_parameter_node")
    {
        rcl_interfaces::msg::ParameterDescriptor string_descriptor;
        string_descriptor.type = rcl_interfaces::msg::ParameterType::PARAMETER_STRING;
        string_descriptor.description = "A required string parameter";

        this->declare_parameter<std::string>("my_string_param", string_descriptor);

        std::string my_param = this->get_parameter("my_string_param").as_string();
        RCLCPP_INFO(this->get_logger(), "Received parameter: '%s'", my_param.c_str());
    }
};

int main(int argc, char **argv)
{
    rclcpp::init(argc, argv);
    rclcpp::spin(std::make_shared<SimpleParameterNode>());
    rclcpp::shutdown();
    return 0;
}

[gstorer]

While digging around in rclpy to create a work around wrapper for my problem I came across this pull request that also suggests that the exception is intended to be raised when accessing an uninitialized variable, not on declaration: #798

So the correct raise exception behavior is implemented when you call get_parameter(). But this is(was?) circumvented if the value is accessed from the object returned by declare_parameter. Which is maybe the bug that should have been fixed in #1216 ?

[fujitatomoya]

@gstorer thanks for digging in this. i will look into this.