Simon Willison's Weblog: monkey-patching

Don't sleep on wrapture

2026-09-11T13:51:32+00:00

Graham Dumpleton's new monkey patching package wrapture is shaping up to be an indispensable tool for Python developers. I'm not sure why I've seen so little buzz about it!

Graham has been posting new tutorials for it almost daily since the initial release on August 31st. Here's everything he's published so far:

Introducing wrapture - a new monkey patching library that serves both testing and observability (think New Relic style tracing) at the same time.
Unit testing with wrapture - how to use it for the same kinds of thing as unittest.mock.
Recording calls with wrapture - recording method calls as timelines and processing and displaying them as trees.
Phased behaviour in wrapture - arranging patched methods to change behavior across multiple calls.
Beyond callables in wrapture - monkey patching attributes, dictionaries, generators.
Live tracing with wrapture - tracing a live application to see exactly how it works.
Zero-code tracing with wrapture - configuring tracing in a separate TOML file without modifying Python code at all.
Tracing Flask with wrapture - using the separate wrapture-instrumenation package to instrument a Flask application. That package also provides instrumentation for aiohttp.client, aiohttp.web, django, fastapi, flask, grpc, http.client, httpx, jinja2, requests, sqlalchemy, sqlite3, starlette, urllib.request, urllib3, uvicorn, werkzeug.serving, wsgiref.simple_server, xmlrpc.client, xmlrpc.server.
Finding slow code with wrapture - wrapture's tools for recording timing information, both individually and aggregated across multiple calls.
OpenTelemetry export in wrapture - exporting traces to OpenTelemetry.

Graham also has a set of interactive workshops for wrapture, implemented as JupyterLab notebooks.

Wrapture is still alpha software but it's already very usable - especially given you can configure and try it out with a TOML file without modifying any Python code at all.

This feels like one of those Swiss Army Knife packages that, once mastered, will provide value against all sorts of problems for years to come.

Tags: graham-dumpleton, monkey-patching, open-source, python, testing, observability

Introducing wrapture

2026-08-31T23:59:36+00:00

Introducing wrapture

New from Graham Dumpleton (of wrapt, mod_wsgi, and New Relic's Python agent fame), who describes Wrapture as taking the monkeypatching ideas from wrapt and extending them to apply to testing and tracing at the same time.

Wrapture (full documentation here) makes it easy to wrap any function or method such that all access can be traced, or can be overridden to return a different value.

It acts as both an alternative to unittest.mock and a way to implement tracing against an existing project:

Attaching observation to code you do not control, recording what flows through it, and doing so without disturbing the program being watched, is a problem I have never really stopped thinking about.

Wrapture includes OpenTelemetry support and even has an entirely configuration-based mechanism for adding tracing to an existing Python project, which looks like this:

capture = "summary"

[[observe]]
target = "domain:Calculator"
name = ["outer", "inner"]

[[sink]]
type = "jsonlines"
path = "trace.jsonl"

This is still a very young project - just a few weeks old - but it's off to a very promising start.

Interestingly, this is also Graham's first attempt at large entirely agent-driven project:

Every line of code and documentation in wrapture was written by an AI assistant working under my direction. I want to be upfront about that, and equally upfront about what it was not. This was not vibe coding, where a one-shot prompt produces a pile of generated code and the person driving hopes for the best because they lack the knowledge to judge what came back. Vibe coding has earned its bad reputation. I engineered wrapture carefully from the start. I have spent a long time in this particular corner of Python and knew exactly what the result needed to be, and the AI was the means of producing it rather than the source of the design.

In a follow-up post, Unit testing with wrapture, Graham shows the testing patterns supported by the new library:

def test_stub_with_wrapture():
    with wrapture.binding(
        Gateway, "charge"
    ).on_call.returns({
        "id": "stub", "amount": 0}
    ):
        assert OrderService().place(
            500
        )["id"] == "stub"

And this neat example of a test that calls and then modifies the return value from the original method:

def test_pinned_result_with_wrapture():
    charge = wrapture.binding(
        Gateway, "charge"
    )
    charge.on_call.transforms_result(
        lambda r: {**r, "id": "ch_TEST"}
    )
    with charge:
        assert OrderService().place(
           500
        ) == {
            "id": "ch_TEST", "amount": 500
        }

(In both of these examples the OrderService().place(...) method calls Gateway().charge(...).)

Tags: graham-dumpleton, monkey-patching, python, testing, pytest, observability, ai-assisted-programming, agentic-engineering, opentelemetry

s3monkey: A Python library that allows you to interact with Amazon S3 Buckets as if they are your local filesystem.

2018-02-21T17:54:36+00:00

s3monkey: A Python library that allows you to interact with Amazon S3 Buckets as if they are your local filesystem.

A particularly devious hack by Kenneth Reitz—provides a context manager within which various Python filesystem APIs such as open() and os.listdir() are monkeypatched to operate against an S3 bucket instead. Kenneth built it to make it easier to work with files from apps running on Heroku. Under the hood it uses pyfakefs, a filesystem mocking library originally released by Google.

Via @kennethreitz

Tags: monkey-patching, python, s3, heroku

Appending the request URL to SQL statements in Django

2010-06-02T09:09:00+00:00

Appending the request URL to SQL statements in Django

A clever frame-walking monkey-patch which pulls the most recent HttpRequest object out of the Python stack and adds the current request.path to each SQL query as an SQL comment, so you can see it in debugging tools such as slow query logs and the PostgreSQL “select * from pg_stat_activity” query.

Tags: chris-lamb, debugging, django, monkey-patching, orm, postgresql, python, sql, recovered

What's wrong with extending the DOM

2010-04-11T22:03:39+00:00

What's wrong with extending the DOM

Detailed explanation of the problems that crop up from extending built-in DOM objects using JavaScript, from Prototype developer kangax. Prototype 2.0 will be dropping this technique entirely—will MooTools follow suit?

Tags: javascript, kangax, monkey-patching, mootools, prototype-js

Quoting Adam Kennedy

2008-03-22T00:28:50+00:00

The Perl community has a long-standing love/hate-affair with making changes that impose "spooky action at a distance". They call it "black magic" and it is generally considered it a last resort. Black Magic that makes GLOBAL changes to things like inheritance is often characterised as being "Octarine" (see disk world novels), because it tends to work ok when there's only one person doing it, but start to mix a few together and KABOOM!

— Adam Kennedy

Tags: adam-kennedy, blackmagic, magic, monkey-patching, perl, ruby

Monkeypatching is Destroying Ruby

2008-03-22T00:27:02+00:00

Monkeypatching is Destroying Ruby

Deliberately provocative title, but makes a well considered case for restrained use of monkey patching in Ruby. Cultural norms around monkey patching seem to me to be one of the core differences between the Ruby and Python communities.

Via Ian Bicking

Tags: ian-bicking, monkey-patching, python, ruby

Hacking Contributed Models

2008-03-11T05:51:00+00:00

Hacking Contributed Models

Neat Django trick using monkeypatching to make some minor tweaks to built-in contributed models such as auth or flatpages.

Tags: contrib, django, monkey-patching, python

Monkeypatching idioms - elegant or ugly?

2008-01-30T00:39:36+00:00

Monkeypatching idioms - elegant or ugly?

Guido offers a decorator and a metaclass as syntactic sugar for monkeypatching existing Python classes.

Tags: decorators, guido-van-rossum, idioms, metaclasses, monkey-patching, python

Test stubbing httplib2

2007-05-10T23:24:09+00:00

Test stubbing httplib2

Nice demonstration of monkey-patching as part of unit testing in Python.

Tags: httplib2, joe-gregorio, monkey-patching, python, testing