rename_party-test01(all) = changes

Author: syntron

OMPython/ModelicaSystem.py

@@ -142,31 +142,31 @@ def arg_set(
         """
 
         def override2str(
-                key: str,
-                val: str | bool | numbers.Number,
+                orkey: str,
+                orval: str | bool | numbers.Number,
         ) -> str:
             """
             Convert a value for 'override' to a string taking into account differences between Modelica and Python.
             """
             # check oval for any string representations of numbers (or bool) and convert these to Python representations
-            if isinstance(val, str):
+            if isinstance(orval, str):
                 try:
-                    val_evaluated = ast.literal_eval(val)
+                    val_evaluated = ast.literal_eval(orval)
                     if isinstance(val_evaluated, (numbers.Number, bool)):
-                        val = val_evaluated
+                        orval = val_evaluated
                 except (ValueError, SyntaxError):
                     pass
 
-            if isinstance(val, str):
-                val_str = val.strip()
-            elif isinstance(val, bool):
-                val_str = 'true' if val else 'false'
-            elif isinstance(val, numbers.Number):
-                val_str = str(val)
+            if isinstance(orval, str):
+                val_str = orval.strip()
+            elif isinstance(orval, bool):
+                val_str = 'true' if orval else 'false'
+            elif isinstance(orval, numbers.Number):
+                val_str = str(orval)
             else:
-                raise ModelExecutionException(f"Invalid value for override key {key}: {type(val)}")
+                raise ModelExecutionException(f"Invalid value for override key {orkey}: {type(orval)}")
 
-            return f"{key}={val_str}"
+            return f"{orkey}={val_str}"
 
         if not isinstance(key, str):
             raise ModelExecutionException(f"Invalid argument key: {repr(key)} (type: {type(key)})")
@@ -195,7 +195,7 @@ def override2str(
                                 f"(was: {repr(self._arg_override[okey])})")
 
                 if oval is not None:
-                    self._arg_override[okey] = override2str(key=okey, val=oval)
+                    self._arg_override[okey] = override2str(orkey=okey, orval=oval)
 
             argval = ','.join(sorted(self._arg_override.values()))
         elif val is None:
@@ -2822,7 +2822,9 @@ def _prepare_structure_parameters(
 
 
 class ModelicaSystemCmd(ModelExecutionCmd):
-    # TODO: docstring
+    """
+    Compatibility class; in the new version it is renamed as MOdelExecutionCmd.
+    """
 
     def __init__(
             self,

OMPython/OMCSession.py

@@ -59,6 +59,7 @@ def wait(self, timeout):
             pass
 
 
+# TODO: rename to OMSessionException
 class OMCSessionException(Exception):
     """
     Exception which is raised by any OMC* class.
@@ -71,6 +72,13 @@ class OMCSessionCmd:
     """
 
     def __init__(self, session: OMSessionABC, readonly: bool = False):
+        warnings.warn(
+            message="The class OMCSessionCMD is depreciated and will be removed in future versions; "
+                    "please use OMCSession*.sendExpression(...) instead!",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+
         if not isinstance(session, OMSessionABC):
             raise OMCSessionException("Invalid OMC process definition!")
         self._session = session
@@ -253,7 +261,7 @@ def getClassNames(self, className=None, recursive=False, qualified=False, sort=F
 # conditions. This is also the reason for OMPathABC, a simple base class to be used in ModelicaSystem* classes.
 # Reason: before Python 3.12, pathlib.PurePosixPath can not be derived from; therefore, OMPathABC is not possible
 if sys.version_info < (3, 12):
-    class OMPathCompatibility(pathlib.Path):
+    class _OMPathCompatibility(pathlib.Path):
         """
         Compatibility class for OMPathABC in Python < 3.12. This allows to run all code which uses OMPathABC (mainly
         ModelicaSystem) on these Python versions. There are remaining limitation as only local execution is possible.
@@ -264,8 +272,8 @@ def __new__(cls, *args, **kwargs):
             logger.warning("Python < 3.12 - using a version of class OMCPath "
                            "based on pathlib.Path for local usage only.")
 
-            if cls is OMPathCompatibility:
-                cls = OMPathCompatibilityWindows if os.name == 'nt' else OMPathCompatibilityPosix
+            if cls is _OMPathCompatibility:
+                cls = _OMPathCompatibilityWindows if os.name == 'nt' else _OMPathCompatibilityPosix
             self = cls._from_parts(args)
             if not self._flavour.is_supported:
                 raise NotImplementedError(f"cannot instantiate {cls.__name__} on your system")
@@ -277,22 +285,20 @@ def size(self) -> int:
             """
             return self.stat().st_size
 
-    class OMPathCompatibilityPosix(pathlib.PosixPath, OMPathCompatibility):
+    class _OMPathCompatibilityPosix(pathlib.PosixPath, _OMPathCompatibility):
         """
         Compatibility class for OMCPath on Posix systems (Python < 3.12)
         """
 
-    class OMPathCompatibilityWindows(pathlib.WindowsPath, OMPathCompatibility):
+    class _OMPathCompatibilityWindows(pathlib.WindowsPath, _OMPathCompatibility):
         """
         Compatibility class for OMCPath on Windows systems (Python < 3.12)
         """
 
-    OMPathABC = OMPathCompatibility
-    OMCPath = OMPathCompatibility
-    OMPathRunnerABC = OMPathCompatibility
-    OMPathRunnerLocal = OMPathCompatibility
-    OMPathRunnerBash = OMPathCompatibility
-
+    OMPathABC = _OMPathCompatibility
+    OMPathRunnerABC = _OMPathCompatibility
+    OMPathRunnerLocal = _OMPathCompatibility
+    OMPathRunnerBash = _OMPathCompatibility
 else:
     class OMPathABC(pathlib.PurePosixPath, metaclass=abc.ABCMeta):
         """
@@ -427,7 +433,7 @@ def is_absolute(self) -> bool:
             """
             Check if the path is an absolute path. Special handling to differentiate Windows and Posix definitions.
             """
-            if isinstance(self._session, OMCSessionLocal) and platform.system() == 'Windows':
+            if self._session.model_execution_windows and self._session.model_execution_local:
                 return pathlib.PureWindowsPath(self.as_posix()).is_absolute()
             return pathlib.PurePosixPath(self.as_posix()).is_absolute()
 
@@ -618,7 +624,7 @@ def resolve(self, strict: bool = False) -> OMPathABC:
 
         def size(self) -> int:
             """
-            Get the size of the file in bytes - implementation baseon on pathlib.Path.
+            Get the size of the file in bytes - implementation based on pathlib.Path.
             """
             if not self.is_file():
                 raise OMCSessionException(f"Path {self.as_posix()} is not a file!")
@@ -776,7 +782,7 @@ def resolve(self, strict: bool = False) -> OMPathABC:
 
         def size(self) -> int:
             """
-            Get the size of the file in bytes - implementation baseon on pathlib.Path.
+            Get the size of the file in bytes - implementation based on pathlib.Path.
             """
             if not self.is_file():
                 raise OMCSessionException(f"Path {self.as_posix()} is not a file!")
@@ -790,7 +796,7 @@ def size(self) -> int:
                 try:
                     return int(stdout)
                 except ValueError as exc:
-                    raise OSError(f"Invalid return value for filesize ({self.as_posix()}): {stdout}") from exc
+                    raise OSError(f"Invalid return value for file size ({self.as_posix()}): {stdout}") from exc
             else:
                 raise OSError(f"Cannot get size for file {self.as_posix()}")
 
@@ -1225,26 +1231,6 @@ def omcpath_tempdir(self, tempdir_base: Optional[OMPathABC] = None) -> OMPathABC
 
         return self._tempdir(tempdir_base=tempdir_base)
 
-    @staticmethod
-    def _tempdir(tempdir_base: OMPathABC) -> OMPathABC:
-        names = [str(uuid.uuid4()) for _ in range(100)]
-
-        tempdir: Optional[OMPathABC] = None
-        for name in names:
-            # create a unique temporary directory name
-            tempdir = tempdir_base / name
-
-            if tempdir.exists():
-                continue
-
-            tempdir.mkdir(parents=True, exist_ok=False)
-            break
-
-        if tempdir is None or not tempdir.is_dir():
-            raise OMCSessionException("Cannot create a temporary directory!")
-
-        return tempdir
-
     def execute(self, command: str):
         warnings.warn(
             message="This function is depreciated and will be removed in future versions; "
@@ -1259,7 +1245,7 @@ def sendExpression(self, expr: str, parsed: bool = True) -> Any:
         """
         Send an expression to the OMC server and return the result.
 
-        The complete error handling of the OMC result is done within this method using '"getMessagesStringInternal()'.
+        The complete error handling of the OMC result is done within this method using 'getMessagesStringInternal()'.
         Caller should only check for OMCSessionException.
         """
 
@@ -1544,6 +1530,8 @@ def __init__(
             raise OMCSessionException("Invalid definition of the OMC process!")
         self.omc_process = omc_process
 
+        super().__init__(timeout=timeout)
+
     def __del__(self):
         if hasattr(self, 'omc_process'):
             del self.omc_process
@@ -2086,16 +2074,16 @@ def _omc_port_get(self) -> str:
         return port
 
 
-class OMSessionRunner(OMSessionABC):
+class OMSessionRunnerABC(OMSessionABC, metaclass=abc.ABCMeta):
     """
     Implementation based on OMSessionABC without any use of an OMC server.
     """
 
     def __init__(
             self,
+            ompath_runner: Type[OMPathRunnerABC],
             timeout: float = 10.0,
             version: str = "1.27.0",
-            ompath_runner: Type[OMPathRunnerABC] = OMPathRunnerLocal,
             cmd_prefix: Optional[list[str]] = None,
             model_execution_local: bool = True,
     ) -> None:
@@ -2110,8 +2098,27 @@ def __init__(
         if cmd_prefix is not None:
             self._cmd_prefix = cmd_prefix
 
-        # TODO: some checking?!
-        # if ompath_runner == Type[OMPathRunnerBash]:
+
+class OMSessionRunner(OMSessionRunnerABC):
+    """
+    Implementation based on OMSessionABC without any use of an OMC server.
+    """
+
+    def __init__(
+            self,
+            ompath_runner: Type[OMPathRunnerABC] = OMPathRunnerLocal,
+            timeout: float = 10.0,
+            version: str = "1.27.0",
+            cmd_prefix: Optional[list[str]] = None,
+            model_execution_local: bool = True,
+    ) -> None:
+        super().__init__(
+            ompath_runner=ompath_runner,
+            timeout=timeout,
+            version=version,
+            cmd_prefix=cmd_prefix,
+            model_execution_local=model_execution_local,
+        )
 
     def __post_init__(self) -> None:
         """

OMPython/__init__.py

@@ -78,8 +78,6 @@
 
     'OMSessionRunner',
 
-    'OMCSessionABC',
-
     'doe_get_solutions',
 
     'OMCSessionCmd',