Skip to main content

A library to provide automatic paging for console output

Project description

autopage

Autopage is a Python library to automatically display terminal output from a program in a pager (like less) whenever you need it, and never when you don't. And it only takes one line of code.

You know how some CLI programs like git (and a handful of others, including man and systemctl) automatically pipe their output to less? Except not if there's less than one screen's worth of data. And if you redirect the output to a file or a pipe, it does the right thing instead. Colours are preserved. Don't you wish all programs worked like that? Now at least all of your Python programs can.

License

© 2020-2022 by Zane Bitter

Open Source licensed under the terms of the Apache Software License, version 2.0.

Installation

Autopage is available from PyPI. The easiest way to install (preferably in a virtualenv virtual environment) is with pip:

$ pip install autopage

On Fedora and CentOS/RHEL

Autopage is packaged for Fedora 35 and later. To install:

# dnf install python3-autopage

Copr repositories are available for older versions of Fedora and EPEL. Before attempting to install on those versions, first enable the copr repository:

# dnf copr enable zaneb/autopage

On Ubuntu and Debian

Autopage is packaged for Ubuntu jammy and later, and for Debian bookworm. To install:

# apt-get install python3-autopage

A PPA is available for older versions of Ubuntu. Before attempting to install on those versions, first enable the PPA:

# add-apt-repository ppa:zaneb/autopage
# apt-get update

On Gentoo

Autopage is packaged for Gentoo. To install:

# emerge dev-python/autopage

Basic Use

The AutoPager class provides a context manager that furnishes the output stream to write to. Here is a basic example that reads from stdin and outputs to a pager connected to stdout:

import sys
import autopage

with autopage.AutoPager() as out:
    for l in sys.stdin:
        out.write(l)

If you are explicitly passing a stream to write to (rather than directly referencing a global variable such as sys.stdout then you may be able to add automatic paging support with only a single line of code.

Paging help output

If your program uses the argparse module from the standard library, you can ensure that the help output is automatically paged when possible by changing the import statement to:

from autopage import argparse

If you don't control the module that imports argparse, you can instead call autopage.argparse.monkey_patch() to patch the module directly. This function can also be used as a context manager.

Environment

The default pager command (autopage.command.DefaultPager()) allows the end user to override the pager command by setting the PAGER environment variable. To disable this behaviour, pass pager_command=autopage.command.PlatformPager() to use the default pager for the current platform, or pass a specific pager from autopage.command. The default pager command is less on most platforms. On AIX the default pager command is more, and on Windows more.com.

The end user can also override the settings for less by setting the LESS environment variable. If not specified, the settings are determined by the allow_color and line_buffering options. By default ANSI control characters for setting colours are respected and the pager will not run if there is less than a full screen of text to display.

Line buffering

Normally output streams are buffered so that data is written to the output file only when the buffer becomes full. This is efficient and generally works fine as long as the data is being produced as fast as it can be consumed. However, when the data is streaming at a slower rate than it could be displayed (e.g. log output from something like tail -f) this results in a large delay between data being produced and consumed. If you have ever tried to grep a streaming log and pipe the output to a pager then you are familiar with how unsatisfactory this is.

The solution is to flush the output buffer after each line is written, which is known as line buffering. The AutoPager class supports a line_buffering argument to enable or disable line buffering. The default is to use the line buffering mode already configured for the output stream (which is usually to disable line buffering).

When reading from an input stream (which may be a file, pipe, or the console) and optionally processing the data before outputting it again, the convenience function line_buffer_from_input() returns the optimal line buffering setting for a given input stream (sys.stdin by default).

import sys
import autopage

with autopage.AutoPager(line_buffering=autopage.line_buffer_from_input()) as o:
    for l in sys.stdin:
        o.write(l)

Terminal reset

By default, when the pager exits it will leave the latest displayed output on screen in the terminal. This can be changed by passing True for the reset_on_exit argument to the AutoPager class. If this option is set, the terminal will be cleared when the pager exits, returning to its position prior to starting the pager (as is the case by default when running less manually from the command line).

Exit code

Programs may wish to return a different exit code if they are interrupted by the user (either with Ctrl-C or by closing the pager) than if they ran to completion. The exceptions generated when the pager is closed prematurely are suppressed, so the AutoPager class offers the exit_code() method to provide a suitable exit code for the program. This also takes into account other exceptions that bubble up through the context manager.

Complete Example

import sys
import autopage

def process(input_stream, output_stream):
    pager = autopage.AutoPager(
        output_stream,
        line_buffering=autopage.line_buffer_from_input(input_stream),
        allow_color=True,
        reset_on_exit=True,
        errors=autopage.ErrorStrategy.REPLACE,
    )

    try:
        with pager as out:
            for l in input_stream:
                out.write(l)
    except Exception as exc:
        sys.stderr.write(f'{str(exc)}\n')
    except KeyboardInterrupt:
        pass
    return pager.exit_code()

sys.exit(process(sys.stdin, sys.stdout))

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

autopage-0.5.2.tar.gz (33.0 kB view details)

Uploaded Source

Built Distribution

autopage-0.5.2-py3-none-any.whl (30.2 kB view details)

Uploaded Python 3

File details

Details for the file autopage-0.5.2.tar.gz.

File metadata

  • Download URL: autopage-0.5.2.tar.gz
  • Upload date:
  • Size: 33.0 kB
  • Tags: Source
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/4.0.1 CPython/3.11.5

File hashes

Hashes for autopage-0.5.2.tar.gz
Algorithm Hash digest
SHA256 826996d74c5aa9f4b6916195547312ac6384bac3810b8517063f293248257b72
MD5 57936e4a9d379fe4a60eb617d8cdce33
BLAKE2b-256 9f9e559b0cfdba9f3ed6744d8cbcdbda58880d3695c43c053a31773cefcedde3

See more details on using hashes here.

File details

Details for the file autopage-0.5.2-py3-none-any.whl.

File metadata

  • Download URL: autopage-0.5.2-py3-none-any.whl
  • Upload date:
  • Size: 30.2 kB
  • Tags: Python 3
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/4.0.1 CPython/3.11.5

File hashes

Hashes for autopage-0.5.2-py3-none-any.whl
Algorithm Hash digest
SHA256 f5eae54dd20ccc8b1ff611263fc87bc46608a9cde749bbcfc93339713a429c55
MD5 76a0d140b036612300cf45a6a481ee0b
BLAKE2b-256 9b63f1c3fa431e91a52bad5e3602e9d5df6c94d8d095ac485424efa4eeddb4d2

See more details on using hashes here.

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page