Watchgod

0.8.2 · renamed · verified Sun Apr 12

Watchgod is a Python library designed for simple file watching and code reloading. It was last released as version 0.8.2 in April 2022. This package is now considered inactive and has been superseded by `watchfiles`, which offers a more performant Rust-based backend for file system notifications. `watchgod` relies on file polling for change detection.

Warnings

breaking This package (watchgod) has been renamed to `watchfiles` and is no longer actively developed. The `watchgod` package will only receive critical security fixes. Users are strongly encouraged to migrate to `watchfiles` for new projects and to update existing `watchgod` installations.
Fix: Migrate to `watchfiles`. Install with `pip install watchfiles`. Update import statements from `watchgod` to `watchfiles`. Be aware of potential API changes, especially regarding `watcher_cls` (replaced by `watch_filter`) and `target` arguments for `run_process` (now keyword-only). Refer to the `watchfiles` migration guide.
gotcha `watchgod` (version 0.8.2 and earlier) uses file polling to detect changes, which can be less efficient and may introduce a slight delay compared to OS-native file system notifications.
Fix: For high-performance, real-time file watching, use the `watchfiles` library, its successor, which utilizes a Rust-based backend for OS-native file system event handling.
deprecated The `Development Status :: 7 - Inactive` classifier has been added to the `watchgod` PyPI project, indicating that the project is no longer under active development.
Fix: Switch to `watchfiles` to ensure you receive ongoing feature development, performance improvements, and non-critical bug fixes.

Install

pip install watchgod Install last stable version

Imports

watch
```
from watchgod import watch
```
awatch
```
from watchgod import awatch
```
run_process
```
from watchgod import run_process
```
arun_process
```
from watchgod import arun_process
```

Quickstart

This quickstart demonstrates how to use `watchgod.watch` to detect file system changes in a specified directory. It creates a temporary directory and file, then watches it for a short period. For real-world use, you would typically run the `watch` loop indefinitely.

import time
from watchgod import watch
import os

def main():
    # Create a dummy directory and file for demonstration
    if not os.path.exists('watched_dir'):
        os.makedirs('watched_dir')
    with open('watched_dir/test.txt', 'w') as f:
        f.write('initial content')
    print("Watching './watched_dir' for changes (will run for 5 seconds)...")

    # The 'watch' function yields sets of changed files
    # In a real application, you'd typically run this indefinitely
    # or within a controlled loop.
    # For this quickstart, we'll simulate a short watch period.
    # Note: watchgod uses polling, so changes might not be immediate.
    start_time = time.time()
    for changes in watch('./watched_dir'):
        print(f"Detected changes: {changes}")
        if time.time() - start_time > 5: # Limit execution time for quickstart
            break

    print("Quickstart demonstration complete.")

if __name__ == '__main__':
    main()

view raw JSON →