mpremote-path: A new pathlib-compatible interface for remotely accessing and manipulating files on a micropython board.

[glenn20]

I wanted a convenient and powerful method for accessing and manipulating files on a micropython board from python programs on my host computer. I like to use the python pathlib module to work with files on my computer, so I built a pathlib.Path compatible interface, based on features provided by mpremote.

If this may be useful to you, please feel free to investigate further at https://github.com/glenn20/mpremote-path. If you have question, ideas or requests for extension post them here or feel welcome to post issues at https://github.com/glenn20/mpremote-path/issues.

It is working well for me and I have gone to some lengths to make it work as seamlessly as possible with pathlib.

There are a few TODOs in the works, including caching remote file status queries which really improves the performace for common operations. There are also a few utility modules for performing common file operations (mpremote_path.util.mpfs and mpremote_path.util.mpfsops). There is some preliminary documentation for those in the README.md.

Of course, this is only possible because of the capabilities provided by the modules packaged in mpremote (ie. the SerialTransport class).

From the README

mpremote-path provides a convenient, pathlib.Path compatible interface to access and manipulate files on a serial-attached micropython board from the host computer.

Provides the MPRemotePath class:

• implements methods to access and manipulate files on micropython boards
  following the familiar pathlib.Path interface:

from mpremote_path import MPRemotePath as MPath

MPath.connect("u0")                 # Use device attached to /dev/ttyUSB0
p = MPath("/main.py")
print(p.read_text())                # Print out contents of /main.py

root = MPath("/")
q = root / "temp.txt"
q.write_bytes(b"Hello World\n")     # Create "/temp.txt"
print(q.read_bytes())               # Print out contents of /temp.txt
q.unlink()                          # Delete temp.txt

d = MPath("/data")
d.mkdir()                           # Create a new directory /data
d.chdir()                           # Set the working directory to /data
root.chdir()                        # Set the working directory to /
d.rmdir()                           # Delete /data
print([str(f) for f in MPath("/lib").rglob("*.py")])  # Print name of all python files in subdirs of /lib

• inherits from pathlib.PosixPath class, so code which works on Path objects will
  also work transparently on MPRemotePath objects, eg:

from pathlib import Path
from mpremote_path import MPRemotePath as MPath

# Recursively copy files and subdirectories from src to dst
def rcopy(src: Path, dst: Path) -> None:
    if src.is_dir():
        print(f"{src}/ -> {dst}/")
        dst.mkdir()
        for child in src.iterdir():
            rcopy(child, dst / child.name)
    elif src.is_file():
        print(f"{src} -> {dst}")
        dst.write_bytes(src.read_bytes())

MPath.connect("u0")               # Use device attached to /dev/ttyUSB0

# Make a local copy of a local directory
rcopy(Path("app"), Path("../app-backup"))

# Copy a local directory to the micropython board
rcopy(Path("app"), MPath("/lib/app"))

# Copy a directory from the micropython board to the local disk
rcopy(MPath("/lib"), Path("./lib2"))

[Josverl]

Interesting,
is the assumption that this is used only with a single board attached to a known serial port , or is there a way to disconnect and switch to another board as well?

[glenn20]

For now, yes, the normal use of the api is to connect to one board. By abusing the api a little, you can manage connections to multiple boards (and its not hard), eg:

from mpremote_path import MPRemotePath as MPath

MPath.connect("u0")                 # Use device attached to /dev/ttyUSB0
b0 = MPath.board                    # Save reference to the current board connection for later

f0 = MPath("/main.py")              # main.py on the first board

MPath.connect("a1")                 # Use device attached to /dev/ttyACM1
b1 = MPath.board                    # Save reference to the new board connection

f1 = MPath("/main.py")              # main.py on the second board

f1.write_bytes(f0.read_bytes())     # Copy main.py from first board to the second

The key point is that contructing a new instance with MPath("name") will use the serial connection currently stored in the MPath.board class variable. Once constructed, each instance saves its own reference to the Board object representing its board. This allows the MPath class to be used just like the Path class and suits all use cases for working with one board.

In the above example you could switch back to using the b0 board by default using MPath.board = b0.

I plan to introduce a clearer api support for working with multiple boards, but it needs to work a little differently from the pathlib.Path interface and needs a little more thought. I am thinking to extend each Board instance to be a "factory" for constructing new MPath instances linked to that board - like b0.path("name") (or just b0("name")).

Alternatively, the MPath constructor could be extended with an optional board parameter. This is tricker than it seems due to the way the pathlib classes manage construction of obects in the pathlib class hierarchy.

If you have any thoughts that would be welcome.

The Board class is just a wrapper around the SerialTransport class from mpremote.