Injectable `magic_open` and other `_os` functions

[fourpoints]

I tried to upgrade from 0.2.0 and I see a lot of things has changed.

One thing I liked in 0.2.0 was the ability to define a few abstract methods, and the other methods would have a simple implementation based on these methods. Now it seems many methods use magic_open instead of relying on implementations of the abstract methods.

While this behavior is also fine, it makes it harder to tell which methods to override, since implementing just the abstract methods is not enough to override the magic behavior. So it would be nice if it was possible to inject this (and the other _os functions) into these methods.

(off-topic: I also miss PathBase, it was a nice way of doing isinstance(obj, Path) with custom classes. There may be another way of doing this which I have missed.)

Thanks for the continued work on pathlib/pathlib-abc.

[barneygale]

Hi @fourpoints, sorry for the long delay, thanks for the feedback

vfsopen() (previously magic_open()) calls abstract methods __open_reader__() or __open_writer__(). I've tried to make the abstract methods clear in the docs.

I don't quite follow what you mean about making them injectable - could you expand on that?

(off-topic: I also miss PathBase, it was a nice way of doing isinstance(obj, Path) with custom classes. There may be another way of doing this which I have missed.)

Does isinstance(obj, ReadablePath) and/or isinstance(obj, WritablePath) do the trick? Personally I don't often need read-write support.

[fourpoints]

No worries, I don't check github every day either :)

I think I got lost in indirection, I read the excerpt below and didn't see the connection between vfsopen and __open_reader/writer__. My mistake on relying on code rather than reading the documentation, but something got broken during an upgrade and it wasn't quite straightforward to tell what went wrong.

    @abstractmethod
    def __open_reader__(self):
        """
        Open the file pointed to by this path for reading in binary mode and
        return a file object.
        """
        raise NotImplementedError

    def read_bytes(self):
        """
        Open the file in bytes mode, read it, and close the file.
        """
        with vfsopen(self, mode='rb') as f:
            return f.read()

But it's actually __init__.ReadablePath.read_bytes -> _os.vfsopen -> _os._open_reader -> __init__.ReadablePath.__open_reader__.

---

On the second point, it's mainly because of backwards compatibility, both in code and in my head. I don't tend to think of paths as writeable paths or readable paths, I tend to think about them as paths. So it's a bit of loose typing, but I think it's a useful type: having a "read/write path" or "IO path". Of course I can always do isinstance(obj, (ReadablePath, WritablePath)), so it's mainly for covenience.

Feel free to close this issue.