EZFS (Easy Filesystem, or Everythingz a Filesystem) is an optimized, minimal dependency (down to 0), virtual filesystem adapter library for Python. EZFS provides access to the most common operations for "files" and "filesystems", while abstracting storage away from the user and developer, to simplify both UX and DX. All you need to know is how to access files in Python, and EZFS will take care of the rest, regardless of your selected backend.

In order to provide a streamlined UX and DX, EZFS leverages existing native Python designs and patterns, such as open/read/write operations, and applies them all backend storage types. The learning curve is minimal: if you know how to read/write a local file in Python, you also know how to read/write to any location in EZFS.

Reading and writing is supported for both text and binary files across local, remote, and memory "filesystems". Additional compression types and storage types can be supported by extending the primary File, Filesystem, and Compressor adapters. EZFS can also be faster than "native" open/read/write operations in some scenarios, due to having a specialized focus. Refer to the compatibility guides, and "Why EZFS", for more information.

• Compatibility
• Getting Started
  • Installation
• How Tos
  • Write a file with compression
  • Read a file with compression
  • Swap between filesystem types
  • Access a file in an S3 bucket
• Why EZFS?
  • What does EZFS provide? What does EZFS not provide?
  • Dependency Simplicity Example
  • Optimized Remote Filesystem Example
• Contributing

• Supports Python 3.10+
• Supports multiple compression types
  • bz2, gzip, lzma (when built into Python)
  • blosc, brotli, lz4, snappy, and zstd (when installed separately)
• Supports multiple storage types
  • sqlite3 (when built into Python)
  • S3 (when installed separately)
• Theoretically any compression type, or backend storage type, by extending Compressor, File, and Filesystem

Install EZFS via pip:

pip install ezfs

Or via git clone:

git clone <path to fork>
cd ezfs
pip install .

Or build and install from wheel:

# Build locally.
git clone <path to fork>
cd ezfs
make wheel

# Push dist/ezfs*.tar.gz to environment where it will be installed.
pip install dist/ezfs*.tar.gz

Or via copy and paste (only a single file is required):

# Copy:
cp ezfs.py <target project directory>

EZFS filesystems and file objects are designed to work nearly identical to native open() file handles. Basic read and write operations can be directly swapped out after creating a filesystem adapter, and calling open() against the filesystem instead of Python built-ins, or 3rd party compression libraries. Here are a few examples of how to use the more advanced features, such as compression and remote storage. Refer to the supported operations table in Why EZFS? for information on additional features.

import ezfs

filesystem = ezfs.LocalFilesystem('/tmp')
with filesystem.open('test-file.txt.gz', 'w+', compression='gzip') as out_file:
    out_file.write('test message')

# Or automatically compress all files on the "filesystem" on write:
filesystem = ezfs.LocalFilesystem('/tmp', compression='gzip')
with filesystem.open('test-file.txt.gz', 'w+') as out_file:
    out_file.write('test message')

import ezfs

filesystem = ezfs.LocalFilesystem('/tmp')
with filesystem.open('test-file.txt.gz', compression='gzip') as in_file:
    print(in_file.read())

# Or automatically decompress all files on the "filesystem" on read:
filesystem = ezfs.LocalFilesystem('/tmp', compression='gzip')
with filesystem.open('test-file.txt.gz') as in_file:
    print(in_file.read())

import ezfs

# Only a change is needed from local folder:
filesystem = ezfs.LocalFilesystem('/tmp')
# To a local database file:
filesystem = ezfs.SQLiteFilesystem('/tmp/tmp.db')

# No change is needed to open/read/write operations:
with filesystem.open('test-file.txt.gz', 'w+', compression='gzip') as out_file:
    out_file.write('test message')

import ezfs

# To use advanced compression types, they must be installed separately.
filesystem = ezfs.S3BotoFilesystem(
    'my-bucket-1234',
    access_key_id='ABC123',
    secret_access_key='abcdefg1234567',
    compression='zstd',
)
with filesystem.open('test-file.txt.zst', 'w+') as out_file:
    out_file.write('test message')
with filesystem.open('test-file.txt.zst') as in_file:
    print(in_file.read())

To simplify simple use cases.

EZFS is a very lightweight library (one file!), used to optimize "simple" use cases, or provide a starting point for more complex use cases. What make a use case "simple? Reliance on core file/filesystem functionality, such as create, read, write, and delete operations. What makes a use case "complex"? Reliance on complex file/filesystem features, such as permissions, streaming, and seeking. The former benefit from EZFS out-of-the-box, while the latter requires developers to extend the functionality further if they need this type of support.

While there are other libraries that can help accomplish file/filesystem-like use cases depending on the backend, such as s3fs for S3, they may be more than needed or wanted. For example, perhaps you have predictable logic to store/read files, and don't need to browse the filesystem tree. Perhaps you want to leverage a custom service to act as storage interchangeably with local files, without installing extra dependencies from other solutions. EZFS adapters can help with that. If you need full metadata support like filesystem tree browsing, or file permissions, EZFS cannot help with that (natively), and recommends using a more feature rich solution, or extending the adapters to fit your needs.

EZFS provides a shared, optimized, interface to read and write files to various backend locations, with or without compression. The backend for the storage can often be changed with a single line, without changing the rest of the code.

EZFS does not provide a complex feature set for advanced use cases, such as managing permissions or other metadata on filesystems. EZFS also not provide streaming interfaces for processing larger than memory files in "chunks". The following is a list of common file/filesystem operations, whether they are supported out-of-the-box, whether they are supported with advanced installs (extras), and whether they are optimized/simplified by EZFS.

¹ Depends on whether Python was built with it
² Depends on compression module used
³ Depends on the backend used

Here is an example of using a library such as sf3s vs ezfs for basic read and write to S3, and its effect on required dependencies in a project. A basic boto3 install (only requirement for ezfs support) will add the following to the environment:

• boto3
• botocore
• jmespath
• python-dateutil
• s3transfer
• six
• urllib3

An s3fs install will add the following in addition to the core boto3 requirements:

• aiobotocore
• aiohttp
• aioitertools
• aiosignal
• async-timeout
• attrs
• idna
• frozenlist
• fsspec
• multidict
• s3fs
• wrapt
• yarl

Perhaps you already have all these requirements. Great! Then S3FS may be a better fit. Perhaps you don't have these, and want to reduce requirements that may add maintenance overhead to resolve security vulnerabilities. Great! EZFS may be a better fit. Still not sure? Continue reading for a performance example.

Here is a basic performance example, using S3 + pandas to store DataFrames. By using a Filesystem adapter to store the results, it can optimize the S3 client used to reduce networking overhead. The optimization benefit is greater with small files, but even larger files benefit, and the simplicity to use stays the same.

• Small file: 100K
• Large file: 1M
• 100 iterations per test

EZFS is not currently accepting new features. Minor features may be added to improve the native use cases, but outside minor changes it will only receive bug fixes and dependency updates. This decision is to ensure EZFS will stay focused on its primary goal: stay simple and efficient, by focusing on simple use cases. Feel free to import, fork, copy, etc., to other projects to expand the scope of its ecosystem. Refer to the Contributing Guide for information on how to contribute to this project.