Interest in Pathlib abstraction?

[Krakonos]

Hi!

I have implemented a wrapper around LittleFS object that provides pathlib abstraction, building on top of PurePosixPath. I can either publish it as a standalone package or make PR and make it part of the this repo. Currently, the idea is:

fs = LittleFS(...)
root_path = littlefs_pathlib.from_lfs(fs)
for file in root_path.glob("**"):
  print(file)

If we build it into this package, I would suggest changing this to fs.get_path("/") or similar, but I would keep it separate and not change the LittleFS object. Alternatively, we could do LittleFSPath object that is constructed with the same arguments as LittleFS, provides access to the lower object.

Right now it's about 250 lines of python + tests, so not much of a maintenance burden, especially since it builds strictly on top of the LittleFS object so it doesn't need to handle all the low level parameters.``

Thoughts? @jrast

Note: I'm not pushing this, so if you feel it's out of the scope, feel free to say no, I my self can't decide what would be better, so I decided to get a second opinion here.

[BrianPugh]

I'm open to this addition!

What if instead of fs.get_path(...) we add a root property to the LittleFS object that's your LittleFSPath object:

fs = LittleFS(...)
for p in fs.root.glob("**/*.txt"):
    print(p, p.stat().size)

cfg = fs.root / "etc" / "config.json"

In my experience, subclassing Path is kind of a pain pre-python3.12; what's your experience with this? Thanks!

[jrast]

I'm also open to this and like the interface proposed by @BrianPugh

[Krakonos]

Thanks for the positive reaction. I don't mind this interface, get_path() is actually a relict of how I split it off into a separate package for testing. Not a big change either.

For PurePosixPath subclass... TBH I chose this idealistically. I vaguely remember I had some issues in the past, but decided to give it a go and it worked. The key feature here is added in python 3.12 though, with_segments[1], that specifically defines API for subclasses to maintain the pointer to the virtual filesystem.

The other issue I found out is I need to override __fspath__() and throw an exception, otherwise doing os.open(LfsPath("/foo"), "r") just tried to open local path "/foo"

Overall though, many operations need to be reimplemented and I may not have done that exhaustively. Glob is an annoying example.

Another option I found is pathlib-abc [2] (and a "reference" project universal-pathlib[3] ). Universal-pathlib is in my opinion a no-go as it drags in so many dependencies (if anything, the littlefs abstraction could live there if accepted, but it's not a great fit). pathlib-abc seems like a much better solution, as it tracks the CPython development (it's basically a preview of the CPython implementation in progress). I don't see too many recent changes, it might be close to releasing. The advantage would be less code to be implemented and less confusion to be had with subclassing PurePosixPath.

Now, the PurePosixPath works but admittedly is rough around the edges -- but has minimal dependencies. I'll prepare a PurePosixPath PR and have a look at pathlib-abc to see if it would be a better choice -- I think it may be, especially if it will get upstreamed soon, and that it supports py3.9 (compared to the PurePosixPath requiring py3.12).

[1] https://docs.python.org/3/library/pathlib.html#pathlib.PurePath.with_segments
[2] https://pypi.org/project/pathlib-abc/
[3] https://universal-pathlib.readthedocs.io/en/latest/