---
id: jurigged
version: "0.6.1"
license: MIT
license_treatment: permissive
maintenance: aging
---

# jurigged — Live update of Python functions

License: permissive · Maintenance: aging · Downloads: 569.8K/mo

## What it is and what it does

Jurigged is a live code reloader for Python that watches your source files and hot-patches running functions when you save changes. Instead of restarting your script to test a modification, you edit a function, save the file, and Jurigged automatically updates all references to that function in the running process—useful for iterative development, debugging, and interactive exploration.

It works by intercepting function definitions and rewriting code pointers so existing instances adopt the new behavior. It includes a command-line interface (run `jurigged your_script.py` instead of `python your_script.py`) and an optional develoop feature that loops a specific function, re-running it each time you edit and save. You can also call `jurigged.watch()` programmatically in a Jupyter or IPython session as an alternative to `%autoreload`. The package depends on watchdog for file monitoring, blessed for terminal UI, codefind for locating functions, and ovld for method dispatch.

Use it for:

- Iterative function development: edit a function, save, and see the result immediately without restarting a long-running data pipeline.
- Interactive debugging: use the develoop loop to repeatedly test a function while editing its implementation.
- Jupyter/IPython workflows: call jurigged.watch() to auto-reload modules, similar to %autoreload but with finer control.
- Live REPL: run `jurigged` with no arguments to start an interactive session where code changes are hot-patched.
- Mocking and testing: use jurigged.make_recoder() to programmatically patch functions for testing without modifying source files.

## Worth the install?

AI-flagged interpretation of the facts above — verify before relying.

Jurigged lets you edit and hot-patch Python functions while a script is running, with changes reflected immediately without restarting the process.

Yes, if you do interactive or iterative Python development and want to avoid restart cycles. The low install friction and permissive license make it a low-risk addition. However, be aware that maintenance is aging (last release 458 days ago) and hot-patching has known limitations: running functions keep old code, decorated functions may not patch reliably, and class initializers cannot be safely changed on existing instances. Best suited for development workflows, not production hot-patching.

## Install

pip install jurigged
uv add jurigged
poetry add jurigged

## Installing jurigged

Before you install: Low install friction with a pure-Python wheel and four runtime dependencies. Maintenance status is aging—last release was 458 days ago, though the repository remains active with 1642 stars and no archived status.

License in practice: MIT license permits commercial and private use with minimal restrictions, making it safe to adopt in most projects.

Quickstart:

pip install jurigged

jurigged your_script.py

# Then edit functions in your_script.py and save; changes are hot-patched automatically.

# Or use programmatically:
import jurigged
jurigged.watch()

Requires Python >= 3.9. Functions already running will continue with old code; only subsequent calls use the patched version.

Verify before relying:

- Behavior when hot-patching decorated functions or closures (description notes this may not work reliably).
- Performance impact of watching and patching on long-running processes.
- Compatibility with async functions and generators that are already executing.

## Package facts

- License: MIT (permissive)
- Python support: supports_current
- Install friction: low
- Maintenance: aging
- Downloads: 569.8K/month (top 15,000 on PyPI)
- Known vulnerabilities: none known

## Tags

live code editing python, hot reload functions, hot patching python, live development environment, code changes without restart, interactive python development, watch and reload code, live-reload, interactive-development, hot-patching

[View on SkillFed](https://skillfed.io/packages/jurigged) · [View on PyPI](https://pypi.org/project/jurigged/)