Merge branch 'master' into ModelicaSystemCmd_spelling_fix

Author: adeas31

OMPython/ModelicaSystem.py

@@ -33,7 +33,6 @@
 """
 
 import ast
-import csv
 from dataclasses import dataclass
 import logging
 import numbers
@@ -361,8 +360,7 @@ def __init__(
         self._override_variables: dict[str, str] = {}
         self._simulate_options_override: dict[str, str] = {}
         self._linearization_options = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8}
-        self._optimization_options = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002,
-                                      'tolerance': 1e-8}
+        self._optimization_options = self._linearization_options | {'numberOfIntervals': 500}
         self._linearized_inputs: list[str] = []  # linearization input list
         self._linearized_outputs: list[str] = []  # linearization output list
         self._linearized_states: list[str] = []  # linearization states list
@@ -383,7 +381,6 @@ def __init__(
         if not isinstance(lmodel, list):
             raise ModelicaSystemError(f"Invalid input type for lmodel: {type(lmodel)} - list expected!")
 
-        self._xml_file = None
         self._lmodel = lmodel  # may be needed if model is derived from other model
         self._model_name = modelName  # Model class name
         self._file_name = pathlib.Path(fileName).resolve() if fileName is not None else None  # Model file/package name
@@ -480,8 +477,8 @@ def buildModel(self, variableFilter: Optional[str] = None):
         buildModelResult = self._requestApi("buildModel", self._model_name, properties=varFilter)
         logger.debug("OM model build result: %s", buildModelResult)
 
-        self._xml_file = pathlib.Path(buildModelResult[0]).parent / buildModelResult[1]
-        self._xmlparse()
+        xml_file = pathlib.Path(buildModelResult[0]).parent / buildModelResult[1]
+        self._xmlparse(xml_file=xml_file)
 
     def sendExpression(self, expr: str, parsed: bool = True):
         try:
@@ -507,30 +504,42 @@ def _requestApi(self, apiName, entity=None, properties=None):  # 2
 
         return self.sendExpression(exp)
 
-    def _xmlparse(self):
-        if not self._xml_file.is_file():
-            raise ModelicaSystemError(f"XML file not generated: {self._xml_file}")
+    def _xmlparse(self, xml_file: pathlib.Path):
+        if not xml_file.is_file():
+            raise ModelicaSystemError(f"XML file not generated: {xml_file}")
 
-        tree = ET.parse(self._xml_file)
+        xml_content = xml_file.read_text()
+        tree = ET.ElementTree(ET.fromstring(xml_content))
         rootCQ = tree.getroot()
         for attr in rootCQ.iter('DefaultExperiment'):
             for key in ("startTime", "stopTime", "stepSize", "tolerance",
                         "solver", "outputFormat"):
-                self._simulate_options[key] = attr.get(key)
+                self._simulate_options[key] = str(attr.get(key))
 
         for sv in rootCQ.iter('ScalarVariable'):
-            scalar = {}
-            for key in ("name", "description", "variability", "causality", "alias"):
-                scalar[key] = sv.get(key)
-            scalar["changeable"] = sv.get('isValueChangeable')
-            scalar["aliasvariable"] = sv.get('aliasVariable')
+            translations = {
+                "alias": "alias",
+                "aliasvariable": "aliasVariable",
+                "causality": "causality",
+                "changeable": "isValueChangeable",
+                "description": "description",
+                "name": "name",
+                "variability": "variability",
+            }
+
+            scalar: dict[str, Any] = {}
+            for key_dst, key_src in translations.items():
+                val = sv.get(key_src)
+                scalar[key_dst] = None if val is None else str(val)
+
             ch = list(sv)
             for att in ch:
                 scalar["start"] = att.get('start')
                 scalar["min"] = att.get('min')
                 scalar["max"] = att.get('max')
                 scalar["unit"] = att.get('unit')
 
+            # save parameters in the corresponding class variables
             if scalar["variability"] == "parameter":
                 if scalar["name"] in self._override_variables:
                     self._params[scalar["name"]] = self._override_variables[scalar["name"]]
@@ -954,16 +963,17 @@ def simulate_cmd(
         if simargs:
             om_cmd.args_set(args=simargs)
 
-        overrideFile = self._tempdir / f"{self._model_name}_override.txt"
         if self._override_variables or self._simulate_options_override:
-            tmpdict = self._override_variables.copy()
-            tmpdict.update(self._simulate_options_override)
-            # write to override file
-            with open(file=overrideFile, mode="w", encoding="utf-8") as fh:
-                for key, value in tmpdict.items():
-                    fh.write(f"{key}={value}\n")
+            override_file = result_file.parent / f"{result_file.stem}_override.txt"
+
+            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"
+            )
 
-            om_cmd.arg_set(key="overrideFile", val=overrideFile.as_posix())
+            override_file.write_text(override_content)
+            om_cmd.arg_set(key="overrideFile", val=override_file.as_posix())
 
         if self._inputs:  # if model has input quantities
             for key in self._inputs:
@@ -1083,9 +1093,9 @@ def getSolutions(self, varList: Optional[str | list[str]] = None, resultfile: Op
         else:
             result_file = pathlib.Path(resultfile)
 
-        # check for result file exits
+        # check if the result file exits
         if not result_file.is_file():
-            raise ModelicaSystemError(f"Result file does not exist {result_file}")
+            raise ModelicaSystemError(f"Result file does not exist {result_file.as_posix()}")
 
         # get absolute path
         result_file = result_file.absolute()
@@ -1402,7 +1412,7 @@ def _createCSVData(self, csvfile: Optional[pathlib.Path] = None) -> pathlib.Path
             interpolated_inputs[signal_name] = np.interp(
                 all_times,
                 signal[:, 0],  # times
-                signal[:, 1]  # values
+                signal[:, 1],  # values
             )
 
         # Write CSV file
@@ -1414,16 +1424,17 @@ def _createCSVData(self, csvfile: Optional[pathlib.Path] = None) -> pathlib.Path
             row = [
                 t,  # time
                 *(interpolated_inputs[name][i] for name in input_names),  # input values
-                0  # trailing 'end' column
+                0,  # trailing 'end' column
             ]
             csv_rows.append(row)
 
         if csvfile is None:
             csvfile = self._tempdir / f'{self._model_name}.csv'
 
-        with open(file=csvfile, mode="w", encoding="utf-8", newline="") as fh:
-            writer = csv.writer(fh)
-            writer.writerows(csv_rows)
+        # basic definition of a CSV file using csv_rows as input
+        csv_content = "\n".join([",".join(map(str, row)) for row in csv_rows]) + "\n"
+
+        csvfile.write_text(csv_content)
 
         return csvfile
 
@@ -1535,7 +1546,8 @@ def linearize(self, lintime: Optional[float] = None, simflags: Optional[str] = N
               compatibility, because linearize() used to return `[A, B, C, D]`.
         """
 
-        if self._xml_file is None:
+        if len(self._quantities) == 0:
+            # if self._quantities has no content, the xml file was not parsed; see self._xmlparse()
             raise ModelicaSystemError(
                 "Linearization cannot be performed as the model is not build, "
                 "use ModelicaSystem() to build the model first"
@@ -1546,10 +1558,10 @@ def linearize(self, lintime: Optional[float] = None, simflags: Optional[str] = N
         overrideLinearFile = self._tempdir / f'{self._model_name}_override_linear.txt'
 
         with open(file=overrideLinearFile, mode="w", encoding="utf-8") as fh:
-            for key, value in self._override_variables.items():
-                fh.write(f"{key}={value}\n")
-            for key, value in self._linearization_options.items():
-                fh.write(f"{key}={value}\n")
+            for key1, value1 in self._override_variables.items():
+                fh.write(f"{key1}={value1}\n")
+            for key2, value2 in self._linearization_options.items():
+                fh.write(f"{key2}={value2}\n")
 
         om_cmd.arg_set(key="overrideFile", val=overrideLinearFile.as_posix())
 

OMPython/OMCSession.py

@@ -483,11 +483,17 @@ def __del__(self):
                 self._omc_process = None
 
     def get_port(self) -> Optional[str]:
+        """
+        Get the port to connect to the OMC process.
+        """
         if not isinstance(self._omc_port, str):
             raise OMCSessionException(f"Invalid port to connect to OMC process: {self._omc_port}")
         return self._omc_port
 
     def get_log(self) -> str:
+        """
+        Get the log file content of the OMC session.
+        """
         if self._omc_loghandle is None:
             raise OMCSessionException("Log file not available!")
 
@@ -509,6 +515,9 @@ def _get_portfile_path(self) -> Optional[pathlib.Path]:
 
 
 class OMCProcessPort(OMCProcess):
+    """
+    OMCProcess implementation which uses a port to connect to an already running OMC server.
+    """
 
     def __init__(
             self,
@@ -519,6 +528,9 @@ def __init__(
 
 
 class OMCProcessLocal(OMCProcess):
+    """
+    OMCProcess implementation which runs the OMC server locally on the machine (Linux / Windows).
+    """
 
     def __init__(
             self,
@@ -600,6 +612,9 @@ def _omc_port_get(self) -> str:
 
 
 class OMCProcessDockerHelper(OMCProcess):
+    """
+    Base class for OMCProcess implementations which run the OMC server in a Docker container.
+    """
 
     def __init__(
             self,
@@ -692,20 +707,29 @@ def _omc_port_get(self) -> str:
         return port
 
     def get_server_address(self) -> Optional[str]:
+        """
+        Get the server address of the OMC server running in a Docker container.
+        """
         if self._dockerNetwork == "separate" and isinstance(self._dockerCid, str):
             output = subprocess.check_output(["docker", "inspect", self._dockerCid]).decode().strip()
             return json.loads(output)[0]["NetworkSettings"]["IPAddress"]
 
         return None
 
     def get_docker_container_id(self) -> str:
+        """
+        Get the Docker container ID of the Docker container with the OMC server.
+        """
         if not isinstance(self._dockerCid, str):
             raise OMCSessionException(f"Invalid docker container ID: {self._dockerCid}!")
 
         return self._dockerCid
 
 
 class OMCProcessDocker(OMCProcessDockerHelper):
+    """
+    OMC process running in a Docker container.
+    """
 
     def __init__(
             self,
@@ -764,9 +788,8 @@ def _docker_omc_cmd(
         if sys.platform == "win32":
             extraFlags = ["-d=zmqDangerousAcceptConnectionsFromAnywhere"]
             if not self._interactivePort:
-                raise OMCSessionException("docker on Windows requires knowing which port to connect to. For "
-                                          "dockerContainer=..., the container needs to have already manually exposed "
-                                          "this port when it was started (-p 127.0.0.1:n:n) or you get an error later.")
+                raise OMCSessionException("docker on Windows requires knowing which port to connect to - "
+                                          "please set the interactivePort argument")
 
         if sys.platform == "win32":
             if isinstance(self._interactivePort, str):
@@ -847,6 +870,9 @@ def _docker_omc_start(self) -> Tuple[subprocess.Popen, DummyPopen, str]:
 
 
 class OMCProcessDockerContainer(OMCProcessDockerHelper):
+    """
+    OMC process running in a Docker container (by container ID).
+    """
 
     def __init__(
             self,
@@ -892,9 +918,10 @@ def _docker_omc_cmd(self, omc_path_and_args_list) -> list:
         if sys.platform == "win32":
             extraFlags = ["-d=zmqDangerousAcceptConnectionsFromAnywhere"]
             if not self._interactivePort:
-                raise OMCSessionException("docker on Windows requires knowing which port to connect to. For "
-                                          "dockerContainer=..., the container needs to have already manually exposed "
-                                          "this port when it was started (-p 127.0.0.1:n:n) or you get an error later.")
+                raise OMCSessionException("Docker on Windows requires knowing which port to connect to - "
+                                          "Please set the interactivePort argument. Furthermore, the container needs "
+                                          "to have already manually exposed this port when it was started "
+                                          "(-p 127.0.0.1:n:n) or you get an error later.")
 
         if isinstance(self._interactivePort, int):
             extraFlags = extraFlags + [f"--interactivePort={int(self._interactivePort)}"]
@@ -936,6 +963,9 @@ def _docker_omc_start(self) -> Tuple[subprocess.Popen, DummyPopen]:
 
 
 class OMCProcessWSL(OMCProcess):
+    """
+    OMC process running in Windows Subsystem for Linux (WSL).
+    """
 
     def __init__(
             self,