Is there a way to check whether two paths (or filesystems) are referencing the same file?

[tfeldmann]

I'd like to know if there is a way to check whether two pathes reference the same file.
I found that not even the filesystems can be compared:

>>> import fs
>>> fs1 = fs.open_fs("~/Desktop")
>>> fs2 = fs.open_fs("~/Desktop")
>>> fs1 == fs2
False

At the moment I'm resorting to this, which is not nice and complete at all.

from typing import NamedTuple

class Resource(NamedTuple):
    fs: FS
    path: str

def is_same(a: Resource, b: Resource):
    from fs.osfs import OSFS
    from fs.zipfs import ZipFS
    from fs.tarfs import TarFS

    if isinstance(a.fs, OSFS) and isinstance(b.fs, OSFS):
        return a.fs.getospath(a.path) == b.fs.getospath(b.path)
    elif isinstance(a.fs, ZipFS) and isinstance(b.fs, ZipFS):
        return a.fs._file == b.fs._file and a.path == b.path
    elif isinstance(a.fs, TarFS) and isinstance(b.fs, TarFS):
        return a.fs._file == b.fs._file and a.path == b.path
    return False

Is there a nicer way to check this?
Would you be interested in a PR that fixes the __eq__ method for some filesystems?

[lurch]

a) What's the use-case for wanting to do that?

b) I think a better starting-approach might be:

def is_same_resource(fs1, path1, fs2, path2):
    if fs1.hassyspath(path1) and fs2.hassyspath(path2):
        return fs1.getsyspath(path1) == fs2.getsyspath(path2)
    elif fs1.hasurl(path1) and fs2.hasurl(path2):
        return fs1.geturl(path1) == fs2.geturl(path2)
    else:
        # add any other special-case code you might want here?
    return False

[tfeldmann]

Ok the use case is a bit complex. I'm currently migrating organize to pyfilesystem. Organize has a duplicate detection.

Now image users having a config with a list of (fs, path) tuples like this:

"locations": [
  ("~/Desktop/", "/"),
  ("~", "/Desktop"),
  ("zip:///Users/test/myzip.zip", "/"),
]

For each tuple a Walker is created. All files emitted by the chained walkers are now checked for duplicates.
So without the is_same_resource check every file on this poor guy's desktop would be detected as a duplicate.

[lurch]

Would users expect a file-inside-a-zipfile to be detected as a duplicate of a file-on-the-desktop? Obviously that'd need slightly more complex logic.

Just to be pedantic, your previous comment is a list of (fsurl, fspath) tuples 😉

[tfeldmann]

Would users expect a file-inside-a-zipfile to be detected as a duplicate of a file-on-the-desktop? Obviously that'd need slightly more complex logic.

Yes, that's expected. The duplicate detection is ultimately done via hashing (first check for same filesize, then check for the hash of the first 1024 bytes, then check full hashes).

What is not expected is that a file is a duplicate of itself if the location is given twice.

Just to be pedantic, your previous comment is a list of (fsurl, fspath) tuples 😉

Yes that's what I meant 😅

[lurch]

What is not expected is that a file is a duplicate of itself if the location is given twice.

I believe my getsyspath suggestion would avoid that. Alternatively, maybe you should (also?) display an error if one of the "(fsurl, fspath) tuples" in the config is the same as, or a subdirectory of, one of the other tuples? (again, that should be fairly easy to check using getsyspath)

[tfeldmann]

Alternatively, maybe you should (also?) display an error if one of the "(fsurl, fspath) tuples" in the config is the same as, or a subdirectory of, one of the other tuples? (again, that should be fairly easy to check using getsyspath)

Yes, that sound good!

Just for reference if somebody else needs it:

from fs.zipfs import WriteZipFS, ReadZipFS
from fs.tarfs import WriteTarFS, ReadTarFS
from fs.errors import NoSysPath, NoURL

def is_same_resource(fs1, path1, fs2, path2):
    if isinstance(fs1, fs2.__class__):
        try:
            return fs1.getsyspath(path1) == fs2.getsyspath(path2)
        except NoSysPath:
            pass
        try:
            return fs1.geturl(path1) == fs2.geturl(path2)
        except NoURL:
            pass
        if isinstance(fs1, (WriteZipFS, ReadZipFS, WriteTarFS, ReadTarFS)):
            return path1 == path2 and fs1._file == fs2._file
    return False

[lurch]

if isinstance(fs1, (WriteZipFS, ReadZipFS, WriteTarFS, ReadTarFS)): - you probably want to check that fs2 has the same type as fs1 as well?

[tfeldmann]

That's ensured in if isinstance(fs1, fs2.__class__)

[lurch]

Oh, haha, I somehow glazed over that bit of the code 👍

[lurch]

Hmmm, strictly-speaking the fs1.getsyspath(path1) == fs2.getsyspath(path2) check could come before the isinstance(fs1, fs2.__class__) check, because the paths may map to the same underlying system-path, even if the filesystems themselves are different classes?

[tfeldmann]

Added support for WrapFS comparison:

def is_same_resource(fs1: FS, path1: str, fs2: FS, path2: str):
    from fs.errors import NoSysPath, NoURL
    from fs.tarfs import ReadTarFS, WriteTarFS
    from fs.zipfs import ReadZipFS, WriteZipFS
    from fs.wrapfs import WrapFS
    from fs.path import normpath, join

    def unwrap(fs, path):
        base = "/"
        if isinstance(fs, WrapFS):
            fs, base = fs.delegate_path("/")
        return fs, normpath(join(base, path))  # to support ".." in path

    # completely unwrap WrapFS instances
    fs1, path1 = unwrap(fs1, path1)
    fs2, path2 = unwrap(fs2, path2)

    # obvious check
    if fs1 == fs2 and path1 == path2:
        return True

    # check all fs with syspath support
    try:
        return fs1.getsyspath(path1) == fs2.getsyspath(path2)
    except NoSysPath:
        pass

    # check zip and tar
    Tar = (WriteTarFS, ReadTarFS)
    Zip = (WriteZipFS, ReadZipFS)
    if (isinstance(fs1, Tar) and isinstance(fs2, Tar)) or (
        isinstance(fs1, Zip) and isinstance(fs2, Zip)
    ):
        return path1 == path2 and fs1._file == fs2._file

    # check all fs with url support
    if isinstance(fs1, fs2.__class__):
        try:
            return fs1.geturl(path1) == fs2.geturl(path2)
        except NoURL:
            pass
    return False

[lurch]

🤮 😉