nost-tools 2.1.1__tar.gz → 2.3.0__tar.gz

{nost_tools-2.1.1 → nost_tools-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nost_tools
-Version: 2.1.1
+Version: 2.3.0
 Summary: Tools for Novel Observing Strategies Testbed (NOS-T) Applications
 Author-email: "Paul T. Grogan" <paul.grogan@asu.edu>, "Emmanuel M. Gonzalez" <emmanuelgonzalez@asu.edu>
 License-Expression: BSD-3-Clause

{nost_tools-2.1.1 → nost_tools-2.3.0}/nost_tools/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.1.1"
+__version__ = "2.3.0"
 
 from .application import Application
 from .application_utils import ConnectionConfig, ModeStatusObserver, TimeStatusPublisher

{nost_tools-2.1.1 → nost_tools-2.3.0}/nost_tools/application.py

@@ -48,13 +48,19 @@ class Application:
         time_status_init (:obj:`datetime`): Scenario time of first time status message
     """
 
-    def __init__(self, app_name: str, app_description: str = None):
+    def __init__(
+        self,
+        app_name: str,
+        app_description: str = None,
+        setup_signal_handlers: bool = True,
+    ):
         """
         Initializes a new application.
 
         Args:
             app_name (str): application name
             app_description (str): application description (optional)
+            setup_signal_handlers (bool): whether to set up signal handlers (default: True)
         """
         self.simulator = Simulator()
         self.connection = None
@@ -85,8 +91,12 @@ class Application:
         self._token_refresh_thread = None
         self.token_refresh_interval = None
         self._reconnect_delay = None
+        # Offset
+        self._wallclock_refresh_thread = None
+        self.wallclock_offset_refresh_interval = None
         # Set up signal handlers for graceful shutdown
-        self._setup_signal_handlers()
+        if setup_signal_handlers:
+            self._setup_signal_handlers()
 
     def _setup_signal_handlers(self):
         """
@@ -194,6 +204,42 @@ class Application:
         self._token_refresh_thread.start()
         logger.debug("Starting refresh token thread successfully completed.")
 
+    def start_wallclock_refresh_thread(self):  # , interval=30, host="pool.ntp.org"):
+        """
+        Starts a background thread to refresh the wallclock offset periodically.
+
+        Args:
+            interval (int): Seconds between wallclock offset refreshes (default: 3600 seconds/1 hour)
+            host (str): NTP host to query (default: 'pool.ntp.org')
+        """
+        logger.debug("Starting wallclock offset refresh thread.")
+
+        def refresh_wallclock_periodically():
+            while not self._should_stop.wait(
+                timeout=self.config.rc.wallclock_offset_properties.wallclock_offset_refresh_interval
+            ):
+                logger.debug("Wallclock refresh thread is running.")
+                try:
+                    logger.info(
+                        f"Contacting {self.config.rc.wallclock_offset_properties.ntp_host} to retrieve wallclock offset."
+                    )
+                    response = ntplib.NTPClient().request(
+                        self.config.rc.wallclock_offset_properties.ntp_host,
+                        version=3,
+                        timeout=2,
+                    )
+                    offset = timedelta(seconds=response.offset)
+                    self.simulator.set_wallclock_offset(offset)
+                    logger.info(f"Wallclock offset updated to {offset}.")
+                except Exception as e:
+                    logger.debug(f"Failed to refresh wallclock offset: {e}")
+
+        self._wallclock_refresh_thread = threading.Thread(
+            target=refresh_wallclock_periodically
+        )
+        self._wallclock_refresh_thread.start()
+        logger.debug("Starting wallclock offset refresh thread successfully completed.")
+
     def update_connection_credentials(self, access_token):
         """
         Updates the connection credentials with the new access token.
@@ -203,14 +249,33 @@ class Application:
         """
         self.connection.update_secret(access_token, "secret")
 
+    def _get_parameters_from_config(self):
+        """
+        Gets application parameters from configuration or returns None if not available.
+        This method can be overridden by subclasses to customize parameter retrieval.
+
+        Returns:
+            object: Configuration parameters object or None
+        """
+        if self.config and self.config.rc.yaml_file:
+            try:
+                return getattr(
+                    self.config.rc.simulation_configuration.execution_parameters,
+                    "application",
+                    None,
+                )
+            except (AttributeError, KeyError):
+                return None
+        return None
+
     def start_up(
         self,
         prefix: str,
         config: ConnectionConfig,
-        set_offset: bool = None,  # True,
+        set_offset: bool = True,
         time_status_step: timedelta = None,
         time_status_init: datetime = None,
-        shut_down_when_terminated: bool = None,
+        shut_down_when_terminated: bool = False,
     ) -> None:
         """
         Starts up the application to prepare for scenario execution.
@@ -225,31 +290,45 @@ class Application:
             time_status_init (:obj:`datetime`): scenario time for first time status message
             shut_down_when_terminated (bool): True, if the application should shut down when the simulation is terminated
         """
-        if (
-            set_offset is not None
-            and time_status_step is not None
-            and time_status_init is not None
-            and shut_down_when_terminated is not None
-        ):
+        self.config = config
+
+        if self.config.rc.yaml_file:
+            logger.info(
+                f"Collecting start up parameters from YAML configuration file: {self.config.rc.yaml_file}"
+            )
+            parameters = self._get_parameters_from_config()
+            if parameters:
+                self.set_offset = getattr(parameters, "set_offset", set_offset)
+                self.time_status_step = getattr(
+                    parameters, "time_status_step", time_status_step
+                )
+                self.time_status_init = getattr(
+                    parameters, "time_status_init", time_status_init
+                )
+                self.shut_down_when_terminated = getattr(
+                    parameters, "shut_down_when_terminated", shut_down_when_terminated
+                )
+            else:
+                logger.warning("No parameters found in configuration, using defaults")
+                self.set_offset = set_offset
+                self.time_status_step = time_status_step
+                self.time_status_init = time_status_init
+                self.shut_down_when_terminated = shut_down_when_terminated
+        else:
+            logger.info(
+                f"Collecting start up parameters from user input or default values."
+            )
             self.set_offset = set_offset
             self.time_status_step = time_status_step
             self.time_status_init = time_status_init
             self.shut_down_when_terminated = shut_down_when_terminated
-        else:
-            self.config = config
-            parameters = getattr(
-                self.config.rc.simulation_configuration.execution_parameters,
-                self.app_name,
-                None,
-            )
-            self.set_offset = parameters.set_offset
-            self.time_status_step = parameters.time_status_step
-            self.time_status_init = parameters.time_status_init
-            self.shut_down_when_terminated = parameters.shut_down_when_terminated
 
         if self.set_offset:
-            # Set the system clock offset
-            self.set_wallclock_offset()
+            # Start periodic wallclock offset updates instead of one-time call
+            logger.info(
+                f"Wallclock offset will be set every {self.config.rc.wallclock_offset_properties.wallclock_offset_refresh_interval} seconds using {self.config.rc.wallclock_offset_properties.ntp_host}."
+            )
+            self.start_wallclock_refresh_thread()
 
         # Set the prefix and configuration parameters
         self.prefix = prefix
@@ -290,7 +369,6 @@ class Application:
             locale=config.rc.server_configuration.servers.rabbitmq.locale,
             blocked_connection_timeout=config.rc.server_configuration.servers.rabbitmq.blocked_connection_timeout,
         )
-        logger.info(parameters)
 
         # Configure transport layer security (TLS) if needed
         if self.config.rc.server_configuration.servers.rabbitmq.tls:
@@ -1348,34 +1426,26 @@ class Application:
                     )
                 else:
                     logger.info("Closing token refresh thread completed successfully")
-
+            # Also stop wallclock refresh thread if it exists
+            if (
+                hasattr(self, "_wallclock_refresh_thread")
+                and self._wallclock_refresh_thread
+                and self._wallclock_refresh_thread.is_alive()
+            ):
+                logger.info("Closing wallclock refresh thread.")
+                # Set a timeout to avoid hanging indefinitely
+                self._wallclock_refresh_thread.join(timeout=60.0)
+                # Check if it's still alive after timeout
+                if self._wallclock_refresh_thread.is_alive():
+                    logger.warning(
+                        "Closing wallclock refresh thread timed out after 60 seconds. "
+                    )
+                else:
+                    logger.info(
+                        "Closing wallclock refresh thread completed successfully"
+                    )
             logger.debug("Stop_application completed successfully.")
 
-    def set_wallclock_offset(
-        self, host="pool.ntp.org", retry_delay_s: int = 5, max_retry: int = 5
-    ) -> None:
-        """
-        Issues a Network Time Protocol (NTP) request to determine the system clock offset.
-
-        Args:
-            host (str): NTP host (default: 'pool.ntp.org')
-            retry_delay_s (int): number of seconds to wait before retrying
-            max_retry (int): maximum number of retries allowed
-        """
-        for i in range(max_retry):
-            try:
-                logger.info(f"Contacting {host} to retrieve wallclock offset.")
-                response = ntplib.NTPClient().request(host, version=3, timeout=2)
-                offset = timedelta(seconds=response.offset)
-                self.simulator.set_wallclock_offset(offset)
-                logger.info(f"Wallclock offset updated to {offset}.")
-                return
-            except ntplib.NTPException:
-                logger.warning(
-                    f"Could not connect to {host}, attempt #{i+1}/{max_retry} in {retry_delay_s} s."
-                )
-                time.sleep(retry_delay_s)
-
     def _create_time_status_publisher(
         self, time_status_step: timedelta, time_status_init: datetime
     ) -> None:

{nost_tools-2.1.1 → nost_tools-2.3.0}/nost_tools/application_utils.py

@@ -253,10 +253,9 @@ class ModeStatusObserver(Observer):
             if not isinstance(self.app.prefix, str):
                 raise ValueError(f"Exchange ({self.app.prefix}) must be a string")
 
-            # Declare the topic exchange
-            if self.app.channel.is_open and self.app.connection.is_open:
-                self.app.send_message(
-                    app_name=self.app.app_name,
-                    app_topics="status.mode",
-                    payload=status.model_dump_json(by_alias=True, exclude_none=True),
-                )
+            # if self.app.channel.is_open and self.app.connection.is_open:
+            self.app.send_message(
+                app_name=self.app.app_name,
+                app_topics="status.mode",
+                payload=status.model_dump_json(by_alias=True, exclude_none=True),
+            )

{nost_tools-2.1.1 → nost_tools-2.3.0}/nost_tools/configuration.py

@@ -21,10 +21,12 @@ from .schemas import (
     RuntimeConfig,
     ServersConfig,
     SimulationConfig,
+    WallclockOffsetProperties,
 )
 
 logger = logging.getLogger(__name__)
 
+
 class ConnectionConfig:
     """Connection configuration.
 
@@ -51,6 +53,7 @@ class ConnectionConfig:
         password: str = None,
         rabbitmq_host: str = None,
         rabbitmq_port: int = None,
+        keycloak_authentication: bool = False,
         keycloak_host: str = None,
         keycloak_port: int = None,
         keycloak_realm: str = None,
@@ -59,6 +62,7 @@ class ConnectionConfig:
         virtual_host: str = None,
         is_tls: bool = True,
         yaml_file: str = None,
+        app_name: str = None,
     ):
         """
         Initializes a new connection configuration.
@@ -68,6 +72,7 @@ class ConnectionConfig:
             password (str): client password, provided by NOS-T operator
             host (str): broker hostname
             rabbitmq_port (int): RabbitMQ broker port number
+            keycloak_authentication (bool): True, if Keycloak IAM authentication is used
             keycloak_port (int): Keycloak IAM port number
             keycloak_realm (str): Keycloak realm name
             client_id (str): Keycloak client ID
@@ -75,12 +80,14 @@ class ConnectionConfig:
             virtual_host (str): RabbitMQ virtual host
             is_tls (bool): True, if the connection uses TLS
             yaml_file (str): Path to the YAML configuration file
+            app_name (str): Name of the application to get specific configuration for
         """
         self.username = username
         self.password = password
         self.rabbitmq_host = rabbitmq_host
         self.keycloak_host = keycloak_host
         self.rabbitmq_port = rabbitmq_port
+        self.keycloak_authentication = keycloak_authentication
         self.keycloak_port = keycloak_port
         self.keycloak_realm = keycloak_realm
         self.client_id = client_id
@@ -93,6 +100,8 @@ class ConnectionConfig:
         self.yaml_file = yaml_file
         self.unique_exchanges = {}
         self.channel_configs = []
+        self.app_name = app_name
+        self.app_specific = None
 
         self.create_connection_config()
 
@@ -208,6 +217,29 @@ class ConnectionConfig:
         except ValidationError as err:
             raise EnvironmentVariableError(f"Invalid environment variables: {err}")
 
+    def get_app_specific_config(self, app_name):
+        """
+        Get application-specific configuration from execution.managed_applications if available.
+
+        Args:
+            app_name (str): Name of the application
+
+        Returns:
+            dict: Application-specific configuration parameters if available, otherwise None.
+        """
+        if not os.path.exists(self.yaml_file):
+            raise ConfigurationError("Couldn't load config file (not found)")
+
+        with open(self.yaml_file, "r", encoding="utf-8") as f:
+            yaml_data = yaml.safe_load(f)
+
+            try:
+                return yaml_data["execution"]["managed_applications"][app_name][
+                    "configuration_parameters"
+                ]
+            except:
+                return None
+
     def load_yaml_config_file(self):
         """
         Loads a YAML configuration file and returns the parsed data.
@@ -243,6 +275,9 @@ class ConnectionConfig:
                 ), "Application names do not match the channels defined in the configuration file."
             except ConfigAssertionError as e:
                 raise ValueError(f"Assertion error: {e}")
+            # Load app-specific configuration if app_name is provided
+            if self.app_name:
+                self.app_specific = self.get_app_specific_config(self.app_name)
         else:
             try:
                 self.yaml_config = Config(
@@ -252,6 +287,7 @@ class ConnectionConfig:
                             port=self.rabbitmq_port,
                             virtual_host=self.virtual_host,
                             tls=self.is_tls,
+                            keycloak_authentication=self.keycloak_authentication,
                         ),
                         keycloak=KeycloakConfig(
                             host=self.keycloak_host,
@@ -281,13 +317,8 @@ class ConnectionConfig:
             del server_config.execution
         self.server_config = server_config
 
-        if (
-            self.username is not None
-            and self.password is not None
-            and self.client_id is not None
-            and self.client_secret_key is not None
-        ):
-            logger.info("Using provided credentials.")
+        if self.username is not None and self.password is not None:
+            logger.info("Using user-provided credentials.")
             self.credentials_config = Credentials(
                 username=self.username,
                 password=self.password,
@@ -298,7 +329,10 @@ class ConnectionConfig:
             self.load_environment_variables()
 
         self.rc = RuntimeConfig(
+            wallclock_offset_properties=WallclockOffsetProperties(),
             credentials=self.credentials_config,
             server_configuration=server_config,
             simulation_configuration=self.simulation_config,
+            application_configuration=self.app_specific,
+            yaml_file=self.yaml_file,
         )

{nost_tools-2.1.1 → nost_tools-2.3.0}/nost_tools/managed_application.py

@@ -32,27 +32,57 @@ class ManagedApplication(Application):
         time_step (:obj:`timedelta`): scenario time step used in execution
     """
 
-    def __init__(self, app_name: str, app_description: str = None):
+    def __init__(
+        self,
+        app_name: str,
+        app_description: str = None,
+        setup_signal_handlers: bool = True,
+    ):
         """
         Initializes a new managed application.
 
         Args:
             app_name (str): application name
             app_description (str): application description
+            setup_signal_handlers (bool): whether to set up signal handlers (default: True)
         """
-        super().__init__(app_name, app_description)
+        super().__init__(
+            app_name, app_description, setup_signal_handlers=setup_signal_handlers
+        )
         self.time_step = None
         self._sim_start_time = None
         self._sim_stop_time = None
 
+    def _get_parameters_from_config(self):
+        """
+        Override to get parameters specific to managed applications
+
+        Returns:
+            object: Configuration parameters for this managed application
+        """
+        if self.config and self.config.rc.yaml_file:
+            try:
+                parameters = (
+                    self.config.rc.simulation_configuration.execution_parameters.managed_applications
+                )
+                try:
+                    # Try to get app-specific parameters
+                    return parameters[self.app_name]
+                except KeyError:
+                    # Fall back to default parameters
+                    return parameters.get("default")
+            except (AttributeError, KeyError):
+                return None
+        return None
+
     def start_up(
         self,
         prefix: str,
         config: ConnectionConfig,
-        set_offset: bool = None,
+        set_offset: bool = True,
         time_status_step: timedelta = None,
         time_status_init: datetime = None,
-        shut_down_when_terminated: bool = None,
+        shut_down_when_terminated: bool = False,
         time_step: timedelta = None,
         manager_app_name: str = None,
     ) -> None:
@@ -70,48 +100,27 @@ class ManagedApplication(Application):
             time_step (:obj:`timedelta`): scenario time step used in execution (Default: 1 second)
             manager_app_name (str): manager application name (Default: manager)
         """
-        if (
-            set_offset is not None
-            and time_status_step is not None
-            and time_status_init is not None
-            and shut_down_when_terminated is not None
-            and time_step is not None
-            and manager_app_name is not None
-        ):
-            self.set_offset = set_offset
-            self.time_status_step = time_status_step
-            self.time_status_init = time_status_init
-            self.shut_down_when_terminated = shut_down_when_terminated
-            self.time_step = time_step
-            self.manager_app_name = manager_app_name
-        else:
-            self.config = config
-            parameters = (
-                self.config.rc.simulation_configuration.execution_parameters.managed_applications
-            )
-
-            try:
-                parameters = parameters[self.app_name]
-            except KeyError:
-                parameters = parameters["default"]
-            self.set_offset = parameters.set_offset
-            self.time_status_step = parameters.time_status_step
-            self.time_status_init = parameters.time_status_init
-            self.shut_down_when_terminated = parameters.shut_down_when_terminated
-            self.time_step = parameters.time_step
-            self.manager_app_name = parameters.manager_app_name
+        self.config = config
 
-        # start up base application
+        # Call base start_up to handle common parameters
         super().start_up(
             prefix,
             config,
-            self.set_offset,
-            self.time_status_step,
-            self.time_status_init,
-            self.shut_down_when_terminated,
+            set_offset,
+            time_status_step,
+            time_status_init,
+            shut_down_when_terminated,
         )
-        self.time_step = self.time_step
-        self.manager_app_name = self.manager_app_name
+
+        # Get additional parameters specific to managed applications
+        if self.config.rc.yaml_file:
+            parameters = self._get_parameters_from_config()
+            if parameters:
+                self.time_step = parameters.time_step
+                self.manager_app_name = parameters.manager_app_name
+        else:
+            self.time_step = time_step
+            self.manager_app_name = manager_app_name
 
         # Register callback functions
         self.add_message_callback(

{nost_tools-2.1.1 → nost_tools-2.3.0}/nost_tools/manager.py

@@ -13,6 +13,7 @@ from typing import List
 from pydantic import ValidationError
 
 from .application import Application
+from .application_utils import ConnectionConfig
 from .schemas import (
     InitCommand,
     ReadyStatus,
@@ -66,12 +67,22 @@ class Manager(Application):
         required_apps_status (dict): Ready status for all required applications
     """
 
-    def __init__(self):
+    def __init__(
+        self,
+        app_name: str = "manager",
+        app_description: str = None,
+        setup_signal_handlers: bool = True,
+    ):
         """
         Initializes a new manager.
+
+        Attributes:
+            setup_signal_handlers (bool): whether to set up signal handlers (default: True)
         """
         # call super class constructor
-        super().__init__("manager")
+        super().__init__(
+            app_name, app_description, setup_signal_handlers=setup_signal_handlers
+        )
         self.required_apps_status = {}
 
         self.sim_start_time = None
@@ -128,6 +139,60 @@ class Manager(Application):
                     f"Heartbeat check: {remaining:.2f} seconds remaining in sleep"
                 )
 
+    def _get_parameters_from_config(self):
+        """
+        Override to get parameters specific to manager application
+
+        Returns:
+            object: Configuration parameters for the manager application
+        """
+        if self.config and self.config.rc.yaml_file:
+            try:
+                return getattr(
+                    self.config.rc.simulation_configuration.execution_parameters,
+                    "manager",
+                    None,
+                )
+            except (AttributeError, KeyError):
+                return None
+        return None
+
+    def start_up(
+        self,
+        prefix: str,
+        config: ConnectionConfig,
+        set_offset: bool = True,
+        time_status_step: timedelta = None,
+        time_status_init: datetime = None,
+        shut_down_when_terminated: bool = False,
+    ) -> None:
+        """
+        Starts up the application by connecting to message broker, starting a background event loop,
+        subscribing to manager events, and registering callback functions.
+
+        Args:
+            prefix (str): execution namespace (prefix)
+            config (:obj:`ConnectionConfig`): connection configuration
+            set_offset (bool): True, if the system clock offset shall be set using a NTP request prior to execution
+            time_status_step (:obj:`timedelta`): scenario duration between time status messages
+            time_status_init (:obj:`datetime`): scenario time for first time status message
+            shut_down_when_terminated (bool): True, if the application should shut down when the simulation is terminated
+        """
+        self.config = config
+
+        # Call base start_up to handle common parameters
+        super().start_up(
+            prefix,
+            config,
+            set_offset,
+            time_status_step,
+            time_status_init,
+            shut_down_when_terminated,
+        )
+
+        # Additional manager-specific setup: establish the exchange
+        self.establish_exchange()
+
     def execute_test_plan(self, *args, **kwargs) -> None:
         """
         Starts the test plan execution in a background thread.
@@ -177,8 +242,33 @@ class Manager(Application):
             init_retry_delay_s (float): number of seconds to wait between initialization commands while waiting for required applications
             init_max_retry (int): number of initialization commands while waiting for required applications before continuing to execution
         """
-        # Initialize parameters from arguments or config
-        if sim_start_time is not None and sim_stop_time is not None:
+        if self.config.rc.yaml_file:
+            logger.info(
+                f"Collecting execution parameters from YAML configuration file: {self.config.rc.yaml_file}"
+            )
+            parameters = getattr(
+                self.config.rc.simulation_configuration.execution_parameters,
+                self.app_name,
+                None,
+            )
+            self.sim_start_time = parameters.sim_start_time
+            self.sim_stop_time = parameters.sim_stop_time
+            self.start_time = parameters.start_time
+            self.time_step = parameters.time_step
+            self.time_scale_factor = parameters.time_scale_factor
+            self.time_scale_updates = parameters.time_scale_updates
+            self.time_status_step = parameters.time_status_step
+            self.time_status_init = parameters.time_status_init
+            self.command_lead = parameters.command_lead
+            self.required_apps = [
+                app for app in parameters.required_apps if app != self.app_name
+            ]
+            self.init_retry_delay_s = parameters.init_retry_delay_s
+            self.init_max_retry = parameters.init_max_retry
+        else:
+            logger.info(
+                f"Collecting execution parameters from user input or default values."
+            )
             self.sim_start_time = sim_start_time
             self.sim_stop_time = sim_stop_time
             self.start_time = start_time
@@ -191,34 +281,17 @@ class Manager(Application):
             self.required_apps = required_apps
             self.init_retry_delay_s = init_retry_delay_s
             self.init_max_retry = init_max_retry
-        else:
-            if self.config.rc:
-                logger.info("Retrieving execution parameters from YAML file.")
-                parameters = getattr(
-                    self.config.rc.simulation_configuration.execution_parameters,
-                    self.app_name,
-                    None,
-                )
-                self.sim_start_time = parameters.sim_start_time
-                self.sim_stop_time = parameters.sim_stop_time
-                self.start_time = parameters.start_time
-                self.time_step = parameters.time_step
-                self.time_scale_factor = parameters.time_scale_factor
-                self.time_scale_updates = parameters.time_scale_updates
-                self.time_status_step = parameters.time_status_step
-                self.time_status_init = parameters.time_status_init
-                self.command_lead = parameters.command_lead
-                self.required_apps = [
-                    app for app in parameters.required_apps if app != self.app_name
-                ]
-                self.init_retry_delay_s = parameters.init_retry_delay_s
-                self.init_max_retry = parameters.init_max_retry
-            else:
-                raise ValueError(
-                    "No configuration runtime. Please provide simulation start and stop times."
-                )
 
-        self.establish_exchange()
+        # Convert TimeScaleUpdateSchema objects to TimeScaleUpdate objects
+        converted_updates = []
+        for update_schema in self.time_scale_updates:
+            converted_updates.append(
+                TimeScaleUpdate(
+                    time_scale_factor=update_schema.time_scale_factor,
+                    sim_update_time=update_schema.sim_update_time,
+                )
+            )
+        self.time_scale_updates = converted_updates
 
         # Set up tracking of required applications
         self.required_apps_status = dict(
@@ -490,8 +563,17 @@ class Manager(Application):
             app_topics="stop",
             payload=command.model_dump_json(by_alias=True),
         )
-        # update the execution end time
-        self.simulator.set_end_time(sim_stop_time)
+
+        # Update the execution end time if simulator is in EXECUTING mode
+        if self.simulator.get_mode() == Mode.EXECUTING:
+            try:
+                self.simulator.set_end_time(sim_stop_time)
+            except RuntimeError as e:
+                logger.warning(f"Could not set simulator end time: {e}")
+        else:
+            logger.debug(
+                "Skipping setting simulator end time as simulator is not in EXECUTING mode"
+            )
 
     def update(self, time_scale_factor: float, sim_update_time: datetime) -> None:
         """

{nost_tools-2.1.1 → nost_tools-2.3.0}/nost_tools/schemas.py

@@ -307,8 +307,34 @@ class ServersConfig(BaseModel):
         return values
 
 
+class WallclockOffsetProperties(BaseModel):
+    """
+    Properties to report wallclock offset.
+    """
+
+    wallclock_offset_refresh_interval: Optional[int] = Field(
+        10800, description="Wallclock offset refresh interval, in seconds."
+    )
+    ntp_host: Optional[str] = Field(
+        "pool.ntp.org", description="NTP host for wallclock offset synchronization."
+    )
+
+
 class GeneralConfig(BaseModel):
-    prefix: str = Field("nost", description="Execution prefix.")
+    prefix: Optional[str] = Field("nost", description="Execution prefix.")
+
+
+class TimeScaleUpdateSchema(BaseModel):
+    """
+    Provides a scheduled update to the simulation time scale factor.
+    """
+
+    time_scale_factor: float = Field(
+        ..., description="Scenario seconds per wallclock second"
+    )
+    sim_update_time: datetime = Field(
+        ..., description="Scenario time that the update will occur"
+    )
 
 
 class ManagerConfig(BaseModel):
@@ -322,7 +348,7 @@ class ManagerConfig(BaseModel):
         description="Time step for the simulation.",
     )
     time_scale_factor: float = Field(1.0, description="Time scale factor.")
-    time_scale_updates: List[str] = Field(
+    time_scale_updates: List[TimeScaleUpdateSchema] = Field(
         default_factory=list, description="List of time scale updates."
     )
     time_status_step: Optional[timedelta] = Field(None, description="Time status step.")
@@ -339,6 +365,10 @@ class ManagerConfig(BaseModel):
     shut_down_when_terminated: bool = Field(
         False, description="Shut down when terminated."
     )
+    is_scenario_time_step: bool = Field(
+        True,
+        description="If True, time_step is in scenario time and won't be scaled. If False, time_step is in wallclock time and will be scaled by the time scale factor.",
+    )
     is_scenario_time_status_step: bool = Field(
         True,
         description="If True, time_status_step is in scenario time and won't be scaled. If False, time_status_step is in wallclock time and will be scaled by the time scale factor.",
@@ -348,6 +378,16 @@ class ManagerConfig(BaseModel):
     def scale_time(cls, values):
         time_scale_factor = values.get("time_scale_factor", 1.0)
 
+        if "time_step" in values and not values.get("is_scenario_time_step", True):
+            time_step = values["time_step"]
+            if isinstance(time_step, str):
+                hours, minutes, seconds = map(int, time_step.split(":"))
+                time_step = timedelta(hours=hours, minutes=minutes, seconds=seconds)
+            if isinstance(time_step, timedelta):
+                values["time_step"] = timedelta(
+                    seconds=time_step.total_seconds() * time_scale_factor
+                )
+
         if "time_status_step" in values and not values.get(
             "is_scenario_time_status_step", True
         ):
@@ -427,7 +467,27 @@ class LoggerApplicationConfig(BaseModel):
         timedelta(seconds=10), description="Time status step."
     )
     time_status_init: Optional[datetime] = Field(
-        datetime(2019, 3, 1, 0, 0, 0), description="Time status init."
+        datetime.now(), description="Time status init."
+    )
+    shut_down_when_terminated: Optional[bool] = Field(
+        False, description="Shut down when terminated."
+    )
+    manager_app_name: Optional[str] = Field(
+        "manager", description="Manager application name."
+    )
+
+
+class ApplicationConfig(BaseModel):
+    set_offset: Optional[bool] = Field(True, description="Set offset.")
+    time_scale_factor: Optional[float] = Field(1.0, description="Time scale factor.")
+    time_step: Optional[timedelta] = Field(
+        timedelta(seconds=1), description="Time step for swe_change."
+    )
+    time_status_step: Optional[timedelta] = Field(
+        timedelta(seconds=10), description="Time status step."
+    )
+    time_status_init: Optional[datetime] = Field(
+        datetime.now(), description="Time status init."
     )
     shut_down_when_terminated: Optional[bool] = Field(
         False, description="Shut down when terminated."
@@ -438,7 +498,9 @@ class LoggerApplicationConfig(BaseModel):
 
 
 class ExecConfig(BaseModel):
-    general: GeneralConfig
+    general: Optional[GeneralConfig] = Field(
+        None, description="General configuration for the execution."
+    )
     manager: Optional[ManagerConfig] = Field(None, description="Manager configuration.")
     managed_applications: Optional[Dict[str, ManagedApplicationConfig]] = Field(
         default_factory=lambda: {"default": ManagedApplicationConfig()},
@@ -447,6 +509,9 @@ class ExecConfig(BaseModel):
     logger_application: Optional[LoggerApplicationConfig] = Field(
         None, description="Logger application configuration."
     )
+    application: Optional[ApplicationConfig] = Field(
+        None, description="Application configuration."
+    )
 
 
 class Config(BaseModel):
@@ -473,11 +538,11 @@ class ChannelConfig(BaseModel):
 
 
 class Credentials(BaseModel):
-    username: str = Field(..., description="Username for authentication.")
-    password: str = Field(..., description="Password for authentication.")
-    client_id: Optional[str] = Field("", description="Client ID for authentication.")
+    username: Optional[str] = Field("admin", description="Username for authentication.")
+    password: Optional[str] = Field("admin", description="Password for authentication.")
+    client_id: Optional[str] = Field(None, description="Client ID for authentication.")
     client_secret_key: Optional[str] = Field(
-        "", description="Client secret key for authentication."
+        None, description="Client secret key for authentication."
     )
 
 
@@ -493,6 +558,9 @@ class SimulationConfig(BaseModel):
 
 
 class RuntimeConfig(BaseModel):
+    wallclock_offset_properties: WallclockOffsetProperties = Field(
+        ..., description="Properties for wallclock offset."
+    )
     credentials: Credentials = Field(..., description="Credentials for authentication.")
     server_configuration: Config = (
         Field(..., description="Simulation configuration."),
@@ -500,3 +568,9 @@ class RuntimeConfig(BaseModel):
     simulation_configuration: SimulationConfig = Field(
         ..., description="Simulation configuration."
     )
+    application_configuration: Optional[Dict] = Field(
+        None, description="Application-specific, user-provided configuration."
+    )
+    yaml_file: Optional[str] = Field(
+        None, description="Path to the YAML file containing the configuration."
+    )

{nost_tools-2.1.1 → nost_tools-2.3.0}/nost_tools/simulator.py

@@ -516,9 +516,7 @@ class Simulator(Observable):
         Args:
             wallclock_offset(:obj:`timedelta`): difference between system clock and trusted wallclock source
         """
-        if self._mode == Mode.EXECUTING:
-            raise RuntimeError("Cannot set wallclock offset: simulator is executing")
-        elif self._mode == Mode.TERMINATING:
+        if self._mode == Mode.TERMINATING:
             raise RuntimeError("Cannot set wallclock offset: simulator is terminating")
         self._wallclock_offset = wallclock_offset
 

{nost_tools-2.1.1 → nost_tools-2.3.0}/nost_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nost_tools
-Version: 2.1.1
+Version: 2.3.0
 Summary: Tools for Novel Observing Strategies Testbed (NOS-T) Applications
 Author-email: "Paul T. Grogan" <paul.grogan@asu.edu>, "Emmanuel M. Gonzalez" <emmanuelgonzalez@asu.edu>
 License-Expression: BSD-3-Clause