gridappsd-python 2026.2.1__tar.gz → 2026.2.1a2__tar.gz

{gridappsd_python-2026.2.1 → gridappsd_python-2026.2.1a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gridappsd-python
-Version: 2026.2.1
+Version: 2026.2.1a2
 Summary: A GridAPPS-D Python Adapter
 Project-URL: Repository, https://github.com/GRIDAPPSD/gridappsd-python
 Project-URL: Homepage, https://gridappsd.readthedocs.io

{gridappsd_python-2026.2.1 → gridappsd_python-2026.2.1a2}/gridappsd/app_registration.py

@@ -1,6 +1,7 @@
 # import json
 import logging
 import os
+from enum import Enum
 from queue import Queue
 import time
 import subprocess
@@ -14,6 +15,30 @@ from . import utils, json_extension as json
 
 _log = logging.getLogger(__name__)
 
+GRIDAPPSD_APPLICATION_STATUS = "GRIDAPPSD_APPLICATION_STATUS"
+
+
+class ApplicationStatusEnum(Enum):
+    """Values this module writes to the GRIDAPPSD_APPLICATION_STATUS environment variable.
+
+    This is a distinct enum from gridappsd.utils.ProcessStatusEnum: this module's
+    STOPPED value has no equivalent in ProcessStatusEnum (which has CLOSED
+    instead), so reusing that enum here would either drop STOPPED or introduce
+    a mismatch between the value written and the value a reader expects.
+    """
+
+    STARTING = "STARTING"
+    STOPPING = "STOPPING"
+    RUNNING = "RUNNING"
+    STOPPED = "STOPPED"
+    ERROR = "ERROR"
+
+
+def _set_application_status(status: ApplicationStatusEnum) -> None:
+    """Write status to the GRIDAPPSD_APPLICATION_STATUS environment variable."""
+    os.environ[GRIDAPPSD_APPLICATION_STATUS] = status.value
+
+
 # determine OS type
 posix = False
 if os.name == "posix":
@@ -35,20 +60,20 @@ class Job(threading.Thread):
     def run(self):
         try:
             self.running = True
-            os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "RUNNING"
+            _set_application_status(ApplicationStatusEnum.RUNNING)
 
             p = subprocess.Popen(args=self._args, shell=False, stdout=self._out, stderr=self._err)
 
             # Loop while process is executing
             while p.poll() is None and self.running:
-                os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "RUNNING"
+                _set_application_status(ApplicationStatusEnum.RUNNING)
                 time.sleep(1)
 
         except Exception as e:
-            os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "ERROR"
+            _set_application_status(ApplicationStatusEnum.ERROR)
             _log.error(repr(e))
         else:
-            os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
+            _set_application_status(ApplicationStatusEnum.STOPPED)
 
 
 class ApplicationController(object):
@@ -58,7 +83,7 @@ class ApplicationController(object):
         if not isinstance(gridappsd, GridAPPSD):
             raise ValueError("Invalid gridappsd instance passed.")
 
-        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
+        _set_application_status(ApplicationStatusEnum.STOPPED)
         self._configDict = config.copy()
         self._validate_config()
         self._gapd = gridappsd
@@ -80,7 +105,7 @@ class ApplicationController(object):
         self._end_callback = None
         self._print_queue = Queue()
         self._heartbeat_thread = None
-        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
+        _set_application_status(ApplicationStatusEnum.STOPPED)
 
         if "type" not in self._configDict or self._configDict["type"] != "REMOTE":
             _log.warning(
@@ -119,7 +144,7 @@ class ApplicationController(object):
         self._stop_control_topic = response.get("stopControlTopic")
 
         os.environ["GRIDAPPSD_APPLICATION_ID"] = self._application_id
-        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
+        _set_application_status(ApplicationStatusEnum.STOPPED)
 
         self._gapd.subscribe(self._stop_control_topic, self.__handle_stop)
         self._gapd.subscribe(self._start_control_topic, self.__handle_start)
@@ -160,7 +185,7 @@ class ApplicationController(object):
             obj = json.loads(message)
         else:
             obj = message
-        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STARTING"
+        _set_application_status(ApplicationStatusEnum.STARTING)
         self._gapd.get_logger().debug("Handling Start: {}\ndict:\n{}".format(headers, obj))
 
         if "command" not in obj:
@@ -176,12 +201,12 @@ class ApplicationController(object):
 
     def __handle_stop(self, headers, message):
         print("Handling Stop: {} {}".format(headers, message))
-        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPING"
+        _set_application_status(ApplicationStatusEnum.STOPPING)
         if self._thread:
             self._thread.join()
         if self._end_callback is not None:
             self._end_callback()
-        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
+        _set_application_status(ApplicationStatusEnum.STOPPED)
 
     def shutdown(self):
         self._shutting_down = True

{gridappsd_python-2026.2.1 → gridappsd_python-2026.2.1a2}/gridappsd/goss.py

@@ -57,7 +57,6 @@ from enum import Enum
 from logging import Logger
 from queue import Queue
 
-import stomp as _stomp_module
 from stomp import Connection12 as Connection
 from stomp.exception import NotConnectedException
 from time import sleep
@@ -66,19 +65,41 @@ from gridappsd import json_extension as json
 
 _log: Logger = logging.getLogger(inspect.getmodulename(__file__))
 
-# stomp.py 8.x changed listener callbacks from (headers, body) to (frame)
-_stomp_major = (
-    int(getattr(_stomp_module, "__version__", (0,))[0])
-    if isinstance(getattr(_stomp_module, "__version__", None), tuple)
-    else 0
-)
-try:
-    from importlib.metadata import version as _pkg_version
-
-    _stomp_major = int(_pkg_version("stomp-py").split(".")[0])
-except Exception:
-    pass
-_STOMP_V8 = _stomp_major >= 8
+
+def _unpack_stomp_args(*args):
+    """Return (headers, body) from a stomp listener callback's arguments.
+
+    stomp-py pre 8.x, and this module's own CallbackRouter dispatch, call
+    on_message/on_error with two positional arguments: headers and body.
+    stomp-py 8.x's raw listener protocol calls with a single Frame object
+    exposing .headers and .body instead. A listener reached through
+    CallbackRouter (any listener registered via subscribe()) always
+    receives the two argument shape, regardless of the installed stomp-py
+    version, because CallbackRouter.run_callbacks is the caller, not
+    stomp itself. Only a listener registered directly on a raw stomp
+    Connection (CallbackRouter itself, TokenResponseListener) is actually
+    invoked by stomp's own version dependent dispatch. Detecting the
+    argument shape at each call, instead of trusting a single global
+    version sniffed flag, is correct for both callers.
+    """
+    if len(args) >= 2:
+        return args[0], args[1]
+    frame = args[0]
+    if hasattr(frame, "headers") and hasattr(frame, "body"):
+        return frame.headers, frame.body
+    headers, body = frame
+    return headers, body
+
+
+def _serialize_message(message):
+    """Return message ready to send on the wire.
+
+    A list or dict body is serialized to a JSON string; any other body
+    (already a string, bytes, etc.) is passed through unchanged.
+    """
+    if isinstance(message, (list, dict)):
+        return json.dumps(message)
+    return message
 
 
 class GRIDAPPSD_ENV_ENUM(Enum):
@@ -168,8 +189,7 @@ class GOSS(object):
 
     def send(self, topic, message):
         self._make_connection()
-        if isinstance(message, list) or isinstance(message, dict):
-            message = json.dumps(message)
+        message = _serialize_message(message)
         _log.debug("Sending topic: {} body: {}".format(topic, message))
         self._conn.send(
             body=message, destination=topic, headers={"GOSS_HAS_SUBJECT": True, "GOSS_SUBJECT": self.__token}
@@ -185,11 +205,8 @@ class GOSS(object):
         if "resultFormat" in message:
             self.result_format = message["resultFormat"]
 
-        # Change message to string if we have a dictionary.
-        if isinstance(message, dict):
-            message = json.dumps(message)
-        elif isinstance(message, list):
-            message = json.dumps(message)
+        # Change message to string if we have a dictionary or list.
+        message = _serialize_message(message)
 
         class ResponseListener(object):
             def __init__(self, topic, result_format):
@@ -198,11 +215,7 @@ class GOSS(object):
                 self.result_format = result_format
 
             def on_message(self, *args):
-                if _STOMP_V8:
-                    frame = args[0]
-                    header, message = frame.headers, frame.body
-                else:
-                    header, message = args[0], args[1]
+                header, message = _unpack_stomp_args(*args)
                 _log.debug("Internal on message is: {} {}".format(header, message))
                 try:
                     if self.result_format == "JSON":
@@ -216,11 +229,7 @@ class GOSS(object):
                     self.response = dict(error="Invalid json returned", header=header, message=message)
 
             def on_error(self, *args):
-                if _STOMP_V8:
-                    frame = args[0]
-                    headers, message = frame.headers, frame.body
-                else:
-                    headers, message = args[0], args[1]
+                headers, message = _unpack_stomp_args(*args)
                 _log.error("ERR: {}".format(headers))
                 _log.error("OUR ERROR: {}".format(message))
 
@@ -337,21 +346,13 @@ class GOSS(object):
                         return self.__token
 
                     def on_message(self, *args):
-                        if _STOMP_V8:
-                            frame = args[0]
-                            header, message = frame.headers, frame.body
-                        else:
-                            header, message = args[0], args[1]
+                        header, message = _unpack_stomp_args(*args)
                         _log.debug("Internal on message is: {} {}".format(header, message))
 
                         self.__token = str(message)
 
                     def on_error(self, *args):
-                        if _STOMP_V8:
-                            frame = args[0]
-                            headers, message = frame.headers, frame.body
-                        else:
-                            headers, message = args[0], args[1]
+                        headers, message = _unpack_stomp_args(*args)
                         _log.error("ERR: {}".format(headers))
                         _log.error("OUR ERROR: {}".format(message))
 
@@ -404,9 +405,10 @@ class CallbackRouter(object):
             cb, hdrs, msg = self._queue_callerback.get()
             try:
                 msg = json.loads(msg)
-            except:
+            except (TypeError, ValueError):
+                # msg was not JSON text (already a dict, or plain string body);
+                # pass it through unchanged rather than as a decode failure.
                 pass
-                # msg = message
 
             for c in cb:
                 c(hdrs, msg)
@@ -429,11 +431,7 @@ class CallbackRouter(object):
                 pass
 
     def on_message(self, *args):
-        if _STOMP_V8:
-            frame = args[0]
-            headers, message = frame.headers, frame.body
-        else:
-            headers, message = args[0], args[1]
+        headers, message = _unpack_stomp_args(*args)
         destination = headers["destination"]
         # _log.debug("Topic map keys are: {keys}".format(keys=self._topics_callback_map.keys()))
         if destination in self._topics_callback_map:
@@ -442,11 +440,7 @@ class CallbackRouter(object):
             _log.error("INVALID DESTINATION {destination}".format(destination=destination))
 
     def on_error(self, *args):
-        if _STOMP_V8:
-            frame = args[0]
-            header, message = frame.headers, frame.body
-        else:
-            header, message = args[0], args[1]
+        header, message = _unpack_stomp_args(*args)
         _log.error("Error in callback router")
         _log.error(header)
         _log.error(message)

{gridappsd_python-2026.2.1 → gridappsd_python-2026.2.1a2}/gridappsd/gridappsd.py

@@ -116,29 +116,32 @@ class GridAPPSD(GOSS):
                 self._simulation_log_topic = t.simulation_log_topic(self._simulation_id)
         return self._simulation_id
 
-    def set_application_status(self, status):
-        """
-        Set the application status.
-        :param status:
+    def _set_status(self, status, kind):
+        """Set self._process_status, warning instead of raising on an invalid value.
+
+        :param status: candidate value for ProcessStatusEnum
+        :param kind: human readable label for the warning message, e.g. "application"
         """
         try:
             self._process_status = ProcessStatusEnum(status)
         except ValueError:
             self.get_logger().warning(
-                "Unsuccessful change of application status." + f"Valid statuses are {ProcessStatusEnum.__members__}."
+                f"Unsuccessful change of {kind} status." + f"Valid statuses are {ProcessStatusEnum.__members__}."
             )
 
+    def set_application_status(self, status):
+        """
+        Set the application status.
+        :param status:
+        """
+        self._set_status(status, "application")
+
     def set_service_status(self, status):
         """
         Set the service status.
         :param status:
         """
-        try:
-            self._process_status = ProcessStatusEnum(status)
-        except ValueError:
-            self.get_logger().warning(
-                "Unsuccessful change of service status." + f"Valid statuses are {ProcessStatusEnum.__members__}."
-            )
+        self._set_status(status, "service")
 
     def set_simulation_id(self, simulation_id):
         if simulation_id is None:
@@ -148,12 +151,16 @@ class GridAPPSD(GOSS):
             self._simulation_id = simulation_id
             self._simulation_log_topic = t.simulation_log_topic(self._simulation_id)
 
+    def _get_status(self):
+        """Return self._process_status as its plain string value."""
+        return self._process_status.value
+
     def get_application_status(self):
         """
         Return the application status
         :return:
         """
-        return self._process_status.value
+        return self._get_status()
 
     def get_application_id(self):
         return utils.get_gridappsd_application_id()
@@ -163,7 +170,7 @@ class GridAPPSD(GOSS):
         Return the service status
         :return:
         """
-        return self._process_status.value
+        return self._get_status()
 
     def query_object_types(self, model_id=None):
         """Allows the caller to query the different object types.

{gridappsd_python-2026.2.1 → gridappsd_python-2026.2.1a2}/gridappsd/simulation.py

@@ -42,11 +42,11 @@ class ConfigBase:
 
 @dataclass
 class ModelCreationConfig(ConfigBase):
-    load_scaling_factor: str = field(default="1")
+    load_scaling_factor: float = field(default=1)
     schedule_name: str = field(default="ieeezipload")
-    z_fraction: str = field(default="0")
-    i_fraction: str = field(default="1")
-    p_fraction: str = field(default="0")
+    z_fraction: float = field(default=0)
+    i_fraction: float = field(default=1)
+    p_fraction: float = field(default=0)
     randomize_zipload_fractions: bool = field(default=False)
     use_houses: bool = field(default=False)
 
@@ -56,14 +56,30 @@ class ModelCreationConfig(ConfigBase):
 
 @dataclass
 class SimulationArgs(ConfigBase):
-    start_time: str = field(default="1655321830")
-    duration: str = field(default="300")
-    timestep_frequency: str = field(default="1000")
-    timestep_increment: str = field(default="1000")
+    start_time: int = field(default=1655321830)
+    duration: int = field(default=300)
+    publish_period: int | None = field(default=None)
+    interval: int | None = field(default=None)
     run_realtime: bool = field(default=True)
     pause_after_measurements: bool = field(default=False)
     simulation_name: str = field(default="ieee13nodeckt")
 
+    def __post_init_(self):
+        if self.run_realtime:
+            self.interval = 1
+            if not self.publish_period:
+                self.publish_period = 3
+        else:
+            if not self.interval:
+                self.interval = 60
+            if not self.publish_period:
+                self.publish_period = 60
+        if self.publish_period < self.interval:
+            raise RuntimeError(
+                "A simulation's publishing_period cannot be less than the simulation's timestep "
+                "interval. please make the publishing_period >= interval!"
+            )
+
 
 @dataclass
 class SimulatorArgs(ConfigBase):
@@ -201,26 +217,30 @@ class Simulation:
         for p in self.__on_start:
             p(self)
 
-    def pause(self):
-        """Pause simulation"""
-        _log.debug("Pausing simulation")
-        command = dict(command="pause")
+    def _send_simulation_command(self, command_name, **command_input):
+        """Send a command to this simulation's input topic.
+
+        :param command_name: value of the command field sent to the simulation
+        :param command_input: when given, nested under the command's "input" key
+        """
+        _log.debug("Sending simulation command: {}".format(command_name))
+        command = dict(command=command_name)
+        if command_input:
+            command["input"] = command_input
         self._gapps.send(t.simulation_input_topic(self.simulation_id), json.dumps(command))
         self._running_or_paused = True
 
+    def pause(self):
+        """Pause simulation"""
+        self._send_simulation_command("pause")
+
     def stop(self):
         """Stop the simulation"""
-        _log.debug("Stopping simulation")
-        command = dict(command="stop")
-        self._gapps.send(t.simulation_input_topic(self.simulation_id), json.dumps(command))
-        self._running_or_paused = True
+        self._send_simulation_command("stop")
 
     def resume(self):
         """Resume the simulation"""
-        _log.debug("Resuming simulation")
-        command = dict(command="resume")
-        self._gapps.send(t.simulation_input_topic(self.simulation_id), json.dumps(command))
-        self._running_or_paused = True
+        self._send_simulation_command("resume")
 
     def run_loop(self):
         """Loop around the running of the simulation itself.
@@ -251,9 +271,7 @@ class Simulation:
         :param pause_in: number of seconds to run before pausing the simulation
         """
         _log.debug("Resuming simulation. Will pause after {} seconds".format(pause_in))
-        command = dict(command="resumePauseAt", input=dict(pauseIn=pause_in))
-        self._gapps.send(t.simulation_input_topic(self.simulation_id), json.dumps(command))
-        self._running_or_paused = True
+        self._send_simulation_command("resumePauseAt", pauseIn=pause_in)
 
     def add_onmeasurement_callback(self, callback, device_filter=()):
         """registers an onmeasurment callback to be called when measurements have come through.

{gridappsd_python-2026.2.1 → gridappsd_python-2026.2.1a2}/gridappsd/timeseries.py

@@ -46,38 +46,37 @@ class Query:
             self.last = n
         return self
 
-    def ge(self, value):
-        """Method to add 'value greater than or equal to' filter to a key.
+    def _add_filter(self, operator, value):
+        """Append a single {key, operator: value} filter for the current key.
 
-        :param value:
+        :param operator: one of "ge", "le", "eq"
+        :param value: value to filter on
         """
         if self.key is None:
             raise ValueError("Key is not specified. Call where_key first.")
-        obj = {"key": self.key, "ge": value}
-        self.queryFilter.append(obj)
+        self.queryFilter.append({"key": self.key, operator: value})
         return self
 
+    def ge(self, value):
+        """Method to add 'value greater than or equal to' filter to a key.
+
+        :param value:
+        """
+        return self._add_filter("ge", value)
+
     def le(self, value):
         """Method to add 'value less than or equal to' filter to a key.
 
         :param value:
         """
-        if self.key is None:
-            raise ValueError("Key is not specified. Call where_key first.")
-        obj = {"key": self.key, "le": value}
-        self.queryFilter.append(obj)
-        return self
+        return self._add_filter("le", value)
 
     def eq(self, value):
         """Method to add 'value equal to' filter to a key.
 
         :param value:
         """
-        if self.key is None:
-            raise ValueError("Key is not specified. Call where_key first.")
-        obj = {"key": self.key, "eq": value}
-        self.queryFilter.append(obj)
-        return self
+        return self._add_filter("eq", value)
 
     def between(self, value1, value2):
         """Method to add 'value between' value1 and value2 filter to a key.
@@ -85,13 +84,8 @@ class Query:
         :param value1: defines 'greater than equal to' filter for key's value
         :param value2: defines 'less than equal to' filter for key's value
         """
-        if self.key is None:
-            raise ValueError("Key is not specified. Call where_key first.")
-        obj = {"key": self.key, "ge": value1}
-        self.queryFilter.append(obj)
-        obj = {"key": self.key, "le": value2}
-        self.queryFilter.append(obj)
-        return self
+        self._add_filter("ge", value1)
+        return self._add_filter("le", value2)
 
     def where_key(self, key):
         self.key = key

{gridappsd_python-2026.2.1 → gridappsd_python-2026.2.1a2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gridappsd-python"
-version = "2026.02.1"
+version = "2026.02.1a2"
 description = "A GridAPPS-D Python Adapter"
 readme = "README.md"
 license = "BSD-3-Clause"

gridappsd_python-2026.2.1a2/tests/test_app_registration.py

@@ -0,0 +1,63 @@
+"""Unit tests for gridappsd.app_registration status handling.
+
+_set_application_status writes ApplicationStatusEnum values to the
+GRIDAPPSD_APPLICATION_STATUS environment variable. These tests assert
+the exact string value written for each status, and that Job.run()
+drives the environment variable through the expected RUNNING then
+STOPPED transition for a command that exits cleanly.
+"""
+
+import os
+
+import pytest
+
+from gridappsd.app_registration import (
+    GRIDAPPSD_APPLICATION_STATUS,
+    ApplicationStatusEnum,
+    Job,
+    _set_application_status,
+)
+
+
+@pytest.fixture(autouse=True)
+def _clear_status_env(monkeypatch):
+    monkeypatch.delenv(GRIDAPPSD_APPLICATION_STATUS, raising=False)
+
+
+class TestSetApplicationStatus:
+    @pytest.mark.parametrize(
+        "status",
+        [
+            ApplicationStatusEnum.STARTING,
+            ApplicationStatusEnum.STOPPING,
+            ApplicationStatusEnum.RUNNING,
+            ApplicationStatusEnum.STOPPED,
+            ApplicationStatusEnum.ERROR,
+        ],
+    )
+    def test_writes_exact_status_value_to_environment(self, status):
+        _set_application_status(status)
+
+        assert os.environ[GRIDAPPSD_APPLICATION_STATUS] == status.value
+
+    def test_overwrites_previous_value(self):
+        _set_application_status(ApplicationStatusEnum.STARTING)
+        _set_application_status(ApplicationStatusEnum.RUNNING)
+
+        assert os.environ[GRIDAPPSD_APPLICATION_STATUS] == "RUNNING"
+
+
+class TestJobRunSetsApplicationStatus:
+    def test_successful_job_ends_in_stopped_status(self):
+        job = Job(args=["true"])
+
+        job.run()
+
+        assert os.environ[GRIDAPPSD_APPLICATION_STATUS] == ApplicationStatusEnum.STOPPED.value
+
+    def test_failing_job_ends_in_error_status(self):
+        job = Job(args=["/nonexistent-command-for-gadp-044-test"])
+
+        job.run()
+
+        assert os.environ[GRIDAPPSD_APPLICATION_STATUS] == ApplicationStatusEnum.ERROR.value