Structural typing with 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 is a Protocol, not an ABC"""
    assert is_protocol(HasArea), "HasArea should inherit from typing.Protocol"


def test_runtime_checkable():
    """isinstance() works with HasArea, and Square and Circle match it"""
    got = isinstance(Square(2), HasArea), isinstance(Circle(1), HasArea), isinstance("text", HasArea)
    assert got == (True, True, False), f"isinstance() gave {got!r}, expected (True, True, False)"


def test_total_area():
    """total_area adds 4 for a square of side 2 and pi for a circle of radius 1"""
    got = total_area([Square(2), Circle(1)])
    assert math.isclose(got, 4 + math.pi), f"total_area returned {got!r}, expected {4 + math.pi!r}"


def test_only_shapes():
    """only_shapes keeps the square and the circle, and drops the rest"""
    square, circle = Square(1), Circle(1)
    got = only_shapes([square, "text", 3, circle])
    assert got == [square, circle], f"only_shapes returned {got!r}, expected the square and the circle"

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() raises TypeError"""
    try:
        Exporter()
    except TypeError:
        return
    assert False, "Exporter() created an object; make render an @abstractmethod of an ABC"


def test_missing_render():
    """A subclass without render() cannot be instantiated"""

    class Broken(Exporter):
        pass

    try:
        Broken()
    except TypeError:
        return
    assert False, "a subclass without render() was instantiated"


def test_csv():
    """CsvExporter writes a header line and one line per row"""
    got = CsvExporter().export(ROWS)
    assert got == "name,city\nAda,London\nAlan,Wilmslow\n", f"CsvExporter().export returned {got!r}"


def test_json():
    """JsonExporter writes the rows as JSON, plus a newline"""
    got = JsonExporter().export(ROWS)
    assert got == json.dumps(ROWS) + "\n", f"JsonExporter().export returned {got!r}"


def test_empty():
    """export([]) returns an empty string"""
    got = JsonExporter().export([])
    assert got == "", f"export([]) returned {got!r}, expected ''"