Outwrite

Readable logs. Live status. Even across processes and threads.

outwrite pairs standard Python logging with one status line that updates in place. Keep the useful messages, skip the progress chatter.

Built on Rich and standard logging. outwrite handles the queue, live display, and cleanup so you don't have to wire them together yourself.

Requires Python 3.11+.

Install

pip install outwrite

Quick start

A tiny coffee run. Keep the milestones in the log; let status handle the play-by-play:

import logging
import time

import outwrite

logger = logging.getLogger("coffee")

with outwrite.configure_console(logger=logger):
    logger.info("Beans ready")

    for cup in range(1, 4):
        outwrite.status.update(f"Brewing cup {cup}/3. Almost human.")
        time.sleep(0.5)  # Simulate brewing.

    logger.info("Coffee ready")

When the with block ends, outwrite finishes printing pending messages and removes the status line. Existing file handlers still receive logs, but not status.

Status is text you provide, not an automatically calculated progress bar. Use it for imports, downloads, long-running checks, or whatever your script is doing now.

Running multiple processes or threads?

Bring their logs into the same console, too. outwrite handles the queue, listener, and cleanup for batch jobs, parallel downloads, and multi-stage pipelines. Just need logging? Set show_status=False.

Logs and status updates travel through a shared queue to a single listener in the main process, rather than each process writing to the terminal on its own.

Pass the connection returned by the main process to each child process and call outwrite.configure_console(console_connection) there before logging or updating status.

import logging
import multiprocessing as mp

import outwrite

logger = logging.getLogger("coffee")


def brew(connection):
    outwrite.configure_console(connection)
    logger.info("Beans ready")
    outwrite.status.update("Brewing coffee")


if __name__ == "__main__":
    context = mp.get_context("spawn")
    with outwrite.configure_console(logger=logger, mp_context=context) as connection:
        process = context.Process(target=brew, args=(connection,))
        process.start()
        process.join()
        if process.exitcode != 0:
            raise RuntimeError(f"Child process exited with code {process.exitcode}")

Save this as a Python file and run it, rather than pasting it into a REPL.

The multiprocessing demo shows the complete setup, including cleanup when interrupted with Ctrl+C.

After installing outwrite, run it from a repository checkout:

python examples/multiprocessing_demo.py

• Use the same logger name and multiprocessing context in the main process and workers.
• Join workers before leaving the with block so their final messages arrive.
• Workers share one status line; the last update received is shown.

Threads share the same setup, so there's no connection to pass around. Messages are displayed in queue-receipt order, not globally sorted by timestamp.

Options

Pass these options to outwrite.configure_console(...):

In workers, pass only console_connection. The other options configure the main process; they are ignored when a connection is supplied.

By default, output goes to stderr. When that stream is redirected to a file or pipe, logs are still written, but the live status line is hidden.

Change how it looks

This example hides the time and source filename in logs and makes status green:

import logging
import time

import outwrite
from rich.console import Console
from rich.logging import RichHandler
from rich.text import Text

logger = logging.getLogger("my_app")
handler = RichHandler(show_time=False, show_path=False, level=logging.INFO)


def render_status(text: str, console: Console) -> Text:
    status_text = Text(text, style="green", no_wrap=True)
    status_text.truncate(max(1, console.width - 2), overflow="ellipsis")
    return status_text


with outwrite.configure_console(
    logger=logger, console_handler=handler, render_status=render_status
):
    logger.info("Starting")
    outwrite.status.update("Brewing coffee. Worth the wait.")
    time.sleep(1)
    # Do your work here.

A supplied handler controls the console and log level; console_level does not override it. Status uses the same console. outwrite reuses your handler without adding it twice or closing it afterward.

License

MIT.