python · nineteendo · Apr 12, 2024 · Apr 12, 2024 · Apr 12, 2024 · Apr 13, 2024
diff --git a/Include/internal/pycore_fileutils.h b/Include/internal/pycore_fileutils.h
@@ -279,7 +279,8 @@ extern size_t _Py_find_basename(const wchar_t *filename);
 // Export for '_testinternalcapi' shared extension
 PyAPI_FUNC(wchar_t*) _Py_normpath(wchar_t *path, Py_ssize_t size);
 
-extern wchar_t *_Py_normpath_and_size(wchar_t *path, Py_ssize_t size, Py_ssize_t *length);
+extern wchar_t *_Py_normpath_and_size(wchar_t *path, Py_ssize_t size, Py_ssize_t start,
+                                      Py_ssize_t *length, int explicit_curdir);
 
 // The Windows Games API family does not provide these functions
 // so provide our own implementations. Remove them in case they get added

diff --git a/Lib/ctypes/__init__.py b/Lib/ctypes/__init__.py
@@ -380,7 +380,7 @@ def __init__(self, name, mode=DEFAULT_MODE, handle=None,
                 import nt
                 mode = nt._LOAD_LIBRARY_SEARCH_DEFAULT_DIRS
                 if '/' in name or '\\' in name:
-                    self._name = nt._getfullpathname(self._name)
+                    self._name = nt._path_abspath(self._name)
                     mode |= nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR
 
         class _FuncPtr(_CFuncPtr):

diff --git a/Lib/ntpath.py b/Lib/ntpath.py
@@ -554,36 +554,47 @@ def normpath(path):
         return prefix + sep.join(comps)
 
 
-def _abspath_fallback(path):
-    """Return the absolute version of a path as a fallback function in case
-    `nt._getfullpathname` is not available or raises OSError. See bpo-31047 for
-    more.
-
-    """
-
-    path = os.fspath(path)
-    if not isabs(path):
-        if isinstance(path, bytes):
-            cwd = os.getcwdb()
-        else:
-            cwd = os.getcwd()
-        path = join(cwd, path)
-    return normpath(path)
-
 # Return an absolute path.
 try:
-    from nt import _getfullpathname
+    from nt import _path_abspath
 
 except ImportError: # not running on Windows - mock up something sensible
-    abspath = _abspath_fallback
+    def abspath(path):
+        """Return the absolute version of a path."""
+        path = os.fspath(path)
+        if not isabs(path):
+            if isinstance(path, bytes):
+                path = join(os.getcwdb(), path)
+            else:
+                path = join(os.getcwd(), path)
+        return normpath(path)
 
 else:  # use native Windows method on Windows
     def abspath(path):
         """Return the absolute version of a path."""
         try:
-            return _getfullpathname(normpath(path))
+            return _path_abspath(path)
         except (OSError, ValueError):
-            return _abspath_fallback(path)
+            # See gh-75230, handle outside for cleaner traceback
+            pass
+        path = os.fspath(path)
+        if not isabs(path):
+            if isinstance(path, bytes):
+                sep = b'/'
+                cwd = os.getcwdb()
+            else:
+                sep = '/'
+                cwd = os.getcwd()
+            drive, root, path = splitroot(path)
+            if drive and drive != splitroot(cwd)[0]:
+                try:
+                    path = join(_path_abspath(drive), path)
+                except (OSError, ValueError):
+                    # Invalid drive \x00: on Windows; assume root directory
+                    path = drive + sep + path
+            else:
+                path = join(cwd, root + path)
+        return normpath(path)
 
 try:
     from nt import _findfirstfile, _getfinalpathname, readlink as _nt_readlink

diff --git a/Lib/posixpath.py b/Lib/posixpath.py
@@ -372,16 +372,19 @@ def normpath(path):
         return path or dot
 
 
-def abspath(path):
-    """Return an absolute path."""
-    path = os.fspath(path)
-    if isinstance(path, bytes):
-        if not path.startswith(b'/'):
-            path = join(os.getcwdb(), path)
-    else:
-        if not path.startswith('/'):
-            path = join(os.getcwd(), path)
-    return normpath(path)
+try:
+    from posix import _path_abspath as abspath
+except ImportError:
+    def abspath(path):
+        """Return an absolute path."""
+        path = os.fspath(path)
+        if isinstance(path, bytes):
+            if not path.startswith(b'/'):
+                path = join(os.getcwdb(), path)
+        else:
+            if not path.startswith('/'):
+                path = join(os.getcwd(), path)
+        return normpath(path)
 
 
 # Return a canonical path (i.e. the absolute location of a file on the

diff --git a/Lib/test/test_ctypes/test_loading.py b/Lib/test/test_ctypes/test_loading.py
@@ -185,11 +185,11 @@ def should_fail(command):
             should_pass("windll.kernel32.SetDllDirectoryW(None); WinDLL('_sqlite3.dll', winmode=0)")
 
             # Full path load without DLL_LOAD_DIR shouldn't find dependency
-            should_fail("WinDLL(nt._getfullpathname('_sqlite3.dll'), " +
+            should_fail("WinDLL(nt._path_abspath('_sqlite3.dll'), " +
                         "winmode=nt._LOAD_LIBRARY_SEARCH_SYSTEM32)")
 
             # Full path load with DLL_LOAD_DIR should succeed
-            should_pass("WinDLL(nt._getfullpathname('_sqlite3.dll'), " +
+            should_pass("WinDLL(nt._path_abspath('_sqlite3.dll'), " +
                         "winmode=nt._LOAD_LIBRARY_SEARCH_SYSTEM32|" +
                         "nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR)")
 

diff --git a/Lib/test/test_ntpath.py b/Lib/test/test_ntpath.py
@@ -347,13 +347,15 @@ def test_normpath(self):
 
         tester("ntpath.normpath('..')", r'..')
         tester("ntpath.normpath('.')", r'.')
+        tester("ntpath.normpath('c:.')", 'c:')
         tester("ntpath.normpath('')", r'.')
         tester("ntpath.normpath('/')", '\\')
         tester("ntpath.normpath('c:/')", 'c:\\')
         tester("ntpath.normpath('/../.././..')", '\\')
         tester("ntpath.normpath('c:/../../..')", 'c:\\')
         tester("ntpath.normpath('../.././..')", r'..\..\..')
         tester("ntpath.normpath('K:../.././..')", r'K:..\..\..')
+        tester("ntpath.normpath('./a/b')", r'a\b')
         tester("ntpath.normpath('C:////a/b')", r'C:\a\b')
         tester("ntpath.normpath('//machine/share//a/b')", r'\\machine\share\a\b')
 
@@ -806,6 +808,9 @@ def test_abspath(self):
         tester('ntpath.abspath("C:\\spam. . .")', "C:\\spam")
         tester('ntpath.abspath("C:/nul")',  "\\\\.\\nul")
         tester('ntpath.abspath("C:\\nul")', "\\\\.\\nul")
+        self.assertTrue(ntpath.isabs(ntpath.abspath("C:spam")))
+        self.assertTrue(ntpath.isabs(ntpath.abspath("C:\x00")))
+        self.assertTrue(ntpath.isabs(ntpath.abspath("\x00:spam")))
         tester('ntpath.abspath("//..")',           "\\\\")
         tester('ntpath.abspath("//../")',          "\\\\..\\")
         tester('ntpath.abspath("//../..")',        "\\\\..\\")
@@ -836,6 +841,20 @@ def test_abspath(self):
             tester('ntpath.abspath("")', cwd_dir)
             tester('ntpath.abspath(" ")', cwd_dir + "\\ ")
             tester('ntpath.abspath("?")', cwd_dir + "\\?")
+            tester('ntpath.abspath("con")', r"\\.\con")
+            # bpo-45354: Windows 11 changed MS-DOS device name handling
+            if sys.getwindowsversion()[:3] < (10, 0, 22000):
+                tester('ntpath.abspath("./con")', r"\\.\con")
+                tester('ntpath.abspath("foo/../con")', r"\\.\con")
+                tester('ntpath.abspath("con/foo/..")', r"\\.\con")
+                tester('ntpath.abspath("con/.")', r"\\.\con")
+            else:
+                tester('ntpath.abspath("./con")', cwd_dir + r"\con")
+                tester('ntpath.abspath("foo/../con")', cwd_dir + r"\con")
+                tester('ntpath.abspath("con/foo/..")', cwd_dir + r"\con")
+                tester('ntpath.abspath("con/.")', cwd_dir + r"\con")
+            tester('ntpath.abspath("./Z:spam")', cwd_dir + r"\Z:spam")
+            tester('ntpath.abspath("spam/../Z:eggs")', cwd_dir + r"\Z:eggs")
             drive, _ = ntpath.splitdrive(cwd_dir)
             tester('ntpath.abspath("/abc/")', drive + "\\abc")
 

diff --git a/Lib/test/test_posixpath.py b/Lib/test/test_posixpath.py
@@ -293,6 +293,8 @@ def test_fast_paths_in_use(self):
         self.assertFalse(inspect.isfunction(os.path.splitroot))
         self.assertTrue(os.path.normpath is posix._path_normpath)
         self.assertFalse(inspect.isfunction(os.path.normpath))
+        self.assertTrue(os.path.abspath is posix._path_abspath)
+        self.assertFalse(inspect.isfunction(os.path.abspath))
 
     def test_expanduser(self):
         self.assertEqual(posixpath.expanduser("foo"), "foo")
@@ -382,6 +384,7 @@ def test_expanduser_pwd2(self):
         ("///..//./foo/.//bar", "/foo/bar"),
         (".", "."),
         (".//.", "."),
+        ("./foo/bar", "foo/bar"),
         ("..", ".."),
         ("../", ".."),
         ("../foo", "../foo"),
@@ -689,19 +692,21 @@ def test_realpath_unreadable_symlink(self):
             os.chmod(ABSTFN, 0o755, follow_symlinks=False)
             os.unlink(ABSTFN)
 
+    @skip_if_ABSTFN_contains_backslash
     def test_relpath(self):
-        (real_getcwd, os.getcwd) = (os.getcwd, lambda: r"/home/user/bar")
         try:
-            curdir = os.path.split(os.getcwd())[-1]
+            os.mkdir(ABSTFN)
             self.assertRaises(TypeError, posixpath.relpath, None)
             self.assertRaises(ValueError, posixpath.relpath, "")
             self.assertEqual(posixpath.relpath("a"), "a")
             self.assertEqual(posixpath.relpath(posixpath.abspath("a")), "a")
             self.assertEqual(posixpath.relpath("a/b"), "a/b")
             self.assertEqual(posixpath.relpath("../a/b"), "../a/b")
-            self.assertEqual(posixpath.relpath("a", "../b"), "../"+curdir+"/a")
-            self.assertEqual(posixpath.relpath("a/b", "../c"),
-                             "../"+curdir+"/a/b")
+            with os_helper.change_cwd(ABSTFN):
+                curdir = basename(ABSTFN)
+                self.assertEqual(posixpath.relpath("a", "../b"), "../"+curdir+"/a")
+                self.assertEqual(posixpath.relpath("a/b", "../c"),
+                                "../"+curdir+"/a/b")
             self.assertEqual(posixpath.relpath("a", "b/c"), "../../a")
             self.assertEqual(posixpath.relpath("a", "a"), ".")
             self.assertEqual(posixpath.relpath("/foo/bar/bat", "/x/y/z"), '../../../foo/bar/bat')
@@ -714,21 +719,23 @@ def test_relpath(self):
             self.assertEqual(posixpath.relpath("/a", "/a"), '.')
             self.assertEqual(posixpath.relpath("/a/b", "/a/b"), '.')
         finally:
-            os.getcwd = real_getcwd
+            safe_rmdir(ABSTFN)
 
+    @skip_if_ABSTFN_contains_backslash
     def test_relpath_bytes(self):
-        (real_getcwdb, os.getcwdb) = (os.getcwdb, lambda: br"/home/user/bar")
         try:
-            curdir = os.path.split(os.getcwdb())[-1]
+            os.mkdir(ABSTFN)
             self.assertRaises(ValueError, posixpath.relpath, b"")
             self.assertEqual(posixpath.relpath(b"a"), b"a")
             self.assertEqual(posixpath.relpath(posixpath.abspath(b"a")), b"a")
             self.assertEqual(posixpath.relpath(b"a/b"), b"a/b")
             self.assertEqual(posixpath.relpath(b"../a/b"), b"../a/b")
-            self.assertEqual(posixpath.relpath(b"a", b"../b"),
-                             b"../"+curdir+b"/a")
-            self.assertEqual(posixpath.relpath(b"a/b", b"../c"),
-                             b"../"+curdir+b"/a/b")
+            with os_helper.change_cwd(ABSTFN):
+                curdir = os.fsencode(basename(ABSTFN))
+                self.assertEqual(posixpath.relpath(b"a", b"../b"),
+                                    b"../"+curdir+b"/a")
+                self.assertEqual(posixpath.relpath(b"a/b", b"../c"),
+                                    b"../"+curdir+b"/a/b")
             self.assertEqual(posixpath.relpath(b"a", b"b/c"), b"../../a")
             self.assertEqual(posixpath.relpath(b"a", b"a"), b".")
             self.assertEqual(posixpath.relpath(b"/foo/bar/bat", b"/x/y/z"), b'../../../foo/bar/bat')
@@ -744,7 +751,7 @@ def test_relpath_bytes(self):
             self.assertRaises(TypeError, posixpath.relpath, b"bytes", "str")
             self.assertRaises(TypeError, posixpath.relpath, "str", b"bytes")
         finally:
-            os.getcwdb = real_getcwdb
+            safe_rmdir(ABSTFN)
 
     def test_commonpath(self):
         def check(paths, expected):

diff --git a/Misc/NEWS.d/next/Core and Builtins/2024-04-13-18-00-18.gh-issue-117587.52AB27.rst b/Misc/NEWS.d/next/Core and Builtins/2024-04-13-18-00-18.gh-issue-117587.52AB27.rst
@@ -0,0 +1 @@
+Speedup :func:`os.path.abspath` with a native implementation.
diff --git a/Modules/clinic/posixmodule.c.h b/Modules/clinic/posixmodule.c.h
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		Speedup :func:`os.path.abspath` with a native implementation.