Python 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):
        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):
        # 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(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(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(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 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 samefile(f1, f2):
	"""
	Backport of samefile from Python 3.2 with support for Windows.
	"""
	return posixpath.samestat(compat_stat(f1), compat_stat(f2))