Remove 'string.commonprefix()' as an alternative

Author: sethmlarson

Doc/deprecations/pending-removal-in-future.rst

@@ -78,9 +78,8 @@ although there is currently no date scheduled for their removal.
 
 * :mod:`os`: Calling :func:`os.register_at_fork` in a multi-threaded process.
 
-* :mod:`os.path`: :func:`os.path.commonprefix` is deprecated, use either
-  :func:`os.path.commonpath` for path prefixes or
-  :func:`string.commonprefix` for string prefixes.
+* :mod:`os.path`: :func:`os.path.commonprefix` is deprecated, use
+  :func:`os.path.commonpath` for path prefixes.
 
 * :class:`!pydoc.ErrorDuringImport`: A tuple value for *exc_info* parameter is
   deprecated, use an exception instance.

Doc/library/os.path.rst

@@ -121,8 +121,7 @@ the :mod:`glob` module.)
       Accepts a :term:`path-like object`.
 
    .. deprecated:: next
-      Deprecated in favor of :func:`os.path.commonpath` for path prefixes and
-      :func:`string.commonprefix` for string prefixes.
+      Deprecated in favor of :func:`os.path.commonpath` for path prefixes.
 
 
 .. function:: dirname(path, /)

Lib/genericpath.py

@@ -107,12 +107,26 @@ def commonprefix(m, /):
     "Given a list of pathnames, returns the longest common leading component"
     import warnings
     warnings.warn('os.path.commonprefix() is deprecated. Use '
-                  'os.path.commonpath() for longest path prefix, or '
-                  'string.commonprefix() for longest string prefix.',
+                  'os.path.commonpath() for longest path prefix.',
                   category=DeprecationWarning,
                   stacklevel=2)
-    import string
-    return string.commonprefix(m)
+    return _commonprefix(m)
+
+def _commonprefix(m, /):
+    "Internal implementation of commonprefix()"
+    if not m: return ''
+    # Some people pass in a list of pathname parts to operate in an OS-agnostic
+    # fashion; don't try to translate in that case as that's an abuse of the
+    # API and they are already doing what they need to be OS-agnostic and so
+    # they most likely won't be using an os.PathLike object in the sublists.
+    if not isinstance(m[0], (list, tuple)):
+        m = tuple(map(os.fspath, m))
+    s1 = min(m)
+    s2 = max(m)
+    for i, c in enumerate(s1):
+        if c != s2[i]:
+            return s1[:i]
+    return s1
 
 # Are two stat buffers (obtained from stat, fstat or lstat)
 # describing the same file?

Lib/posixpath.py

@@ -26,7 +26,6 @@
 import os
 import sys
 import stat
-import string
 import genericpath
 from genericpath import *
 
@@ -543,7 +542,7 @@ def relpath(path, start=None):
         start_list = start_tail.split(sep) if start_tail else []
         path_list = path_tail.split(sep) if path_tail else []
         # Work out how much of the filepath is shared by start and path.
-        i = len(string.commonprefix([start_list, path_list]))
+        i = len(genericpath._commonprefix([start_list, path_list]))
 
         rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
         if not rel_list:

Lib/string/__init__.py

@@ -48,27 +48,6 @@ def capwords(s, sep=None):
     return (sep or ' ').join(map(str.capitalize, s.split(sep)))
 
 
-def commonprefix(m, /):
-    """Given a list of strings, returns the longest common leading component."""
-    if not m:
-        return ''
-    # Note that previously this function was in the 'os.path' module, hence the
-    # handling for paths. Maintain compatibility so users have a 1-to-1 drop-in.
-    # Some people pass in a list of pathname parts to operate in an OS-agnostic
-    # fashion; don't try to translate in that case as that's an abuse of the
-    # API and they are already doing what they need to be OS-agnostic and so
-    # they most likely won't be using an os.PathLike object in the sublists.
-    if not isinstance(m[0], (list, tuple)):
-        import os
-        m = tuple(map(os.fspath, m))
-    s1 = min(m)
-    s2 = max(m)
-    for i, c in enumerate(s1):
-        if c != s2[i]:
-            return s1[:i]
-    return s1
-
-
 ####################################################################
 _sentinel_dict = {}
 

Lib/test/test_string/test_string.py

@@ -41,97 +41,6 @@ def test_capwords(self):
         self.assertEqual(string.capwords('\taBc\tDeF\t'), 'Abc Def')
         self.assertEqual(string.capwords('\taBc\tDeF\t', '\t'), '\tAbc\tDef\t')
 
-    def test_commonprefix(self):
-        self.assertEqual(
-            string.commonprefix([]),
-            ""
-        )
-        self.assertEqual(
-            string.commonprefix(["a", "b"]),
-            ""
-        )
-        self.assertEqual(
-            string.commonprefix(["/home/swenson/spam", "/home/swen/spam"]),
-            "/home/swen"
-        )
-        self.assertEqual(
-            string.commonprefix(["/home/swen/spam", "/home/swen/eggs"]),
-            "/home/swen/"
-        )
-        self.assertEqual(
-            string.commonprefix(["/home/swen/spam", "/home/swen/spam"]),
-            "/home/swen/spam"
-        )
-        self.assertEqual(
-            string.commonprefix(["home:swenson:spam", "home:swen:spam"]),
-            "home:swen"
-        )
-        self.assertEqual(
-            string.commonprefix([":home:swen:spam", ":home:swen:eggs"]),
-            ":home:swen:"
-        )
-        self.assertEqual(
-            string.commonprefix([":home:swen:spam", ":home:swen:spam"]),
-            ":home:swen:spam"
-        )
-
-        self.assertEqual(
-            string.commonprefix([b"/home/swenson/spam", b"/home/swen/spam"]),
-            b"/home/swen"
-        )
-        self.assertEqual(
-            string.commonprefix([b"/home/swen/spam", b"/home/swen/eggs"]),
-            b"/home/swen/"
-        )
-        self.assertEqual(
-            string.commonprefix([b"/home/swen/spam", b"/home/swen/spam"]),
-            b"/home/swen/spam"
-        )
-        self.assertEqual(
-            string.commonprefix([b"home:swenson:spam", b"home:swen:spam"]),
-            b"home:swen"
-        )
-        self.assertEqual(
-            string.commonprefix([b":home:swen:spam", b":home:swen:eggs"]),
-            b":home:swen:"
-        )
-        self.assertEqual(
-            string.commonprefix([b":home:swen:spam", b":home:swen:spam"]),
-            b":home:swen:spam"
-        )
-
-        testlist = ['', 'abc', 'Xbcd', 'Xb', 'XY', 'abcd',
-                    'aXc', 'abd', 'ab', 'aX', 'abcX']
-        for s1 in testlist:
-            for s2 in testlist:
-                p = string.commonprefix([s1, s2])
-                self.assertStartsWith(s1, p)
-                self.assertStartsWith(s2, p)
-                if s1 != s2:
-                    n = len(p)
-                    self.assertNotEqual(s1[n:n+1], s2[n:n+1])
-
-    def test_commonprefix_paths(self):
-        # Test backwards-compatibility with os.path.commonprefix()
-        # This function must handle PathLike objects.
-        file_name = os_helper.TESTFN
-        file_path = os_helper.FakePath(file_name)
-        self.assertEqual(string.commonprefix([file_path, file_name]),
-                         file_name)
-
-    def test_commonprefix_sequence_of_str(self):
-        # Test backwards-compatibility with os.path.commonprefix()
-        # This function must handle lists and tuples of strings.
-        for type_ in (tuple, list):
-            seq1 = type_(["abc", "de", "fgh"])
-            seq2 = type_(["abc", "def", "gh"])
-            self.assertEqual(string.commonprefix([seq1, seq2]),
-                             type_(["abc"]))
-
-            seq1 = type_(["ab"])
-            seq2 = type_(["ac"])
-            self.assertEqual(string.commonprefix([seq1, seq2]), type_([]))
-
     def test_basic_formatter(self):
         fmt = string.Formatter()
         self.assertEqual(fmt.format("foo"), "foo")

Lib/textwrap.py

@@ -432,7 +432,7 @@ def dedent(text):
         msg = f'expected str object, not {type(text).__qualname__!r}'
         raise TypeError(msg) from None
 
-    # Get length of leading whitespace, inspired by ``string.commonprefix()``.
+    # Get length of leading whitespace, inspired by ``os.path.commonprefix()``.
     non_blank_lines = [l for l in lines if l and not l.isspace()]
     l1 = min(non_blank_lines, default='')
     l2 = max(non_blank_lines, default='')

Lib/unittest/util.py

@@ -1,7 +1,6 @@
 """Various utility functions."""
 
 from collections import namedtuple, Counter
-from string import commonprefix
 
 __unittest = True
 
@@ -21,13 +20,25 @@ def _shorten(s, prefixlen, suffixlen):
         s = '%s[%d chars]%s' % (s[:prefixlen], skip, s[len(s) - suffixlen:])
     return s
 
+def _commonprefix(m, /):
+    if not m:
+        return ""
+    m = sorted(m)
+    prefix = m[0]
+    for item in m[1:]:
+        for i in range(len(prefix)):
+            if item[i] != prefix[i]:
+                prefix = prefix[:i]
+                break
+    return prefix
+
 def _common_shorten_repr(*args):
     args = tuple(map(safe_repr, args))
     maxlen = max(map(len, args))
     if maxlen <= _MAX_LENGTH:
         return args
 
-    prefix = commonprefix(args)
+    prefix = _commonprefix(args)
     prefixlen = len(prefix)
 
     common_len = _MAX_LENGTH - \

Misc/NEWS.d/next/Library/2026-02-02-12-09-38.gh-issue-74453.19h4Z5.rst

@@ -1,4 +1,2 @@
 Deprecate :func:`os.path.commonprefix` in favor of
-:func:`os.path.commonpath` for path segment prefixes
-and :func:`string.commonprefix` for character prefixes.
-
+:func:`os.path.commonpath` for path segment prefixes.