Merge branch 'test_cleanup' into v4.1.0-syntron5

Author: syntron

OMPython/ModelicaSystem.py

@@ -38,6 +38,7 @@
 import logging
 import numbers
 import os
+import pathlib
 import queue
 import textwrap
 import threading
@@ -450,18 +451,30 @@ def model(
         # set variables
         self._model_name = name  # Model class name
         self._libraries = libraries  # may be needed if model is derived from other model
-        if file is not None:
-            file_name = self._session.omcpath(file).resolve()
-        else:
-            file_name = None
-        self._file_name = file_name  # Model file/package name
         self._variable_filter = variable_filter
 
-        if self._file_name is not None and not self._file_name.is_file():  # if file does not exist
-            raise IOError(f"{self._file_name} does not exist!")
-
         if self._libraries:
             self._loadLibrary(libraries=self._libraries)
+
+        self._file_name = None
+        if file is not None:
+            file_path = pathlib.Path(file)
+            # special handling for OMCProcessLocal - consider a relative path
+            if isinstance(self._session.omc_process, OMCProcessLocal) and not file_path.is_absolute():
+                file_path = pathlib.Path.cwd() / file_path
+            if not file_path.is_file():
+                raise IOError(f"Model file {file_path} does not exist!")
+
+            self._file_name = self.getWorkDirectory() / file_path.name
+            if (isinstance(self._session.omc_process, OMCProcessLocal)
+                    and file_path.as_posix() == self._file_name.as_posix()):
+                pass
+            elif self._file_name.is_file():
+                raise IOError(f"Simulation model file {self._file_name} exist - not overwriting!")
+            else:
+                content = file_path.read_text(encoding='utf-8')
+                self._file_name.write_text(content)
+
         if self._file_name is not None:
             self._loadFile(fileName=self._file_name)
 
@@ -1635,7 +1648,7 @@ def convertMo2Fmu(
             fmuType: str = "me_cs",
             fileNamePrefix: Optional[str] = None,
             includeResources: bool = True,
-    ) -> str:
+    ) -> OMCPath:
         """Translate the model into a Functional Mockup Unit.
 
         Args:
@@ -1662,15 +1675,19 @@ def convertMo2Fmu(
         properties = (f'version="{version}", fmuType="{fmuType}", '
                       f'fileNamePrefix="{fileNamePrefix}", includeResources={includeResourcesStr}')
         fmu = self._requestApi(apiName='buildModelFMU', entity=self._model_name, properties=properties)
+        fmu_path = self._session.omcpath(fmu)
 
         # report proper error message
-        if not os.path.exists(fmu):
-            raise ModelicaSystemError(f"Missing FMU file: {fmu}")
+        if not fmu_path.is_file():
+            raise ModelicaSystemError(f"Missing FMU file: {fmu_path.as_posix()}")
 
-        return fmu
+        return fmu_path
 
     # to convert FMU to Modelica model
-    def convertFmu2Mo(self, fmuName):  # 20
+    def convertFmu2Mo(
+            self,
+            fmu: os.PathLike,
+    ) -> OMCPath:
         """
         In order to load FMU, at first it needs to be translated into Modelica model. This method is used to generate
         Modelica model from the given FMU. It generates "fmuName_me_FMU.mo".
@@ -1679,13 +1696,24 @@ def convertFmu2Mo(self, fmuName):  # 20
         >>> convertFmu2Mo("c:/BouncingBall.Fmu")
         """
 
-        fileName = self._requestApi(apiName='importFMU', entity=fmuName)
+        fmu_path = self._session.omcpath(fmu)
+
+        if not fmu_path.is_file():
+            raise ModelicaSystemError(f"Missing FMU file: {fmu_path.as_posix()}")
+
+        filename = self._requestApi(apiName='importFMU', entity=fmu_path.as_posix())
+        filepath = self.getWorkDirectory() / filename
 
         # report proper error message
-        if not os.path.exists(fileName):
-            raise ModelicaSystemError(f"Missing file {fileName}")
+        if not filepath.is_file():
+            raise ModelicaSystemError(f"Missing file {filepath.as_posix()}")
+
+        self.model(
+            name=f"{fmu_path.stem}_me_FMU",
+            file=filepath,
+        )
 
-        return fileName
+        return filepath
 
     def optimize(self) -> dict[str, Any]:
         """Perform model-based optimization.

tests/test_FMIImport.py

@@ -0,0 +1,57 @@
+import numpy as np
+import os
+import pytest
+import shutil
+
+import OMPython
+
+
+@pytest.fixture
+def model_firstorder(tmp_path):
+    mod = tmp_path / "M.mo"
+    mod.write_text("""model M
+  Real x(start = 1, fixed = true);
+  parameter Real a = -1;
+equation
+  der(x) = x*a;
+end M;
+""")
+    return mod
+
+
+def test_FMIImport(model_firstorder):
+    filePath = model_firstorder.as_posix()
+
+    # create model & simulate it
+    mod1 = OMPython.ModelicaSystem()
+    mod1.model(file=filePath, name="M")
+    mod1.simulate()
+
+    # create FMU & check
+    fmu = mod1.convertMo2Fmu(fileNamePrefix="M")
+    assert os.path.exists(fmu)
+
+    # import FMU & check & simulate
+    # TODO: why is '--allowNonStandardModelica=reinitInAlgorithms' needed? any example without this possible?
+    mod2 = OMPython.ModelicaSystem(commandLineOptions=['--allowNonStandardModelica=reinitInAlgorithms'])
+    mo = mod2.convertFmu2Mo(fmu=fmu)
+    assert os.path.exists(mo)
+
+    mod2.simulate()
+
+    # get and verify result
+    res1 = mod1.getSolutions(['time', 'x'])
+    res2 = mod2.getSolutions(['time', 'x'])
+
+    # check last value for time
+    assert res1[0][-1] == res2[0][-1] == 1.0
+    # check last value for x
+    assert np.isclose(res1[1][-1], 0.3678794515)  # 0.36787945153397683
+    assert np.isclose(res2[1][-1], 0.3678794515)  # 0.3678794515707647
+
+    # cleanup
+    tmp2 = mod1.getWorkDirectory()
+    shutil.rmtree(tmp2, ignore_errors=True)
+
+    tmp2 = mod2.getWorkDirectory()
+    shutil.rmtree(tmp2, ignore_errors=True)

tests/test_ModelicaSystem.py

@@ -51,10 +51,11 @@ def worker():
 
 def test_setParameters():
     omc = OMPython.OMCSessionZMQ()
-    model_path = omc.sendExpression("getInstallationDirectoryPath()") + "/share/doc/omc/testmodels/"
+    model_path_str = omc.sendExpression("getInstallationDirectoryPath()") + "/share/doc/omc/testmodels"
+    model_path = omc.omcpath(model_path_str)
     mod = OMPython.ModelicaSystem()
     mod.model(
-        file=model_path + "BouncingBall.mo",
+        file=model_path / "BouncingBall.mo",
         name="BouncingBall",
     )
 
@@ -85,10 +86,11 @@ def test_setParameters():
 
 def test_setSimulationOptions():
     omc = OMPython.OMCSessionZMQ()
-    model_path = omc.sendExpression("getInstallationDirectoryPath()") + "/share/doc/omc/testmodels/"
+    model_path_str = omc.sendExpression("getInstallationDirectoryPath()") + "/share/doc/omc/testmodels"
+    model_path = omc.omcpath(model_path_str)
     mod = OMPython.ModelicaSystem()
     mod.model(
-        file=model_path + "BouncingBall.mo",
+        file=model_path / "BouncingBall.mo",
         name="BouncingBall",
     )
 
@@ -112,7 +114,6 @@ def test_setSimulationOptions():
     assert d["tolerance"] == "1.2e-08"
 
 
-@pytest.mark.skip("will fail / fix available")
 def test_relative_path(model_firstorder):
     cwd = pathlib.Path.cwd()
     (fd, name) = tempfile.mkstemp(prefix='tmpOMPython.tests', dir=cwd, text=True)
@@ -152,30 +153,25 @@ def test_customBuildDirectory(tmp_path, model_firstorder):
 
 @skip_on_windows
 @skip_python_older_312
-def test_getSolutions_docker(model_firstorder_content):
+def test_getSolutions_docker(model_firstorder):
     omcp = OMPython.OMCProcessDocker(docker="openmodelica/openmodelica:v1.25.0-minimal")
     omc = OMPython.OMCSessionZMQ(omc_process=omcp)
 
-    modelpath = omc.omcpath_tempdir() / 'M.mo'
-    modelpath.write_text(model_firstorder_content)
-
-    file_path = pathlib.Path(modelpath)
     mod = OMPython.ModelicaSystem(
         omc_process=omc.omc_process,
     )
     mod.model(
         name="M",
-        file=file_path,
+        file=model_firstorder.as_posix(),
     )
 
     _run_getSolutions(mod)
 
 
 def test_getSolutions(model_firstorder):
-    filePath = model_firstorder.as_posix()
     mod = OMPython.ModelicaSystem()
     mod.model(
-        file=filePath,
+        file=model_firstorder.as_posix(),
         name="M",
     )
 

tests/test_ModelicaSystemDoE.py

@@ -71,15 +71,11 @@ def test_ModelicaSystemDoE_docker(tmp_path, model_doe, param_doe):
     omc = OMPython.OMCSessionZMQ(omc_process=omcp)
     assert omc.sendExpression("getVersion()") == "OpenModelica 1.25.0"
 
-    modelpath = omc.omcpath_tempdir() / 'M.mo'
-    modelpath.write_text(model_doe.read_text())
-
     doe_mod = OMPython.ModelicaSystemDoE(
-        fileName=modelpath.as_posix(),
+        fileName=model_doe.as_posix(),
         modelName="M",
         parameters=param_doe,
         omc_process=omcp,
-        resultpath=modelpath.parent,
         simargs={"override": {'stopTime': 1.0}},
     )