[ModelicaSystem] update handling of work directory

* use as input str or os.PathLike; the later covers all pathlib objects
* rename _tempdir to _work_dir
* rename setTempDirectory() => setWorkDirectory()
* setWorkDirectory() sets the work dir and also returns its path
* use setWorkDirectory() within code; this allows to add special handling
  to the function if needed

Author: syntron

OMPython/ModelicaSystem.py

@@ -301,7 +301,7 @@ def __init__(
             lmodel: Optional[list[str | tuple[str, str]]] = None,
             commandLineOptions: Optional[str] = None,
             variableFilter: Optional[str] = None,
-            customBuildDirectory: Optional[str | os.PathLike | pathlib.Path] = None,
+            customBuildDirectory: Optional[str | os.PathLike] = None,
             omhome: Optional[str] = None,
             omc_process: Optional[OMCProcessLocal] = None,
             build: bool = True,
@@ -400,7 +400,7 @@ def __init__(
         self.setCommandLineOptions("--linearizationDumpLanguage=python")
         self.setCommandLineOptions("--generateSymbolicLinearization")
 
-        self._tempdir = self.setTempDirectory(customBuildDirectory)
+        self._work_dir: pathlib.Path = self.setWorkDirectory(customBuildDirectory)
 
         if self._file_name is not None:
             self._loadLibrary(lmodel=self._lmodel)
@@ -448,25 +448,34 @@ def _loadLibrary(self, lmodel: list):
                                               '1)["Modelica"]\n'
                                               '2)[("Modelica","3.2.3"), "PowerSystems"]\n')
 
-    def setTempDirectory(self, customBuildDirectory: Optional[str | os.PathLike | pathlib.Path] = None) -> pathlib.Path:
-        # create a unique temp directory for each session and build the model in that directory
+    def setWorkDirectory(self, customBuildDirectory: Optional[str | os.PathLike] = None) -> pathlib.Path:
+        """
+        Define the work directory for the ModelicaSystem / OpenModelica session. The model is build within this
+        directory. If no directory is defined a unique temporary directory is created.
+        """
         if customBuildDirectory is not None:
-            if not os.path.exists(customBuildDirectory):
-                raise IOError(f"{customBuildDirectory} does not exist")
-            tempdir = pathlib.Path(customBuildDirectory).absolute()
+            workdir = pathlib.Path(customBuildDirectory).absolute()
+            if not workdir.is_dir():
+                raise IOError(f"Provided work directory does not exists: {customBuildDirectory}!")
         else:
-            tempdir = pathlib.Path(tempfile.mkdtemp()).absolute()
-            if not tempdir.is_dir():
-                raise IOError(f"{tempdir} could not be created")
+            workdir = pathlib.Path(tempfile.mkdtemp()).absolute()
+            if not workdir.is_dir():
+                raise IOError(f"{workdir} could not be created")
 
-        logger.info("Define tempdir as %s", tempdir)
-        exp = f'cd("{tempdir.as_posix()}")'
+        logger.info("Define work dir as %s", workdir)
+        exp = f'cd("{workdir.as_posix()}")'
         self.sendExpression(exp)
 
-        return tempdir
+        # set the class variable _tempdir ...
+        self._work_dir = workdir
+        # ... and also return the defined path
+        return workdir
 
     def getWorkDirectory(self) -> pathlib.Path:
-        return self._tempdir
+        """
+        Return the defined working directory for this ModelicaSystem / OpenModelica session.
+        """
+        return self._work_dir
 
     def buildModel(self, variableFilter: Optional[str] = None):
         if variableFilter is not None:
@@ -942,7 +951,11 @@ def simulate_cmd(
             An instance if ModelicaSystemCmd to run the requested simulation.
         """
 
-        om_cmd = ModelicaSystemCmd(runpath=self._tempdir, modelname=self._model_name, timeout=timeout)
+        om_cmd = ModelicaSystemCmd(
+            runpath=self.getWorkDirectory(),
+            modelname=self._model_name,
+            timeout=timeout,
+        )
 
         # always define the result file to use
         om_cmd.arg_set(key="r", val=result_file.as_posix())
@@ -954,7 +967,7 @@ def simulate_cmd(
         if simargs:
             om_cmd.args_set(args=simargs)
 
-        overrideFile = self._tempdir / f"{self._model_name}_override.txt"
+        overrideFile = self.getWorkDirectory() / 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)
@@ -1013,11 +1026,11 @@ def simulate(
 
         if resultfile is None:
             # default result file generated by OM
-            self._result_file = self._tempdir / f"{self._model_name}_res.mat"
+            self._result_file = self.getWorkDirectory() / f"{self._model_name}_res.mat"
         elif os.path.exists(resultfile):
             self._result_file = pathlib.Path(resultfile)
         else:
-            self._result_file = self._tempdir / resultfile
+            self._result_file = self.getWorkDirectory() / resultfile
 
         om_cmd = self.simulate_cmd(
             result_file=self._result_file,
@@ -1419,7 +1432,7 @@ def _createCSVData(self, csvfile: Optional[pathlib.Path] = None) -> pathlib.Path
             csv_rows.append(row)
 
         if csvfile is None:
-            csvfile = self._tempdir / f'{self._model_name}.csv'
+            csvfile = self.getWorkDirectory() / f'{self._model_name}.csv'
 
         with open(file=csvfile, mode="w", encoding="utf-8", newline="") as fh:
             writer = csv.writer(fh)
@@ -1541,9 +1554,13 @@ def linearize(self, lintime: Optional[float] = None, simflags: Optional[str] = N
                 "use ModelicaSystem() to build the model first"
             )
 
-        om_cmd = ModelicaSystemCmd(runpath=self._tempdir, modelname=self._model_name, timeout=timeout)
+        om_cmd = ModelicaSystemCmd(
+            runpath=self.getWorkDirectory(),
+            modelname=self._model_name,
+            timeout=timeout,
+        )
 
-        overrideLinearFile = self._tempdir / f'{self._model_name}_override_linear.txt'
+        overrideLinearFile = self.getWorkDirectory() / 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():
@@ -1573,19 +1590,17 @@ def linearize(self, lintime: Optional[float] = None, simflags: Optional[str] = N
             om_cmd.args_set(args=simargs)
 
         # the file create by the model executable which contains the matrix and linear inputs, outputs and states
-        linear_file = self._tempdir / "linearized_model.py"
-
+        linear_file = self.getWorkDirectory() / "linearized_model.py"
         linear_file.unlink(missing_ok=True)
 
         returncode = om_cmd.run()
         if returncode != 0:
             raise ModelicaSystemError(f"Linearize failed with return code: {returncode}")
-
-        self._simulated = True
-
         if not linear_file.exists():
             raise ModelicaSystemError(f"Linearization failed: {linear_file} not found!")
 
+        self._simulated = True
+
         # extract data from the python file with the linearized model using the ast module - this allows to get the
         # needed information without executing the created code
         linear_data = {}