functools and decorators

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') is shouted"""
    got = greet("ada")
    assert got == "HELLO, ADA!", f"greet('ada') returned {got!r}, expected 'HELLO, ADA!'"


def test_keyword_argument():
    """Keyword arguments reach the function"""
    got = greet("bo", punctuation="?")
    assert got == "HELLO, BO?", f"greet('bo', punctuation='?') returned {got!r}, expected 'HELLO, BO?'"


def test_name_and_docstring():
    """greet keeps its name and docstring"""
    got = greet.__name__, greet.__doc__
    assert got == ("greet", "Greet someone by name."), f"greet.__name__ and __doc__ are {got!r}: use functools.wraps"


def test_other_function():
    """shout works on any function that returns a string"""

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

    got = join("a", "b")
    assert got == "A-B", f"a shouted join('a', 'b') returned {got!r}, expected '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():
    """A 1 by 1 grid has 2 paths, a 2 by 2 grid has 6"""
    got = count_paths(1, 1), count_paths(2, 2)
    assert got == (2, 6), f"count_paths(1, 1) and count_paths(2, 2) returned {got!r}, expected (2, 6)"


def test_straight_line():
    """With no steps down there is one path"""
    got = count_paths(0, 5)
    assert got == 1, f"count_paths(0, 5) returned {got!r}, expected 1"


def test_bigger_grid():
    """A 10 by 10 grid has 184756 paths"""
    got = count_paths(10, 10)
    assert got == 184756, f"count_paths(10, 10) returned {got!r}, expected 184756"


def test_is_cached():
    """count_paths is cached and reuses results"""
    assert hasattr(count_paths, "cache_info"), "count_paths has no cache_info(): put @cache above def count_paths"
    count_paths(3, 3)
    hits = count_paths.cache_info().hits
    assert hits > 0, f"the cache reports {hits} hits after 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():
    """Base 2 reads 101 as 5, base 16 reads ff as 255"""
    got = parse_base(2)("101"), parse_base(16)("ff")
    assert got == (5, 255), f"parse_base(2)('101') and parse_base(16)('ff') returned {got!r}, expected (5, 255)"


def test_merge():
    """Later dicts win"""
    got = merge_all([{"a": 1}, {"b": 2}, {"a": 3}])
    assert got == {"a": 3, "b": 2}, f"merge_all returned {got!r}, expected {{'a': 3, 'b': 2}}"


def test_merge_empty():
    """No dicts give an empty dict"""
    got = merge_all([])
    assert got == {}, f"merge_all([]) returned {got!r}, expected {{}}"


def test_inputs_unchanged():
    """merge_all does not change the dicts it is given"""
    first = {"a": 1}
    merge_all([first, {"a": 2}])
    assert first == {"a": 1}, f"the first dict was changed to {first!r}"