Usage¶
This is quick-start documentation to help people get familiar with the layout and functioning of fsspec
.
Instantiate a file-system¶
fsspec
provides an abstract file-system interface as a base class, to be used by other filesystems.
A file-system instance is an object for manipulating files on some
remote store, local files, files within some wrapper, or anything else that is capable of producing
file-like objects.
Some concrete implementations are bundled with fsspec
and others can be installed separately. They
can be instantiated directly, or the registry
can be used to find them.
Direct instantiation:
from fsspec.implementations.local import LocalFileSystem
fs = LocalFileSystem()
Look-up via registry:
import fsspec
fs = fsspec.filesystem('file')
Many filesystems also take extra parameters, some of which may be options - see API Reference, or use
fsspec.get_filesystem_class()
to get the class object and inspect its docstring.
import fsspec
fs = fsspec.filesystem('ftp', host=host, port=port, username=user, password=pw)
The list of implemented fsspec
protocols can be retrieved using fsspec.available_protocols()
.
Use a file-system¶
File-system instances offer a large number of methods for getting information about and manipulating files
for the given back-end. Although some specific implementations may not offer all features (e.g., http
is read-only), generally all normal operations, such as ls
, rm
, should be expected to work (see the
full list: fsspec.spec.AbstractFileSystem
).
Note that this quick-start will prefer posix-style naming, but
many common operations are aliased: cp()
and copy()
are identical, for instance.
Functionality is generally chosen to be as close to the builtin os
module’s working for things like
glob
as possible. The following block of operations should seem very familiar.
fs.mkdir("/remote/output")
fs.touch("/remote/output/success") # creates empty file
assert fs.exists("/remote/output/success")
assert fs.isfile("/remote/output/success")
assert fs.cat("/remote/output/success") == b"" # get content as bytestring
fs.copy("/remote/output/success", "/remote/output/copy")
assert fs.ls("/remote/output", detail=False) == ["/remote/output/success", "/remote/output/copy")
fs.rm("/remote/output", recursive=True)
The open()
method will return a file-like object which can be passed to any other library that expects
to work with python files, or used by your own code as you would a normal python file object.
These will normally be binary-mode only, but may implement internal buffering
in order to limit the number of reads from a remote source. They respect the use of with
contexts. If
you have pandas
installed, for example, you can do the following:
f = fs.open("/remote/path/notes.txt", "rb")
lines = f.readline() # read to first b"\n"
f.seek(-10, 2)
foot = f.read() # read last 10 bytes of file
f.close()
import pandas as pd
with fs.open('/remote/data/myfile.csv') as f:
df = pd.read_csv(f, sep='|', header=None)
Higher-level¶
For many situations, the only function that will be needed is fsspec.open_files()
, which will return
fsspec.core.OpenFile
instances created from a single URL and parameters to pass to the backend(s).
This supports text-mode and compression on the fly, and the objects can be serialized for passing between
processes or machines (so long as each has access to the same backend file-system). The protocol (i.e.,
backend) is inferred from the URL passed, and glob characters are expanded in read mode (search for files)
or write mode (create names). Critically, the file on the backend system is not actually opened until the
OpenFile
instance is used in a with
context.
of = fsspec.open("github://dask:fastparquet@main/test-data/nation.csv", "rt")
# of is an OpenFile container object. The "with" context below actually opens it
with of as f:
# now f is a text-mode file
for line in f:
# iterate text lines
print(line)
if "KENYA" in line:
break