Make fake filesystem, fake os and fake os.path respect additional_skip_names

Author: sassanh

pyfakefs/fake_os.py

@@ -54,6 +54,7 @@
 from pyfakefs.fake_scandir import scandir, walk, ScanDirIter
 from pyfakefs.helpers import (
     FakeStatResult,
+    is_called_from_skipped_module,
     is_int_type,
     is_byte_string,
     make_string_path,
@@ -1409,27 +1410,36 @@ def __getattr__(self, name: str) -> Any:
         return getattr(self.os_module, name)
 
 
-if sys.version_info > (3, 10):
+def handle_original_call(f: Callable) -> Callable:
+    """Decorator used for real pathlib Path methods to ensure that
+    real os functions instead of faked ones are used.
+    Applied to all non-private methods of `FakeOsModule`."""
 
-    def handle_original_call(f: Callable) -> Callable:
-        """Decorator used for real pathlib Path methods to ensure that
-        real os functions instead of faked ones are used.
-        Applied to all non-private methods of `FakeOsModule`."""
+    @functools.wraps(f)
+    def wrapped(*args, **kwargs):
+        should_use_original = FakeOsModule.use_original
 
-        @functools.wraps(f)
-        def wrapped(*args, **kwargs):
-            if FakeOsModule.use_original:
-                # remove the `self` argument for FakeOsModule methods
-                if args and isinstance(args[0], FakeOsModule):
-                    args = args[1:]
-                return getattr(os, f.__name__)(*args, **kwargs)
-            return f(*args, **kwargs)
+        if not should_use_original and args:
+            self = args[0]
+            if self.filesystem.patcher:
+                skip_names = self.filesystem.patcher._skip_names
+                if is_called_from_skipped_module(skip_names=skip_names):
+                    should_use_original = True
 
-        return wrapped
+        if should_use_original:
+            # remove the `self` argument for FakeOsModule methods
+            if args and isinstance(args[0], FakeOsModule):
+                args = args[1:]
+            return getattr(os, f.__name__)(*args, **kwargs)
 
-    for name, fn in inspect.getmembers(FakeOsModule, inspect.isfunction):
-        if not fn.__name__.startswith("_"):
-            setattr(FakeOsModule, name, handle_original_call(fn))
+        return f(*args, **kwargs)
+
+    return wrapped
+
+
+for name, fn in inspect.getmembers(FakeOsModule, inspect.isfunction):
+    if not fn.__name__.startswith("_"):
+        setattr(FakeOsModule, name, handle_original_call(fn))
 
 
 @contextmanager

pyfakefs/fake_path.py

@@ -15,6 +15,8 @@
 """Faked ``os.path`` module replacement. See ``fake_filesystem`` for usage."""
 
 import errno
+import functools
+import inspect
 import os
 import sys
 from stat import (
@@ -23,6 +25,7 @@
 )
 from types import ModuleType
 from typing import (
+    Callable,
     List,
     Optional,
     Union,
@@ -36,6 +39,7 @@
 )
 
 from pyfakefs.helpers import (
+    is_called_from_skipped_module,
     make_string_path,
     to_string,
     matching_string,
@@ -536,3 +540,34 @@ def _isdir(self, path: AnyStr) -> bool:
         def __getattr__(self, name: str) -> Any:
             """Forwards any non-faked calls to the real nt module."""
             return getattr(self.nt_module, name)
+
+
+def handle_original_call(f: Callable) -> Callable:
+    """Decorator used for real pathlib Path methods to ensure that
+    real os functions instead of faked ones are used.
+    Applied to all non-private methods of `FakePathModule`."""
+
+    @functools.wraps(f)
+    def wrapped(*args, **kwargs):
+        if args:
+            self = args[0]
+            should_use_original = self.os.use_original
+            if not should_use_original and self.filesystem.patcher:
+                skip_names = self.filesystem.patcher._skip_names
+                if is_called_from_skipped_module(skip_names=skip_names):
+                    should_use_original = True
+
+            if should_use_original:
+                # remove the `self` argument for FakePathModule methods
+                if args and isinstance(args[0], FakePathModule):
+                    args = args[1:]
+                return getattr(os.path, f.__name__)(*args, **kwargs)
+
+        return f(*args, **kwargs)
+
+    return wrapped
+
+
+for name, fn in inspect.getmembers(FakePathModule, inspect.isfunction):
+    if not fn.__name__.startswith("_"):
+        setattr(FakePathModule, name, handle_original_call(fn))

pyfakefs/fake_pathlib.py

@@ -47,7 +47,7 @@
 from pyfakefs.fake_filesystem import FakeFilesystem
 from pyfakefs.fake_open import fake_open
 from pyfakefs.fake_os import FakeOsModule, use_original_os
-from pyfakefs.helpers import IS_PYPY
+from pyfakefs.helpers import IS_PYPY, is_called_from_skipped_module
 
 
 def init_module(filesystem):
@@ -92,6 +92,18 @@ def init_module(filesystem):
 def _wrap_strfunc(strfunc):
     @functools.wraps(strfunc)
     def _wrapped(pathobj, *args, **kwargs):
+        should_use_original = False
+        if pathobj.filesystem.patcher:
+            skip_names = pathobj.filesystem.patcher._skip_names
+            if is_called_from_skipped_module(skip_names=skip_names):
+                should_use_original = True
+
+        if should_use_original:
+            return getattr(pathobj._original_accessor, strfunc.__name__)(
+                str(pathobj),
+                *args,
+                **kwargs,
+            )
         return strfunc(pathobj.filesystem, str(pathobj), *args, **kwargs)
 
     return staticmethod(_wrapped)
@@ -100,6 +112,18 @@ def _wrapped(pathobj, *args, **kwargs):
 def _wrap_binary_strfunc(strfunc):
     @functools.wraps(strfunc)
     def _wrapped(pathobj1, pathobj2, *args):
+        should_use_original = False
+        if pathobj1.filesystem.patcher:
+            skip_names = pathobj1.filesystem.patcher._skip_names
+            if is_called_from_skipped_module(skip_names=skip_names):
+                should_use_original = True
+
+        if should_use_original:
+            return getattr(pathobj1._original_accessor, strfunc.__name__)(
+                str(pathobj1),
+                str(pathobj2),
+                *args,
+            )
         return strfunc(pathobj1.filesystem, str(pathobj1), str(pathobj2), *args)
 
     return staticmethod(_wrapped)
@@ -108,6 +132,18 @@ def _wrapped(pathobj1, pathobj2, *args):
 def _wrap_binary_strfunc_reverse(strfunc):
     @functools.wraps(strfunc)
     def _wrapped(pathobj1, pathobj2, *args):
+        should_use_original = False
+        if pathobj2.filesystem.patcher:
+            skip_names = pathobj2.filesystem.patcher._skip_names
+            if is_called_from_skipped_module(skip_names=skip_names):
+                should_use_original = True
+
+        if should_use_original:
+            return getattr(pathobj2._original_accessor, strfunc.__name__)(
+                str(pathobj2),
+                str(pathobj1),
+                *args,
+            )
         return strfunc(pathobj2.filesystem, str(pathobj2), str(pathobj1), *args)
 
     return staticmethod(_wrapped)
@@ -573,6 +609,7 @@ def _from_parsed_parts(cls, drv, root, parts):
 
         def _init(self, template=None):
             """Initializer called from base class."""
+            self._original_accessor = self._accessor
             # only needed until Python 3.10
             self._accessor = _fake_accessor
             # only needed until Python 3.8

pyfakefs/helpers.py

@@ -18,7 +18,9 @@
 import platform
 import stat
 import sys
+import sysconfig
 import time
+import traceback
 from collections import namedtuple
 from copy import copy
 from stat import S_IFLNK
@@ -38,6 +40,13 @@
 PERM_DEF_FILE = 0o666  # Default permission bits (regular file)
 PERM_ALL = 0o7777  # All permission bits.
 
+STDLIB_PATH = os.path.realpath(sysconfig.get_path("stdlib"))
+PYFAKEFS_PATH = os.path.dirname(__file__)
+PYFAKEFS_TEST_PATHS = [
+    os.path.join(PYFAKEFS_PATH, "tests"),
+    os.path.join(PYFAKEFS_PATH, "pytest_tests"),
+]
+
 _OpenModes = namedtuple(
     "_OpenModes",
     "must_exist can_read can_write truncate append must_not_exist",
@@ -426,3 +435,42 @@ def getvalue(self) -> bytes:
 
     def putvalue(self, value: bytes) -> None:
         self._bytestream.write(value)
+
+
+def is_called_from_skipped_module(skip_names: list) -> bool:
+    stack = traceback.extract_stack()
+    from_open_code = (
+        sys.version_info >= (3, 12)
+        and stack[0].name == "open_code"
+        and stack[0].line == "return self._io_module.open_code(path)"
+    )
+
+    caller_filename = next(
+        (
+            frame.filename
+            for frame in stack[::-1]
+            if not frame.filename.startswith("<frozen importlib")
+            and not frame.filename.startswith(STDLIB_PATH)
+            and (
+                not frame.filename.startswith(PYFAKEFS_PATH)
+                or any(
+                    frame.filename.startswith(test_path)
+                    for test_path in PYFAKEFS_TEST_PATHS
+                )
+            )
+        ),
+        None,
+    )
+
+    if caller_filename:
+        caller_module_name = os.path.splitext(caller_filename)[0]
+        caller_module_name = caller_module_name.replace(os.sep, ".")
+
+        if from_open_code or any(
+            [
+                caller_module_name == sn or caller_module_name.endswith("." + sn)
+                for sn in skip_names
+            ]
+        ):
+            return True
+    return False

pyfakefs/tests/fake_pathlib_test.py

@@ -33,6 +33,7 @@
 from pyfakefs.fake_filesystem import OSType
 from pyfakefs.helpers import IS_PYPY, is_root
 from pyfakefs.tests.skipped_pathlib import (
+    check_exists_pathlib,
     read_bytes_pathlib,
     read_pathlib,
     read_text_pathlib,
@@ -1336,6 +1337,9 @@ def test_read_bytes_in_skipped_module(self):
         contents = read_bytes_pathlib("skipped_pathlib.py")
         self.assertTrue(contents.startswith(b"# Licensed under the Apache License"))
 
+    def test_exists(self):
+        self.assertTrue(check_exists_pathlib())
+
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)

pyfakefs/tests/skipped_pathlib.py

@@ -29,6 +29,10 @@ def read_bytes_pathlib(file_name):
     return (Path(__file__).parent / file_name).read_bytes()
 
 
+def check_exists_pathlib():
+    return os.path.exists(__file__) and Path(__file__).exists()
+
+
 def read_open(file_name):
     with open(os.path.join(os.path.dirname(__file__), file_name)) as f:
         return f.read()