Add parent_mode parameter to pathlib.Path.mkdir

- Add parent_mode parameter to Path.mkdir() for specifying intermediate
  directory permissions when parents=True
- Maintain pathlib's independence by using recursive implementation
  rather than delegating to os.makedirs
- Add comprehensive tests including umask behavior verification
- Update documentation and whatsnew entries
- Provides consistency with os.makedirs parent_mode parameter

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: gpshead

Doc/library/pathlib.rst

@@ -1492,7 +1492,7 @@ Creating files and directories
       :meth:`~Path.write_bytes` methods are often used to create files.
 
 
-.. method:: Path.mkdir(mode=0o777, parents=False, exist_ok=False)
+.. method:: Path.mkdir(mode=0o777, parents=False, exist_ok=False, *, parent_mode=None)
 
    Create a new directory at this given path.  If *mode* is given, it is
    combined with the process's ``umask`` value to determine the file mode
@@ -1503,6 +1503,11 @@ Creating files and directories
    as needed; they are created with the default permissions without taking
    *mode* into account (mimicking the POSIX ``mkdir -p`` command).
 
+   If *parent_mode* is not ``None``, it will be used as the mode for any
+   newly-created intermediate-level directories when *parents* is true.
+   Otherwise, intermediate directories are created with the default
+   permissions (respecting umask).
+
    If *parents* is false (the default), a missing parent raises
    :exc:`FileNotFoundError`.
 
@@ -1516,6 +1521,9 @@ Creating files and directories
    .. versionchanged:: 3.5
       The *exist_ok* parameter was added.
 
+   .. versionadded:: next
+      The *parent_mode* parameter.
+
 
 .. method:: Path.symlink_to(target, target_is_directory=False)
 

Doc/whatsnew/3.15.rst

@@ -364,7 +364,7 @@ os
 * :func:`os.makedirs` function now has a *parent_mode* parameter that allows
   specifying the mode for intermediate directories. This can be used to match
   the behavior from Python 3.6 and earlier by passing ``parent_mode=mode``.
-  (Contributed by Zackery Spytz in :gh:`86533`.)
+  (Contributed by Zackery Spytz and Gregory P. Smith in :gh:`86533`.)
 
 
 os.path
@@ -550,6 +550,10 @@ http.server
 pathlib
 -------
 
+* :meth:`pathlib.Path.mkdir` now has a *parent_mode* parameter that allows
+  specifying the mode for intermediate directories when ``parents=True``.
+  (Contributed by Gregory P. Smith in :gh:`86533`.)
+
 * Removed deprecated :meth:`!pathlib.PurePath.is_reserved`.
   Use :func:`os.path.isreserved` to detect reserved paths on Windows.
   (Contributed by Nikita Sobolev in :gh:`133875`.)

Lib/pathlib/__init__.py

@@ -997,7 +997,7 @@ def touch(self, mode=0o666, exist_ok=True):
         fd = os.open(self, flags, mode)
         os.close(fd)
 
-    def mkdir(self, mode=0o777, parents=False, exist_ok=False):
+    def mkdir(self, mode=0o777, parents=False, exist_ok=False, *, parent_mode=None):
         """
         Create a new directory at this given path.
         """
@@ -1006,7 +1006,10 @@ def mkdir(self, mode=0o777, parents=False, exist_ok=False):
         except FileNotFoundError:
             if not parents or self.parent == self:
                 raise
-            self.parent.mkdir(parents=True, exist_ok=True)
+            if parent_mode is not None:
+                self.parent.mkdir(mode=parent_mode, parents=True, exist_ok=True, parent_mode=parent_mode)
+            else:
+                self.parent.mkdir(parents=True, exist_ok=True)
             self.mkdir(mode, parents=False, exist_ok=exist_ok)
         except OSError:
             # Cannot rely on checking for EEXIST, since the operating system

Lib/test/test_pathlib/test_pathlib.py

@@ -2489,6 +2489,87 @@ def my_mkdir(path, mode=0o777):
                 self.assertNotIn(str(p12), concurrently_created)
             self.assertTrue(p.exists())
 
+    @unittest.skipIf(
+        is_emscripten or is_wasi,
+        "umask is not implemented on Emscripten/WASI."
+    )
+    def test_mkdir_parents_umask(self):
+        # Test that parent directories respect umask when parent_mode is not set
+        p = self.cls(self.base, 'umasktest', 'child')
+        self.assertFalse(p.exists())
+        if os.name != 'nt':
+            old_mask = os.umask(0o002)
+            try:
+                p.mkdir(0o755, parents=True)
+                self.assertTrue(p.exists())
+                # Leaf directory gets the specified mode
+                self.assertEqual(stat.S_IMODE(p.stat().st_mode), 0o755)
+                # Parent directory respects umask (0o777 & ~0o002 = 0o775)
+                self.assertEqual(stat.S_IMODE(p.parent.stat().st_mode), 0o775)
+            finally:
+                os.umask(old_mask)
+
+    def test_mkdir_with_parent_mode(self):
+        # Test the parent_mode parameter
+        p = self.cls(self.base, 'newdirPM', 'subdirPM')
+        self.assertFalse(p.exists())
+        if os.name != 'nt':
+            # Specify different modes for parent and leaf directories
+            p.mkdir(0o755, parents=True, parent_mode=0o750)
+            self.assertTrue(p.exists())
+            self.assertTrue(p.is_dir())
+            # Leaf directory gets the mode parameter
+            self.assertEqual(stat.S_IMODE(p.stat().st_mode), 0o755)
+            # Parent directory gets the parent_mode parameter
+            self.assertEqual(stat.S_IMODE(p.parent.stat().st_mode), 0o750)
+
+    def test_mkdir_parent_mode_deep_hierarchy(self):
+        # Test parent_mode with deep directory hierarchy
+        p = self.cls(self.base, 'level1PM', 'level2PM', 'level3PM')
+        self.assertFalse(p.exists())
+        if os.name != 'nt':
+            p.mkdir(0o755, parents=True, parent_mode=0o700)
+            self.assertTrue(p.exists())
+            # Check that all parent directories have parent_mode
+            level1 = self.cls(self.base, 'level1PM')
+            level2 = level1 / 'level2PM'
+            self.assertEqual(stat.S_IMODE(level1.stat().st_mode), 0o700)
+            self.assertEqual(stat.S_IMODE(level2.stat().st_mode), 0o700)
+            # Leaf directory has the regular mode
+            self.assertEqual(stat.S_IMODE(p.stat().st_mode), 0o755)
+
+    @unittest.skipIf(
+        is_emscripten or is_wasi,
+        "umask is not implemented on Emscripten/WASI."
+    )
+    def test_mkdir_parent_mode_overrides_umask(self):
+        # Test that parent_mode overrides umask for parent directories
+        p = self.cls(self.base, 'overridetest', 'child')
+        self.assertFalse(p.exists())
+        if os.name != 'nt':
+            old_mask = os.umask(0o022)  # Restrictive umask
+            try:
+                # parent_mode should override umask for parents
+                p.mkdir(0o755, parents=True, parent_mode=0o700)
+                self.assertTrue(p.exists())
+                # Leaf directory gets the specified mode
+                self.assertEqual(stat.S_IMODE(p.stat().st_mode), 0o755)
+                # Parent directory gets parent_mode, not affected by umask
+                self.assertEqual(stat.S_IMODE(p.parent.stat().st_mode), 0o700)
+            finally:
+                os.umask(old_mask)
+
+    def test_mkdir_parent_mode_same_as_mode(self):
+        # Test setting parent_mode same as mode
+        p = self.cls(self.base, 'samedirPM', 'subdirPM')
+        self.assertFalse(p.exists())
+        if os.name != 'nt':
+            p.mkdir(0o705, parents=True, parent_mode=0o705)
+            self.assertTrue(p.exists())
+            # Both directories should have the same mode
+            self.assertEqual(stat.S_IMODE(p.stat().st_mode), 0o705)
+            self.assertEqual(stat.S_IMODE(p.parent.stat().st_mode), 0o705)
+
     @needs_symlinks
     def test_symlink_to(self):
         P = self.cls(self.base)

Misc/NEWS.d/next/Library/2025-08-30-07-44-30.gh-issue-86533.pathlib.rst

@@ -0,0 +1,3 @@
+The :meth:`pathlib.Path.mkdir` method now has a *parent_mode* parameter to
+specify the mode for intermediate directories when creating parent directories,
+providing consistency with the new :func:`os.makedirs` *parent_mode* parameter.