Update override handling (#402)

* [ModelicaSystem] move import re

Pylint is recommenting to order the imports in several sections alphabetically:
(1) python standard library
(2) third party packages
(3) current package

* [ModelicaSystem] parse OM version in __init__()

* [ModelicaSystem] simplify processing of override data

Would it make sense to combine this code and the code in linearize() in one new function?

def _process_override_data(self, om_cmd, sim_override, file_override) -> None:
The code could:
(1) check the version; set command line parameters as needed
(2) create the content of the override file
(3) create the overwrite file and set it as command line parameter

The advantage would be, that the modified code is not in two places but only in one ...

* [ModelicaSystem] define _linearization_options and _optimization_options as dict[str, str]

* after OMC is run, the values will be string anyway
* simplify code / align on one common definition for these dicts

* [ModelicaSystem] simplify call to sendExpression()

* [ModelicaSystem] check for dict content using len() == 0

* [ModelicaSystem] fix overwrite file (write only if there is content)

* [ModelicaSystem] add docstring for _process_override_data()

---------

Co-authored-by: Adeel Asghar <adeel.asghar@liu.se>

Author: syntron

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,
@@ -332,14 +331,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
@@ -351,7 +350,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
@@ -950,7 +950,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:
@@ -964,17 +964,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
@@ -988,7 +987,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:
@@ -1002,9 +1001,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()
@@ -1023,13 +1021,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,
@@ -1073,29 +1105,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():
@@ -1775,26 +1790,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():