def test_samestat(self): f = open(test_support.TESTFN + "1", "wb") try: f.write("foo") f.close() self.assertIs( posixpath.samestat(os.stat(test_support.TESTFN + "1"), os.stat(test_support.TESTFN + "1")), True) # If we don't have links, assume that os.stat() doesn't return # reasonable inode information and thus, that samestat() doesn't # work. if hasattr(os, "symlink"): os.symlink(test_support.TESTFN + "1", test_support.TESTFN + "2") self.assertIs( posixpath.samestat(os.stat(test_support.TESTFN + "1"), os.stat(test_support.TESTFN + "2")), True) os.remove(test_support.TESTFN + "2") f = open(test_support.TESTFN + "2", "wb") f.write("bar") f.close() self.assertIs( posixpath.samestat(os.stat(test_support.TESTFN + "1"), os.stat(test_support.TESTFN + "2")), False) finally: if not f.close(): f.close()
def test_samestat(self): f = open(support.TESTFN + "1", "wb") try: f.write(b"foo") f.close() self.assertIs( posixpath.samestat(os.stat(support.TESTFN + "1"), os.stat(support.TESTFN + "1")), True) # If we don't have links, assume that os.stat() doesn't return resonable # inode information and thus, that samefile() doesn't work if hasattr(os, "symlink"): if hasattr(os, "symlink"): os.symlink(support.TESTFN + "1", support.TESTFN + "2") self.assertIs( posixpath.samestat(os.stat(support.TESTFN + "1"), os.stat(support.TESTFN + "2")), True) os.remove(support.TESTFN + "2") f = open(support.TESTFN + "2", "wb") f.write(b"bar") f.close() self.assertIs( posixpath.samestat(os.stat(support.TESTFN + "1"), os.stat(support.TESTFN + "2")), False) finally: if not f.close(): f.close() self.assertRaises(TypeError, posixpath.samestat)
def test_samestat(self): f = open(test_support.TESTFN + "1", "wb") try: f.write("foo") f.close() self.assertIs( posixpath.samestat(os.stat(test_support.TESTFN + "1"), os.stat(test_support.TESTFN + "1")), True ) # If we don't have links, assume that os.stat() doesn't return resonable # inode information and thus, that samefile() doesn't work if hasattr(os, "symlink"): if hasattr(os, "symlink"): os.symlink(test_support.TESTFN + "1", test_support.TESTFN + "2") self.assertIs( posixpath.samestat(os.stat(test_support.TESTFN + "1"), os.stat(test_support.TESTFN + "2")), True ) os.remove(test_support.TESTFN + "2") f = open(test_support.TESTFN + "2", "wb") f.write("bar") f.close() self.assertIs( posixpath.samestat(os.stat(test_support.TESTFN + "1"), os.stat(test_support.TESTFN + "2")), False ) finally: if not f.close(): f.close()
def test_samestat_on_links(self) -> None: test_fn1 = support.TESTFN + "1" test_fn2 = support.TESTFN + "2" self._create_file(test_fn1) test_fns = [test_fn1, test_fn2] Any(os.symlink)(*test_fns) stats = map(os.stat, test_fns) self.assertTrue(posixpath.samestat(*stats)) os.remove(test_fn2) self._create_file(test_fn2) stats = map(os.stat, test_fns) self.assertFalse(posixpath.samestat(*stats)) self.assertRaises(TypeError, posixpath.samestat)
def test_samestat_on_links(self): test_fn1 = support.TESTFN + "1" test_fn2 = support.TESTFN + "2" self._create_file(test_fn1) test_fns = (test_fn1, test_fn2) os.symlink(*test_fns) stats = map(os.stat, test_fns) self.assertTrue(posixpath.samestat(*stats)) os.remove(test_fn2) self._create_file(test_fn2) stats = map(os.stat, test_fns) self.assertFalse(posixpath.samestat(*stats)) self.assertRaises(TypeError, posixpath.samestat)
def _fwalk(topfd, toppath, isbytes, topdown, onerror, follow_symlinks): scandir_it = scandir(topfd) dirs = [] nondirs = [] entries = None if topdown or follow_symlinks else [] for entry in scandir_it: name = entry.name if isbytes: name = fsencode(name) try: if entry.is_dir(): dirs.append(name) if entries is not None: entries.append(entry) else: nondirs.append(name) except OSError: try: if entry.is_symlink(): nondirs.append(name) except OSError: pass if topdown: yield (toppath, dirs, nondirs, topfd) for name in dirs if entries is None else zip(dirs, entries): try: if not follow_symlinks: if topdown: orig_st = stat(name, dir_fd=topfd, follow_symlinks=False) elif not entries is not None: raise AssertionError else: name, entry = name orig_st = entry.stat(follow_symlinks=False) dirfd = open(name, O_RDONLY, dir_fd=topfd) except OSError as err: try: if onerror is not None: onerror(err) continue finally: err = None del err try: if follow_symlinks or path.samestat(orig_st, stat(dirfd)): dirpath = path.join(toppath, name) yield from _fwalk(dirfd, dirpath, isbytes, topdown, onerror, follow_symlinks) finally: close(dirfd) if not topdown: yield (toppath, dirs, nondirs, topfd)
def _fwalk(topfd, toppath, isbytes, topdown, onerror, follow_symlinks): # Note: This uses O(depth of the directory tree) file descriptors: if # necessary, it can be adapted to only require O(1) FDs, see issue # #13734. scandir_it = scandir(topfd) dirs = [] nondirs = [] entries = None if topdown or follow_symlinks else [] for entry in scandir_it: name = entry.name if isbytes: name = fsencode(name) try: if entry.is_dir(): dirs.append(name) if entries is not None: entries.append(entry) else: nondirs.append(name) except OSError: try: # Add dangling symlinks, ignore disappeared files if entry.is_symlink(): nondirs.append(name) except OSError: pass if topdown: yield toppath, dirs, nondirs, topfd for name in dirs if entries is None else zip(dirs, entries): try: if not follow_symlinks: if topdown: orig_st = stat(name, dir_fd=topfd, follow_symlinks=False) else: assert entries is not None name, entry = name orig_st = entry.stat(follow_symlinks=False) dirfd = open(name, O_RDONLY, dir_fd=topfd) except OSError as err: if onerror is not None: onerror(err) continue try: if follow_symlinks or path.samestat(orig_st, stat(dirfd)): dirpath = path.join(toppath, name) yield from _fwalk(dirfd, dirpath, isbytes, topdown, onerror, follow_symlinks) finally: close(dirfd) if not topdown: yield toppath, dirs, nondirs, topfd
def fwalk(top=".", topdown=True, onerror=None, *, follow_symlinks=False, dir_fd=None): """Directory tree generator. This behaves exactly like walk(), except that it yields a 4-tuple dirpath, dirnames, filenames, dirfd `dirpath`, `dirnames` and `filenames` are identical to walk() output, and `dirfd` is a file descriptor referring to the directory `dirpath`. The advantage of fwalk() over walk() is that it's safe against symlink races (when follow_symlinks is False). If dir_fd is not None, it should be a file descriptor open to a directory, and top should be relative; top will then be relative to that directory. (dir_fd is always supported for fwalk.) Caution: Since fwalk() yields file descriptors, those are only valid until the next iteration step, so you should dup() them if you want to keep them for a longer period. Example: import os for root, dirs, files, rootfd in os.fwalk('python/Lib/email'): print(root, "consumes", end="") print(sum(os.stat(name, dir_fd=rootfd).st_size for name in files), end="") print("bytes in", len(files), "non-directory files") if 'CVS' in dirs: dirs.remove('CVS') # don't visit CVS directories """ sys.audit("os.fwalk", top, topdown, onerror, follow_symlinks, dir_fd) if not isinstance(top, int) or not hasattr(top, '__index__'): top = fspath(top) # Note: To guard against symlink races, we use the standard # lstat()/open()/fstat() trick. if not follow_symlinks: orig_st = stat(top, follow_symlinks=False, dir_fd=dir_fd) topfd = open(top, O_RDONLY, dir_fd=dir_fd) try: if (follow_symlinks or (st.S_ISDIR(orig_st.st_mode) and path.samestat(orig_st, stat(topfd)))): yield from _fwalk(topfd, top, isinstance(top, bytes), topdown, onerror, follow_symlinks) finally: close(topfd)
def _fwalk(topfd, toppath, isbytes, topdown, onerror, follow_symlinks): # Note: This uses O(depth of the directory tree) file descriptors: if # necessary, it can be adapted to only require O(1) FDs, see issue # #13734. names = listdir(topfd) if isbytes: names = map(fsencode, names) dirs, nondirs = [], [] for name in names: try: # Here, we don't use AT_SYMLINK_NOFOLLOW to be consistent with # walk() which reports symlinks to directories as directories. # We do however check for symlinks before recursing into # a subdirectory. if st.S_ISDIR(stat(name, dir_fd=topfd).st_mode): dirs.append(name) else: nondirs.append(name) except OSError: try: # Add dangling symlinks, ignore disappeared files if st.S_ISLNK( stat(name, dir_fd=topfd, follow_symlinks=False).st_mode): nondirs.append(name) except OSError: continue if topdown: yield toppath, dirs, nondirs, topfd for name in dirs: try: orig_st = stat(name, dir_fd=topfd, follow_symlinks=follow_symlinks) dirfd = open(name, O_RDONLY, dir_fd=topfd) except OSError as err: if onerror is not None: onerror(err) continue try: if follow_symlinks or path.samestat(orig_st, stat(dirfd)): dirpath = path.join(toppath, name) yield from _fwalk(dirfd, dirpath, isbytes, topdown, onerror, follow_symlinks) finally: close(dirfd) if not topdown: yield toppath, dirs, nondirs, topfd
def fwalk(top='.', topdown=True, onerror=None, *, follow_symlinks=False, dir_fd=None): orig_st = stat(top, follow_symlinks=False, dir_fd=dir_fd) topfd = open(top, O_RDONLY, dir_fd=dir_fd) try: while follow_symlinks or st.S_ISDIR( orig_st.st_mode) and path.samestat(orig_st, stat(topfd)): yield _fwalk(topfd, top, topdown, onerror, follow_symlinks) finally: close(topfd)
def _fwalk(topfd, toppath, topdown, onerror, follow_symlinks): # Note: This uses O(depth of the directory tree) file descriptors: if # necessary, it can be adapted to only require O(1) FDs, see issue # #13734. names = listdir(topfd) dirs, nondirs = [], [] for name in names: try: # Here, we don't use AT_SYMLINK_NOFOLLOW to be consistent with # walk() which reports symlinks to directories as directories. # We do however check for symlinks before recursing into # a subdirectory. if st.S_ISDIR(stat(name, dir_fd=topfd).st_mode): dirs.append(name) else: nondirs.append(name) except FileNotFoundError: try: # Add dangling symlinks, ignore disappeared files if st.S_ISLNK( stat(name, dir_fd=topfd, follow_symlinks=False) .st_mode): nondirs.append(name) except FileNotFoundError: continue if topdown: yield toppath, dirs, nondirs, topfd for name in dirs: try: orig_st = stat(name, dir_fd=topfd, follow_symlinks=follow_symlinks) dirfd = open(name, O_RDONLY, dir_fd=topfd) except OSError as err: if onerror is not None: onerror(err) continue try: if follow_symlinks or path.samestat(orig_st, stat(dirfd)): dirpath = path.join(toppath, name) yield from _fwalk(dirfd, dirpath, topdown, onerror, follow_symlinks) finally: close(dirfd) if not topdown: yield toppath, dirs, nondirs, topfd
def fwalk(top=".", topdown=True, onerror=None, *, follow_symlinks=False, dir_fd=None): """Directory tree generator. This behaves exactly like walk(), except that it yields a 4-tuple dirpath, dirnames, filenames, dirfd `dirpath`, `dirnames` and `filenames` are identical to walk() output, and `dirfd` is a file descriptor referring to the directory `dirpath`. The advantage of fwalk() over walk() is that it's safe against symlink races (when follow_symlinks is False). If dir_fd is not None, it should be a file descriptor open to a directory, and top should be relative; top will then be relative to that directory. (dir_fd is always supported for fwalk.) Caution: Since fwalk() yields file descriptors, those are only valid until the next iteration step, so you should dup() them if you want to keep them for a longer period. Example: import os for root, dirs, files, rootfd in os.fwalk('python/Lib/email'): print(root, "consumes", end="") print(sum([os.stat(name, dir_fd=rootfd).st_size for name in files]), end="") print("bytes in", len(files), "non-directory files") if 'CVS' in dirs: dirs.remove('CVS') # don't visit CVS directories """ if not isinstance(top, int) or not hasattr(top, '__index__'): top = fspath(top) # Note: To guard against symlink races, we use the standard # lstat()/open()/fstat() trick. if not follow_symlinks: orig_st = stat(top, follow_symlinks=False, dir_fd=dir_fd) topfd = open(top, O_RDONLY, dir_fd=dir_fd) try: if (follow_symlinks or (st.S_ISDIR(orig_st.st_mode) and path.samestat(orig_st, stat(topfd)))): yield from _fwalk(topfd, top, isinstance(top, bytes), topdown, onerror, follow_symlinks) finally: close(topfd)
def fwalk(top=".", topdown=True, onerror=None, *, follow_symlinks=False, dir_fd=None): if not isinstance(top, int) or not hasattr(top, '__index__'): top = fspath(top) # Note: To guard against symlink races, we use the standard # lstat()/open()/fstat() trick. if not follow_symlinks: orig_st = stat(top, follow_symlinks=False, dir_fd=dir_fd) topfd = open(top, O_RDONLY, dir_fd=dir_fd) try: if (follow_symlinks or (st.S_ISDIR(orig_st.st_mode) and path.samestat(orig_st, stat(topfd)))): yield from _fwalk(topfd, top, isinstance(top, bytes), topdown, onerror, follow_symlinks) finally: close(topfd)
def fwalk(top, topdown=True, onerror=None, followlinks=False): """Directory tree generator. This behaves exactly like walk(), except that it yields a 4-tuple dirpath, dirnames, filenames, dirfd `dirpath`, `dirnames` and `filenames` are identical to walk() output, and `dirfd` is a file descriptor referring to the directory `dirpath`. The advantage of walkfd() over walk() is that it's safe against symlink races (when followlinks is False). Caution: Since fwalk() yields file descriptors, those are only valid until the next iteration step, so you should dup() them if you want to keep them for a longer period. Example: import os for root, dirs, files, rootfd in os.fwalk('python/Lib/email'): print(root, "consumes", end="") print(sum([os.fstatat(rootfd, name).st_size for name in files]), end="") print("bytes in", len(files), "non-directory files") if 'CVS' in dirs: dirs.remove('CVS') # don't visit CVS directories """ # Note: To guard against symlink races, we use the standard # lstat()/open()/fstat() trick. orig_st = lstat(top) topfd = open(top, O_RDONLY) try: if (followlinks or (st.S_ISDIR(orig_st.st_mode) and path.samestat(orig_st, fstat(topfd)))): for x in _fwalk(topfd, top, topdown, onerror, followlinks): yield x finally: close(topfd)
def _fwalk(topfd, toppath, topdown, onerror, followlinks): # Note: This uses O(depth of the directory tree) file descriptors: if # necessary, it can be adapted to only require O(1) FDs, see issue # #13734. # whether to follow symlinks flag = 0 if followlinks else AT_SYMLINK_NOFOLLOW names = flistdir(topfd) dirs, nondirs = [], [] for name in names: # Here, we don't use AT_SYMLINK_NOFOLLOW to be consistent with # walk() which reports symlinks to directories as directories. We do # however check for symlinks before recursing into a subdirectory. if st.S_ISDIR(fstatat(topfd, name).st_mode): dirs.append(name) else: nondirs.append(name) if topdown: yield toppath, dirs, nondirs, topfd for name in dirs: try: orig_st = fstatat(topfd, name, flag) dirfd = openat(topfd, name, O_RDONLY) except error as err: if onerror is not None: onerror(err) return try: if followlinks or path.samestat(orig_st, fstat(dirfd)): dirpath = path.join(toppath, name) for x in _fwalk(dirfd, dirpath, topdown, onerror, followlinks): yield x finally: close(dirfd) if not topdown: yield toppath, dirs, nondirs, topfd
def _fwalk(topfd, toppath, topdown, onerror, follow_symlinks): names = listdir(topfd) dirs, nondirs = [], [] for name in names: try: if st.S_ISDIR(stat(name, dir_fd=topfd).st_mode): dirs.append(name) else: nondirs.append(name) except OSError: try: if st.S_ISLNK( stat(name, dir_fd=topfd, follow_symlinks=False).st_mode): nondirs.append(name) except OSError: continue if topdown: yield toppath, dirs, nondirs, topfd for name in dirs: try: orig_st = stat(name, dir_fd=topfd, follow_symlinks=follow_symlinks) dirfd = open(name, O_RDONLY, dir_fd=topfd) except OSError as err: if onerror is not None: onerror(err) continue try: if follow_symlinks or path.samestat(orig_st, stat(dirfd)): dirpath = path.join(toppath, name) yield from _fwalk(dirfd, dirpath, topdown, onerror, follow_symlinks) finally: close(dirfd) if not topdown: yield toppath, dirs, nondirs, topfd
def samefile(f1, f2): """ Backport of samefile from Python 3.2 with support for Windows. """ return posixpath.samestat(compat_stat(f1), compat_stat(f2))
def test_samestat(self) -> None: test_fn = support.TESTFN + "1" self._create_file(test_fn) test_fns = [test_fn] * 2 stats = map(os.stat, test_fns) self.assertTrue(posixpath.samestat(*stats))
def test_samestat(self): test_fn = support.TESTFN + "1" self._create_file(test_fn) test_fns = [test_fn] * 2 stats = map(os.stat, test_fns) self.assertTrue(posixpath.samestat(*stats))
def update_event(self, inp=-1): self.set_output_val(0, posixpath.samestat(self.input(0), self.input(1)))