Strukturelle Typisierung mit Protocol

import math
from abc import ABC, abstractmethod


class HasArea(ABC):
    @abstractmethod
    def area(self) -> float: ...


# From a library: do not change these two classes.
class Square:
    def __init__(self, side: float) -> None:
        self.side = side

    def area(self) -> float:
        return self.side**2


class Circle:
    def __init__(self, radius: float) -> None:
        self.radius = radius

    def area(self) -> float:
        return math.pi * self.radius**2


def total_area(shapes: list[HasArea]) -> float:
    return sum(shape.area() for shape in shapes)


def only_shapes(items: list[object]) -> list[HasArea]:
    return []

import math
from typing import is_protocol

from main import Circle, HasArea, Square, only_shapes, total_area


def test_is_protocol():
    """HasArea ist ein Protocol, keine ABC"""
    assert is_protocol(HasArea), "HasArea sollte von typing.Protocol erben"


def test_runtime_checkable():
    """isinstance() funktioniert mit HasArea, und Square und Circle passen"""
    got = isinstance(Square(2), HasArea), isinstance(Circle(1), HasArea), isinstance("text", HasArea)
    assert got == (True, True, False), f"isinstance() ergab {got!r}, erwartet war (True, True, False)"


def test_total_area():
    """total_area addiert 4 für ein Quadrat der Seite 2 und pi für einen Kreis mit Radius 1"""
    got = total_area([Square(2), Circle(1)])
    assert math.isclose(got, 4 + math.pi), f"total_area lieferte {got!r}, erwartet war {4 + math.pi!r}"


def test_only_shapes():
    """only_shapes behält Quadrat und Kreis und verwirft den Rest"""
    square, circle = Square(1), Circle(1)
    got = only_shapes([square, "text", 3, circle])
    assert got == [square, circle], f"only_shapes lieferte {got!r}, erwartet waren das Quadrat und der Kreis"

import json


class Exporter:
    """Base class for exporters: subclasses must implement render()."""

    def render(self, rows: list[dict[str, str]]) -> str:
        raise NotImplementedError

    def export(self, rows: list[dict[str, str]]) -> str:
        if not rows:
            return ""
        return self.render(rows) + "\n"


class CsvExporter(Exporter):
    def render(self, rows: list[dict[str, str]]) -> str:
        header = ",".join(rows[0])
        lines = [",".join(row.values()) for row in rows]
        return "\n".join([header, *lines])


class JsonExporter(Exporter):
    pass

import json

from main import CsvExporter, Exporter, JsonExporter

ROWS = [{"name": "Ada", "city": "London"}, {"name": "Alan", "city": "Wilmslow"}]


def test_base_is_abstract():
    """Exporter() löst TypeError aus"""
    try:
        Exporter()
    except TypeError:
        return
    assert False, "Exporter() hat ein Objekt erzeugt; machen Sie render zu einer @abstractmethod einer ABC"


def test_missing_render():
    """Eine Unterklasse ohne render() lässt sich nicht instanziieren"""

    class Broken(Exporter):
        pass

    try:
        Broken()
    except TypeError:
        return
    assert False, "eine Unterklasse ohne render() wurde instanziiert"


def test_csv():
    """CsvExporter schreibt eine Kopfzeile und eine Zeile pro Datensatz"""
    got = CsvExporter().export(ROWS)
    assert got == "name,city\nAda,London\nAlan,Wilmslow\n", f"CsvExporter().export lieferte {got!r}"


def test_json():
    """JsonExporter schreibt die Datensätze als JSON, plus Zeilenumbruch"""
    got = JsonExporter().export(ROWS)
    assert got == json.dumps(ROWS) + "\n", f"JsonExporter().export lieferte {got!r}"


def test_empty():
    """export([]) liefert einen leeren String"""
    got = JsonExporter().export([])
    assert got == "", f"export([]) lieferte {got!r}, erwartet war ''"