oceanum.storage.FileSystem#

class oceanum.storage.FileSystem(*args, **kwargs)[source]#

Datamesh storage filesystem.

This follows the fsspec specification and can be used with dask.

You can use this class directly, for example:

fs = FileSystem(token=”my_datamesh_token”) fs.ls(“/myfolder”)

or use fsspec convenience functions with protocol “oceanum”. For example:

of=fsspec.open(“oceanum://myfolder/myfile.txt”, token=”my_datamesh_token”)

Attributes

async_impl

blocksize

cachable

disable_throttling

fsid

Persistent filesystem id that can be used to compare filesystems across sessions.

loop

mirror_sync_methods

protocol

root_marker

sep

transaction

A context within which files are committed together upon exit

storage_args

storage_options

Methods

__init__(token: str | None = None, service: str | None = None, asynchronous: bool = False, loop: AbstractEventLoop | None = None, timeout: int = 3600, batch_size: int = 16)[source]#

Storage filesystem constructor

Parameters:

  • token (string) – Your datamesh access token. Defaults to os.environ.get(“DATAMESH_TOKEN”, None).

  • service (string, optional) – URL of datamesh service. If not provided, constructed from OCEANUM_DOMAIN environment variable (defaults to “oceanum.io”).

  • timeout (int, optional) – Timeout for requests in seconds. Defaults to 3600.

  • batch_size (int, optional) – Number of concurrent requests. Defaults to 16.

Raises:

ValueError – Missing or invalid arguments

cat(path, recursive=False, on_error='raise', **kwargs)#

Fetch (potentially multiple) paths’ contents

Parameters:

  • recursive (bool) – If True, assume the path(s) are directories, and get all the contained files

  • on_error ("raise", "omit", "return") – If raise, an underlying exception will be raised (converted to KeyError if the type is in self.missing_exceptions); if omit, keys with exception will simply not be included in the output; if “return”, all keys are included in the output, but the value will be bytes or an exception instance.

  • kwargs (passed to cat_file)

Returns:

  • dict of {path (contents} if there are multiple paths)

  • or the path has been otherwise expanded

cat_file(path, start=None, end=None, **kwargs)#

Get the content of a file

Parameters:

  • path (URL of file on this filesystems)

  • start (int) – Bytes limits of the read. If negative, backwards from end, like usual python slices. Either can be None for start or end of file, respectively

  • end (int) – Bytes limits of the read. If negative, backwards from end, like usual python slices. Either can be None for start or end of file, respectively

  • kwargs (passed to open().)

cat_ranges(paths, starts, ends, max_gap=None, on_error='return', **kwargs)#

Get the contents of byte ranges from one or more files

Parameters:

  • paths (list) – A list of of filepaths on this filesystems

  • starts (int or list) – Bytes limits of the read. If using a single int, the same value will be used to read all the specified files.

  • ends (int or list) – Bytes limits of the read. If using a single int, the same value will be used to read all the specified files.

checksum(path)#

Unique value for current version of file

If the checksum is the same from one moment to another, the contents are guaranteed to be the same. If the checksum changes, the contents might have changed.

This should normally be overridden; default will probably capture creation/modification timestamp (which would be good) or maybe access timestamp (which would be bad)

classmethod clear_instance_cache()#

Clear the cache of filesystem instances.

Notes

Unless overridden by setting the cachable class attribute to False, the filesystem class stores a reference to newly created instances. This prevents Python’s normal rules around garbage collection from working, since the instances refcount will not drop to zero until clear_instance_cache is called.

static close_session(loop, session)[source]#
copy(path1, path2, recursive=False, maxdepth=None, on_error=None, **kwargs)#

Copy within two locations in the filesystem

on_error“raise”, “ignore”

If raise, any not-found exceptions will be raised; if ignore any not-found exceptions will cause the path to be skipped; defaults to raise unless recursive is true, where the default is ignore

cp(path1, path2, **kwargs)#

Alias of AbstractFileSystem.copy.

cp_file(path1, path2, **kwargs)#
created(path)#

Return the created timestamp of a file as a datetime.datetime

classmethod current()#

Return the most recently instantiated FileSystem

If no instance has been created, then create one with defaults

delete(path, recursive=False, maxdepth=None)#

Alias of AbstractFileSystem.rm.

disk_usage(path, total=True, maxdepth=None, **kwargs)#

Alias of AbstractFileSystem.du.

download(rpath, lpath, recursive=False, **kwargs)#

Alias of AbstractFileSystem.get.

du(path, total=True, maxdepth=None, withdirs=False, **kwargs)#

Space used by files and optionally directories within a path

Directory size does not include the size of its contents.

Parameters:

  • path (str)

  • total (bool) – Whether to sum all the file sizes

  • maxdepth (int or None) – Maximum number of directory levels to descend, None for unlimited.

  • withdirs (bool) – Whether to include directory paths in the output.

  • kwargs (passed to find)

Returns:

  • Dict of {path (size} if total=False, or int otherwise, where numbers)

  • refer to bytes used.

end_transaction()#

Finish write transaction, non-context version

exists(path, **kwargs)#

Is there a file at the given path

expand_path(path, recursive=False, maxdepth=None, **kwargs)#

Turn one or more globs or directories into a list of all matching paths to files or directories.

kwargs are passed to glob or find, which may in turn call ls

find(path, maxdepth=None, withdirs=False, detail=False, **kwargs)#

List all files below path.

Like posix find command without conditions

Parameters:

  • path (str)

  • maxdepth (int or None) – If not None, the maximum number of levels to descend

  • withdirs (bool) – Whether to include directory paths in the output. This is True when used by glob, but users usually only want files.

  • ls. (kwargs are passed to)

static from_dict(dct: dict[str, Any]) → AbstractFileSystem#

Recreate a filesystem instance from dictionary representation.

See .to_dict() for the expected structure of the input.

Parameters:

dct (Dict[str, Any])

Return type:

file system instance, not necessarily of this particular class.

Warning

This can import arbitrary modules (as determined by the cls key). Make sure you haven’t installed any modules that may execute malicious code at import time.

static from_json(blob: str) → AbstractFileSystem#

Recreate a filesystem instance from JSON representation.

See .to_json() for the expected structure of the input.

Parameters:

blob (str)

Return type:

file system instance, not necessarily of this particular class.

Warning

This can import arbitrary modules (as determined by the cls key). Make sure you haven’t installed any modules that may execute malicious code at import time.

get(rpath, lpath, recursive=False, callback=<fsspec.callbacks.NoOpCallback object>, maxdepth=None, **kwargs)#

Copy file(s) to local.

Copies a specific file or tree of files (if recursive=True). If lpath ends with a “/”, it will be assumed to be a directory, and target files will go within. Can submit a list of paths, which may be glob-patterns and will be expanded.

Calls get_file for each source.

get_file(rpath, lpath, callback=<fsspec.callbacks.NoOpCallback object>, outfile=None, **kwargs)#

Copy single remote file to local

get_mapper(root='', check=False, create=False, missing_exceptions=None)#

Create key/value store based on this file-system

Makes a MutableMapping interface to the FS at the given root path. See fsspec.mapping.FSMap for further details.

glob(path, maxdepth=None, **kwargs)#

Find files by glob-matching.

Pattern matching capabilities for finding files that match the given pattern.

Parameters:

  • path (str) – The glob pattern to match against

  • maxdepth (int or None) – Maximum depth for '**' patterns. Applied on the first '**' found. Must be at least 1 if provided.

  • kwargs – Additional arguments passed to find (e.g., detail=True)

Return type:

List of matched paths, or dict of paths and their info if detail=True

Notes

Supported patterns: - ‘*’: Matches any sequence of characters within a single directory level - '**': Matches any number of directory levels (must be an entire path component) - ‘?’: Matches exactly one character - ‘[abc]’: Matches any character in the set - ‘[a-z]’: Matches any character in the range - ‘[!abc]’: Matches any character NOT in the set

Special behaviors: - If the path ends with ‘/’, only folders are returned - Consecutive ‘*’ characters are compressed into a single ‘*’ - Empty brackets ‘[]’ never match anything - Negated empty brackets ‘[!]’ match any single character - Special characters in character classes are escaped properly

Limitations: - '**' must be a complete path component (e.g., 'a/**/b', not 'a**b') - No brace expansion (‘{a,b}.txt’) - No extended glob patterns (‘+(pattern)’, ‘!(pattern)’)

head(path, size=1024)#

Get the first size bytes from file

info(path, **kwargs)#

Give details of entry at path

Returns a single dictionary, with exactly the same information as ls would with detail=True.

The default implementation calls ls and could be overridden by a shortcut. kwargs are passed on to `ls().

Some file systems might not be able to measure the file’s size, in which case, the returned dict will include 'size': None.

Returns:

  • dict with keys (name (full path in the FS), size (in bytes), type (file,)

  • directory, or something else) and other FS-specific keys.

invalidate_cache(path=None)#

Discard any cached directory information

Parameters:

path (string or None) – If None, clear all listings cached else listings at or under given path.

isdir(path)#

Is this entry directory-like?

isfile(path)#

Is this entry file-like?

lexists(path, **kwargs)#

If there is a file at the given path (including broken links)

listdir(path, detail=True, **kwargs)#

Alias of AbstractFileSystem.ls.

ls(path='', detail=True, file_prefix=None, match_glob=None, limit=None)#

List objects at path.

This should include subdirectories and files at that location. The difference between a file and a directory must be clear when details are requested.

The specific keys, or perhaps a FileInfo class, or similar, is TBD, but must be consistent across implementations. Must include:

  • full path to the entry (without protocol)

  • size of the entry, in bytes. If the value cannot be determined, will be None.

  • type of entry, “file”, “directory” or other

Additional information may be present, appropriate to the file-system, e.g., generation, checksum, etc.

May use refresh=True|False to allow use of self._ls_from_cache to check for a saved listing and avoid calling the backend. This would be common where listing may be expensive.

Parameters:

  • path (str)

  • detail (bool) – if True, gives a list of dictionaries, where each is the same as the result of info(path). If False, gives a list of paths (str).

  • kwargs (may have additional backend-specific options, such as version) – information

Returns:

  • List of strings if detail is False, or list of directory information

  • dicts if detail is True.

makedir(path, create_parents=True, **kwargs)#

Alias of AbstractFileSystem.mkdir.

makedirs(path, exist_ok=False)#

Recursively make directories

Creates directory at path and any intervening required directories. Raises exception if, for instance, the path already exists but is a file.

Parameters:

  • path (str) – leaf directory name

  • exist_ok (bool (False)) – If False, will error if the target already exists

mkdir(path, create_parents=True, **kwargs)#

Create directory entry at path

For systems that don’t have true directories, may create an for this instance only and not touch the real filesystem

Parameters:

  • path (str) – location

  • create_parents (bool) – if True, this is equivalent to makedirs

  • kwargs – may be permissions, etc.

mkdirs(path, exist_ok=False)#

Alias of AbstractFileSystem.makedirs.

modified(path)#

Return the modified timestamp of a file as a datetime.datetime

move(path1, path2, **kwargs)#

Alias of AbstractFileSystem.mv.

mv(path1, path2, recursive=False, maxdepth=None, **kwargs)#

Move file(s) from one location to another

open(path, mode='rb', block_size=None, cache_options=None, compression=None, **kwargs)#

Return a file-like object from the filesystem

The resultant instance must function correctly in a context with block.

Parameters:

  • path (str) – Target file

  • mode (str like 'rb', 'w') – See builtin open() Mode “x” (exclusive write) may be implemented by the backend. Even if it is, whether it is checked up front or on commit, and whether it is atomic is implementation-dependent.

  • block_size (int) – Some indication of buffering - this is a value in bytes

  • cache_options (dict, optional) – Extra arguments to pass through to the cache.

  • compression (string or None) – If given, open file using compression codec. Can either be a compression name (a key in fsspec.compression.compr) or “infer” to guess the compression from the filename suffix.

  • encoding (passed on to TextIOWrapper for text mode)

  • errors (passed on to TextIOWrapper for text mode)

  • newline (passed on to TextIOWrapper for text mode)

async open_async(path, mode='rb', **kwargs)#
pipe(path, value=None, **kwargs)#

Put value into path

(counterpart to cat)

Parameters:

  • path (string or dict(str, bytes)) – If a string, a single remote location to put value bytes; if a dict, a mapping of {path: bytesvalue}.

  • value (bytes, optional) – If using a single path, these are the bytes to put there. Ignored if path is a dict

pipe_file(path, value, mode='overwrite', **kwargs)#

Set the bytes of given file

put(lpath, rpath, recursive=False, callback=<fsspec.callbacks.NoOpCallback object>, maxdepth=None, **kwargs)#

Copy file(s) from local.

Copies a specific file or tree of files (if recursive=True). If rpath ends with a “/”, it will be assumed to be a directory, and target files will go within.

Calls put_file for each source.

put_file(lpath, rpath, callback=<fsspec.callbacks.NoOpCallback object>, mode='overwrite', **kwargs)#

Copy single file to remote

read_block(fn, offset, length, delimiter=None)#

Read a block of bytes from

Starting at offset of the file, read length bytes. If delimiter is set then we ensure that the read starts and stops at delimiter boundaries that follow the locations offset and offset + length. If offset is zero then we start at zero. The bytestring returned WILL include the end delimiter string.

If offset+length is beyond the eof, reads to eof.

Parameters:

  • fn (string) – Path to filename

  • offset (int) – Byte offset to start read

  • length (int) – Number of bytes to read. If None, read to end.

  • delimiter (bytes (optional)) – Ensure reading starts and stops at delimiter bytestring

Examples

>>> fs.read_block('data/file.csv', 0, 13)  
b'Alice, 100\nBo'
>>> fs.read_block('data/file.csv', 0, 13, delimiter=b'\n')  
b'Alice, 100\nBob, 200\n'

Use length=None to read to the end of the file. >>> fs.read_block(‘data/file.csv’, 0, None, delimiter=b’n’) # doctest: +SKIP b’Alice, 100nBob, 200nCharlie, 300’

See also

fsspec.utils.read_block()

read_bytes(path, start=None, end=None, **kwargs)#

Alias of AbstractFileSystem.cat_file.

read_text(path, encoding=None, errors=None, newline=None, **kwargs)#

Get the contents of the file as a string.

Parameters:

  • path (str) – URL of file on this filesystems

  • encoding (same as open.)

  • errors (same as open.)

  • newline (same as open.)

rename(path1, path2, **kwargs)#

Alias of AbstractFileSystem.mv.

rm(path, recursive=False, maxdepth=None)#

Delete files.

Parameters:

  • path (str or list of str) – File(s) to delete.

  • recursive (bool) – If file(s) are directories, recursively delete contents and then also remove the directory

  • maxdepth (int or None) – Depth to pass to walk for finding files to delete, if recursive. If None, there will be no limit and infinite recursion may be possible.

rm_file(path)#

Delete a file

rmdir(path)#

Remove a directory, if empty

async set_session()[source]#
sign(path, expiration=100, **kwargs)#

Create a signed URL representing the given path

Some implementations allow temporary URLs to be generated, as a way of delegating credentials.

Parameters:

  • path (str) – The path on the filesystem

  • expiration (int) – Number of seconds to enable the URL for (if supported)

Returns:

URL – The signed URL

Return type:

str

:raises NotImplementedError : if method is not implemented for a filesystem:

size(path)#

Size in bytes of file

sizes(paths)#

Size in bytes of each file in a list of paths

start_transaction()#

Begin write transaction for deferring files, non-context version

stat(path, **kwargs)#

Alias of AbstractFileSystem.info.

tail(path, size=1024)#

Get the last size bytes from file

to_dict(*, include_password: bool = True) → dict[str, Any]#

JSON-serializable dictionary representation of this filesystem instance.

Parameters:

include_password (bool, default True) – Whether to include the password (if any) in the output.

Returns:

  • Dictionary with keys cls (the python location of this class),

  • protocol (text name of this class’s protocol, first one in case of

  • multiple), args (positional args, usually empty), and all other

  • keyword arguments as their own keys.

Warning

Serialized filesystems may contain sensitive information which have been passed to the constructor, such as passwords and tokens. Make sure you store and send them in a secure environment!

to_json(*, include_password: bool = True) → str#

JSON representation of this filesystem instance.

Parameters:

include_password (bool, default True) – Whether to include the password (if any) in the output.

Returns:

  • JSON string with keys cls (the python location of this class),

  • protocol (text name of this class’s protocol, first one in case of

  • multiple), args (positional args, usually empty), and all other

  • keyword arguments as their own keys.

Warning

Serialized filesystems may contain sensitive information which have been passed to the constructor, such as passwords and tokens. Make sure you store and send them in a secure environment!

touch(path, truncate=True, **kwargs)#

Create empty file, or update timestamp

Parameters:

  • path (str) – file location

  • truncate (bool) – If True, always set file size to 0; if False, update timestamp and leave file unchanged, if backend allows this

tree(path: str = '/', recursion_limit: int = 2, max_display: int = 25, display_size: bool = False, prefix: str = '', is_last: bool = True, first: bool = True, indent_size: int = 4) → str#

Return a tree-like structure of the filesystem starting from the given path as a string.

Parameters:

  • path (Root path to start traversal from)

  • recursion_limit (Maximum depth of directory traversal)

  • max_display (Maximum number of items to display per directory)

  • display_size (Whether to display file sizes)

  • prefix (Current line prefix for visual tree structure)

  • is_last (Whether current item is last in its level)

  • first (Whether this is the first call (displays root path))

  • indent_size (Number of spaces by indent)

Returns:

str

Return type:

A string representing the tree structure.

Example

>>> from fsspec import filesystem

>>> fs = filesystem('ftp', host='test.rebex.net', user='demo', password='password')
>>> tree = fs.tree(display_size=True, recursion_limit=3, indent_size=8, max_display=10)
>>> print(tree)
ukey(path)[source]#

Unique identifier

unstrip_protocol(name: str) → str#

Format FS-specific path to generic, including protocol

upload(lpath, rpath, recursive=False, **kwargs)#

Alias of AbstractFileSystem.put.

walk(path, maxdepth=None, topdown=True, on_error='omit', **kwargs)#

Return all files under the given path.

List all files, recursing into subdirectories; output is iterator-style, like os.walk(). For a simple list of files, find() is available.

When topdown is True, the caller can modify the dirnames list in-place (perhaps using del or slice assignment), and walk() will only recurse into the subdirectories whose names remain in dirnames; this can be used to prune the search, impose a specific order of visiting, or even to inform walk() about directories the caller creates or renames before it resumes walk() again. Modifying dirnames when topdown is False has no effect. (see os.walk)

Note that the “files” outputted will include anything that is not a directory, such as links.

Parameters:

  • path (str) – Root to recurse into

  • maxdepth (int) – Maximum recursion depth. None means limitless, but not recommended on link-based file-systems.

  • topdown (bool (True)) – Whether to walk the directory tree from the top downwards or from the bottom upwards.

  • on_error ("omit", "raise", a callable) – if omit (default), path with exception will simply be empty; If raise, an underlying exception will be raised; if callable, it will be called with a single OSError instance as argument

  • kwargs (passed to ls)

write_bytes(path, value, **kwargs)#

Alias of AbstractFileSystem.pipe_file.

write_text(path, value, encoding=None, errors=None, newline=None, **kwargs)#

Write the text to the given file.

An existing file will be overwritten.

Parameters:

  • path (str) – URL of file on this filesystems

  • value (str) – Text to write.

  • encoding (same as open.)

  • errors (same as open.)

  • newline (same as open.)

On this page
Show Source