[ModelicaSystem] session => omc_process

Author: syntron

OMPython/ModelicaSystem.py

@@ -377,9 +377,9 @@ def __init__(
         self._linearized_states: list[str] = []  # linearization states list
 
         if omc_process is not None:
-            self._session = OMCSessionZMQ(omc_process=omc_process)
+            self._omc_process = OMCSessionZMQ(omc_process=omc_process)
         else:
-            self._session = OMCSessionZMQ(omhome=omhome)
+            self._omc_process = OMCSessionZMQ(omhome=omhome)
 
         # set commandLineOptions using default values or the user defined list
         if command_line_options is None:
@@ -464,13 +464,13 @@ def model(
         if model_file is not None:
             file_path = pathlib.Path(model_file)
             # special handling for OMCProcessLocal - consider a relative path
-            if isinstance(self._session.omc_process, OMCProcessLocal) and not file_path.is_absolute():
+            if isinstance(self._omc_process.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)
+            if (isinstance(self._omc_process.omc_process, OMCProcessLocal)
                     and file_path.as_posix() == self._file_name.as_posix()):
                 pass
             elif self._file_name.is_file():
@@ -485,11 +485,11 @@ def model(
         if build:
             self.buildModel(variable_filter)
 
-    def session(self) -> OMCSessionZMQ:
+    def get_omc_process(self) -> OMCSessionZMQ:
         """
         Return the OMC session used for this class.
         """
-        return self._session
+        return self._omc_process
 
     def set_command_line_options(self, command_line_option: str):
         """
@@ -532,11 +532,11 @@ def setWorkDirectory(self, work_directory: Optional[str | os.PathLike] = None) -
         directory. If no directory is defined a unique temporary directory is created.
         """
         if work_directory is not None:
-            workdir = self._session.omcpath(work_directory).absolute()
+            workdir = self._omc_process.omcpath(work_directory).absolute()
             if not workdir.is_dir():
                 raise IOError(f"Provided work directory does not exists: {work_directory}!")
         else:
-            workdir = self._session.omcpath_tempdir().absolute()
+            workdir = self._omc_process.omcpath_tempdir().absolute()
             if not workdir.is_dir():
                 raise IOError(f"{workdir} could not be created")
 
@@ -572,24 +572,24 @@ def buildModel(self, variableFilter: Optional[str] = None):
 
         # check if the executable exists ...
         om_cmd = ModelicaSystemCmd(
-            omc_process=self._session,
+            omc_process=self._omc_process,
             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._session.run_model_executable(cmd_run_data=cmd_definition)
+        returncode = self._omc_process.run_model_executable(cmd_run_data=cmd_definition)
         if returncode != 0:
             raise ModelicaSystemError("Model executable not working!")
 
-        xml_file = self._session.omcpath(build_model_result[0]).parent / build_model_result[1]
+        xml_file = self._omc_process.omcpath(build_model_result[0]).parent / build_model_result[1]
         self._xmlparse(xml_file=xml_file)
 
     def sendExpression(self, expr: str, parsed: bool = True) -> Any:
         try:
-            retval = self._session.sendExpression(expr, parsed)
+            retval = self._omc_process.sendExpression(expr, parsed)
         except OMCProcessException as ex:
             raise ModelicaSystemError(f"Error executing {repr(expr)}: {ex}") from ex
 
@@ -1083,7 +1083,7 @@ def simulate_cmd(
         """
 
         om_cmd = ModelicaSystemCmd(
-            omc_process=self._session,
+            omc_process=self._omc_process,
             runpath=self.getWorkDirectory(),
             modelname=self._model_name,
             timeout=timeout,
@@ -1164,7 +1164,7 @@ def simulate(
         elif isinstance(resultfile, OMCPath):
             self._result_file = resultfile
         else:
-            self._result_file = self._session.omcpath(resultfile)
+            self._result_file = self._omc_process.omcpath(resultfile)
             if not self._result_file.is_absolute():
                 self._result_file = self.getWorkDirectory() / resultfile
 
@@ -1183,7 +1183,7 @@ def simulate(
             self._result_file.unlink()
         # ... run simulation ...
         cmd_definition = om_cmd.definition()
-        returncode = self._session.run_model_executable(cmd_run_data=cmd_definition)
+        returncode = self._omc_process.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
@@ -1207,12 +1207,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._session.omc_process, OMCProcessLocal):
+        if not isinstance(self._omc_process.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._session.omcpath(resultfile)
+            plot_result_file = self._omc_process.omcpath(resultfile)
         elif self._result_file is not None:
             plot_result_file = self._result_file
         else:
@@ -1266,7 +1266,7 @@ def getSolutions(
                 raise ModelicaSystemError("No result file found. Run simulate() first.")
             result_file = self._result_file
         else:
-            result_file = self._session.omcpath(resultfile)
+            result_file = self._omc_process.omcpath(resultfile)
 
         # check if the result file exits
         if not result_file.is_file():
@@ -1683,7 +1683,7 @@ def convertMo2Fmu(
         properties = (f'version="{version}", fmuType="{fmuType}", '
                       f'fileNamePrefix="{fileNamePrefix}", includeResources={include_resources_str}')
         fmu = self._requestApi(apiName='buildModelFMU', entity=self._model_name, properties=properties)
-        fmu_path = self._session.omcpath(fmu)
+        fmu_path = self._omc_process.omcpath(fmu)
 
         # report proper error message
         if not fmu_path.is_file():
@@ -1704,7 +1704,7 @@ def convertFmu2Mo(
         >>> convertFmu2Mo("c:/BouncingBall.Fmu")
         """
 
-        fmu_path = self._session.omcpath(fmu)
+        fmu_path = self._omc_process.omcpath(fmu)
 
         if not fmu_path.is_file():
             raise ModelicaSystemError(f"Missing FMU file: {fmu_path.as_posix()}")
@@ -1789,7 +1789,7 @@ def linearize(
             )
 
         om_cmd = ModelicaSystemCmd(
-            omc_process=self._session,
+            omc_process=self._omc_process,
             runpath=self.getWorkDirectory(),
             modelname=self._model_name,
             timeout=timeout,
@@ -1828,7 +1828,7 @@ def linearize(
         linear_file.unlink(missing_ok=True)
 
         cmd_definition = om_cmd.definition()
-        returncode = self._session.run_model_executable(cmd_run_data=cmd_definition)
+        returncode = self._omc_process.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():
@@ -2022,7 +2022,7 @@ def session(self) -> OMCSessionZMQ:
         """
         Return the OMC session used for this class.
         """
-        return self._mod.session()
+        return self._mod.get_omc_process()
 
     def prepare(self) -> int:
         """

tests/test_ModelicaSystemCmd.py

@@ -24,7 +24,7 @@ def mscmd_firstorder(model_firstorder):
         model_name="M",
     )
     mscmd = OMPython.ModelicaSystemCmd(
-        omc_process=mod.session(),
+        omc_process=mod.get_omc_process(),
         runpath=mod.getWorkDirectory(),
         modelname=mod._model_name,
     )

tests/test_OMSessionCmd.py

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

tests/test_optimization.py

@@ -56,7 +56,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.session().omcpath(resultfile_str)
+    resultfile_omcpath = mod.get_omc_process().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)