pyproject.toml und ein installierbares Paket

import tomllib

# Add a [build-system] table for setuptools, requires-python = ">=3.10",
# and a [project.scripts] table with wordstat = "wordstat.cli:main".
PYPROJECT = """
[project]
name = "wordstat"
version = "0.1.0"
description = "Show the most common words in a text file"
"""

if __name__ == "__main__":
    data = tomllib.loads(PYPROJECT)
    print(data["project"]["name"], data["project"]["version"])
    print("scripts:", data["project"].get("scripts", {}))

import tomllib

import main


def load():
    try:
        return tomllib.loads(main.PYPROJECT)
    except tomllib.TOMLDecodeError as err:
        raise AssertionError(f"PYPROJECT ist kein gültiges TOML: {err}") from None


def test_build_system():
    """[build-system] nennt, was zu installieren ist, und das Backend zum Bauen"""
    build = load().get("build-system")
    assert build is not None, "ergänzen Sie eine Tabelle [build-system]"
    assert build.get("requires"), "[build-system] braucht requires, eine Liste wie [\"setuptools >= 77.0.3\"]"
    assert build.get("build-backend") == "setuptools.build_meta", "für setuptools ist build-backend \"setuptools.build_meta\""


def test_name_and_version():
    """[project] hat den Namen wordstat und eine Version"""
    project = load().get("project", {})
    assert project.get("name") == "wordstat", f"name ist {project.get('name')!r}; es muss \"wordstat\""
    assert project.get("version"), "ergänzen Sie eine Version, etwa \"0.1.0\""


def test_requires_python():
    """requires-python nennt das älteste Python, 3.10"""
    project = load().get("project", {})
    assert project.get("requires-python") == ">=3.10", f"requires-python ist {project.get('requires-python')!r}; nehmen Sie \">=3.10\""


def test_console_script():
    """[project.scripts] ordnet dem Befehl wordstat wordstat.cli:main zu"""
    scripts = load().get("project", {}).get("scripts", {})
    assert scripts.get("wordstat") == "wordstat.cli:main", f"[project.scripts] enthält {scripts}; ergänzen Sie wordstat = \"wordstat.cli:main\""

import argparse
import sys
from pathlib import Path

from wordstat.core import top_words


def main(argv: list[str] | None = None) -> int:
    """Entry point of the wordstat command: wordstat = "wordstat.cli:main"."""
    parser = argparse.ArgumentParser(prog="wordstat", description="Show the most common words in a file.")
    parser.add_argument("path", help="the text file to read")
    # Add -n/--top (an int, default 3), and return 1 with a message on
    # stderr when the file does not exist.
    args = parser.parse_args(argv)
    text = Path(args.path).read_text(encoding="utf-8")
    for word, count in top_words(text):
        print(f"{count} {word}")
    return 0


if __name__ == "__main__":
    sys.exit(main())

import contextlib
import io
import tempfile
from pathlib import Path

import main

TEXT = "The cat sat. The cat ran! The end."


def run(*args):
    out, err = io.StringIO(), io.StringIO()
    with tempfile.TemporaryDirectory() as tmp:
        path = Path(tmp, "story.txt")
        path.write_text(TEXT, encoding="utf-8")
        argv = [str(path) if arg == "FILE" else arg for arg in args]
        with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
            status = main.main(argv)
    return status, out.getvalue(), err.getvalue()


def test_prints_top_three():
    """wordstat FILE gibt die drei häufigsten Wörter aus und liefert 0"""
    status, out, _ = run("FILE")
    assert out == "3 the\n2 cat\n1 sat\n", f"ausgegeben: {out!r}"
    assert status == 0, f"geliefert: {status!r}; liefern Sie bei Erfolg 0"


def test_top_option():
    """-n 1 und --top 2 wählen, wie viele Wörter ausgegeben werden"""
    _, out, _ = run("-n", "1", "FILE")
    assert out == "3 the\n", f"mit -n 1 ausgegeben: {out!r}"
    _, out, _ = run("--top", "2", "FILE")
    assert out == "3 the\n2 cat\n", f"mit --top 2 ausgegeben: {out!r}"


def test_missing_file():
    """Eine fehlende Datei gibt eine Meldung auf stderr aus und liefert 1"""
    try:
        status, out, err = run("no-such-file.txt")
    except FileNotFoundError:
        raise AssertionError("FileNotFoundError ist aus main entkommen; fangen Sie ihn ab und liefern Sie 1") from None
    assert status == 1, f"geliefert: {status!r}; liefern Sie 1, wenn die Datei fehlt"
    assert "no-such-file.txt" in err, f"stderr war {err!r}; nennen Sie dort die fehlende Datei"
    assert out == "", f"stdout sollte leer bleiben, erhalten: {out!r}"

"""Show the most common words in a text."""

__version__ = "0.1.0"

from collections import Counter


def top_words(text: str, n: int = 3) -> list[tuple[str, int]]:
    """The n most common words, lowercased and without punctuation, most common first."""
    words = [word.strip(".,!?;:\"'()").lower() for word in text.split()]
    return Counter(word for word in words if word).most_common(n)

import unittest

from wordstat.core import top_words


class TestTopWords(unittest.TestCase):
    # Add one focused test per behaviour: case is ignored, punctuation is
    # stripped, and n limits how many words come back.
    def test_most_common_first(self) -> None:
        self.assertEqual(top_words("b a b", 2), [("b", 2), ("a", 1)])


if __name__ == "__main__":
    suite = unittest.TestLoader().loadTestsFromTestCase(TestTopWords)
    unittest.TextTestRunner(verbosity=2).run(suite)

import unittest
from collections import Counter

import main


def run_against(implementation):
    saved = main.top_words
    main.top_words = implementation
    try:
        result = unittest.TestResult()
        unittest.TestLoader().loadTestsFromTestCase(main.TestTopWords).run(result)
    finally:
        main.top_words = saved
    return result


def keeps_case(text, n=3):
    words = [word.strip(".,!?;:\"'()") for word in text.split()]
    return Counter(word for word in words if word).most_common(n)


def keeps_punctuation(text, n=3):
    return Counter(word.lower() for word in text.split()).most_common(n)


def ignores_n(text, n=3):
    words = [word.strip(".,!?;:\"'()").lower() for word in text.split()]
    return Counter(word for word in words if word).most_common()


BROKEN = {
    "Groß- und Kleinschreibung nicht ignoriert wird": keeps_case,
    "Satzzeichen erhalten bleiben": keeps_punctuation,
    "n ignoriert wird": ignores_n,
}


def test_correct_code_passes():
    """Mindestens 4 Tests, und alle bestehen mit dem echten top_words"""
    result = run_against(main.top_words)
    failing = [test.id() for test, _ in result.failures + result.errors]
    assert result.wasSuccessful(), f"diese Tests scheitern an korrektem Code: {failing}"
    assert result.testsRun >= 4, f"{result.testsRun} Tests liefen; schreiben Sie mindestens 4 fokussierte Tests"


def test_every_bug_is_caught():
    """Jede der drei fehlerhaften Versionen lässt einen Test scheitern"""
    missed = [bug for bug, broken in BROKEN.items() if run_against(broken).wasSuccessful()]
    if missed:
        assert False, f"kein Test scheitert, wenn {missed[0]}; ergänzen Sie einen Test dafür"

"""Show the most common words in a text."""

__version__ = "0.1.0"

from collections import Counter


def top_words(text: str, n: int = 3) -> list[tuple[str, int]]:
    """The n most common words, lowercased and without punctuation, most common first."""
    words = [word.strip(".,!?;:\"'()").lower() for word in text.split()]
    return Counter(word for word in words if word).most_common(n)