Merge branch 'ModelicaSystem_rename_getconn_session' into v4.1.0-syntron2

Author: syntron

OMPython/ModelicaSystem.py

@@ -362,9 +362,9 @@ def __init__(
         self._linearized_states: list[str] = []  # linearization states list
 
         if omc_process is not None:
-            self._getconn = OMCSessionZMQ(omc_process=omc_process)
+            self._session = OMCSessionZMQ(omc_process=omc_process)
         else:
-            self._getconn = OMCSessionZMQ(omhome=omhome)
+            self._session = OMCSessionZMQ(omhome=omhome)
 
         # set commandLineOptions using default values or the user defined list
         if commandLineOptions is None:
@@ -449,13 +449,13 @@ def model(
         if file is not None:
             file_path = pathlib.Path(file)
             # special handling for OMCProcessLocal - consider a relative path
-            if isinstance(self._getconn.omc_process, OMCProcessLocal) and not file_path.is_absolute():
+            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._getconn.omc_process, OMCProcessLocal)
+            if (isinstance(self._session.omc_process, OMCProcessLocal)
                     and file_path.as_posix() == self._file_name.as_posix()):
                 pass
             elif self._file_name.is_file():
@@ -474,7 +474,7 @@ def session(self) -> OMCSessionZMQ:
         """
         Return the OMC session used for this class.
         """
-        return self._getconn
+        return self._session
 
     def setCommandLineOptions(self, commandLineOptions: str):
         """
@@ -517,11 +517,11 @@ def setWorkDirectory(self, customBuildDirectory: Optional[str | os.PathLike] = N
         directory. If no directory is defined a unique temporary directory is created.
         """
         if customBuildDirectory is not None:
-            workdir = self._getconn.omcpath(customBuildDirectory).absolute()
+            workdir = self._session.omcpath(customBuildDirectory).absolute()
             if not workdir.is_dir():
                 raise IOError(f"Provided work directory does not exists: {customBuildDirectory}!")
         else:
-            workdir = self._getconn.omcpath_tempdir().absolute()
+            workdir = self._session.omcpath_tempdir().absolute()
             if not workdir.is_dir():
                 raise IOError(f"{workdir} could not be created")
 
@@ -557,24 +557,24 @@ def buildModel(self, variableFilter: Optional[str] = None):
 
         # check if the executable exists ...
         om_cmd = ModelicaSystemCmd(
-            session=self._getconn,
+            session=self._session,
             runpath=self.getWorkDirectory(),
             modelname=self._model_name,
             timeout=5.0,
         )
         # ... by running it - output help for command help
         om_cmd.arg_set(key="help", val="help")
         cmd_definition = om_cmd.definition()
-        returncode = self._getconn.run_model_executable(cmd_run_data=cmd_definition)
+        returncode = self._session.run_model_executable(cmd_run_data=cmd_definition)
         if returncode != 0:
             raise ModelicaSystemError("Model executable not working!")
 
-        xml_file = self._getconn.omcpath(buildModelResult[0]).parent / buildModelResult[1]
+        xml_file = self._session.omcpath(buildModelResult[0]).parent / buildModelResult[1]
         self._xmlparse(xml_file=xml_file)
 
     def sendExpression(self, expr: str, parsed: bool = True) -> Any:
         try:
-            retval = self._getconn.sendExpression(expr, parsed)
+            retval = self._session.sendExpression(expr, parsed)
         except OMCSessionException as ex:
             raise ModelicaSystemError(f"Error executing {repr(expr)}: {ex}") from ex
 
@@ -1047,7 +1047,7 @@ def simulate_cmd(
         """
 
         om_cmd = ModelicaSystemCmd(
-            session=self._getconn,
+            session=self._session,
             runpath=self.getWorkDirectory(),
             modelname=self._model_name,
             timeout=timeout,
@@ -1128,7 +1128,7 @@ def simulate(
         elif isinstance(resultfile, OMCPath):
             self._result_file = resultfile
         else:
-            self._result_file = self._getconn.omcpath(resultfile)
+            self._result_file = self._session.omcpath(resultfile)
             if not self._result_file.is_absolute():
                 self._result_file = self.getWorkDirectory() / resultfile
 
@@ -1147,7 +1147,7 @@ def simulate(
             self._result_file.unlink()
         # ... run simulation ...
         cmd_definition = om_cmd.definition()
-        returncode = self._getconn.run_model_executable(cmd_run_data=cmd_definition)
+        returncode = self._session.run_model_executable(cmd_run_data=cmd_definition)
         # and check returncode *AND* resultfile
         if returncode != 0 and self._result_file.is_file():
             # check for an empty (=> 0B) result file which indicates a crash of the model executable
@@ -1171,12 +1171,12 @@ def plot(
         plot is created by OMC which needs access to the local display. This is not the case for docker and WSL.
         """
 
-        if not isinstance(self._getconn.omc_process, OMCProcessLocal):
+        if not isinstance(self._session.omc_process, OMCProcessLocal):
             raise ModelicaSystemError("Plot is using the OMC plot functionality; "
                                       "thus, it is only working if OMC is running locally!")
 
         if resultfile is not None:
-            plot_result_file = self._getconn.omcpath(resultfile)
+            plot_result_file = self._session.omcpath(resultfile)
         elif self._result_file is not None:
             plot_result_file = self._result_file
         else:
@@ -1230,7 +1230,7 @@ def getSolutions(
                 raise ModelicaSystemError("No result file found. Run simulate() first.")
             result_file = self._result_file
         else:
-            result_file = self._getconn.omcpath(resultfile)
+            result_file = self._session.omcpath(resultfile)
 
         # check if the result file exits
         if not result_file.is_file():
@@ -1642,7 +1642,7 @@ 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._getconn.omcpath(fmu)
+        fmu_path = self._session.omcpath(fmu)
 
         # report proper error message
         if not fmu_path.is_file():
@@ -1663,7 +1663,7 @@ def convertFmu2Mo(
         >>> convertFmu2Mo("c:/BouncingBall.Fmu")
         """
 
-        fmu_path = self._getconn.omcpath(fmu)
+        fmu_path = self._session.omcpath(fmu)
 
         if not fmu_path.is_file():
             raise ModelicaSystemError(f"Missing FMU file: {fmu_path.as_posix()}")
@@ -1751,7 +1751,7 @@ def linearize(
             )
 
         om_cmd = ModelicaSystemCmd(
-            session=self._getconn,
+            session=self._session,
             runpath=self.getWorkDirectory(),
             modelname=self._model_name,
             timeout=timeout,
@@ -1790,7 +1790,7 @@ def linearize(
         linear_file.unlink(missing_ok=True)
 
         cmd_definition = om_cmd.definition()
-        returncode = self._getconn.run_model_executable(cmd_run_data=cmd_definition)
+        returncode = self._session.run_model_executable(cmd_run_data=cmd_definition)
         if returncode != 0:
             raise ModelicaSystemError(f"Linearize failed with return code: {returncode}")
         if not linear_file.is_file():
@@ -2146,7 +2146,7 @@ def worker(worker_id, task_queue):
                 logger.info(f"[Worker {worker_id}] Performing task: {resultpath.name}")
 
                 try:
-                    returncode = self._mod._getconn.run_model_executable(cmd_run_data=cmd_definition)
+                    returncode = self.session().run_model_executable(cmd_run_data=cmd_definition)
                     logger.info(f"[Worker {worker_id}] Simulation {resultpath.name} "
                                 f"finished with return code: {returncode}")
                 except ModelicaSystemError as ex:

tests/test_ModelicaSystemCmd.py

@@ -23,7 +23,7 @@ def mscmd_firstorder(model_firstorder):
         name="M",
     )
     mscmd = OMPython.ModelicaSystemCmd(
-        session=mod._getconn,
+        session=mod.session(),
         runpath=mod.getWorkDirectory(),
         modelname=mod._model_name,
     )

tests/test_OMSessionCmd.py

@@ -13,7 +13,7 @@ def test_isPackage2():
         name="Modelica.Electrical.Analog.Examples.CauerLowPassAnalog",
         libraries=["Modelica"],
     )
-    omccmd = OMPython.OMCSessionCmd(session=mod._getconn)
+    omccmd = OMPython.OMCSessionCmd(session=mod.session())
     assert omccmd.isPackage('Modelica')
 
 

tests/test_optimization.py

@@ -55,7 +55,7 @@ def test_optimization_example(tmp_path):
     r = mod.optimize()
     # it is necessary to specify resultfile, otherwise it wouldn't find it.
     resultfile_str = r["resultFile"]
-    resultfile_omcpath = mod._getconn.omcpath(resultfile_str)
+    resultfile_omcpath = mod.session().omcpath(resultfile_str)
     time, f, v = mod.getSolutions(["time", "f", "v"], resultfile=resultfile_omcpath.as_posix())
     assert np.isclose(f[0], 10)
     assert np.isclose(f[-1], -10)