[OMCPath] implementation version 2

* differentiate between
  * OMCPathReal => using OMC and
  * OMCPathLocal => using pathlibPath
* OMCPathLocal uses the same strategy as pathlib.Path to differentiate
  * Posix or
  * Windows
* align function definitions

* for Python < 3.12 only local usage is allowed (as before!)
* only change: use OMCPath instead of pathlib.Path; this should be done to
  allow usage of OMCPathReal for docker or WSL

Author: syntron

OMPython/OMCSession.py

@@ -34,6 +34,7 @@
  CONDITIONS OF OSMC-PL.
 """
 
+import abc
 import io
 import json
 import logging
@@ -268,7 +269,54 @@ def getClassNames(self, className=None, recursive=False, qualified=False, sort=F
         return self._ask(question='getClassNames', opt=opt)
 
 
-class OMCPathReal(pathlib.PurePosixPath):
+class OMCPath(pathlib.PurePath, metaclass=abc.ABCMeta):
+    """
+    Define the interface for OMCPath
+    """
+
+    def __init__(self, *path):
+        super().__init__(*path)
+
+    # functions from pathlib.Path
+    def with_segments(self, *pathsegments):
+        raise NotImplementedError
+
+    def is_file(self, *, follow_symlinks=True):
+        raise NotImplementedError
+
+    def is_dir(self, *, follow_symlinks=True):
+        raise NotImplementedError
+
+    def read_text(self, encoding=None, errors=None, newline=None):
+        raise NotImplementedError
+
+    def write_text(self, data: str, encoding=None, errors=None, newline=None):
+        raise NotImplementedError
+
+    def mkdir(self, mode=0o777, parents=False, exist_ok=False):
+        raise NotImplementedError
+
+    def cwd(self):
+        raise NotImplementedError
+
+    def unlink(self, missing_ok: bool = False):
+        raise NotImplementedError
+
+    def resolve(self, strict: bool = False):
+        raise NotImplementedError
+
+    def absolute(self):
+        raise NotImplementedError
+
+    def exists(self, *, follow_symlinks=True):
+        raise NotImplementedError
+
+    # additional function specific for OMCPath
+    def size(self) -> int:
+        raise NotImplementedError
+
+
+class OMCPathReal(OMCPath, pathlib.PurePosixPath):
     """
     Implementation of a basic Path object which uses OMC as backend. The connection to OMC is provided via a
     OMCSessionZMQ session object.
@@ -286,27 +334,27 @@ def with_segments(self, *pathsegments):
         """
         return type(self)(*pathsegments, session=self._session)
 
-    def is_file(self) -> bool:
+    def is_file(self, *, follow_symlinks=True):
         """
         Check if the path is a regular file.
         """
         return self._session.sendExpression(f'regularFileExists("{self.as_posix()}")')
 
-    def is_dir(self) -> bool:
+    def is_dir(self, *, follow_symlinks=True):
         """
         Check if the path is a directory.
         """
         return self._session.sendExpression(f'directoryExists("{self.as_posix()}")')
 
-    def read_text(self, encoding=None, errors=None) -> str:
+    def read_text(self, encoding=None, errors=None, newline=None):
         """
         Read the content of the file represented by this path as text.
 
         The additional arguments `encoding` and `errors` are only defined for compatibility with Path() definitions.
         """
         return self._session.sendExpression(f'readFile("{self.as_posix()}")')
 
-    def write_text(self, data: str, encoding=None, errors=None, newline=None) -> bool:
+    def write_text(self, data: str, encoding=None, errors=None, newline=None):
         """
         Write text data to the file represented by this path.
 
@@ -335,9 +383,9 @@ def cwd(self):
         Returns the current working directory as an OMCPath object.
         """
         cwd_str = self._session.sendExpression('cd()')
-        return OMCPath(cwd_str, session=self._session)
+        return self.__class__(cwd_str, session=self._session)
 
-    def unlink(self, missing_ok: bool = False) -> bool:
+    def unlink(self, missing_ok: bool = False):
         """
         Unlink (delete) the file or directory represented by this path.
         """
@@ -346,7 +394,7 @@ def unlink(self, missing_ok: bool = False) -> bool:
             raise FileNotFoundError(f"Cannot delete file {self.as_posix()} - it does not exists!")
         return res
 
-    def resolve(self, strict: bool = False) -> OMCPath:
+    def resolve(self, strict: bool = False):
         """
         Resolve the path to an absolute path. This is done based on available OMC functions.
         """
@@ -386,14 +434,14 @@ def _omc_resolve(self, pathstr: str) -> OMCPath:
 
         return omcpath_resolved
 
-    def absolute(self) -> OMCPath:
+    def absolute(self):
         """
         Resolve the path to an absolute path. This is done by calling resolve() as it is the best we can do
         using OMC functions.
         """
         return self.resolve(strict=True)
 
-    def exists(self) -> bool:
+    def exists(self, *, follow_symlinks=True):
         """
         Semi replacement for pathlib.Path.exists().
         """
@@ -413,22 +461,39 @@ def size(self) -> int:
         raise OMCSessionException(f"Error reading file size for path {self.as_posix()}!")
 
 
-if sys.version_info < (3, 12):
-    warnings.warn(
-        message="Python < 3.12 - using a limited compatibility class as OMCPath replacement.",
-        category=DeprecationWarning,
-        stacklevel=1,
-    )
+class OMCPathLocal(OMCPath, pathlib.Path):
+    """
+    Compatibility class for OMCPath in Python < 3.12. This allows to run all code which uses OMCPath (mainly
+    ModelicaSystem) on these Python versions. There is one remaining limitation: only OMCProcessLocal will work as
+    OMCPathCompatibility is based on the standard pathlib.Path implementation.
+    """
+
+    # modified copy of pathlib.Path.__new__() definition
+    def __new__(cls, *args, **kwargs):
+        logger.warning("Python < 3.12 - using a limited version of class OMCPath.")
+
+        if cls is OMCPathLocal:
+            cls = OMCPathLocalWindows if os.name == 'nt' else OMCPathLocalPosix
+        # noinspection PyUnresolvedReferences
+        self = cls._from_parts(args)
+        if not self._flavour.is_supported:
+            raise NotImplementedError("cannot instantiate %r on your system"
+                                      % (cls.__name__,))
+        return self
+
+    def size(self) -> int:
+        """
+        Needed compatibility function to have the same interface as OMCPathReal
+        """
+        return self.stat().st_size
 
-    class OMCPathCompatibility(pathlib.PosixPath):
 
-        def size(self) -> int:
-            return self.stat().st_size
+class OMCPathLocalPosix(pathlib.PosixPath, OMCPathLocal):
+    pass
 
-    OMCPath = OMCPathCompatibility  # noqa: F811
 
-else:
-    OMCPath = OMCPathReal
+class OMCPathLocalWindows(pathlib.WindowsPath, OMCPathLocal):
+    pass
 
 
 class OMCSessionZMQ:
@@ -490,21 +555,29 @@ def omcpath(self, *path) -> OMCPath:
         Create an OMCPath object based on the given path segments and the current OMC session.
         """
 
-        # fallback solution for Python < 3.12; a modified pathlib.Path object is used as OMCPath replacement
+        if isinstance(self.omc_process, OMCProcessLocal):
+            return OMCPathLocal(*path)
+
         if sys.version_info < (3, 12):
-            # noinspection PyArgumentList
-            return OMCPath(*path)
-        else:
-            return OMCPath(*path, session=self)
+            raise OMCSessionException("OMCPath for non-local usage is only supported for Python >= 3.12!")
+
+        return OMCPathReal(*path, session=self)
 
-    def omcpath_tempdir(self) -> OMCPath:
+    def omcpath_tempdir(self, tempdir_base: Optional[OMCPath] = None) -> OMCPath:
         """
-        Get a temporary directory using OMC.
+        Get a temporary directory using OMC. It is our own implementation as non-local usage relies on OMC to run all
+        filesystem related access.
         """
         names = [str(uuid.uuid4()) for _ in range(100)]
 
-        tempdir_str = self.sendExpression("getTempDirectoryPath()")
-        tempdir_base = self.omcpath(tempdir_str)
+        if tempdir_base is None:
+            # shortcut for local usage
+            if isinstance(self.omc_process, OMCProcessLocal):
+                tempdir_str = tempfile.gettempdir()
+            else:
+                tempdir_str = self.sendExpression("getTempDirectoryPath()")
+            tempdir_base = self.omcpath(tempdir_str)
+
         tempdir: Optional[OMCPath] = None
         for name in names:
             # create a unique temporary directory name