* :mod:`macpath` for old-style MacOS paths
+.. versionchanged:: 3.8
+
+ :func:`exists`, :func:`lexists`, :func:`isdir`, :func:`isfile`,
+ :func:`islink`, and :func:`ismount` now return ``False`` instead of
+ raising an exception for paths that contain characters or bytes
+ unrepresentable at the OS level.
+
+
.. function:: abspath(path)
Return a normalized absolutized version of the pathname *path*. On most
Concrete paths provide the following methods in addition to pure paths
methods. Many of these methods can raise an :exc:`OSError` if a system
-call fails (for example because the path doesn't exist):
+call fails (for example because the path doesn't exist).
+
+.. versionchanged:: 3.8
+
+ :meth:`~Path.exists()`, :meth:`~Path.is_dir()`, :meth:`~Path.is_file()`,
+ :meth:`~Path.is_mount()`, :meth:`~Path.is_symlink()`,
+ :meth:`~Path.is_block_device()`, :meth:`~Path.is_char_device()`,
+ :meth:`~Path.is_fifo()`, :meth:`~Path.is_socket()` now return ``False``
+ instead of raising an exception for paths that contain characters
+ unrepresentable at the OS level.
+
.. classmethod:: Path.cwd()
Improved Modules
================
+os.path
+-------
+
+:mod:`os.path` functions that return a boolean result like
+:func:`~os.path.exists`, :func:`~os.path.lexists`, :func:`~os.path.isdir`,
+:func:`~os.path.isfile`, :func:`~os.path.islink`, and :func:`~os.path.ismount`
+now return ``False`` instead of raising :exc:`ValueError` or its subclasses
+:exc:`UnicodeEncodeError` and :exc:`UnicodeDecodeError` for paths that contain
+characters or bytes unrepresentable at the OS level.
+(Contributed by Serhiy Storchaka in :issue:`33721`.)
+
+pathlib
+-------
+
+:mod:`pathlib.Path` methods that return a boolean result like
+:meth:`~pathlib.Path.exists()`, :meth:`~pathlib.Path.is_dir()`,
+:meth:`~pathlib.Path.is_file()`, :meth:`~pathlib.Path.is_mount()`,
+:meth:`~pathlib.Path.is_symlink()`, :meth:`~pathlib.Path.is_block_device()`,
+:meth:`~pathlib.Path.is_char_device()`, :meth:`~pathlib.Path.is_fifo()`,
+:meth:`~pathlib.Path.is_socket()` now return ``False`` instead of raising
+:exc:`ValueError` or its subclass :exc:`UnicodeEncodeError` for paths that
+contain characters unrepresentable at the OS level.
+(Contributed by Serhiy Storchaka in :issue:`33721`.)
+
+
Optimizations
=============
"""Test whether a path exists. Returns False for broken symbolic links"""
try:
os.stat(path)
- except OSError:
+ except (OSError, ValueError):
return False
return True
"""Test whether a path is a regular file"""
try:
st = os.stat(path)
- except OSError:
+ except (OSError, ValueError):
return False
return stat.S_ISREG(st.st_mode)
"""Return true if the pathname refers to an existing directory."""
try:
st = os.stat(s)
- except OSError:
+ except (OSError, ValueError):
return False
return stat.S_ISDIR(st.st_mode)
try:
st = os.lstat(path)
- except OSError:
+ except (OSError, ValueError):
return False
return True
"""
try:
st = os.lstat(path)
- except (OSError, AttributeError):
+ except (OSError, ValueError, AttributeError):
return False
return stat.S_ISLNK(st.st_mode)
"""Test whether a path exists. Returns True for broken symbolic links"""
try:
st = os.lstat(path)
- except OSError:
+ except (OSError, ValueError):
return False
return True
"""Return the absolute version of a path."""
try:
return _getfullpathname(path)
- except OSError:
+ except (OSError, ValueError):
return _abspath_fallback(path)
# realpath is a no-op on systems without islink support
if e.errno not in _IGNORED_ERROS:
raise
return False
+ except ValueError:
+ # Non-encodable path
+ return False
return True
def is_dir(self):
# Path doesn't exist or is a broken symlink
# (see https://bitbucket.org/pitrou/pathlib/issue/12/)
return False
+ except ValueError:
+ # Non-encodable path
+ return False
def is_file(self):
"""
# Path doesn't exist or is a broken symlink
# (see https://bitbucket.org/pitrou/pathlib/issue/12/)
return False
+ except ValueError:
+ # Non-encodable path
+ return False
def is_mount(self):
"""
raise
# Path doesn't exist
return False
+ except ValueError:
+ # Non-encodable path
+ return False
def is_block_device(self):
"""
# Path doesn't exist or is a broken symlink
# (see https://bitbucket.org/pitrou/pathlib/issue/12/)
return False
+ except ValueError:
+ # Non-encodable path
+ return False
def is_char_device(self):
"""
# Path doesn't exist or is a broken symlink
# (see https://bitbucket.org/pitrou/pathlib/issue/12/)
return False
+ except ValueError:
+ # Non-encodable path
+ return False
def is_fifo(self):
"""
# Path doesn't exist or is a broken symlink
# (see https://bitbucket.org/pitrou/pathlib/issue/12/)
return False
+ except ValueError:
+ # Non-encodable path
+ return False
def is_socket(self):
"""
# Path doesn't exist or is a broken symlink
# (see https://bitbucket.org/pitrou/pathlib/issue/12/)
return False
+ except ValueError:
+ # Non-encodable path
+ return False
def expanduser(self):
""" Return a new path with expanded ~ and ~user constructs
"""Test whether a path is a symbolic link"""
try:
st = os.lstat(path)
- except (OSError, AttributeError):
+ except (OSError, ValueError, AttributeError):
return False
return stat.S_ISLNK(st.st_mode)
"""Test whether a path exists. Returns True for broken symbolic links"""
try:
os.lstat(path)
- except OSError:
+ except (OSError, ValueError):
return False
return True
"""Test whether a path is a mount point"""
try:
s1 = os.lstat(path)
- except OSError:
+ except (OSError, ValueError):
# It doesn't exist -- so not a mount point. :-)
return False
else:
parent = realpath(parent)
try:
s2 = os.lstat(parent)
- except OSError:
+ except (OSError, ValueError):
return False
dev1 = s1.st_dev
self.assertIs(self.pathmodule.exists(filename), True)
self.assertIs(self.pathmodule.exists(bfilename), True)
+ self.assertIs(self.pathmodule.exists(filename + '\udfff'), False)
+ self.assertIs(self.pathmodule.exists(bfilename + b'\xff'), False)
+ self.assertIs(self.pathmodule.exists(filename + '\x00'), False)
+ self.assertIs(self.pathmodule.exists(bfilename + b'\x00'), False)
+
if self.pathmodule is not genericpath:
self.assertIs(self.pathmodule.lexists(filename), True)
self.assertIs(self.pathmodule.lexists(bfilename), True)
+ self.assertIs(self.pathmodule.lexists(filename + '\udfff'), False)
+ self.assertIs(self.pathmodule.lexists(bfilename + b'\xff'), False)
+ self.assertIs(self.pathmodule.lexists(filename + '\x00'), False)
+ self.assertIs(self.pathmodule.lexists(bfilename + b'\x00'), False)
+
@unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
def test_exists_fd(self):
r, w = os.pipe()
self.assertIs(self.pathmodule.isdir(filename), False)
self.assertIs(self.pathmodule.isdir(bfilename), False)
+ self.assertIs(self.pathmodule.isdir(filename + '\udfff'), False)
+ self.assertIs(self.pathmodule.isdir(bfilename + b'\xff'), False)
+ self.assertIs(self.pathmodule.isdir(filename + '\x00'), False)
+ self.assertIs(self.pathmodule.isdir(bfilename + b'\x00'), False)
+
try:
create_file(filename)
self.assertIs(self.pathmodule.isdir(filename), False)
self.assertIs(self.pathmodule.isfile(filename), False)
self.assertIs(self.pathmodule.isfile(bfilename), False)
+ self.assertIs(self.pathmodule.isfile(filename + '\udfff'), False)
+ self.assertIs(self.pathmodule.isfile(bfilename + b'\xff'), False)
+ self.assertIs(self.pathmodule.isfile(filename + '\x00'), False)
+ self.assertIs(self.pathmodule.isfile(bfilename + b'\x00'), False)
+
try:
create_file(filename)
self.assertIs(self.pathmodule.isfile(filename), True)
continue
func = getattr(self.pathmodule, attr)
with self.subTest(attr=attr):
- try:
+ if attr in ('exists', 'isdir', 'isfile'):
func('/tmp\udfffabcds')
- except (OSError, UnicodeEncodeError):
- pass
- try:
func(b'/tmp\xffabcds')
- except (OSError, UnicodeDecodeError):
- pass
- with self.assertRaisesRegex(ValueError, 'embedded null'):
func('/tmp\x00abcds')
- with self.assertRaisesRegex(ValueError, 'embedded null'):
func(b'/tmp\x00abcds')
+ else:
+ with self.assertRaises((OSError, UnicodeEncodeError)):
+ func('/tmp\udfffabcds')
+ with self.assertRaises((OSError, UnicodeDecodeError)):
+ func(b'/tmp\xffabcds')
+ with self.assertRaisesRegex(ValueError, 'embedded null'):
+ func('/tmp\x00abcds')
+ with self.assertRaisesRegex(ValueError, 'embedded null'):
+ 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).
self.assertIs(False, (p / 'linkA' / 'bah').exists())
self.assertIs(False, (p / 'foo').exists())
self.assertIs(False, P('/xyzzy').exists())
+ self.assertIs(False, P(BASE + '\udfff').exists())
+ self.assertIs(False, P(BASE + '\x00').exists())
def test_open_common(self):
p = self.cls(BASE)
if support.can_symlink():
self.assertFalse((P / 'linkA').is_dir())
self.assertTrue((P / 'linkB').is_dir())
- self.assertFalse((P/ 'brokenLink').is_dir())
+ self.assertFalse((P/ 'brokenLink').is_dir(), False)
+ self.assertIs((P / 'dirA\udfff').is_dir(), False)
+ self.assertIs((P / 'dirA\x00').is_dir(), False)
def test_is_file(self):
P = self.cls(BASE)
self.assertTrue((P / 'linkA').is_file())
self.assertFalse((P / 'linkB').is_file())
self.assertFalse((P/ 'brokenLink').is_file())
+ self.assertIs((P / 'fileA\udfff').is_file(), False)
+ self.assertIs((P / 'fileA\x00').is_file(), False)
@only_posix
def test_is_mount(self):
self.assertTrue(R.is_mount())
if support.can_symlink():
self.assertFalse((P / 'linkA').is_mount())
+ self.assertIs(self.cls('/\udfff').is_mount(), False)
+ self.assertIs(self.cls('/\x00').is_mount(), False)
def test_is_symlink(self):
P = self.cls(BASE)
self.assertTrue((P / 'linkA').is_symlink())
self.assertTrue((P / 'linkB').is_symlink())
self.assertTrue((P/ 'brokenLink').is_symlink())
+ self.assertIs((P / 'fileA\udfff').is_file(), False)
+ self.assertIs((P / 'fileA\x00').is_file(), False)
+ if support.can_symlink():
+ self.assertIs((P / 'linkA\udfff').is_file(), False)
+ self.assertIs((P / 'linkA\x00').is_file(), False)
def test_is_fifo_false(self):
P = self.cls(BASE)
self.assertFalse((P / 'dirA').is_fifo())
self.assertFalse((P / 'non-existing').is_fifo())
self.assertFalse((P / 'fileA' / 'bah').is_fifo())
+ self.assertIs((P / 'fileA\udfff').is_fifo(), False)
+ self.assertIs((P / 'fileA\x00').is_fifo(), False)
@unittest.skipUnless(hasattr(os, "mkfifo"), "os.mkfifo() required")
def test_is_fifo_true(self):
self.assertTrue(P.is_fifo())
self.assertFalse(P.is_socket())
self.assertFalse(P.is_file())
+ self.assertIs(self.cls(BASE, 'myfifo\udfff').is_fifo(), False)
+ self.assertIs(self.cls(BASE, 'myfifo\x00').is_fifo(), False)
def test_is_socket_false(self):
P = self.cls(BASE)
self.assertFalse((P / 'dirA').is_socket())
self.assertFalse((P / 'non-existing').is_socket())
self.assertFalse((P / 'fileA' / 'bah').is_socket())
+ self.assertIs((P / 'fileA\udfff').is_socket(), False)
+ self.assertIs((P / 'fileA\x00').is_socket(), False)
@unittest.skipUnless(hasattr(socket, "AF_UNIX"), "Unix sockets required")
def test_is_socket_true(self):
self.assertTrue(P.is_socket())
self.assertFalse(P.is_fifo())
self.assertFalse(P.is_file())
+ self.assertIs(self.cls(BASE, 'mysock\udfff').is_socket(), False)
+ self.assertIs(self.cls(BASE, 'mysock\x00').is_socket(), False)
def test_is_block_device_false(self):
P = self.cls(BASE)
self.assertFalse((P / 'dirA').is_block_device())
self.assertFalse((P / 'non-existing').is_block_device())
self.assertFalse((P / 'fileA' / 'bah').is_block_device())
+ self.assertIs((P / 'fileA\udfff').is_block_device(), False)
+ self.assertIs((P / 'fileA\x00').is_block_device(), False)
def test_is_char_device_false(self):
P = self.cls(BASE)
self.assertFalse((P / 'dirA').is_char_device())
self.assertFalse((P / 'non-existing').is_char_device())
self.assertFalse((P / 'fileA' / 'bah').is_char_device())
+ self.assertIs((P / 'fileA\udfff').is_char_device(), False)
+ self.assertIs((P / 'fileA\x00').is_char_device(), False)
def test_is_char_device_true(self):
# Under Unix, /dev/null should generally be a char device
self.assertTrue(P.is_char_device())
self.assertFalse(P.is_block_device())
self.assertFalse(P.is_file())
+ self.assertIs(self.cls('/dev/null\udfff').is_char_device(), False)
+ self.assertIs(self.cls('/dev/null\x00').is_char_device(), False)
def test_pickling_common(self):
p = self.cls(BASE, 'fileA')
def test_islink(self):
self.assertIs(posixpath.islink(support.TESTFN + "1"), False)
self.assertIs(posixpath.lexists(support.TESTFN + "2"), False)
+
with open(support.TESTFN + "1", "wb") as f:
f.write(b"foo")
self.assertIs(posixpath.islink(support.TESTFN + "1"), False)
+
if support.can_symlink():
os.symlink(support.TESTFN + "1", support.TESTFN + "2")
self.assertIs(posixpath.islink(support.TESTFN + "2"), True)
self.assertIs(posixpath.exists(support.TESTFN + "2"), False)
self.assertIs(posixpath.lexists(support.TESTFN + "2"), True)
+ self.assertIs(posixpath.islink(support.TESTFN + "\udfff"), False)
+ self.assertIs(posixpath.islink(os.fsencode(support.TESTFN) + b"\xff"), False)
+ self.assertIs(posixpath.islink(support.TESTFN + "\x00"), False)
+ self.assertIs(posixpath.islink(os.fsencode(support.TESTFN) + b"\x00"), False)
+
def test_ismount(self):
self.assertIs(posixpath.ismount("/"), True)
self.assertIs(posixpath.ismount(b"/"), True)
finally:
safe_rmdir(ABSTFN)
+ self.assertIs(posixpath.ismount('/\udfff'), False)
+ self.assertIs(posixpath.ismount(b'/\xff'), False)
+ self.assertIs(posixpath.ismount('/\x00'), False)
+ self.assertIs(posixpath.ismount(b'/\x00'), False)
+
@unittest.skipUnless(support.can_symlink(),
"Test requires symlink support")
def test_ismount_symlinks(self):
# Issue 5258
pth_dir, pth_fn = self.make_pth("abc\x00def\n")
with captured_stderr() as err_out:
- site.addpackage(pth_dir, pth_fn, set())
- self.assertRegex(err_out.getvalue(), "line 1")
- self.assertRegex(err_out.getvalue(),
- re.escape(os.path.join(pth_dir, pth_fn)))
- # XXX: ditto previous XXX comment.
- self.assertRegex(err_out.getvalue(), 'Traceback')
- self.assertRegex(err_out.getvalue(), 'ValueError')
+ self.assertFalse(site.addpackage(pth_dir, pth_fn, set()))
+ self.assertEqual(err_out.getvalue(), "")
+ for path in sys.path:
+ if isinstance(path, str):
+ self.assertNotIn("abc\x00def", path)
def test_addsitedir(self):
# Same tests for test_addpackage since addsitedir() essentially just
--- /dev/null
+:mod:`os.path` functions that return a boolean result like
+:func:`~os.path.exists`, :func:`~os.path.lexists`, :func:`~os.path.isdir`,
+:func:`~os.path.isfile`, :func:`~os.path.islink`, and :func:`~os.path.ismount`,
+and :mod:`pathlib.Path` methods that return a boolean result like
+:meth:`~pathlib.Path.exists()`, :meth:`~pathlib.Path.is_dir()`,
+:meth:`~pathlib.Path.is_file()`, :meth:`~pathlib.Path.is_mount()`,
+:meth:`~pathlib.Path.is_symlink()`, :meth:`~pathlib.Path.is_block_device()`,
+:meth:`~pathlib.Path.is_char_device()`, :meth:`~pathlib.Path.is_fifo()`,
+:meth:`~pathlib.Path.is_socket()` now return ``False`` instead of raising
+:exc:`ValueError` or its subclasses :exc:`UnicodeEncodeError` and
+:exc:`UnicodeDecodeError` for paths that contain characters or bytes
+unrepresentable at the OS level.
#define OS__ISDIR_METHODDEF \
{"_isdir", (PyCFunction)os__isdir, METH_O, os__isdir__doc__},
-static PyObject *
-os__isdir_impl(PyObject *module, path_t *path);
-
-static PyObject *
-os__isdir(PyObject *module, PyObject *arg)
-{
- PyObject *return_value = NULL;
- path_t path = PATH_T_INITIALIZE("_isdir", "path", 0, 0);
-
- if (!PyArg_Parse(arg, "O&:_isdir", path_converter, &path)) {
- goto exit;
- }
- return_value = os__isdir_impl(module, &path);
-
-exit:
- /* Cleanup for path */
- path_cleanup(&path);
-
- return return_value;
-}
-
#endif /* defined(MS_WINDOWS) */
#if defined(MS_WINDOWS)
#ifndef OS_GETRANDOM_METHODDEF
#define OS_GETRANDOM_METHODDEF
#endif /* !defined(OS_GETRANDOM_METHODDEF) */
-/*[clinic end generated code: output=0f23518dd4482e66 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=40cac0135f846202 input=a9049054013a1b77]*/
/*[clinic input]
os._isdir
- path: path_t
+ path as arg: object
/
Return true if the pathname refers to an existing directory.
[clinic start generated code]*/
static PyObject *
-os__isdir_impl(PyObject *module, path_t *path)
-/*[clinic end generated code: output=75f56f32720836cb input=5e0800149c0ad95f]*/
+os__isdir(PyObject *module, PyObject *arg)
+/*[clinic end generated code: output=404f334d85d4bf25 input=36cb6785874d479e]*/
{
DWORD attributes;
+ path_t path = PATH_T_INITIALIZE("_isdir", "path", 0, 0);
+
+ if (!path_converter(arg, &path)) {
+ if (PyErr_ExceptionMatches(PyExc_ValueError)) {
+ PyErr_Clear();
+ Py_RETURN_FALSE;
+ }
+ return NULL;
+ }
Py_BEGIN_ALLOW_THREADS
- attributes = GetFileAttributesW(path->wide);
+ attributes = GetFileAttributesW(path.wide);
Py_END_ALLOW_THREADS
+ path_cleanup(&path);
if (attributes == INVALID_FILE_ATTRIBUTES)
Py_RETURN_FALSE;
projects / thirdparty / Python / cpython.git / commitdiff
