functools und Dekoratoren

import functools
from collections.abc import Callable
from typing import Any


def shout(func: Callable[..., str]) -> Callable[..., str]:
    """Make the string result of func upper case."""

    def wrapper(*args: Any, **kwargs: Any) -> str:
        return func(*args, **kwargs)

    return wrapper


@shout
def greet(name: str, punctuation: str = "!") -> str:
    """Greet someone by name."""
    return f"hello, {name}{punctuation}"


if __name__ == "__main__":
    print(greet("ada"))

from main import greet, shout


def test_upper():
    """greet('ada') wird groß geschrieben"""
    got = greet("ada")
    assert got == "HELLO, ADA!", f"greet('ada') lieferte {got!r}, erwartet: 'HELLO, ADA!'"


def test_keyword_argument():
    """Schlüsselwortargumente erreichen die Funktion"""
    got = greet("bo", punctuation="?")
    assert got == "HELLO, BO?", f"greet('bo', punctuation='?') lieferte {got!r}, erwartet: 'HELLO, BO?'"


def test_name_and_docstring():
    """greet behält Namen und Docstring"""
    got = greet.__name__, greet.__doc__
    assert got == ("greet", "Greet someone by name."), f"greet.__name__ und __doc__ sind {got!r}: Nutzen Sie functools.wraps"


def test_other_function():
    """shout funktioniert mit jeder Funktion, die einen String liefert"""

    @shout
    def join(*words):
        return "-".join(words)

    got = join("a", "b")
    assert got == "A-B", f"ein dekoriertes join('a', 'b') lieferte {got!r}, erwartet: 'A-B'"

from functools import cache


def count_paths(rows: int, cols: int) -> int:
    """Count the paths through a grid, moving only right or down."""
    if rows == 0 or cols == 0:
        return 1
    return count_paths(rows - 1, cols) + count_paths(rows, cols - 1)


if __name__ == "__main__":
    print(count_paths(2, 2))

from main import count_paths


def test_small_grids():
    """Ein 1-mal-1-Gitter hat 2 Wege, ein 2-mal-2-Gitter 6"""
    got = count_paths(1, 1), count_paths(2, 2)
    assert got == (2, 6), f"count_paths(1, 1) und count_paths(2, 2) lieferten {got!r}, erwartet: (2, 6)"


def test_straight_line():
    """Ohne Schritte nach unten gibt es einen Weg"""
    got = count_paths(0, 5)
    assert got == 1, f"count_paths(0, 5) lieferte {got!r}, erwartet: 1"


def test_bigger_grid():
    """Ein 10-mal-10-Gitter hat 184756 Wege"""
    got = count_paths(10, 10)
    assert got == 184756, f"count_paths(10, 10) lieferte {got!r}, erwartet: 184756"


def test_is_cached():
    """count_paths ist gecacht und nutzt Ergebnisse wieder"""
    assert hasattr(count_paths, "cache_info"), "count_paths hat kein cache_info(): Setzen Sie @cache über def count_paths"
    count_paths(3, 3)
    hits = count_paths.cache_info().hits
    assert hits > 0, f"der Cache meldet {hits} Treffer nach count_paths(3, 3)"

from collections.abc import Callable
from functools import partial, reduce


def parse_base(base: int) -> Callable[[str], int]:
    """Return a function that reads a string as a number in base."""
    return int


def merge_all(dicts: list[dict[str, int]]) -> dict[str, int]:
    """Merge dicts from left to right; later values win."""
    return {}


if __name__ == "__main__":
    print(parse_base(16)("ff"))
    print(merge_all([{"a": 1}, {"a": 3, "b": 2}]))

from main import merge_all, parse_base


def test_parse_base():
    """Basis 2 liest 101 als 5, Basis 16 liest ff als 255"""
    got = parse_base(2)("101"), parse_base(16)("ff")
    assert got == (5, 255), f"parse_base(2)('101') und parse_base(16)('ff') lieferten {got!r}, erwartet: (5, 255)"


def test_merge():
    """Spätere Dicts gewinnen"""
    got = merge_all([{"a": 1}, {"b": 2}, {"a": 3}])
    assert got == {"a": 3, "b": 2}, f"merge_all lieferte {got!r}, erwartet: {{'a': 3, 'b': 2}}"


def test_merge_empty():
    """Ohne Dicts kommt ein leeres Dict"""
    got = merge_all([])
    assert got == {}, f"merge_all([]) lieferte {got!r}, erwartet: {{}}"


def test_inputs_unchanged():
    """merge_all ändert die übergebenen Dicts nicht"""
    first = {"a": 1}
    merge_all([first, {"a": 2}])
    assert first == {"a": 1}, f"das erste Dict wurde zu {first!r} geändert"