From 3a259c11706864bc52d2aec4f1fa0368dd0f8888 Mon Sep 17 00:00:00 2001 From: Twirre Meulenbelt <43213592+TwirreM@users.noreply.github.com> Date: Wed, 10 Dec 2025 13:28:13 +0100 Subject: [PATCH] feat: add environment variables and docs ref: N25B-352 --- .env.example | 25 +++++ README.md | 7 +- requirements.txt | 1 + src/robot_interface/core/config.py | 94 ++++++++++--------- .../endpoints/actuation_receiver.py | 2 +- .../endpoints/main_receiver.py | 7 +- src/robot_interface/endpoints/socket_base.py | 4 +- src/robot_interface/utils/get_config.py | 32 +++++++ test/integration/test_config.py | 32 +++++++ test/unit/test_get_config.py | 45 +++++++++ 10 files changed, 200 insertions(+), 49 deletions(-) create mode 100644 .env.example create mode 100644 src/robot_interface/utils/get_config.py create mode 100644 test/integration/test_config.py create mode 100644 test/unit/test_get_config.py diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..173b63c --- /dev/null +++ b/.env.example @@ -0,0 +1,25 @@ +# Example .env file. To use, make a copy, call it ".env" (i.e. removing the ".example" suffix), then you edit values. +# To make a variable apply, uncomment it (remove the "#" in front of the line). + +# First, some variables that are likely to be configured: + +# The hostname or IP address of the Control Backend. +AGENT__CONTROL_BACKEND_HOST=localhost + + + +# Variables that are unlikely to be configured, you can probably ignore these: + +#AGENT__ACTUATION_RECEIVER_PORT= +#AGENT__MAIN_RECEIVER_PORT= +#AGENT__VIDEO_SENDER_PORT= +#AGENT__AUDIO_SENDER_PORT= +#VIDEO__CAMERA_INDEX= +#VIDEO__RESOLUTION= +#VIDEO__COLOR_SPACE= +#VIDEO__FPS= +#VIDEO__STREAM_NAME= +#VIDEO__IMAGE_BUFFER= +#AUDIO__SAMPLE_RATE= +#AUDIO__CHUNK_SIZE= +#AUDIO__CHANNELS= diff --git a/README.md b/README.md index 37458df..97fab48 100644 --- a/README.md +++ b/README.md @@ -108,10 +108,15 @@ On Windows: $env:PYTHONPATH="src"; python -m robot_interface.main ``` -With both, if you want to connect to the actual robot (or simulator), pass the `--qi-url` argument. +### Program Arguments + +If you want to connect to the actual robot (or simulator), pass the `--qi-url` argument. There's also a `--microphone` argument that can be used to choose a microphone to use. If not given, the program will try the default microphone. If you don't know the name of the microphone, pass the argument with any value, and it will list the names of available microphones. +### Environment Variables + +You may use environment variables to change settings. Make a copy of the [`.env.example`](.env.example) file, name it `.env` and put it in the root directory. The file itself describes how to do the configuration. ## Testing diff --git a/requirements.txt b/requirements.txt index d46c38e..bc679f4 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,3 +6,4 @@ pytest-cov<3.0.0 sphinx sphinx_rtd_theme pre-commit +python-dotenv diff --git a/src/robot_interface/core/config.py b/src/robot_interface/core/config.py index 86cbe5a..9e638b5 100644 --- a/src/robot_interface/core/config.py +++ b/src/robot_interface/core/config.py @@ -1,95 +1,101 @@ from __future__ import unicode_literals +from robot_interface.utils.get_config import get_config + class AgentSettings(object): """ Agent port configuration. - :ivar actuating_receiver_port: Port for receiving actuation commands. - :vartype actuating_receiver_port: int - :ivar main_receiver_port: Port for receiving main messages. + :ivar control_backend_host: Hostname of the control backend, defaults to "localhost". + :vartype control_backend_host: string + :ivar actuation_receiver_port: Port for receiving actuation commands, defaults to 5557. + :vartype actuation_receiver_port: int + :ivar main_receiver_port: Port for receiving main messages, defaults to 5555. :vartype main_receiver_port: int - :ivar video_sender_port: Port used for sending video frames. + :ivar video_sender_port: Port used for sending video frames, defaults to 5556. :vartype video_sender_port: int - :ivar audio_sender_port: Port used for sending audio data. + :ivar audio_sender_port: Port used for sending audio data, defaults to 5558. :vartype audio_sender_port: int """ def __init__( - self, - actuating_receiver_port=5557, - main_receiver_port=5555, - video_sender_port=5556, - audio_sender_port=5558, + self, + control_backend_host=None, + actuation_receiver_port=None, + main_receiver_port=None, + video_sender_port=None, + audio_sender_port=None, ): - self.actuating_receiver_port = actuating_receiver_port - self.main_receiver_port = main_receiver_port - self.video_sender_port = video_sender_port - self.audio_sender_port = audio_sender_port + self.control_backend_host = get_config(control_backend_host, "AGENT__CONTROL_BACKEND_HOST", "localhost") + self.actuation_receiver_port = get_config(actuation_receiver_port, "AGENT__ACTUATION_RECEIVER_PORT", 5557, int) + self.main_receiver_port = get_config(main_receiver_port, "AGENT__MAIN_RECEIVER_PORT", 5555, int) + self.video_sender_port = get_config(video_sender_port, "AGENT__VIDEO_SENDER_PORT", 5556, int) + self.audio_sender_port = get_config(audio_sender_port, "AGENT__AUDIO_SENDER_PORT", 5558, int) class VideoConfig(object): """ Video configuration constants. - :ivar camera_index: Index of the camera used. + :ivar camera_index: Index of the camera used, defaults to 0. :vartype camera_index: int - :ivar resolution: Video resolution mode. + :ivar resolution: Video resolution mode, defaults to 2. :vartype resolution: int - :ivar color_space: Color space identifier. + :ivar color_space: Color space identifier, defaults to 11. :vartype color_space: int - :ivar fps: Frames per second of the video stream. + :ivar fps: Frames per second of the video stream, defaults to 15. :vartype fps: int - :ivar stream_name: Name of the video stream. + :ivar stream_name: Name of the video stream, defaults to "Pepper Video". :vartype stream_name: str - :ivar image_buffer: Internal buffer size for video frames. + :ivar image_buffer: Internal buffer size for video frames, defaults to 6. :vartype image_buffer: int """ def __init__( self, - camera_index=0, - resolution=2, - color_space=11, - fps=15, - stream_name="Pepper Video", - image_buffer=6, + camera_index=None, + resolution=None, + color_space=None, + fps=None, + stream_name=None, + image_buffer=None, ): - self.camera_index = camera_index - self.resolution = resolution - self.color_space = color_space - self.fps = fps - self.stream_name = stream_name - self.image_buffer = image_buffer + self.camera_index = get_config(camera_index, "VIDEO__CAMERA_INDEX", 0, int) + self.resolution = get_config(resolution, "VIDEO__RESOLUTION", 2, int) + self.color_space = get_config(color_space, "VIDEO__COLOR_SPACE", 11, int) + self.fps = get_config(fps, "VIDEO__FPS", 15, int) + self.stream_name = get_config(stream_name, "VIDEO__STREAM_NAME", "Pepper Video") + self.image_buffer = get_config(image_buffer, "VIDEO__IMAGE_BUFFER", 6, int) class AudioConfig(object): """ Audio configuration constants. - :ivar sample_rate: Audio sampling rate in Hz. + :ivar sample_rate: Audio sampling rate in Hz, defaults to 16000. :vartype sample_rate: int - :ivar chunk_size: Size of audio chunks to capture/process. + :ivar chunk_size: Size of audio chunks to capture/process, defaults to 512. :vartype chunk_size: int - :ivar channels: Number of audio channels. + :ivar channels: Number of audio channels, defaults to 1. :vartype channels: int """ - def __init__(self, sample_rate=16000, chunk_size=512, channels=1): - self.sample_rate = sample_rate - self.chunk_size = chunk_size - self.channels = channels + def __init__(self, sample_rate=None, chunk_size=None, channels=None): + self.sample_rate = get_config(sample_rate, "AUDIO__SAMPLE_RATE", 16000, int) + self.chunk_size = get_config(chunk_size, "AUDIO__CHUNK_SIZE", 512, int) + self.channels = get_config(channels, "AUDIO__CHANNELS", 1, int) class MainConfig(object): """ Main system configuration. - :ivar poll_timeout_ms: Timeout for polling events, in milliseconds. + :ivar poll_timeout_ms: Timeout for polling events, in milliseconds, defaults to 100. :vartype poll_timeout_ms: int - :ivar max_handler_time_ms: Maximum allowed handler time, in milliseconds. + :ivar max_handler_time_ms: Maximum allowed handler time, in milliseconds, defaults to 50. :vartype max_handler_time_ms: int """ - def __init__(self, poll_timeout_ms=100, max_handler_time_ms=50): - self.poll_timeout_ms = poll_timeout_ms - self.max_handler_time_ms = max_handler_time_ms + def __init__(self, poll_timeout_ms=None, max_handler_time_ms=None): + self.poll_timeout_ms = get_config(poll_timeout_ms, "MAIN__POLL_TIMEOUT_MS", 100, int) + self.max_handler_time_ms = get_config(max_handler_time_ms, "MAIN__MAX_HANDLER_TIME_MS", 50, int) class Settings(object): diff --git a/src/robot_interface/endpoints/actuation_receiver.py b/src/robot_interface/endpoints/actuation_receiver.py index 927efbd..ee09acb 100644 --- a/src/robot_interface/endpoints/actuation_receiver.py +++ b/src/robot_interface/endpoints/actuation_receiver.py @@ -22,7 +22,7 @@ class ActuationReceiver(ReceiverBase): :ivar _tts_service: The text-to-speech service object from the Qi session. :vartype _tts_service: qi.Session | None """ - def __init__(self, zmq_context, port=settings.agent_settings.actuating_receiver_port): + def __init__(self, zmq_context, port=settings.agent_settings.actuation_receiver_port): super(ActuationReceiver, self).__init__("actuation") self.create_socket(zmq_context, zmq.SUB, port) self.socket.setsockopt_string(zmq.SUBSCRIBE, u"") # Causes block if given in options diff --git a/src/robot_interface/endpoints/main_receiver.py b/src/robot_interface/endpoints/main_receiver.py index bd47198..2882970 100644 --- a/src/robot_interface/endpoints/main_receiver.py +++ b/src/robot_interface/endpoints/main_receiver.py @@ -5,6 +5,7 @@ from robot_interface.state import state from robot_interface.core.config import settings + class MainReceiver(ReceiverBase): """ The main receiver endpoint, responsible for handling ping and negotiation requests. @@ -12,10 +13,12 @@ class MainReceiver(ReceiverBase): :param zmq_context: The ZeroMQ context to use. :type zmq_context: zmq.Context - :param port: The port to use. + :param port: The port to use, defaults to value in `settings.agent_settings.main_receiver_port`. :type port: int """ - def __init__(self, zmq_context, port=settings.agent_settings.main_receiver_port): + def __init__(self, zmq_context, port=None): + if port is None: + port = settings.agent_settings.main_receiver_port super(MainReceiver, self).__init__("main") self.create_socket(zmq_context, zmq.REP, port, bind=False) diff --git a/src/robot_interface/endpoints/socket_base.py b/src/robot_interface/endpoints/socket_base.py index 9c7c20b..d2279a4 100644 --- a/src/robot_interface/endpoints/socket_base.py +++ b/src/robot_interface/endpoints/socket_base.py @@ -2,6 +2,8 @@ from abc import ABCMeta import zmq +from robot_interface.core.config import settings + class SocketBase(object): """ @@ -59,7 +61,7 @@ class SocketBase(object): if bind: self.socket.bind("tcp://*:{}".format(port)) else: - self.socket.connect("tcp://localhost:{}".format(port)) + self.socket.connect("tcp://{}:{}".format(settings.agent_settings.control_backend_host, port)) def close(self): """Close the ZeroMQ socket.""" diff --git a/src/robot_interface/utils/get_config.py b/src/robot_interface/utils/get_config.py new file mode 100644 index 0000000..ac4cef0 --- /dev/null +++ b/src/robot_interface/utils/get_config.py @@ -0,0 +1,32 @@ +import os +from dotenv import load_dotenv + +load_dotenv() + + +def get_config(value, env, default, cast=None): + """ + Small utility to get a configuration value, returns `value` if it is not None, else it will try to get the + environment variable cast with `cast`. If the environment variable is not set, it will return `default`. + + :param value: The value to check. + :type value: Any + :param env: The environment variable to check. + :type env: string + :param default: The default value to return if the environment variable is not set. + :type default: Any + :param cast: A function to use to cast the environment variable. Must support string input. + :type cast: Callable[[Any], Any], optional + + :return: The value, the environment variable value, or the default. + :rtype: Any + """ + if value is not None: + return value + + env = os.environ.get(env, default) + + if cast is None: + return env + + return cast(env) diff --git a/test/integration/test_config.py b/test/integration/test_config.py new file mode 100644 index 0000000..a9709b5 --- /dev/null +++ b/test/integration/test_config.py @@ -0,0 +1,32 @@ +from mock import patch, mock + +from robot_interface.core.config import Settings +from robot_interface.endpoints.main_receiver import MainReceiver + + +def test_environment_variables(monkeypatch): + """ + When environment variables are set, creating settings should use these. + """ + monkeypatch.setenv("AGENT__CONTROL_BACKEND_HOST", "some_value_that_should_be_different") + + settings = Settings() + + assert settings.agent_settings.control_backend_host == "some_value_that_should_be_different" + + +@patch("robot_interface.endpoints.main_receiver.settings") +@patch("robot_interface.endpoints.socket_base.settings") +def test_create_endpoint_custom_host(base_settings, main_settings): + """ + When a custom host is given in the settings, check that an endpoint's socket connects to it. + """ + fake_context = mock.Mock() + fake_socket = mock.Mock() + fake_context.socket.return_value = fake_socket + base_settings.agent_settings.control_backend_host = "not_localhost" + main_settings.agent_settings.main_receiver_port = 9999 + + _ = MainReceiver(fake_context) + + fake_socket.connect.assert_called_once_with("tcp://not_localhost:9999") diff --git a/test/unit/test_get_config.py b/test/unit/test_get_config.py new file mode 100644 index 0000000..d2b00e4 --- /dev/null +++ b/test/unit/test_get_config.py @@ -0,0 +1,45 @@ +from robot_interface.utils.get_config import get_config + + +def test_get_config_prefers_explicit_value(monkeypatch): + """ + When a direct value is provided it should be returned without reading the environment. + """ + monkeypatch.setenv("GET_CONFIG_TEST", "from-env") + + result = get_config("explicit", "GET_CONFIG_TEST", "default") + + assert result == "explicit" + + +def test_get_config_returns_env_value(monkeypatch): + """ + If value is None the environment variable should be used. + """ + monkeypatch.setenv("GET_CONFIG_TEST", "from-env") + + result = get_config(None, "GET_CONFIG_TEST", "default") + + assert result == "from-env" + + +def test_get_config_casts_env_value(monkeypatch): + """ + The env value should be cast when a cast function is provided. + """ + monkeypatch.setenv("GET_CONFIG_PORT", "1234") + + result = get_config(None, "GET_CONFIG_PORT", 0, int) + + assert result == 1234 + + +def test_get_config_casts_default_when_env_missing(monkeypatch): + """ + When the env var is missing it should fall back to the default and still apply the cast. + """ + monkeypatch.delenv("GET_CONFIG_MISSING", raising=False) + + result = get_config(None, "GET_CONFIG_MISSING", "42", int) + + assert result == 42