[ModelicaSystem*] omc_process => session

Author: syntron

OMPython/ModelicaSystem.py

@@ -336,7 +336,7 @@ def __init__(
             command_line_options: Optional[list[str]] = None,
             work_directory: Optional[str | os.PathLike] = None,
             omhome: Optional[str] = None,
-            omc_process: Optional[OMCSession] = None,
+            session: Optional[OMCSession] = None,
     ) -> None:
         """Create a ModelicaSystem instance. To define the model use model() or convertFmu2Mo().
 
@@ -348,7 +348,7 @@ def __init__(
               files like the model executable. If left unspecified, a tmp
               directory will be created.
             omhome: path to OMC to be used when creating the OMC session (see OMCSessionZMQ).
-            omc_process: definition of a (local) OMC process to be used. If
+            session: definition of a (local) OMC session to be used. If
               unspecified, a new local session will be created.
         """
 
@@ -376,8 +376,8 @@ def __init__(
         self._linearized_outputs: list[str] = []  # linearization output list
         self._linearized_states: list[str] = []  # linearization states list
 
-        if omc_process is not None:
-            self._session = OMCSessionZMQ(omc_process=omc_process)
+        if session is not None:
+            self._session = OMCSessionZMQ(omc_process=session)
         else:
             self._session = OMCSessionZMQ(omhome=omhome)
 
@@ -485,7 +485,7 @@ def model(
         if build:
             self.buildModel(variable_filter)
 
-    def session(self) -> OMCSessionZMQ:
+    def get_session(self) -> OMCSessionZMQ:
         """
         Return the OMC session used for this class.
         """
@@ -1967,7 +1967,7 @@ def __init__(
             variable_filter: Optional[str] = None,
             work_directory: Optional[str | os.PathLike] = None,
             omhome: Optional[str] = None,
-            omc_process: Optional[OMCSession] = None,
+            session: Optional[OMCSession] = None,
             # simulation specific input
             # TODO: add more settings (simulation options, input options, ...)
             simargs: Optional[dict[str, Optional[str | dict[str, str] | numbers.Number]]] = None,
@@ -1988,7 +1988,7 @@ def __init__(
             command_line_options=command_line_options,
             work_directory=work_directory,
             omhome=omhome,
-            omc_process=omc_process,
+            session=session,
         )
         self._mod.model(
             model_file=model_file,
@@ -2003,9 +2003,9 @@ def __init__(
         self._timeout = timeout
 
         if resultpath is None:
-            self._resultpath = self.session().omcpath_tempdir()
+            self._resultpath = self.get_session().omcpath_tempdir()
         else:
-            self._resultpath = self.session().omcpath(resultpath)
+            self._resultpath = self.get_session().omcpath(resultpath)
         if not self._resultpath.is_dir():
             raise ModelicaSystemError("Argument resultpath must be set to a valid path within the environment used "
                                       f"for the OpenModelica session: {resultpath}!")
@@ -2018,11 +2018,11 @@ def __init__(
         self._doe_def: Optional[dict[str, dict[str, Any]]] = None
         self._doe_cmd: Optional[dict[str, OMCSessionRunData]] = None
 
-    def session(self) -> OMCSessionZMQ:
+    def get_session(self) -> OMCSessionZMQ:
         """
         Return the OMC session used for this class.
         """
-        return self._mod.session()
+        return self._mod.get_session()
 
     def prepare(self) -> int:
         """
@@ -2061,7 +2061,7 @@ def prepare(self) -> int:
 
                 pk_value = pc_structure[idx_structure]
                 if isinstance(pk_value, str):
-                    pk_value_str = self.session().escape_str(pk_value)
+                    pk_value_str = self.get_session().escape_str(pk_value)
                     expression = f"setParameterValue({self._model_name}, {pk_structure}, \"{pk_value_str}\")"
                 elif isinstance(pk_value, bool):
                     pk_value_bool_str = "true" if pk_value else "false"
@@ -2183,12 +2183,12 @@ def worker(worker_id, task_queue):
                     raise ModelicaSystemError("Missing simulation definition!")
 
                 resultfile = cmd_definition.cmd_result_path
-                resultpath = self.session().omcpath(resultfile)
+                resultpath = self.get_session().omcpath(resultfile)
 
                 logger.info(f"[Worker {worker_id}] Performing task: {resultpath.name}")
 
                 try:
-                    returncode = self.session().run_model_executable(cmd_run_data=cmd_definition)
+                    returncode = self.get_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_ModelicaSystem.py

@@ -159,7 +159,7 @@ def test_getSolutions_docker(model_firstorder):
     omc = OMPython.OMCSessionZMQ(omc_process=omcp)
 
     mod = OMPython.ModelicaSystem(
-        omc_process=omc.omc_process,
+        session=omc.omc_process,
     )
     mod.model(
         model_file=model_firstorder,

tests/test_ModelicaSystemCmd.py

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

tests/test_ModelicaSystemDoE.py

@@ -77,7 +77,7 @@ def test_ModelicaSystemDoE_docker(tmp_path, model_doe, param_doe):
         model_file=model_doe,
         model_name="M",
         parameters=param_doe,
-        omc_process=omcp,
+        session=omcp,
         simargs={"override": {'stopTime': 1.0}},
     )
 

tests/test_OMSessionCmd.py

@@ -13,7 +13,7 @@ def test_isPackage2():
         model_name="Modelica.Electrical.Analog.Examples.CauerLowPassAnalog",
         libraries=["Modelica"],
     )
-    omccmd = OMPython.OMCSessionCmd(session=mod.session())
+    omccmd = OMPython.OMCSessionCmd(session=mod.get_session())
     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_session().omcpath(resultfile_str)
     time, f, v = mod.getSolutions(
         varList=["time", "f", "v"],
         resultfile=resultfile_omcpath,