PyFilesystem2

2.4.16 · active · verified Thu Apr 09

PyFilesystem2 is a Python library that provides a common, high-level abstraction layer for interacting with various filesystems, including local, memory, zip, FTP, and more. It enables consistent management of files and directories across different storage backends. The current version is 2.4.16, with frequent maintenance and minor feature releases.

Warnings

breaking PyFilesystem v1 (pyfilesystem) vs. v2 (fs) - Complete API and import path rewrite.
Fix: Code written for `pyfilesystem` (v1) is incompatible with `fs` (v2). You must rewrite your code to use the `fs` (v2) API and import paths (e.g., `from fs import open_fs` instead of `from fs.opener import open_fs`). The `fs` package on PyPI refers to v2.
gotcha Filesystem objects should be properly closed using context managers or explicit close() calls.
Fix: Always use filesystem objects within a `with` statement (e.g., `with open_fs('osfs://') as my_fs:`). This ensures resources (like file handles or network connections) are released automatically. If not using a context manager, call `my_fs.close()` explicitly when done.
gotcha Paths within PyFilesystem are 'universal' and use `/` as the separator, regardless of the underlying OS.
Fix: Always use `/` as the path separator when interacting with `fs` objects. Avoid using `os.sep` or platform-specific separators directly within `fs` methods. The `fs.path` module provides utility functions for path manipulation that are consistent with `fs` conventions.
gotcha Attempting write operations on a read-only filesystem will raise errors.
Fix: Ensure the filesystem is opened with write permissions if you intend to modify it. `fs.open_fs` has a `writable` parameter, and some filesystems (e.g., `ZipFS` opened in read mode) are inherently read-only. Check `my_fs.is_writable` before attempting writes. For creating read-only views of a writable FS, use `fs.wrap.read_only`.

Install

pip install fs Install PyFilesystem2

Imports

open_fs
```
from fs import open_fs
```
The `open_fs` factory function is now directly available from the top-level `fs` package, not `fs.opener` (which was a v1 pattern).
OSFS
```
from fs.osfs import OSFS
```
MemoryFS
```
from fs.memoryfs import MemoryFS
```
FS
```
from fs.base import FS
```
While `import fs` is valid, `FS` (the base class) resides in `fs.base`. Directly importing `FS` is more precise. This also avoids confusion with the legacy `pyfilesystem` v1, which had different module structures.

Quickstart

Demonstrates opening and interacting with a memory filesystem and a local OS filesystem. It shows creating, writing, reading, listing, and cleaning up resources, emphasizing the use of context managers for proper resource handling.

from fs import open_fs
from fs.osfs import OSFS
import os

# Example 1: Using a memory filesystem
print("--- Memory Filesystem Example ---")
with open_fs("mem://") as mem_fs:
    mem_fs.writetext("hello.txt", "Hello from MemoryFS!")
    print(f"Content of hello.txt: {mem_fs.readtext('hello.txt')}")
    print(f"Files in memory FS: {mem_fs.listdir('/')}")

# Example 2: Using the local operating system filesystem
print("\n--- OS Filesystem Example ---")
# Opens a filesystem for the current working directory
with OSFS('.') as os_fs:
    temp_dir_path = "_fs_temp_dir_"
    temp_file_path = os.path.join(temp_dir_path, "temp_quickstart.txt")

    if not os_fs.exists(temp_dir_path):
        os_fs.makedir(temp_dir_path)
        print(f"Created directory: {temp_dir_path}")

    os_fs.writetext(temp_file_path, "This is a temporary file in OSFS.")
    print(f"Content of {temp_file_path}: {os_fs.readtext(temp_file_path)}")

    # Clean up the created file and directory
    os_fs.remove(temp_file_path)
    os_fs.removedir(temp_dir_path)
    print(f"Cleaned up: {temp_file_path} and {temp_dir_path}")

view raw JSON →