bpo-35471: Remove the macpath module (GH-11129)

Python 2.4 dropped MacOS 9 support. The macpath module was deprecated
in Python 3.7. This change removes it.

Doc/library/filesys.rst

@@ -22,7 +22,6 @@ in this chapter is:
    fnmatch.rst
    linecache.rst
    shutil.rst
-   macpath.rst
 
 
 .. seealso::

Doc/library/macpath.rst

-:mod:`macpath` --- Mac OS 9 path manipulation functions
-=======================================================
-
-.. module:: macpath
-   :synopsis: Mac OS 9 path manipulation functions.
-
-**Source code:** :source:`Lib/macpath.py`
-
-.. deprecated-removed:: 3.7 3.8
-
---------------
-
-This module is the Mac OS 9 (and earlier) implementation of the :mod:`os.path`
-module. It can be used to manipulate old-style Macintosh pathnames on Mac OS X
-(or any other platform).
-
-The following functions are available in this module: :func:`normcase`,
-:func:`normpath`, :func:`isabs`, :func:`join`, :func:`split`, :func:`isdir`,
-:func:`isfile`, :func:`walk`, :func:`exists`. For other functions available in
-:mod:`os.path` dummy counterparts are available.
-

Doc/library/os.path.rst

@@ -4,9 +4,8 @@
 .. module:: os.path
    :synopsis: Operations on pathnames.
 
-**Source code:** :source:`Lib/posixpath.py` (for POSIX),
-:source:`Lib/ntpath.py` (for Windows NT),
-and :source:`Lib/macpath.py` (for Macintosh)
+**Source code:** :source:`Lib/posixpath.py` (for POSIX) and
+:source:`Lib/ntpath.py` (for Windows NT).
 
 .. index:: single: path; operations
 
@@ -52,7 +51,6 @@ the :mod:`glob` module.)
 
    * :mod:`posixpath` for UNIX-style paths
    * :mod:`ntpath` for Windows paths
-   * :mod:`macpath` for old-style MacOS paths
 
 
 .. versionchanged:: 3.8

Doc/whatsnew/3.8.rst

@@ -378,6 +378,9 @@ API and Feature Removals
 
 The following features and APIs have been removed from Python 3.8:
 
+* The :mod:`macpath` module, deprecated in Python 3.7, has been removed.
+  (Contributed by Victor Stinner in :issue:`35471`.)
+
 * The function :func:`platform.popen` has been removed, it was deprecated since
   Python 3.3: use :func:`os.popen` instead.
 

Lib/macpath.py

-"""Pathname and path-related operations for the Macintosh."""
-
-# strings representing various path-related bits and pieces
-# These are primarily for export; internally, they are hardcoded.
-# Should be set before imports for resolving cyclic dependency.
-curdir = ':'
-pardir = '::'
-extsep = '.'
-sep = ':'
-pathsep = '\n'
-defpath = ':'
-altsep = None
-devnull = 'Dev:Null'
-
-import os
-from stat import *
-import genericpath
-from genericpath import *
-import warnings
-
-warnings.warn('the macpath module is deprecated in 3.7 and will be removed '
-              'in 3.8', DeprecationWarning, stacklevel=2)
-
-__all__ = ["normcase","isabs","join","splitdrive","split","splitext",
-           "basename","dirname","commonprefix","getsize","getmtime",
-           "getatime","getctime", "islink","exists","lexists","isdir","isfile",
-           "expanduser","expandvars","normpath","abspath",
-           "curdir","pardir","sep","pathsep","defpath","altsep","extsep",
-           "devnull","realpath","supports_unicode_filenames"]
-
-def _get_colon(path):
-    if isinstance(path, bytes):
-        return b':'
-    else:
-        return ':'
-
-# Normalize the case of a pathname.  Dummy in Posix, but <s>.lower() here.
-
-def normcase(path):
-    if not isinstance(path, (bytes, str)):
-        raise TypeError("normcase() argument must be str or bytes, "
-                        "not '{}'".format(path.__class__.__name__))
-    return path.lower()
-
-
-def isabs(s):
-    """Return true if a path is absolute.
-    On the Mac, relative paths begin with a colon,
-    but as a special case, paths with no colons at all are also relative.
-    Anything else is absolute (the string up to the first colon is the
-    volume name)."""
-
-    colon = _get_colon(s)
-    return colon in s and s[:1] != colon
-
-
-def join(s, *p):
-    try:
-        colon = _get_colon(s)
-        path = s
-        if not p:
-            path[:0] + colon  #23780: Ensure compatible data type even if p is null.
-        for t in p:
-            if (not path) or isabs(t):
-                path = t
-                continue
-            if t[:1] == colon:
-                t = t[1:]
-            if colon not in path:
-                path = colon + path
-            if path[-1:] != colon:
-                path = path + colon
-            path = path + t
-        return path
-    except (TypeError, AttributeError, BytesWarning):
-        genericpath._check_arg_types('join', s, *p)
-        raise
-
-
-def split(s):
-    """Split a pathname into two parts: the directory leading up to the final
-    bit, and the basename (the filename, without colons, in that directory).
-    The result (s, t) is such that join(s, t) yields the original argument."""
-
-    colon = _get_colon(s)
-    if colon not in s: return s[:0], s
-    col = 0
-    for i in range(len(s)):
-        if s[i:i+1] == colon: col = i + 1
-    path, file = s[:col-1], s[col:]
-    if path and not colon in path:
-        path = path + colon
-    return path, file
-
-
-def splitext(p):
-    if isinstance(p, bytes):
-        return genericpath._splitext(p, b':', altsep, b'.')
-    else:
-        return genericpath._splitext(p, sep, altsep, extsep)
-splitext.__doc__ = genericpath._splitext.__doc__
-
-def splitdrive(p):
-    """Split a pathname into a drive specification and the rest of the
-    path.  Useful on DOS/Windows/NT; on the Mac, the drive is always
-    empty (don't use the volume name -- it doesn't have the same
-    syntactic and semantic oddities as DOS drive letters, such as there
-    being a separate current directory per drive)."""
-
-    return p[:0], p
-
-
-# Short interfaces to split()
-
-def dirname(s): return split(s)[0]
-def basename(s): return split(s)[1]
-
-def ismount(s):
-    if not isabs(s):
-        return False
-    components = split(s)
-    return len(components) == 2 and not components[1]
-
-def islink(s):
-    """Return true if the pathname refers to a symbolic link."""
-
-    try:
-        import Carbon.File
-        return Carbon.File.ResolveAliasFile(s, 0)[2]
-    except:
-        return False
-
-# Is `stat`/`lstat` a meaningful difference on the Mac?  This is safe in any
-# case.
-
-def lexists(path):
-    """Test whether a path exists.  Returns True for broken symbolic links"""
-
-    try:
-        st = os.lstat(path)
-    except (OSError, ValueError):
-        return False
-    return True
-
-def expandvars(path):
-    """Dummy to retain interface-compatibility with other operating systems."""
-    return path
-
-
-def expanduser(path):
-    """Dummy to retain interface-compatibility with other operating systems."""
-    return path
-
-class norm_error(Exception):
-    """Path cannot be normalized"""
-
-def normpath(s):
-    """Normalize a pathname.  Will return the same result for
-    equivalent paths."""
-
-    colon = _get_colon(s)
-
-    if colon not in s:
-        return colon + s
-
-    comps = s.split(colon)
-    i = 1
-    while i < len(comps)-1:
-        if not comps[i] and comps[i-1]:
-            if i > 1:
-                del comps[i-1:i+1]
-                i = i - 1
-            else:
-                # best way to handle this is to raise an exception
-                raise norm_error('Cannot use :: immediately after volume name')
-        else:
-            i = i + 1
-
-    s = colon.join(comps)
-
-    # remove trailing ":" except for ":" and "Volume:"
-    if s[-1:] == colon and len(comps) > 2 and s != colon*len(s):
-        s = s[:-1]
-    return s
-
-def abspath(path):
-    """Return an absolute path."""
-    if not isabs(path):
-        if isinstance(path, bytes):
-            cwd = os.getcwdb()
-        else:
-            cwd = os.getcwd()
-        path = join(cwd, path)
-    return normpath(path)
-
-# realpath is a no-op on systems without islink support
-def realpath(path):
-    path = abspath(path)
-    try:
-        import Carbon.File
-    except ImportError:
-        return path
-    if not path:
-        return path
-    colon = _get_colon(path)
-    components = path.split(colon)
-    path = components[0] + colon
-    for c in components[1:]:
-        path = join(path, c)
-        try:
-            path = Carbon.File.FSResolveAliasFile(path, 1)[0].as_pathname()
-        except Carbon.File.Error:
-            pass
-    return path
-
-supports_unicode_filenames = True

Lib/posixpath.py

@@ -2,9 +2,9 @@
 
 Instead of importing this module directly, import os and refer to
 this module as os.path.  The "os.path" name is an alias for this
-module on Posix systems; on other systems (e.g. Mac, Windows),
+module on Posix systems; on other systems (e.g. Windows),
 os.path provides the same operations in a manner specific to that
-platform, and is an alias to another module (e.g. macpath, ntpath).
+platform, and is an alias to another module (e.g. ntpath).
 
 Some of this can actually be useful on non-Posix systems too, e.g.
 for manipulation of the pathname component of URLs.

Lib/test/test_genericpath.py

 """
-Tests common to genericpath, macpath, ntpath and posixpath
+Tests common to genericpath, ntpath and posixpath
 """
 
 import genericpath
@@ -334,7 +334,7 @@ class TestGenericTest(GenericTest, unittest.TestCase):
                         func(b'/tmp\x00abcds')
 
 # Following TestCase is not supposed to be run from test_genericpath.
-# It is inherited by other test modules (macpath, ntpath, posixpath).
+# It is inherited by other test modules (ntpath, posixpath).
 
 class CommonTest(GenericTest):
     common_attributes = GenericTest.common_attributes + [
@@ -373,8 +373,6 @@ class CommonTest(GenericTest):
         self.assertEqual(splitdrive(b":foo:bar"), (b"", b":foo:bar"))
 
     def test_expandvars(self):
-        if self.pathmodule.__name__ == 'macpath':
-            self.skipTest('macpath.expandvars is a stub')
         expandvars = self.pathmodule.expandvars
         with support.EnvironmentVarGuard() as env:
             env.clear()
@@ -407,8 +405,6 @@ class CommonTest(GenericTest):
 
     @unittest.skipUnless(support.FS_NONASCII, 'need support.FS_NONASCII')
     def test_expandvars_nonascii(self):
-        if self.pathmodule.__name__ == 'macpath':
-            self.skipTest('macpath.expandvars is a stub')
         expandvars = self.pathmodule.expandvars
         def check(value, expected):
             self.assertEqual(expandvars(value), expected)

Lib/test/test_macpath.py

-from test import test_genericpath
-import unittest
-import warnings
-
-
-with warnings.catch_warnings():
-    warnings.filterwarnings("ignore", "the macpath module is deprecated",
-                            DeprecationWarning)
-    import macpath
-
-
-class MacPathTestCase(unittest.TestCase):
-
-    def test_abspath(self):
-        self.assertEqual(macpath.abspath("xx:yy"), "xx:yy")
-
-    def test_isabs(self):
-        isabs = macpath.isabs
-        self.assertTrue(isabs("xx:yy"))
-        self.assertTrue(isabs("xx:yy:"))
-        self.assertTrue(isabs("xx:"))
-        self.assertFalse(isabs("foo"))
-        self.assertFalse(isabs(":foo"))
-        self.assertFalse(isabs(":foo:bar"))
-        self.assertFalse(isabs(":foo:bar:"))
-
-        self.assertTrue(isabs(b"xx:yy"))
-        self.assertTrue(isabs(b"xx:yy:"))
-        self.assertTrue(isabs(b"xx:"))
-        self.assertFalse(isabs(b"foo"))
-        self.assertFalse(isabs(b":foo"))
-        self.assertFalse(isabs(b":foo:bar"))
-        self.assertFalse(isabs(b":foo:bar:"))
-
-    def test_split(self):
-        split = macpath.split
-        self.assertEqual(split("foo:bar"),
-                          ('foo:', 'bar'))
-        self.assertEqual(split("conky:mountpoint:foo:bar"),
-                          ('conky:mountpoint:foo', 'bar'))
-
-        self.assertEqual(split(":"), ('', ''))
-        self.assertEqual(split(":conky:mountpoint:"),
-                          (':conky:mountpoint', ''))
-
-        self.assertEqual(split(b"foo:bar"),
-                          (b'foo:', b'bar'))
-        self.assertEqual(split(b"conky:mountpoint:foo:bar"),
-                          (b'conky:mountpoint:foo', b'bar'))
-
-        self.assertEqual(split(b":"), (b'', b''))
-        self.assertEqual(split(b":conky:mountpoint:"),
-                          (b':conky:mountpoint', b''))
-
-    def test_join(self):
-        join = macpath.join
-        self.assertEqual(join('a', 'b'), ':a:b')
-        self.assertEqual(join(':a', 'b'), ':a:b')
-        self.assertEqual(join(':a:', 'b'), ':a:b')
-        self.assertEqual(join(':a::', 'b'), ':a::b')
-        self.assertEqual(join(':a', '::b'), ':a::b')
-        self.assertEqual(join('a', ':'), ':a:')
-        self.assertEqual(join('a:', ':'), 'a:')
-        self.assertEqual(join('a', ''), ':a:')
-        self.assertEqual(join('a:', ''), 'a:')
-        self.assertEqual(join('', ''), '')
-        self.assertEqual(join('', 'a:b'), 'a:b')
-        self.assertEqual(join('', 'a', 'b'), ':a:b')
-        self.assertEqual(join('a:b', 'c'), 'a:b:c')
-        self.assertEqual(join('a:b', ':c'), 'a:b:c')
-        self.assertEqual(join('a', ':b', ':c'), ':a:b:c')
-        self.assertEqual(join('a', 'b:'), 'b:')
-        self.assertEqual(join('a:', 'b:'), 'b:')
-
-        self.assertEqual(join(b'a', b'b'), b':a:b')
-        self.assertEqual(join(b':a', b'b'), b':a:b')
-        self.assertEqual(join(b':a:', b'b'), b':a:b')
-        self.assertEqual(join(b':a::', b'b'), b':a::b')
-        self.assertEqual(join(b':a', b'::b'), b':a::b')
-        self.assertEqual(join(b'a', b':'), b':a:')
-        self.assertEqual(join(b'a:', b':'), b'a:')
-        self.assertEqual(join(b'a', b''), b':a:')
-        self.assertEqual(join(b'a:', b''), b'a:')
-        self.assertEqual(join(b'', b''), b'')
-        self.assertEqual(join(b'', b'a:b'), b'a:b')
-        self.assertEqual(join(b'', b'a', b'b'), b':a:b')
-        self.assertEqual(join(b'a:b', b'c'), b'a:b:c')
-        self.assertEqual(join(b'a:b', b':c'), b'a:b:c')
-        self.assertEqual(join(b'a', b':b', b':c'), b':a:b:c')
-        self.assertEqual(join(b'a', b'b:'), b'b:')
-        self.assertEqual(join(b'a:', b'b:'), b'b:')
-
-    def test_splitext(self):
-        splitext = macpath.splitext
-        self.assertEqual(splitext(":foo.ext"), (':foo', '.ext'))
-        self.assertEqual(splitext("foo:foo.ext"), ('foo:foo', '.ext'))
-        self.assertEqual(splitext(".ext"), ('.ext', ''))
-        self.assertEqual(splitext("foo.ext:foo"), ('foo.ext:foo', ''))
-        self.assertEqual(splitext(":foo.ext:"), (':foo.ext:', ''))
-        self.assertEqual(splitext(""), ('', ''))
-        self.assertEqual(splitext("foo.bar.ext"), ('foo.bar', '.ext'))
-
-        self.assertEqual(splitext(b":foo.ext"), (b':foo', b'.ext'))
-        self.assertEqual(splitext(b"foo:foo.ext"), (b'foo:foo', b'.ext'))
-        self.assertEqual(splitext(b".ext"), (b'.ext', b''))
-        self.assertEqual(splitext(b"foo.ext:foo"), (b'foo.ext:foo', b''))
-        self.assertEqual(splitext(b":foo.ext:"), (b':foo.ext:', b''))
-        self.assertEqual(splitext(b""), (b'', b''))
-        self.assertEqual(splitext(b"foo.bar.ext"), (b'foo.bar', b'.ext'))
-
-    def test_ismount(self):
-        ismount = macpath.ismount
-        self.assertEqual(ismount("a:"), True)
-        self.assertEqual(ismount("a:b"), False)
-        self.assertEqual(ismount("a:b:"), True)
-        self.assertEqual(ismount(""), False)
-        self.assertEqual(ismount(":"), False)
-
-        self.assertEqual(ismount(b"a:"), True)
-        self.assertEqual(ismount(b"a:b"), False)
-        self.assertEqual(ismount(b"a:b:"), True)
-        self.assertEqual(ismount(b""), False)
-        self.assertEqual(ismount(b":"), False)
-
-    def test_normpath(self):
-        normpath = macpath.normpath
-        self.assertEqual(normpath("a:b"), "a:b")
-        self.assertEqual(normpath("a"), ":a")
-        self.assertEqual(normpath("a:b::c"), "a:c")
-        self.assertEqual(normpath("a:b:c:::d"), "a:d")
-        self.assertRaises(macpath.norm_error, normpath, "a::b")
-        self.assertRaises(macpath.norm_error, normpath, "a:b:::c")
-        self.assertEqual(normpath(":"), ":")
-        self.assertEqual(normpath("a:"), "a:")
-        self.assertEqual(normpath("a:b:"), "a:b")
-
-        self.assertEqual(normpath(b"a:b"), b"a:b")
-        self.assertEqual(normpath(b"a"), b":a")
-        self.assertEqual(normpath(b"a:b::c"), b"a:c")
-        self.assertEqual(normpath(b"a:b:c:::d"), b"a:d")
-        self.assertRaises(macpath.norm_error, normpath, b"a::b")
-        self.assertRaises(macpath.norm_error, normpath, b"a:b:::c")
-        self.assertEqual(normpath(b":"), b":")
-        self.assertEqual(normpath(b"a:"), b"a:")
-        self.assertEqual(normpath(b"a:b:"), b"a:b")
-
-
-class MacCommonTest(test_genericpath.CommonTest, unittest.TestCase):
-    pathmodule = macpath
-
-    test_relpath_errors = None
-
-
-if __name__ == "__main__":
-    unittest.main()

Misc/NEWS.d/next/Library/2018-12-12-16-25-21.bpo-35471.SK8jFC.rst

+Python 2.4 dropped MacOS 9 support. The macpath module was deprecated in
+Python 3.7. The module is now removed.

PCbuild/lib.pyproj

@@ -655,7 +655,6 @@
     <Compile Include="logging\handlers.py" />
     <Compile Include="logging\__init__.py" />
     <Compile Include="lzma.py" />
-    <Compile Include="macpath.py" />
     <Compile Include="mailbox.py" />
     <Compile Include="mailcap.py" />
     <Compile Include="mimetypes.py" />
@@ -1176,7 +1175,6 @@
     <Compile Include="test\test_long.py" />
     <Compile Include="test\test_longexp.py" />
     <Compile Include="test\test_lzma.py" />
-    <Compile Include="test\test_macpath.py" />
     <Compile Include="test\test_mailbox.py" />
     <Compile Include="test\test_mailcap.py" />
     <Compile Include="test\test_marshal.py" />
@@ -1816,4 +1814,4 @@
     <Folder Include="xml\sax" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Python Tools\Microsoft.PythonTools.targets" />
-</Project>
+</Project>
\ No newline at end of file

Tools/freeze/freeze.py

@@ -124,7 +124,7 @@ def main():
 
     # default the exclude list for each platform
     if win: exclude = exclude + [
-        'dos', 'dospath', 'mac', 'macpath', 'macfs', 'MACFS', 'posix', ]
+        'dos', 'dospath', 'mac', 'macfs', 'MACFS', 'posix', ]
 
     fail_import = exclude[:]