Add Status.exists()

Author: barneygale

Doc/library/pathlib.rst

@@ -1953,6 +1953,14 @@ The :mod:`pathlib.types` module provides types for static type checking.
    :attr:`Path.status <pathlib.Path.status>` attribute. Implementations may
    return cached results from their methods.
 
+   .. method:: exists(*, follow_symlinks=True)
+
+      Return ``True`` if this path status is for an existing file or
+      directory, or any other kind of file.
+
+      If *follow_symlinks* is ``False``, return ``True`` for symlinks without
+      checking if their targets exist.
+
    .. method:: is_dir(*, follow_symlinks=True)
 
       Return ``True`` if this status is a directory or a symbolic link

Lib/pathlib/_local.py

@@ -89,6 +89,12 @@ def _get_mode(self, *, follow_symlinks=True):
                 self._mode = [mode, mode]
         return mode
 
+    def exists(self, *, follow_symlinks=True):
+        """
+        Whether this path exists
+        """
+        return self._get_mode(follow_symlinks=follow_symlinks) > 0
+
     def is_dir(self, *, follow_symlinks=True):
         """
         Whether this path is a directory.
@@ -118,6 +124,17 @@ def __init__(self, path, entry):
     def __repr__(self):
         return self._repr
 
+    def exists(self, *, follow_symlinks=True):
+        """
+        Whether this path exists
+        """
+        if follow_symlinks:
+            try:
+                self._entry.stat()
+            except FileNotFoundError:
+                return False
+        return True
+
     def is_dir(self, *, follow_symlinks=True):
         """
         Whether this path is a directory.

Lib/pathlib/types.py

@@ -27,6 +27,7 @@ class Status(Protocol):
     """Protocol for path statuses, which support querying the file type.
     Methods may return cached results.
     """
+    def exists(self, *, follow_symlinks: bool = True) -> bool: ...
     def is_dir(self, *, follow_symlinks: bool = True) -> bool: ...
     def is_file(self, *, follow_symlinks: bool = True) -> bool: ...
     def is_symlink(self) -> bool: ...

Lib/test/test_pathlib/test_pathlib.py

@@ -1769,6 +1769,22 @@ def test_symlink_to_unsupported(self):
         with self.assertRaises(pathlib.UnsupportedOperation):
             q.symlink_to(p)
 
+    def test_status_exists_caching(self):
+        p = self.cls(self.base)
+        q = p / 'myfile'
+        self.assertFalse(q.status.exists())
+        self.assertFalse(q.status.exists(follow_symlinks=False))
+        q.write_text('hullo')
+        self.assertFalse(q.status.exists())
+        self.assertFalse(q.status.exists(follow_symlinks=False))
+
+        q = p / 'myfile'  # same path, new instance.
+        self.assertTrue(q.status.exists())
+        self.assertTrue(q.status.exists(follow_symlinks=False))
+        q.unlink()
+        self.assertTrue(q.status.exists())
+        self.assertTrue(q.status.exists(follow_symlinks=False))
+
     def test_status_is_dir_caching(self):
         p = self.cls(self.base)
         q = p / 'mydir'

Lib/test/test_pathlib/test_pathlib_abc.py

@@ -1876,13 +1876,23 @@ def test_iterdir_status(self):
         for child in p.iterdir():
             entry = child.status
             self.assertIsInstance(entry, Status)
+            self.assertTrue(entry.exists(follow_symlinks=False))
             self.assertEqual(entry.is_dir(follow_symlinks=False),
                              child.is_dir(follow_symlinks=False))
             self.assertEqual(entry.is_file(follow_symlinks=False),
                              child.is_file(follow_symlinks=False))
             self.assertEqual(entry.is_symlink(),
                              child.is_symlink())
-            if child.name != 'brokenLinkLoop':
+            if child.name == 'brokenLink':
+                self.assertFalse(entry.exists())
+                self.assertFalse(entry.is_dir())
+                self.assertFalse(entry.is_file())
+            elif child.name == 'brokenLinkLoop':
+                self.assertRaises(OSError, entry.exists)
+                self.assertRaises(OSError, entry.is_dir)
+                self.assertRaises(OSError, entry.is_file)
+            else:
+                self.assertTrue(entry.exists())
                 self.assertEqual(entry.is_dir(), child.is_dir())
                 self.assertEqual(entry.is_file(), child.is_file())
 
@@ -2010,6 +2020,27 @@ def test_rglob_windows(self):
         self.assertEqual(set(p.rglob("FILEd")), { P(self.base, "dirC/dirD/fileD") })
         self.assertEqual(set(p.rglob("*\\")), { P(self.base, "dirC/dirD/") })
 
+    def test_exists(self):
+        p = self.cls(self.base)
+        self.assertTrue(p.status.exists())
+        self.assertTrue((p / 'dirA').status.exists())
+        self.assertTrue((p / 'dirA').status.exists(follow_symlinks=False))
+        self.assertTrue((p / 'fileA').status.exists())
+        self.assertTrue((p / 'fileA').status.exists(follow_symlinks=False))
+        self.assertFalse((p / 'non-existing').status.exists())
+        self.assertFalse((p / 'non-existing').status.exists(follow_symlinks=False))
+        if self.can_symlink:
+            self.assertTrue((p / 'linkA').status.exists())
+            self.assertTrue((p / 'linkA').status.exists(follow_symlinks=False))
+            self.assertTrue((p / 'linkB').status.exists())
+            self.assertTrue((p / 'linkB').status.exists(follow_symlinks=True))
+            self.assertFalse((p / 'brokenLink').status.exists())
+            self.assertTrue((p / 'brokenLink').status.exists(follow_symlinks=False))
+        self.assertFalse((p / 'fileA\udfff').status.exists())
+        self.assertFalse((p / 'fileA\udfff').status.exists(follow_symlinks=False))
+        self.assertFalse((p / 'fileA\x00').status.exists())
+        self.assertFalse((p / 'fileA\x00').status.exists(follow_symlinks=False))
+
     def test_status_is_dir(self):
         p = self.cls(self.base)
         self.assertTrue((p / 'dirA').status.is_dir())