watchfiles vs watchdog which is better?

Watchfiles uses Rust for superior performance and modern async support, while Watchdog is pure Python with broader legacy compatibility. Choose Watchfiles for speed in async contexts, Watchdog for simplicity and older Python versions.

how to use watchfiles to auto-reload a FastAPI server?

Use the `run_process` function with your FastAPI app instance. For example, wrap `uvicorn.run(app)` in a target function, and `run_process` will restart it on file changes, similar to development servers but with more control over reloading logic.

why does watchfiles miss file changes on network drives?

Network file systems often have limited support for native OS notifications that Watchfiles relies on. You might need to enable polling mode or use alternative monitoring tools specifically designed for network volumes.

can I filter out temporary files with watchfiles?

Yes, use the `watch_filter` parameter with built-in filters like `DefaultFilter` or create custom filters to ignore files like `.swp` or `__pycache__` directories, improving event relevance.

how to install watchfiles without Rust on macOS?

Pre-built binaries are available via pip, so running `pip install watchfiles` should work seamlessly. If installation fails, ensure your Python version is compatible and pip is updated to fetch binaries automatically.

Open-Awesome

watchfiles

MITPythonv1.2.0

A high-performance file watching and code reload library for Python, built with Rust for speed and reliability.

Visit Website GitHub

2.5k stars141 forks0 contributors

What is watchfiles?

Watchfiles is a Python library for monitoring file system changes and automatically reloading code during development. It provides high-performance file watching capabilities using Rust under the hood, eliminating the need for manual restarts when source files are modified.

Target Audience

Python developers who need efficient file watching for development tools, auto-reload servers, or build automation scripts.

Value Proposition

Developers choose Watchfiles for its speed, simplicity, and cross-platform reliability, offering both sync and async APIs with built-in code reloading functions out of the box.

Overview

Simple, modern and fast file watching and code reload for Python, written in Rust

Use Cases

Best For

Auto-reloading Python web servers during development
Building development tools that react to file changes
Creating hot-reload functionality for applications
Monitoring directories for changes in automation scripts
Improving developer workflow with automatic code execution
Watching configuration files for dynamic updates

Not Ideal For

Projects that only need simple, polling-based file watching without performance concerns, where lightweight pure-Python libraries suffice.
Environments where Rust toolchain installation is prohibited or pre-built binaries are unavailable, such as air-gapped or custom-built systems.
Applications requiring real-time monitoring of non-file system events like database changes, network requests, or process states.

Pros & Cons

Pros

Rust-Powered Performance

Leverages the Rust `notify` library for efficient, low-level file system notifications, ensuring faster and more reliable event detection compared to pure Python solutions.

Dual Sync/Async APIs

Provides both synchronous `watch` and asynchronous `awatch` functions, allowing seamless integration into any Python application architecture without forcing async adoption.

Built-in Code Reloading

Includes `run_process` and `arun_process` to automatically restart Python processes on file changes, simplifying development workflows and reducing manual intervention.

Cross-Platform Binaries

Offers pre-built binaries for most architectures on Linux, macOS, and Windows, minimizing installation barriers and ensuring consistent performance across platforms.

Cons

Rust Compilation Barrier

Installing from source requires Rust stable, which can be a significant hurdle for teams without Rust expertise or in environments with restricted toolchains.

Limited Event Scope

Focused solely on file system events, so projects needing to monitor other sources like APIs or databases require additional tooling or custom implementations.

Python Version Constraints

Supports only Python 3.9 to 3.14, excluding older versions that legacy projects might depend on, potentially forcing upgrades or alternative solutions.

Frequently Asked Questions

Related Projects

watchdog

Python library and shell utilities to monitor filesystem events.

Stars7,385

Forks759

Last commit4 days ago

python-magic

A python wrapper for libmagic

Stars2,914

Forks304