《Python编程实战》14.1 Click / Typer 构建 CLI

# textkit/core.py
import re
from collections import Counter
from dataclasses import dataclass
from pathlib import Path

WORD_RE = re.compile(r"[A-Za-z0-9']+")

@dataclass(frozen=True)
class TextStats:
    path: Path
    lines: int
    words: int
    chars: int

def count_text(text: str) -> tuple[int, int, int]:
    return len(text.splitlines()), len(WORD_RE.findall(text)), len(text)

def count_file(path: Path) -> TextStats:
    text = path.read_text(encoding="utf-8", errors="replace")   # 坏字节不中断整批
    lines, words, chars = count_text(text)
    return TextStats(path, lines, words, chars)

def iter_files(root: Path, pattern: str = "*.txt") -> list[Path]:
    if root.is_file():
        return [root]
    return sorted(p for p in root.rglob(pattern) if p.is_file())

def scan(root: Path, pattern: str = "*.txt") -> list[TextStats]:
    return [count_file(p) for p in iter_files(root, pattern)]

def top_words(root: Path, n: int = 10, pattern: str = "*.txt") -> list[tuple[str, int]]:
    counter: Counter[str] = Counter()
    for path in iter_files(root, pattern):
        text = path.read_text(encoding="utf-8", errors="replace")
        counter.update(w.lower() for w in WORD_RE.findall(text))
    return counter.most_common(n)

def totals(stats: list[TextStats]) -> tuple[int, int, int]:
    return (sum(s.lines for s in stats), sum(s.words for s in stats), sum(s.chars for s in stats))

# textkit/cli.py
import json
import click
from pathlib import Path
from . import __version__
from .core import scan, top_words, totals

@click.group()
@click.version_option(version=__version__, prog_name="textkit")
@click.option("-v", "--verbose", count=True, help="提高日志详细度，可叠加（-vv）。")
@click.pass_context
def cli(ctx: click.Context, verbose: int) -> None:
    """textkit —— 目录文本统计小工具。"""
    ctx.ensure_object(dict)
    ctx.obj["verbose"] = verbose
    if verbose:
        click.echo(f"[verbose={verbose}] 已提升日志详细度", err=True)

@cli.command()
@click.argument("paths", nargs=-1, required=True,
                type=click.Path(exists=True, path_type=Path))
@click.option("--pattern", default="*.txt", show_default=True)
@click.option("--format", "fmt", type=click.Choice(["text", "json"]), default="text")
@click.pass_obj
def count(obj: dict, paths: tuple[Path, ...], pattern: str, fmt: str) -> None:
    """统计每个文件的行数、词数与字符数。"""
    stats = []
    for root in paths:
        if obj["verbose"]:
            click.echo(f"[verbose] 扫描 {root}", err=True)
        stats.extend(scan(root, pattern))
    if not stats:
        click.echo(f"没有匹配 {pattern} 的文件", err=True)
        raise SystemExit(1)
    click.echo(render_json(stats) if fmt == "json" else render_text(stats))

python -m textkit --help

Usage: python -m textkit [OPTIONS] COMMAND [ARGS]...

  textkit —— 目录文本统计小工具。

Options:
  --version      Show the version and exit.
  -v, --verbose  提高日志详细度，可叠加（-vv）。
  --help         Show this message and exit.

Commands:
  count  统计每个文件的行数、词数与字符数。
  words  列出目录中出现频率最高的词。

文件                        行      词     字符
-------------------------------------------------
a.txt                        3      11       52
b.txt                        2       9       50
c.txt                        1       4       25
-------------------------------------------------
合计(3 个)                   6      24      127

{
  "files": [
    { "path": "../sample/a.txt", "lines": 3, "words": 11, "chars": 52 }
  ],
  "total": { "files": 3, "lines": 6, "words": 24, "chars": 127 }
}

$ python -m textkit -vv count sample
[verbose=2] 已提升日志详细度
[verbose] 扫描 sample
文件                        行      词     字符
...

$ python -m textkit count ../nope; echo $?
Error: Invalid value for 'PATHS...': Path '../nope' does not exist.
2
$ python -m textkit count sample --pattern '*.md'; echo $?
没有匹配 *.md 的文件
1

import unicodedata

def display_width(text: str) -> int:
    return sum(2 if unicodedata.east_asian_width(ch) in "WF" else 1 for ch in text)

def pad(text: str, width: int, align: str = "<") -> str:
    fill = " " * max(0, width - display_width(text))
    return fill + text if align == ">" else text + fill

# tests/test_cli.py
import json
import pytest
from pathlib import Path
from click.testing import CliRunner
from textkit.cli import cli

@pytest.fixture
def sample(tmp_path: Path) -> Path:
    (tmp_path / "a.txt").write_text("hello world\nhello python\n", encoding="utf-8")
    (tmp_path / "sub").mkdir()
    (tmp_path / "sub" / "b.txt").write_text("one two three\n", encoding="utf-8")
    return tmp_path

def test_count_json(sample: Path) -> None:
    result = CliRunner().invoke(cli, ["count", str(sample), "--format", "json"])
    assert result.exit_code == 0
    assert json.loads(result.output)["total"]["words"] == 7

def test_missing_path() -> None:
    result = CliRunner().invoke(cli, ["count", "/definitely/nope"])
    assert result.exit_code == 2
    assert "does not exist" in result.output

# textkit/cli_typer.py
from enum import Enum
from pathlib import Path
from typing import Annotated
import typer

class OutputFormat(str, Enum):
    text = "text"
    json = "json"

app = typer.Typer(help="textkit —— 目录文本统计小工具（Typer 版）。",
                  no_args_is_help=True, add_completion=False)

@app.command()
def count(
    paths: Annotated[list[Path], typer.Argument(exists=True, help="要统计的文件或目录。")],
    pattern: Annotated[str, typer.Option(help="递归匹配的文件通配符。")] = "*.txt",
    fmt: Annotated[OutputFormat, typer.Option("--format")] = OutputFormat.text,
    verbose: Annotated[int, typer.Option("-v", "--verbose", count=True)] = 0,
) -> None:
    """统计每个文件的行数、词数与字符数。"""
    ...

 Usage: python -m textkit.typer_main count [OPTIONS] {paths}...

 统计每个文件的行数、词数与字符数。

╭─ Arguments ──────────────────────────────────────────────────────────────╮
│ *    paths      <path>  要统计的文件或目录。 [required]                  │
╰──────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────╮
│ --pattern          <str>        递归匹配的文件通配符。 [default: *.txt]  │
│ --format           <text|json>  输出格式。 [default: text]               │
│ --verbose  -v      <int>        详细度，可叠加。 [default: 0]            │
╰──────────────────────────────────────────────────────────────────────────╯