Importing typos within Python for programmatic use

[jamesbraza]

Is there some way to import and use typos from within Python? With Python 3.12 and typos==1.32.0:

>>> import typos
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ModuleNotFoundError: No module named 'typos'

I am looking to programmatically inspect a massive repository of language model outputs for typos.

As a workaround I can use the subprocess module and just wrap typos' CLI.

[epage]

The Python package exists just for simpler integration with pre-commit. We don't offer an API. We don't even have a full API for Rust.

subprocess would be the way to go.

[jamesbraza]

Alright sounds good, I have made:

import json
import multiprocessing
import subprocess
from collections.abc import Collection, Mapping
from enum import IntEnum

from tqdm import tqdm


class TyposReturnCodes(IntEnum):
    """Return codes for the `typos` spellchecker."""

    NO_TYPOS_FOUND = 0
    TYPOS_FOUND = 2


def invoke_typos(text: str) -> Mapping[str, Collection[str]]:
    """Invoke the spellchecker `typos` as a subprocess on the input paragraphs.

    Returns:
        Mapping of typos to their suggested fixes.
    """
    try:
        result = subprocess.run(
            ("typos", "-", "--format", "json"),
            input=text,
            text=True,
            capture_output=True,
            check=False,
        )
    except FileNotFoundError as exc:
        raise ImportError(
            "The tool `typos` was not found, please `pip install typos`."
        ) from exc
    try:
        return_code = TyposReturnCodes(result.returncode)
    except ValueError as exc:
        raise NotImplementedError(
            f"Didn't yet account for return code {result.returncode} from typos in"
            f" result {result}."
        ) from exc
    if result.stderr or return_code not in {
        TyposReturnCodes.TYPOS_FOUND,
        TyposReturnCodes.NO_TYPOS_FOUND,
    }:
        raise RuntimeError(
            f"`typos` failed with result {result} on the input text {text}."
        )
    if return_code == TyposReturnCodes.NO_TYPOS_FOUND:
        return {}
    typos = {}
    for line in result.stdout.splitlines():
        try:
            entry = json.loads(line)
        except json.JSONDecodeError as exc:
            raise NotImplementedError(
                f"Unexpected non-JSON shape of `typos` stdout {result.stdout}."
            ) from exc
        if entry["type"] != "typo":
            raise NotImplementedError(f"Unexpected `typos` type in entry {entry}.")
        typos[entry["typo"]] = set(entry.get("corrections", []))
    return typos


def bulk_invoke_typos(
    texts: Collection[str], processes: int | None = None
) -> Mapping[str, Collection[str]]:
    """Bulk invoke typos using multiprocessing with a progress bar."""
    with multiprocessing.Pool(processes=processes) as pool:
        results = list(
            tqdm(
                pool.imap(invoke_typos, texts), total=len(texts), desc="Checking typos"
            )
        )
    return dict(zip(texts, results, strict=True))