Move to pathlib._os.

python · barneygale · Jun 14, 2024 · May 14, 2024 · May 15, 2024 · May 15, 2024
commit 738f8ed91dbf87249dfb1cf9631b2eb1688f7364
@@ -12,19 +12,10 @@
 """
 
 import functools
-import os
-import sys
 from glob import _Globber, _no_recurse_symlinks
 from errno import ENOTDIR, ELOOP, EBADF, EOPNOTSUPP, ETXTBSY, EXDEV
 from stat import S_ISDIR, S_ISLNK, S_ISREG, S_ISSOCK, S_ISBLK, S_ISCHR, S_ISFIFO
-try:
-    import fcntl
-except ImportError:
-    fcntl = None
-try:
-    import posix
-except ImportError:
-    posix = None
+from ._os import clonefd, copyfd, copyfileobj
 
 
 __all__ = ["UnsupportedOperation"]
@@ -35,88 +26,6 @@ def _is_case_sensitive(parser):
     return parser.normcase('Aa') == 'Aa'
 
 
-def _get_copy_blocksize(infd):
-    """Determine blocksize for fastcopying on Linux.
-    Hopefully the whole file will be copied in a single call.
-    The copying itself should be performed in a loop 'till EOF is
-    reached (0 return) so a blocksize smaller or bigger than the actual
-    file size should not make any difference, also in case the file
-    content changes while being copied.
-    """
-    try:
-        blocksize = max(os.fstat(infd).st_size, 2 ** 23)  # min 8 MiB
-    except OSError:
-        blocksize = 2 ** 27  # 128 MiB
-    # On 32-bit architectures truncate to 1 GiB to avoid OverflowError,
-    # see gh-82500.
-    if sys.maxsize < 2 ** 32:
-        blocksize = min(blocksize, 2 ** 30)
-    return blocksize
-
-
-if fcntl and hasattr(fcntl, 'FICLONE'):
-    def _clonefd(source_fd, target_fd):
-        """
-        Perform a lightweight copy of two files, where the data blocks are
-        copied only when modified. This is known as Copy on Write (CoW),
-        instantaneous copy or reflink.
-        """
-        fcntl.ioctl(target_fd, fcntl.FICLONE, source_fd)
-else:
-    _clonefd = None
-
-
-if posix and hasattr(posix, '_fcopyfile'):
-    def _copyfd(source_fd, target_fd):
-        """
-        Copy a regular file content using high-performance fcopyfile(3)
-        syscall (macOS).
-        """
-        posix._fcopyfile(source_fd, target_fd, posix._COPYFILE_DATA)
-elif hasattr(os, 'copy_file_range'):
-    def _copyfd(source_fd, target_fd):
-        """
-        Copy data from one regular mmap-like fd to another by using a
-        high-performance copy_file_range(2) syscall that gives filesystems
-        an opportunity to implement the use of reflinks or server-side
-        copy.
-        This should work on Linux >= 4.5 only.
-        """
-        blocksize = _get_copy_blocksize(source_fd)
-        offset = 0
-        while True:
-            sent = os.copy_file_range(source_fd, target_fd, blocksize,
-                                      offset_dst=offset)
-            if sent == 0:
-                break  # EOF
-            offset += sent
-elif hasattr(os, 'sendfile'):
-    def _copyfd(source_fd, target_fd):
-        """Copy data from one regular mmap-like fd to another by using
-        high-performance sendfile(2) syscall.
-        This should work on Linux >= 2.6.33 only.
-        """
-        blocksize = _get_copy_blocksize(source_fd)
-        offset = 0
-        while True:
-            sent = os.sendfile(target_fd, source_fd, offset, blocksize)
-            if sent == 0:
-                break  # EOF
-            offset += sent
-else:
-    _copyfd = None
-
-
-def _copyfileobj(source_f, target_f):
-    """
-    Copy data from file-like object source_f to file-like object target_f.
-    """
-    read_source = source_f.read
-    write_target = target_f.write
-    while buf := read_source(1024 * 1024):
-        write_target(buf)
-
-
 class UnsupportedOperation(NotImplementedError):
     """An exception that is raised when an unsupported operation is called on
     a path object.
@@ -904,22 +813,22 @@ def copy(self, target, follow_symlinks=True):
                         source_fd = source_f.fileno()
                         target_fd = target_f.fileno()
                     except Exception:
-                        return _copyfileobj(source_f, target_f)
+                        return copyfileobj(source_f, target_f)
                     try:
                         # Use OS copy-on-write where available.
-                        if _clonefd:
+                        if clonefd:
                             try:
-                                return _clonefd(source_fd, target_fd)
+                                return clonefd(source_fd, target_fd)
                             except OSError as err:
                                 if err.errno not in (EBADF, EOPNOTSUPP, ETXTBSY, EXDEV):
                                     raise err
 
                         # Use OS copy where available.
-                        if _copyfd:
-                            return _copyfd(source_fd, target_fd)
+                        if copyfd:
+                            return copyfd(source_fd, target_fd)
 
                         # Last resort: copy between file objects.
-                        return _copyfileobj(source_f, target_f)
+                        return copyfileobj(source_f, target_f)
                     except OSError as err:
                         # Produce more useful error messages.
                         err.filename = str(self)

@@ -0,0 +1,96 @@
+"""
+Low-level OS functionality wrappers used by pathlib.
+"""
+
+import os
+import sys
+try:
+    import fcntl
+except ImportError:
+    fcntl = None
+try:
+    import posix
+except ImportError:
+    posix = None
+
+
+def get_copy_blocksize(infd):
+    """Determine blocksize for fastcopying on Linux.
+    Hopefully the whole file will be copied in a single call.
+    The copying itself should be performed in a loop 'till EOF is
+    reached (0 return) so a blocksize smaller or bigger than the actual
+    file size should not make any difference, also in case the file
+    content changes while being copied.
+    """
+    try:
+        blocksize = max(os.fstat(infd).st_size, 2 ** 23)  # min 8 MiB
+    except OSError:
+        blocksize = 2 ** 27  # 128 MiB
+    # On 32-bit architectures truncate to 1 GiB to avoid OverflowError,
+    # see gh-82500.
+    if sys.maxsize < 2 ** 32:
+        blocksize = min(blocksize, 2 ** 30)
+    return blocksize
+
+
+if fcntl and hasattr(fcntl, 'FICLONE'):
+    def clonefd(source_fd, target_fd):
+        """
+        Perform a lightweight copy of two files, where the data blocks are
+        copied only when modified. This is known as Copy on Write (CoW),
+        instantaneous copy or reflink.
+        """
+        fcntl.ioctl(target_fd, fcntl.FICLONE, source_fd)
+else:
+    clonefd = None
+
+
+if posix and hasattr(posix, '_fcopyfile'):
+    def copyfd(source_fd, target_fd):
+        """
+        Copy a regular file content using high-performance fcopyfile(3)
+        syscall (macOS).
+        """
+        posix._fcopyfile(source_fd, target_fd, posix._COPYFILE_DATA)
+elif hasattr(os, 'copy_file_range'):
+    def copyfd(source_fd, target_fd):
+        """
+        Copy data from one regular mmap-like fd to another by using a
+        high-performance copy_file_range(2) syscall that gives filesystems
+        an opportunity to implement the use of reflinks or server-side
+        copy.
+        This should work on Linux >= 4.5 only.
+        """
+        blocksize = get_copy_blocksize(source_fd)
+        offset = 0
+        while True:
+            sent = os.copy_file_range(source_fd, target_fd, blocksize,
+                                      offset_dst=offset)
+            if sent == 0:
+                break  # EOF
+            offset += sent
+elif hasattr(os, 'sendfile'):
+    def copyfd(source_fd, target_fd):
+        """Copy data from one regular mmap-like fd to another by using
+        high-performance sendfile(2) syscall.
+        This should work on Linux >= 2.6.33 only.
+        """
+        blocksize = get_copy_blocksize(source_fd)
+        offset = 0
+        while True:
+            sent = os.sendfile(target_fd, source_fd, offset, blocksize)
+            if sent == 0:
+                break  # EOF
+            offset += sent
+else:
+    copyfd = None
+
+
+def copyfileobj(source_f, target_f):
+    """
+    Copy data from file-like object source_f to file-like object target_f.
+    """
+    read_source = source_f.read
+    write_target = target_f.write
+    while buf := read_source(1024 * 1024):
+        write_target(buf)