Merge branch 'master' into linter_fix

Author: adeas31

OMPython/ModelicaSystem.py

@@ -11,6 +11,7 @@
 import os
 import pathlib
 import queue
+import re
 import textwrap
 import threading
 from typing import Any, cast, Optional
@@ -19,8 +20,6 @@
 
 import numpy as np
 
-import re
-
 from OMPython.OMCSession import (
     OMCSessionException,
     OMCSessionRunData,
@@ -334,14 +333,14 @@ def __init__(
         self._simulate_options: dict[str, str] = {}
         self._override_variables: dict[str, str] = {}
         self._simulate_options_override: dict[str, str] = {}
-        self._linearization_options: dict[str, str | float] = {
-            'startTime': 0.0,
-            'stopTime': 1.0,
-            'stepSize': 0.002,
-            'tolerance': 1e-8,
+        self._linearization_options: dict[str, str] = {
+            'startTime': str(0.0),
+            'stopTime': str(1.0),
+            'stepSize': str(0.002),
+            'tolerance': str(1e-8),
         }
         self._optimization_options = self._linearization_options | {
-            'numberOfIntervals': 500,
+            'numberOfIntervals': str(500),
         }
         self._linearized_inputs: list[str] = []  # linearization input list
         self._linearized_outputs: list[str] = []  # linearization output list
@@ -353,7 +352,8 @@ def __init__(
             self._session = OMCSessionLocal(omhome=omhome)
 
         # get OpenModelica version
-        self._version = self._session.sendExpression("getVersion()", parsed=True)
+        version_str = self.sendExpression(expr="getVersion()")
+        self._version = self._parse_om_version(version=version_str)
         # set commandLineOptions using default values or the user defined list
         if command_line_options is None:
             # set default command line options to improve the performance of linearization and to avoid recompilation if
@@ -952,7 +952,7 @@ def getSimulationOptions(
     def getLinearizationOptions(
             self,
             names: Optional[str | list[str]] = None,
-    ) -> dict[str, str | float] | list[str | float]:
+    ) -> dict[str, str] | list[str]:
         """Get simulation options used for linearization.
 
         Args:
@@ -966,17 +966,16 @@ def getLinearizationOptions(
             returned.
             If `names` is a list, a list with one value for each option name
             in names is returned: [option1_value, option2_value, ...].
-            Some option values are returned as float when first initialized,
-            but always as strings after setLinearizationOptions is used to
-            change them.
+
+            The option values are always returned as strings.
 
         Examples:
             >>> mod.getLinearizationOptions()
-            {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-08}
+            {'startTime': '0.0', 'stopTime': '1.0', 'stepSize': '0.002', 'tolerance': '1e-08'}
             >>> mod.getLinearizationOptions("stopTime")
-            [1.0]
+            ['1.0']
             >>> mod.getLinearizationOptions(["tolerance", "stopTime"])
-            [1e-08, 1.0]
+            ['1e-08', '1.0']
         """
         if names is None:
             return self._linearization_options
@@ -990,7 +989,7 @@ def getLinearizationOptions(
     def getOptimizationOptions(
             self,
             names: Optional[str | list[str]] = None,
-    ) -> dict[str, str | float] | list[str | float]:
+    ) -> dict[str, str] | list[str]:
         """Get simulation options used for optimization.
 
         Args:
@@ -1004,9 +1003,8 @@ def getOptimizationOptions(
             returned.
             If `names` is a list, a list with one value for each option name
             in names is returned: [option1_value, option2_value, ...].
-            Some option values are returned as float when first initialized,
-            but always as strings after setOptimizationOptions is used to
-            change them.
+
+            The option values are always returned as string.
 
         Examples:
             >>> mod.getOptimizationOptions()
@@ -1025,13 +1023,47 @@ def getOptimizationOptions(
 
         raise ModelicaSystemError("Unhandled input for getOptimizationOptions()")
 
-    def parse_om_version(self, version: str) -> tuple[int, int, int]:
+    def _parse_om_version(self, version: str) -> tuple[int, int, int]:
         match = re.search(r"v?(\d+)\.(\d+)\.(\d+)", version)
         if not match:
             raise ValueError(f"Version not found in: {version}")
         major, minor, patch = map(int, match.groups())
+
         return major, minor, patch
 
+    def _process_override_data(
+            self,
+            om_cmd: ModelicaSystemCmd,
+            override_file: OMCPath,
+            override_var: dict[str, str],
+            override_sim: dict[str, str],
+    ) -> None:
+        """
+        Define the override parameters. As the definition of simulation specific override parameter changes with OM
+        1.26.0, version specific code is needed. Please keep in mind, that this will fail if OMC is not used to run the
+        model executable.
+        """
+        if len(override_var) == 0 and len(override_sim) == 0:
+            return
+
+        override_content = ""
+        if override_var:
+            override_content += "\n".join([f"{key}={value}" for key, value in override_var.items()]) + "\n"
+
+        # simulation options are not read from override file from version >= 1.26.0,
+        # pass them to simulation executable directly as individual arguments
+        # see https://github.com/OpenModelica/OpenModelica/pull/14813
+        if override_sim:
+            if self._version >= (1, 26, 0):
+                for key, opt_value in override_sim.items():
+                    om_cmd.arg_set(key=key, val=str(opt_value))
+            else:
+                override_content += "\n".join([f"{key}={value}" for key, value in override_sim.items()]) + "\n"
+
+        if override_content:
+            override_file.write_text(override_content)
+            om_cmd.arg_set(key="overrideFile", val=override_file.as_posix())
+
     def simulate_cmd(
             self,
             result_file: OMCPath,
@@ -1075,29 +1107,12 @@ def simulate_cmd(
         if simargs:
             om_cmd.args_set(args=simargs)
 
-        if self._override_variables or self._simulate_options_override:
-            override_file = result_file.parent / f"{result_file.stem}_override.txt"
-
-            # simulation options are not read from override file from version >= 1.26.0,
-            # pass them to simulation executable directly as individual arguments
-            # see https://github.com/OpenModelica/OpenModelica/pull/14813
-            major, minor, patch = self.parse_om_version(self._version)
-            if (major, minor, patch) >= (1, 26, 0):
-                for key, opt_value in self._simulate_options_override.items():
-                    om_cmd.arg_set(key=key, val=str(opt_value))
-                override_content = (
-                    "\n".join([f"{key}={value}" for key, value in self._override_variables.items()])
-                    + "\n"
-                )
-            else:
-                override_content = (
-                    "\n".join([f"{key}={value}" for key, value in self._override_variables.items()])
-                    + "\n".join([f"{key}={value}" for key, value in self._simulate_options_override.items()])
-                    + "\n"
-                )
-
-            override_file.write_text(override_content)
-            om_cmd.arg_set(key="overrideFile", val=override_file.as_posix())
+        self._process_override_data(
+            om_cmd=om_cmd,
+            override_file=result_file.parent / f"{result_file.stem}_override.txt",
+            override_var=self._override_variables,
+            override_sim=self._simulate_options_override,
+        )
 
         if self._inputs:  # if model has input quantities
             for key, val in self._inputs.items():
@@ -1777,26 +1792,12 @@ def linearize(
             modelname=self._model_name,
         )
 
-        # See comment in simulate_cmd regarding override file and OM version
-        major, minor, patch = self.parse_om_version(self._version)
-        if (major, minor, patch) >= (1, 26, 0):
-            for key, opt_value in self._linearization_options.items():
-                om_cmd.arg_set(key=key, val=str(opt_value))
-            override_content = (
-                "\n".join([f"{key}={value}" for key, value in self._override_variables.items()])
-                + "\n"
-            )
-        else:
-            override_content = (
-                "\n".join([f"{key}={value}" for key, value in self._override_variables.items()])
-                + "\n".join([f"{key}={value}" for key, value in self._linearization_options.items()])
-                + "\n"
-            )
-
-        override_file = self.getWorkDirectory() / f'{self._model_name}_override_linear.txt'
-        override_file.write_text(override_content)
-
-        om_cmd.arg_set(key="overrideFile", val=override_file.as_posix())
+        self._process_override_data(
+            om_cmd=om_cmd,
+            override_file=self.getWorkDirectory() / f'{self._model_name}_override_linear.txt',
+            override_var=self._override_variables,
+            override_sim=self._linearization_options,
+        )
 
         if self._inputs:
             for key, data in self._inputs.items():

OMPython/OMCSession.py

@@ -702,8 +702,8 @@ def __del__(self):
         if isinstance(self._omc_zmq, zmq.Socket):
             try:
                 self.sendExpression("quit()")
-            except OMCSessionException:
-                pass
+            except OMCSessionException as exc:
+                logger.warning(f"Exception on sending 'quit()' to OMC: {exc}! Continue nevertheless ...")
             finally:
                 self._omc_zmq = None
 
@@ -720,7 +720,7 @@ def __del__(self):
                 self._omc_process.wait(timeout=2.0)
             except subprocess.TimeoutExpired:
                 if self._omc_process:
-                    logger.warning("OMC did not exit after being sent the quit() command; "
+                    logger.warning("OMC did not exit after being sent the 'quit()' command; "
                                    "killing the process with pid=%s", self._omc_process.pid)
                     self._omc_process.kill()
                     self._omc_process.wait()
@@ -1024,11 +1024,27 @@ def __init__(
         super().__init__()
         self._omc_port = omc_port
 
+    @staticmethod
+    def run_model_executable(cmd_run_data: OMCSessionRunData) -> int:
+        """
+        Run the command defined in cmd_run_data. This class is defined as static method such that there is no need to
+        keep instances of over classes around.
+        """
+        raise OMCSessionException("OMCSessionPort does not support run_model_executable()!")
+
+    def get_log(self) -> str:
+        """
+        Get the log file content of the OMC session.
+        """
+        log = f"No log available if OMC session is defined by port ({self.__class__.__name__})"
+
+        return log
+
     def omc_run_data_update(self, omc_run_data: OMCSessionRunData) -> OMCSessionRunData:
         """
         Update the OMCSessionRunData object based on the selected OMCSession implementation.
         """
-        raise OMCSessionException("OMCSessionPort does not support omc_run_data_update()!")
+        raise OMCSessionException(f"({self.__class__.__name__}) does not support omc_run_data_update()!")
 
 
 class OMCSessionLocal(OMCSession):

OMPython/__init__.py

@@ -15,6 +15,7 @@
     ModelicaSystemError,
 )
 from OMPython.OMCSession import (
+    OMCSession,
     OMCSessionCmd,
     OMCSessionException,
     OMCSessionRunData,
@@ -34,6 +35,7 @@
     'ModelicaSystemDoE',
     'ModelicaSystemError',
 
+    'OMCSession',
     'OMCSessionCmd',
     'OMCSessionException',
     'OMCSessionRunData',

tests/test_ArrayDimension.py

@@ -2,18 +2,18 @@
 
 
 def test_ArrayDimension(tmp_path):
-    omc = OMPython.OMCSessionZMQ()
+    omcs = OMPython.OMCSessionLocal()
 
-    omc.sendExpression(f'cd("{tmp_path.as_posix()}")')
+    omcs.sendExpression(f'cd("{tmp_path.as_posix()}")')
 
-    omc.sendExpression('loadString("model A Integer x[5+1,1+6]; end A;")')
-    omc.sendExpression("getErrorString()")
+    omcs.sendExpression('loadString("model A Integer x[5+1,1+6]; end A;")')
+    omcs.sendExpression("getErrorString()")
 
-    result = omc.sendExpression("getComponents(A)")
+    result = omcs.sendExpression("getComponents(A)")
     assert result[0][-1] == (6, 7), "array dimension does not match"
 
-    omc.sendExpression('loadString("model A Integer y = 5; Integer x[y+1,1+9]; end A;")')
-    omc.sendExpression("getErrorString()")
+    omcs.sendExpression('loadString("model A Integer y = 5; Integer x[y+1,1+9]; end A;")')
+    omcs.sendExpression("getErrorString()")
 
-    result = omc.sendExpression("getComponents(A)")
+    result = omcs.sendExpression("getComponents(A)")
     assert result[-1][-1] == ('y+1', 10), "array dimension does not match"

tests/test_FMIRegression.py

@@ -7,21 +7,21 @@
 
 
 def buildModelFMU(modelName):
-    omc = OMPython.OMCSessionZMQ()
+    omcs = OMPython.OMCSessionLocal()
 
     tempdir = pathlib.Path(tempfile.mkdtemp())
     try:
-        omc.sendExpression(f'cd("{tempdir.as_posix()}")')
+        omcs.sendExpression(f'cd("{tempdir.as_posix()}")')
 
-        omc.sendExpression("loadModel(Modelica)")
-        omc.sendExpression("getErrorString()")
+        omcs.sendExpression("loadModel(Modelica)")
+        omcs.sendExpression("getErrorString()")
 
         fileNamePrefix = modelName.split(".")[-1]
         exp = f'buildModelFMU({modelName}, fileNamePrefix="{fileNamePrefix}")'
-        fmu = omc.sendExpression(exp)
+        fmu = omcs.sendExpression(exp)
         assert os.path.exists(fmu)
     finally:
-        del omc
+        del omcs
         shutil.rmtree(tempdir, ignore_errors=True)
 
 

tests/test_ModelicaSystem.py

@@ -47,14 +47,15 @@ def worker():
         )
         mod.simulate()
         mod.convertMo2Fmu(fmuType="me")
+
     for _ in range(10):
         worker()
 
 
 def test_setParameters():
-    omc = OMPython.OMCSessionZMQ()
-    model_path_str = omc.sendExpression("getInstallationDirectoryPath()") + "/share/doc/omc/testmodels"
-    model_path = omc.omcpath(model_path_str)
+    omcs = OMPython.OMCSessionLocal()
+    model_path_str = omcs.sendExpression("getInstallationDirectoryPath()") + "/share/doc/omc/testmodels"
+    model_path = omcs.omcpath(model_path_str)
     mod = OMPython.ModelicaSystem()
     mod.model(
         model_file=model_path / "BouncingBall.mo",
@@ -87,9 +88,9 @@ def test_setParameters():
 
 
 def test_setSimulationOptions():
-    omc = OMPython.OMCSessionZMQ()
-    model_path_str = omc.sendExpression("getInstallationDirectoryPath()") + "/share/doc/omc/testmodels"
-    model_path = omc.omcpath(model_path_str)
+    omcs = OMPython.OMCSessionLocal()
+    model_path_str = omcs.sendExpression("getInstallationDirectoryPath()") + "/share/doc/omc/testmodels"
+    model_path = omcs.omcpath(model_path_str)
     mod = OMPython.ModelicaSystem()
     mod.model(
         model_file=model_path / "BouncingBall.mo",
@@ -155,11 +156,9 @@ def test_customBuildDirectory(tmp_path, model_firstorder):
 @skip_on_windows
 @skip_python_older_312
 def test_getSolutions_docker(model_firstorder):
-    omcp = OMPython.OMCSessionDocker(docker="openmodelica/openmodelica:v1.25.0-minimal")
-    omc = OMPython.OMCSessionZMQ(omc_process=omcp)
-
+    omcs = OMPython.OMCSessionDocker(docker="openmodelica/openmodelica:v1.25.0-minimal")
     mod = OMPython.ModelicaSystem(
-        session=omc.omc_process,
+        session=omcs,
     )
     mod.model(
         model_file=model_firstorder,