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.
This commit is contained in:
Victor Stinner
GitHub
parent
4aa917c5fe
commit
d7538dd5e3
|
|
@ -22,7 +22,6 @@ in this chapter is:
|
|||
fnmatch.rst
|
||||
linecache.rst
|
||||
shutil.rst
|
||||
macpath.rst
|
||||
|
||||
|
||||
.. seealso::
|
||||
|
|
|
|||
|
|
@ -1,21 +0,0 @@
|
|||
: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.
|
||||
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
||||
|
|
|
|||
216
Lib/macpath.py
216
Lib/macpath.py
|
|
@ -1,216 +0,0 @@
|
|||
"""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
|
||||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
"""
|
||||
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)
|
||||
|
|
|
|||
|
|
@ -1,155 +0,0 @@
|
|||
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()
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
Python 2.4 dropped MacOS 9 support. The macpath module was deprecated in
|
||||
Python 3.7. The module is now removed.
|
||||
|
|
@ -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>
|
||||
|
|
|
|||
|
|
@ -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[:]
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue