TypedDict, Literal and Final

import json
from typing import TypedDict


class Book(TypedDict):
    title: str
    author: str
    year: int
    isbn: str


def load_books(text: str) -> list[Book]:
    books: list[Book] = json.loads(text)
    return books


def label(book: Book) -> str:
    return f"{book['title']} ({book['author']}, {book['year']}) ISBN {book['isbn']}"

from typing import is_typeddict

from main import Book, label, load_books

DATA = '[{"title": "Dune", "author": "Frank Herbert", "year": 1965, "isbn": "9780441013593"}, {"title": "Emma", "author": "Jane Austen", "year": 1815}]'


def test_keys():
    """title, author and year are required; isbn is optional"""
    assert is_typeddict(Book), "Book should be a TypedDict"
    got = sorted(Book.__required_keys__), sorted(Book.__optional_keys__)
    assert got == (['author', 'title', 'year'], ['isbn']), f"required and optional keys are {got!r}"


def test_label_with_isbn():
    """A book with an isbn shows it at the end"""
    got = label(load_books(DATA)[0])
    assert got == "Dune (Frank Herbert, 1965) ISBN 9780441013593", f"label returned {got!r}"


def test_label_without_isbn():
    """A book without an isbn has no ISBN part"""
    got = label(load_books(DATA)[1])
    assert got == "Emma (Jane Austen, 1815)", f"label returned {got!r}"

from typing import Final, Literal

# Define the alias Light, and annotate the constants as Final.
LIGHTS = ("red", "green", "yellow")
NEXT = {"red": "green", "green": "yellow", "yellow": "red"}


def next_light(light: str) -> str:
    return NEXT[light]


def parse_light(text: str) -> str:
    return text

from typing import Final, get_args, get_origin

import main


def test_light_alias():
    """Light is an alias for Literal["red", "green", "yellow"]"""
    light = getattr(main, "Light", None)
    assert light is not None, "main.py defines no Light"
    got = get_args(light.__value__)
    assert got == ("red", "green", "yellow"), f"Light allows {got!r}"


def test_constants_are_final():
    """LIGHTS and NEXT are annotated with Final[...]"""
    hints = getattr(main, "__annotations__", {})
    for name in ("LIGHTS", "NEXT"):
        assert get_origin(hints.get(name)) is Final, f"{name} is annotated as {hints.get(name)!r}, expected Final[...]"


def test_next_light():
    """red, green and yellow follow each other in a cycle"""
    got = [main.next_light(light) for light in ("red", "green", "yellow")]
    assert got == ["green", "yellow", "red"], f"next_light gave {got!r}"


def test_parse_light():
    """parse_light cleans the text: " Green " becomes "green\""""
    got = main.parse_light(" Green ")
    assert got == "green", f"parse_light(' Green ') returned {got!r}"


def test_parse_rejects_unknown():
    """parse_light("blue") raises ValueError"""
    try:
        main.parse_light("blue")
    except ValueError:
        return
    assert False, "parse_light('blue') did not raise ValueError"