(D008) add v4.0.0 compatibility layer

[OMTypedParser] compatibility layer

[__init__/OMCSession] prepare compatibility layer

[ModelicaSystem] define as compatibility layer

[ModelicaSystemCmd] define as compatibility layer

Author: syntron

OMPython/ModelicaSystem.py

@@ -2120,6 +2120,138 @@ class ModelicaSystem(ModelicaSystemOMC):
     Compatibility class.
     """
 
+    def __init__(
+            self,
+            fileName: Optional[str | os.PathLike | pathlib.Path] = None,
+            modelName: Optional[str] = None,
+            lmodel: Optional[list[str | tuple[str, str]]] = None,
+            commandLineOptions: Optional[list[str]] = None,
+            variableFilter: Optional[str] = None,
+            customBuildDirectory: Optional[str | os.PathLike] = None,
+            omhome: Optional[str] = None,
+            omc_process: Optional[OMCSessionLocal] = None,
+            build: bool = True,
+    ) -> None:
+        super().__init__(
+            command_line_options=commandLineOptions,
+            work_directory=customBuildDirectory,
+            omhome=omhome,
+            session=omc_process,
+        )
+        self.model(
+            model_name=modelName,
+            model_file=fileName,
+            libraries=lmodel,
+            variable_filter=variableFilter,
+            build=build,
+        )
+        self._getconn = self._session
+
+    def setCommandLineOptions(self, commandLineOptions: str):
+        super().set_command_line_options(command_line_option=commandLineOptions)
+
+    def setContinuous(  # type: ignore[override]
+            self,
+            cvals: str | list[str] | dict[str, Any],
+    ) -> bool:
+        if isinstance(cvals, dict):
+            return super().setContinuous(**cvals)
+        raise ModelicaSystemError("Only dict input supported for setContinuous()")
+
+    def setParameters(  # type: ignore[override]
+            self,
+            pvals: str | list[str] | dict[str, Any],
+    ) -> bool:
+        if isinstance(pvals, dict):
+            return super().setParameters(**pvals)
+        raise ModelicaSystemError("Only dict input supported for setParameters()")
+
+    def setOptimizationOptions(  # type: ignore[override]
+            self,
+            optimizationOptions: str | list[str] | dict[str, Any],
+    ) -> bool:
+        if isinstance(optimizationOptions, dict):
+            return super().setOptimizationOptions(**optimizationOptions)
+        raise ModelicaSystemError("Only dict input supported for setOptimizationOptions()")
+
+    def setInputs(  # type: ignore[override]
+            self,
+            name: str | list[str] | dict[str, Any],
+    ) -> bool:
+        if isinstance(name, dict):
+            return super().setInputs(**name)
+        raise ModelicaSystemError("Only dict input supported for setInputs()")
+
+    def setSimulationOptions(  # type: ignore[override]
+            self,
+            simOptions: str | list[str] | dict[str, Any],
+    ) -> bool:
+        if isinstance(simOptions, dict):
+            return super().setSimulationOptions(**simOptions)
+        raise ModelicaSystemError("Only dict input supported for setSimulationOptions()")
+
+    def setLinearizationOptions(  # type: ignore[override]
+            self,
+            linearizationOptions: str | list[str] | dict[str, Any],
+    ) -> bool:
+        if isinstance(linearizationOptions, dict):
+            return super().setLinearizationOptions(**linearizationOptions)
+        raise ModelicaSystemError("Only dict input supported for setLinearizationOptions()")
+
+    def getContinuous(
+            self,
+            names: Optional[str | list[str]] = None,
+    ):
+        retval = super().getContinuous(names=names)
+        if self._simulated:
+            return retval
+
+        if isinstance(retval, dict):
+            retval2: dict = {}
+            for key, val in retval.items():
+                if np.isnan(val):
+                    retval2[key] = None
+                else:
+                    retval2[key] = str(val)
+            return retval2
+        if isinstance(retval, list):
+            retval3: list[str | None] = []
+            for val in retval:
+                if np.isnan(val):
+                    retval3.append(None)
+                else:
+                    retval3.append(str(val))
+            return retval3
+
+        raise ModelExecutionException("Invalid data!")
+
+    def getOutputs(
+            self,
+            names: Optional[str | list[str]] = None,
+    ):
+        retval = super().getOutputs(names=names)
+        if self._simulated:
+            return retval
+
+        if isinstance(retval, dict):
+            retval2: dict = {}
+            for key, val in retval.items():
+                if np.isnan(val):
+                    retval2[key] = None
+                else:
+                    retval2[key] = str(val)
+            return retval2
+        if isinstance(retval, list):
+            retval3: list[str | None] = []
+            for val in retval:
+                if np.isnan(val):
+                    retval3.append(None)
+                else:
+                    retval3.append(str(val))
+            return retval3
+
+        raise ModelExecutionException("Invalid data!")
+
 
 class ModelicaDoEABC(metaclass=abc.ABCMeta):
     """
@@ -2691,3 +2823,50 @@ def _prepare_structure_parameters(
                                       "pre-compiled binary of model.")
 
         return {}
+
+
+class ModelicaSystemCmd(ModelExecutionCmd):
+    # TODO: docstring
+
+    def __init__(
+            self,
+            runpath: pathlib.Path,
+            modelname: str,
+            timeout: float = 10.0,
+    ) -> None:
+        super().__init__(
+            runpath=runpath,
+            timeout=timeout,
+            cmd_prefix=[],
+            model_name=modelname,
+        )
+
+    def get_exe(self) -> pathlib.Path:
+        """Get the path to the compiled model executable."""
+        # TODO: move to the top
+        import platform
+
+        path_run = pathlib.Path(self._runpath)
+        if platform.system() == "Windows":
+            path_exe = path_run / f"{self._model_name}.exe"
+        else:
+            path_exe = path_run / self._model_name
+
+        if not path_exe.exists():
+            raise ModelicaSystemError(f"Application file path not found: {path_exe}")
+
+        return path_exe
+
+    def get_cmd(self) -> list:
+        """Get a list with the path to the executable and all command line args.
+
+        This can later be used as an argument for subprocess.run().
+        """
+
+        cmdl = [self.get_exe().as_posix()] + self.get_cmd_args()
+
+        return cmdl
+
+    def run(self):
+        cmd_definition = self.definition()
+        return cmd_definition.run()

OMPython/OMCSession.py

@@ -2154,3 +2154,11 @@ def omcpath_tempdir(self, tempdir_base: Optional[OMPathABC] = None) -> OMPathABC
 
     def sendExpression(self, expr: str, parsed: bool = True) -> Any:
         raise OMCSessionException(f"{self.__class__.__name__} does not uses an OMC server!")
+
+
+DummyPopen = DockerPopen
+OMCProcessLocal = OMCSessionLocal
+OMCProcessPort = OMCSessionPort
+OMCProcessDocker = OMCSessionDocker
+OMCProcessDockerContainer = OMCSessionDockerContainer
+OMCProcessWSL = OMCSessionWSL

OMPython/OMTypedParser.py

@@ -161,3 +161,6 @@ def om_parser_typed(string) -> Any:
     if len(res) == 0:
         return None
     return res[0]
+
+
+parseString = om_parser_typed

OMPython/__init__.py

@@ -23,6 +23,8 @@
     ModelicaDoERunner,
 
     doe_get_solutions,
+
+    ModelicaSystemCmd,
 )
 from OMPython.OMCSession import (
     OMPathABC,
@@ -47,6 +49,11 @@
 
     OMCSessionWSL,
     OMCSessionZMQ,
+
+    OMCProcessLocal,
+    OMCProcessPort,
+    OMCProcessDocker,
+    OMCProcessDockerContainer,
 )
 
 # global names imported if import 'from OMPython import *' is used
@@ -58,6 +65,7 @@
 
     'ModelicaSystem',
     'ModelicaSystemOMC',
+    'ModelicaSystemCmd',
     'ModelExecutionCmd',
     'ModelicaSystemDoE',
     'ModelicaDoEOMC',
@@ -87,4 +95,9 @@
 
     'OMCSessionWSL',
     'OMCSessionZMQ',
+
+    'OMCProcessLocal',
+    'OMCProcessPort',
+    'OMCProcessDocker',
+    'OMCProcessDockerContainer',
 ]

tests/test_ModelicaSystemRunner.py

@@ -39,7 +39,7 @@ def param():
 
 def test_runner(model_firstorder, param):
     # create a model using ModelicaSystem
-    mod = OMPython.ModelicaSystem()
+    mod = OMPython.ModelicaSystemOMC()
     mod.model(
         model_file=model_firstorder,
         model_name="M",