caesura 1.0.0

Mid-execution distributed locking with zero boilerplate.

caesura 📜

Mid-execution distributed locking with zero boilerplate.

Standard distributed locks force you to wrap your entire function in a with block, even if you need heavy parsing or database lookups just to find out what needs locking. caesura lets you safely acquire locks mid-execution: yield signals exactly where the blocking I/O happens, and the decorator manages teardown—even on crash.

uv add caesura

Why

Concept	Standard Context Managers	caesura
Lock Boundary	The entire function.	Exactly where it matters.
Deadlock Prevention	Manual ordering required.	Mathematically guaranteed via tuples.
Infrastructure Coupling	High (imports Redis/Postgres).	Zero (accepts any context manager).
Type Visibility	Lost behind the wrapper.	See-through: signature & return preserved.

Usage

import caesura

@caesura.serialize
def process_webhook(payload):
    parsed_data = heavy_json_parse(payload)  # lock-free work first

    yield redis.lock(f"user:{parsed_data.user_id}")  # hand the lock to the decorator

    db.update_balance(parsed_data.user_id)  # resumes safely locked
    return True  # locks released on return — or on crash — via Python's ExitStack

Deadlock Prevention

Yield multiple resources as a tuple. caesura sorts them by their name (falling back to str()) and acquires them in an identical, deterministic order across all workers — making deadlocks mathematically impossible.

@caesura.serialize
def transfer_funds(sender_id, receiver_id):
    yield (redis.lock(sender_id), redis.lock(receiver_id))  # sorted before acquiring
    db.execute_transfer(sender_id, receiver_id)