acbart · October 14, 2025 16:07
diff --git a/commenter.py b/commenter.py
 from drafter import *
 from dataclasses import dataclass

 add_website_css(
    ".comment-line",
    "display: flex; justify-content: space-between; align-items: center; border-bottom: 1px dashed #ccc;",
 )


 @dataclass
 class Line:
    """
    A line of code with an optional comment.
    Attributes:
        original (str): The original line of code.
        comment (str): The comment associated with the line of code.
        index (int): The line number in the original text.
    """

    original: str
    comment: str
    index: int


 @dataclass
 class State:
    """
    The state of the code commenter application.

    Attributes:
        comments (list[Line]): A list of Line objects representing the code lines and their comments.
        original_text (str): The original text of the code being commented on.
    """

    comments: list[Line]
    original_text: str


 def parse_lines(text: str) -> list[Line]:
    """
    Parses the input text into a list of Line objects.

    Args:
        text (str): The input text to parse.
    Returns:
        list[Line]: A list of Line objects.
    """
    lines = []
    for i, line in enumerate(text.split("\n")):
        lines.append(Line(line.rstrip(), "", i))
    return lines


 @route
 def index(state: State) -> Page:
    """
    Display the main page of the code commenter application.

    Args:
        state (State): The current state of the application.
    Returns:
        Page: The rendered main page.
    """
    return Page(
        state,
        [
            Header("Code Commenter"),
            "Upload a file or type some code to get started.",
            FileUpload("code_file"),
            TextArea("text_box", state.original_text),
            Button("Start", "start_commenting"),
        ],
    )


 @route
 def error_page(message: str) -> Page:
    """
    Display an error page with the given message.

    Args:
        message (str): The error message to display.
    Returns:
        Page: The rendered error page.
    """
    return Page(
        None,
        [
            Header("Error"),
            f"Error: {message}",
            Button("Back", "index"),
        ],
    )


 @route
 def start_commenting(state: State, code_file: str = "", text_box: str = "") -> Page:
    """
    Starts the commenting process by parsing the input text or file.

    Args:
        state (State): The current state of the application.
        code_file (str): The content of the uploaded file (if any).
        text_box (str): The content of the text area (if any).
    Returns:
        Page: The page displaying the code lines for commenting.
    """
    if code_file:
        text = code_file
    elif text_box:
        text = text_box
    else:
        return error_page("Please upload a file or enter some text.")

    lines = parse_lines(text)
    state.comments = lines
    state.original_text = text

    return page_commenter(state)


 @route
 def page_commenter(state: State) -> Page:
    """
    Displays the page for commenting on code lines.

    Args:
        state (State): The current state of the application.
    Returns:
        Page: The page displaying the code lines for commenting.
    """
    content = [Header("Code Commenter")]
    for line in state.comments:
        if line.original:
            content.append(
                Div(
                    line.original,
                    Button("💬", "comment", Argument("index", line.index)),
                    classes="comment-line",
                )
            )
        else:
            content.append(Div(classes="comment-line", style_height="1.5em"))
        if line.comment:
            content.append(Div(small_font(line.comment), classes="comment-line"))

    content.append(Button("Reset", "index"))

    return Page(state, content)


 @route
 def comment(state: State, index: int) -> Page:
    """
    Displays the comment box for a specific line of code.

    Args:
        state (State): The current state of the application.
        index (int): The index of the line to comment on.
    Returns:
        Page: The page displaying the comment box for the specified line.
    """
    comment = state.comments[index]
    return Page(
        state,
        [
            Header("Add Comment"),
            PreformattedText(comment.original),
            TextArea("comment_box", comment.comment),
            Button(
                "Save Comment",
                "save_comment",
                arguments=Argument("index", index),
            ),
            Button("Back", "page_commenter"),
        ],
    )


 @route
 def save_comment(state: State, index: int, comment_box: str) -> Page:
    """
    Saves the comment for a specific line of code.

    Args:
        state (State): The current state of the application.
        index (int): The index of the line to save the comment for.
        comment_box (str): The content of the comment box.
    Returns:
        Page: The updated page displaying the code lines for commenting.
    """
    state.comments[index].comment = comment_box
    return page_commenter(state)


 start_server(State([], ""))
diff --git a/food_lookup.py b/food_lookup.py
 from dataclasses import dataclass
 from drafter import *

 # The path to the food data file.
 FOOD_DATA_FILE = "food_simple.tsv"


 @dataclass
 class State:
    """
    Represents the state of the food lookup application.

    Attributes:
        food_items (list[int]): A list of food item IDs that the user has selected.
    """

    food_items: list[int]


 @dataclass
 class Food:
    """
    Represents a food item with its details.

    Attributes:
        category (str): The category of the food item.
        name (str): The name of the food item.
        id (int): The unique identifier of the food item.
        protein (float): The protein content of the food item in grams.
    """

    category: str
    name: str
    id: int
    protein: float


 def parse_food(line: str) -> Food:
    """
    Parses a line from the food_simple.tsv file and returns a Food object.

    Args:
        line (str): A line from the food_simple.tsv file.
    Returns:
        Food: A Food object with the parsed details.
    """
    pieces = line.strip().split("\t")
    category = pieces[0]
    name = pieces[1]
    food_id = int(pieces[2])
    protein = float(pieces[3])
    return Food(category, name, food_id, protein)


 def load_foods() -> list[Food]:
    """
    Loads food items from the food_simple.tsv file.

    Returns:
        list[Food]: A list of Food objects loaded from the file.
    """
    food_items = []
    with open(FOOD_DATA_FILE) as file:
        for line in file:
            food_items.append(parse_food(line))
    return food_items


 # Load the food items once at the start of the program.
 FOODS = load_foods()


 def find_foods(foods: list[Food], query: str) -> list[Food]:
    """
    Finds food items that match the given query. Ignores capitalization.
    As long as the query is a substring of the food name, it is considered a match.

    Args:
        foods (list[Food]): A list of Food objects to search.
        query (str): The search query string.
    Returns:
        list[Food]: A list of Food objects that match the query.
    """
    results = []
    query_lower = query.lower()
    for food in foods:
        if query_lower in food.name.lower():
            results.append(food)
    return results


 def get_food(foods: list[Food], food_ids: list[int]) -> list[Food]:
    """
    Retrieves food items that match the given list of food IDs.

    Args:
        foods (list[Food]): A list of Food objects to search.
        food_ids (list[int]): A list of food IDs to look for.
    Returns:
        list[Food]: A list of Food objects that match the given food IDs.
    """
    selected_foods = []
    for food in foods:
        if food.id in food_ids:
            selected_foods.append(food)
    return selected_foods


 @route
 def index(state: State):
    """
    The main page of the food lookup application, where users can search for foods
    and see their protein content. Also lists the foods the user has selected, and
    shows the total protein content of those foods.

    Args:
        state (State): The current state of the application.
    Returns:
        Page: The main page of the application.
    """
    selected_foods = get_food(FOODS, state.food_items)
    total_protein_value = total_protein(selected_foods)
    return Page(
        state,
        [
            Header("Food Lookup"),
            "Find foods by name and see their protein content.",
            TextBox("query"),
            Button("Search", "search"),
            Table(selected_foods),
            "Total protein:",
            str(total_protein_value),
        ],
    )


 def total_protein(foods: list[Food]) -> float:
    """
    Calculates the total protein content of a list of food items.

    Args:
        foods (list[Food]): A list of Food objects.
    Returns:
        float: The total protein content of the food items.
    """
    total = 0.0
    for food in foods:
        total += food.protein
    return total


 def no_food_found_page(state: State) -> Page:
    """
    Displays a page indicating that no food items were found for the given search query.

    Args:
        state (State): The current state of the application.
    Returns:
        Page: A page indicating that no food items were found.
    """
    return Page(
        state,
        [
            Header("No results found"),
            "Try a different search term.",
            Button("Back", "index"),
        ],
    )


 def make_food_button(food: Food) -> PageContent:
    """
    Creates a button for a food item that can be added to the user's selected foods.
    Also shows the category and protein content of the food item.

    Args:
        food (Food): The food item to create a button for.
    Returns:
        Button: A button that, when clicked, will add the food item to the user's selected foods.
    """
    return Row(
        Button(food.name, "add_food", arguments=[Argument("food_id", food.id)]),
        food.category + " - " + str(food.protein) + "g protein",
    )


 @route
 def search(state: State, query: str):
    """
    Searches for food items that match the given query and displays the results.
    If no results are found, an error message is displayed.

    Args:
        state (State): The current state of the application.
        query (str): The search query string.
    Returns:
        Page: A page displaying the search results or an error message.
    """
    results = find_foods(FOODS, query)
    if not results:
        return no_food_found_page(state)
    buttons = []
    for food in results:
        buttons.append(make_food_button(food))
    return Page(
        state,
        [
            Header(f"Search results for '{query}'"),
            BulletedList(buttons),
            Button("Back", "index"),
        ],
    )


 @route
 def add_food(state: State, food_id: int):
    """
    Adds a food item to the user's selected foods.

    Args:
        state (State): The current state of the application.
        food_id (int): The ID of the food item to add.
    Returns:
        Page: The main page of the application with the updated selected foods.
    """
    if food_id not in state.food_items:
        state.food_items.append(food_id)

    return index(state)


 start_server(State([]))
diff --git a/food_simple.tsv b/food_simple.tsv
diff --git a/ghost_hunt.py b/ghost_hunt.py
 from drafter import *
 from dataclasses import dataclass
 from random import choice, shuffle, seed


 @dataclass
 class Tile:
    """
    Represents a tile on the game board.

    Attributes:
        text (str): The text displayed on the tile (e.g., ghost, treat, or empty).
        flipped (bool): Whether the tile has been flipped or not.
        x (int): The x-coordinate of the tile on the grid.
        y (int): The y-coordinate of the tile on the grid.
    """

    text: str
    flipped: bool
    x: int
    y: int


 @dataclass
 class State:
    """
    Represents the state of the game.

    Attributes:
        grid (list[list[Tile]]): The game board represented as a grid of tiles.
        seed (int): The seed value used for randomizing the game board.
        score (int): The current score of the player.
        size (int): The size of the game board (size x size).
        ghosts (int): The total number of ghosts hidden on the board.
    """

    grid: list[list[Tile]]
    seed: int
    score: int
    size: int
    ghosts: int


 GHOST = "👻"
 EMPTY = "⬜"
 TREAT = "🍬"


 def make_ghost_grid(seed_value: int, size: int, ghosts: int) -> list[list[Tile]]:
    """
    Generates a game board with ghosts and treats.

    Args:
        seed_value (int): The seed value for randomization.
        size (int): The size of the grid (size x size).
        ghosts (int): The number of ghosts to place on the board.
    Returns:
        list[list[Tile]]: The generated game board as a grid of tiles.
    """
    seed(seed_value)
    grid = make_empty_grid(size)
    positions = choose_ghost_spots(grid, ghosts)
    fill_in_board(grid, positions)
    return grid


 def make_empty_grid(size: int) -> list[list[Tile]]:
    """
    Creates an empty game board of the specified size.

    Args:
        size (int): The size of the grid (size x size).
    Returns:
        list[list[Tile]]: An empty grid of tiles.
    """
    grid = []
    for y in range(size):
        row = []
        for x in range(size):
            row.append(Tile(EMPTY, False, x, y))
        grid.append(row)
    return grid


 def choose_ghost_spots(grid: list[list[Tile]], ghosts: int) -> list[list[int]]:
    """
    Randomly selects positions on the grid to place ghosts.

    Args:
        grid (list[list[Tile]]): The game board grid.
        ghosts (int): The number of ghosts to place.
    Returns:
        list[list[int]]: A list of [x, y] positions for the ghosts.
            The inner list will always have length 2.
    """
    size = len(grid)
    ys = list(range(size))
    xs = list(range(size))
    shuffle(xs)
    shuffle(ys)
    positions = []
    for ghost in range(ghosts):
        positions.append([xs.pop(), ys.pop()])
    return positions


 def add_treat_if_empty(grid: list[list[Tile]], x: int, y: int):
    """
    Adds a treat to the specified position on the grid if it is empty.

    Args:
        grid (list[list[Tile]]): The game board grid.
        x (int): The x-coordinate of the position.
        y (int): The y-coordinate of the position.
    """
    if x < 0 or y < 0 or y >= len(grid) or x >= len(grid):
        return
    if grid[y][x].text == EMPTY:
        grid[y][x].text = TREAT


 def fill_in_board(grid: list[list[Tile]], positions: list[tuple[int, int]]):
    """
    Fills in the game board with ghosts and treats based on the specified ghost positions.

    Args:
        grid (list[list[Tile]]): The game board grid.
        positions (list[tuple[int, int]]): A list of [x, y]
            positions where ghosts should be placed.
    """
    for x, y in positions:
        grid[y][x].text = GHOST
        add_treat_if_empty(grid, x + 1, y)
        add_treat_if_empty(grid, x - 1, y)
        add_treat_if_empty(grid, x, y + 1)
        add_treat_if_empty(grid, x, y - 1)
        add_treat_if_empty(grid, x + 1, y + 1)
        add_treat_if_empty(grid, x - 1, y - 1)
        add_treat_if_empty(grid, x + 1, y - 1)
        add_treat_if_empty(grid, x - 1, y + 1)


 @route
 def index(state: State) -> Page:
    """
    The main page of the game, where players can start a new game.

    Args:
        state (State): The current state of the game.
    Returns:
        Page: The main game page.
    """
    return Page(
        state,
        [
            Header("Ghost Hunt"),
            "Find all the ghosts by flipping tiles!",
            Button("New Game", "new_game"),
        ],
    )


 @route
 def new_game(state: State) -> Page:
    """
    Starts a new game by initializing the game state.

    Args:
        state (State): The current state of the game.
    Returns:
        Page: The game page with the new game state.
    """
    state.grid = make_ghost_grid(state.seed, state.size, state.ghosts)
    state.score = 0
    return play_game(state)


 def make_tile_button(tile: Tile) -> Button:
    """
    Creates a button for a tile that can be flipped.

    Args:
        tile (Tile): The tile to create a button for.
    Returns:
        Button: A button that, when clicked, will flip the tile.
    """
    return Button(
        "",
        "flip_tile",
        arguments=[Argument("x", tile.x), Argument("y", tile.y)],
    )


 def draw_grid(grid: list[list[Tile]]) -> list[list[PageContent]]:
    """
    Draws the game board grid, showing flipped tiles and buttons for unflipped tiles.

    Args:
        grid (list[list[Tile]]): The game board grid.
    Returns:
        list[list[PageContent]]: A grid representation where flipped tiles show their text
            and unflipped tiles are represented as buttons.
    """
    display = []
    for row in grid:
        display_row = []
        for tile in row:
            if tile.flipped:
                display_row.append(tile.text)
            else:
                display_row.append(make_tile_button(tile))
        display.append(display_row)
    return display


 @route
 def play_game(state: State) -> Page:
    """
    Plays the game by displaying the current state of the grid.

    Args:
        state (State): The current state of the game.
    Returns:
        Page: The game page showing the current grid.
    """
    grid_display = draw_grid(state.grid)
    return Page(
        state,
        [
            "Press a button to look for ghosts.",
            "Candy means a ghost is nearby!",
            Table(grid_display),
        ],
    )


 @route
 def flip_tile(state: State, x: int, y: int) -> Page:
    """
    Flips a tile at the specified coordinates and updates the game state.

    Args:
        state (State): The current state of the game.
        x (int): The x-coordinate of the tile to flip.
        y (int): The y-coordinate of the tile to flip.
    Returns:
        Page: The updated game page after flipping the tile.
    """
    tile = state.grid[y][x]
    tile.flipped = True
    if tile.text == GHOST:
        state.score += 1
    if state.score == state.ghosts:
        return game_won(state)
    return play_game(state)


 @route
 def game_won(state: State) -> Page:
    """
    Displays the game won page when all ghosts have been found.

    Args:
        state (State): The current state of the game.
    Returns:
        Page: The game won page.
    """
    return Page(
        state,
        [
            Header("You found all the ghosts!"),
            GHOST * state.ghosts,
            "Congratulations!",
            Button("Play Again", "new_game"),
        ],
    )


 start_server(State([], 42, 0, 5, 3))
diff --git a/todo.py b/todo.py
 from drafter import *


 @dataclass
 class TodoItem:
    """
    An individual list item that should be done.

    Attributes:
        id (int): A unique identifier for the to-do item.
        name (str): The name of the to-do item.
        description (str): A detailed description of the to-do item.
        completed (bool): A boolean indicating whether the to-do item has been completed.
        difficulty (int): An integer rating (1-3) indicating the difficulty of the to-do item.
    """

    id: int
    name: str
    description: str
    completed: bool
    difficulty: int


 @dataclass
 class State:
    """
    The state of the to-do application, containing a list of to-do items.

    Attributes:
        count (int): The total number of to-do items that have ever been created. Used to assign unique IDs.
        todos (list[TodoItem]): A list of TodoItem objects representing the to-do items.
    """

    count: int
    todos: list[TodoItem]


 @route
 def index(state: State) -> Page:
    """
    Display the main to-do list page.

    Args:
        state (State): The current state of the to-do application.

    Returns:
        Page: The rendered to-do list page.
    """
    current_items = make_todo_list(state.todos)

    return Page(
        state,
        [
            Header("To-Do List"),
            "Add and manage your to-do items.",
            Button("Add New To-Do", "add_todo"),
            Div(current_items),
        ],
    )


 def make_todo_toggle(completed: bool, target_id: Argument) -> Button:
    """
    Creates a button to toggle the completion status of a to-do item.

    Args:
        completed (bool): The current completion status of the to-do item.
        target_id (Argument): The unique ID of the to-do item.
    Returns:
        Button: A button that displays a checked or unchecked box based on the completion status.
    """
    if completed:
        return Button("☑️", "toggle_complete", target_id)
    else:
        return Button("🔲", "toggle_complete", target_id)


 def make_todo_list(todos: list[TodoItem]) -> PageContent:
    """
    Generates a page content displaying a list of to-do items.

    Args:
        todos (list[TodoItem]): A list of TodoItem objects representing the to-do items.

    Returns:
        PageContent: A page content object containing either a message indicating no to-do items,
        or a table displaying each to-do item with its name, difficulty, description, and action buttons
        for toggling completion, removing, and editing the item.
    """
    if not todos:
        return Div("No to-do items yet.")

    items = []
    for todo in todos:
        difficulty = "⭐" * todo.difficulty
        target_id = Argument("target_id", todo.id)
        items.append(
            [
                make_todo_toggle(todo.completed, target_id),
                Div(
                    todo.name,
                    difficulty,
                    LineBreak(),
                    small_font(Text(todo.description)),
                ),
                Button("Remove", "remove_todo", target_id),
                Button("Edit", "edit_todo", target_id),
            ]
        )
    return Table(items)


 def lookup_todo_item(todos: list[TodoItem], target_id: int) -> TodoItem:
    """
    Looks up a to-do item by its unique ID.

    Args:
        todos (list[TodoItem]): A list of TodoItem objects representing the to-do items.
        target_id (int): The unique ID of the to-do item to look up.

    Returns:
        TodoItem: The to-do item with the specified ID.
    """
    for todo in todos:
        if todo.id == target_id:
            return todo
    return None


 @route
 def toggle_complete(state: State, target_id: int) -> Page:
    """
    Toggles the completion status of a to-do item.

    Args:
        state (State): The current state of the to-do application.
        target_id (int): The unique ID of the to-do item to toggle.

    Returns:
        Page: The updated to-do list page.
    """
    todo = lookup_todo_item(state.todos, target_id)
    if todo:
        todo.completed = not todo.completed
    return index(state)


 @route
 def remove_todo(state: State, target_id: int) -> Page:
    """
    Removes a to-do item from the list.

    Args:
        state (State): The current state of the to-do application.
        target_id (int): The unique ID of the to-do item to remove.

    Returns:
        Page: The updated to-do list page.
    """
    new_todos = []
    for todo in state.todos:
        if todo.id != target_id:
            new_todos.append(todo)
    state.todos = new_todos
    return index(state)


 DIFFICULTY_RATINGS = ["1", "2", "3"]


 @route
 def edit_todo(state: State, target_id: int) -> Page:
    """
    Displays the edit page for a specific to-do item.

    Args:
        state (State): The current state of the to-do application.
        target_id (int): The unique ID of the to-do item to edit.
    Returns:
        Page: The edit page for the specified to-do item.
    """
    editing = lookup_todo_item(state.todos, target_id)
    return Page(
        state,
        [
            Header("Edit:"),
            Row("Name:", TextBox("new_name", editing.name)),
            Row(
                "Difficulty:",
                SelectBox(
                    "new_difficulty", DIFFICULTY_RATINGS, str(editing.difficulty)
                ),
            ),
            Row("Description:", TextArea("new_description", editing.description)),
            Button("Save Changes", "save_changes", Argument("target_id", target_id)),
            Button("Cancel", "index"),
        ],
    )


 @route
 def save_changes(
    state: State,
    new_name: str,
    new_difficulty: int,
    new_description: str,
    target_id: int,
 ) -> Page:
    """Saves the changes made to a to-do item.

    Args:
        state (State): The current state of the to-do application.
        new_name (str): The new name for the to-do item.
        new_difficulty (int): The new difficulty level for the to-do item.
        new_description (str): The new description for the to-do item.
        target_id (int): The unique ID of the to-do item to update.

    Returns:
        Page: The updated to-do list page.
    """
    todo = lookup_todo_item(state.todos, target_id)
    if todo:
        todo.name = new_name
        todo.difficulty = new_difficulty
        todo.description = new_description

    return index(state)


 @route
 def add_todo(state: State) -> Page:
    """
    Displays the page to add a new to-do item.
    Args:
        state (State): The current state of the to-do application.
    Returns:
        Page: The page to add a new to-do item.
    """
    return Page(
        state,
        [
            Header("Create New Todo"),
            Row("Name:", TextBox("new_name", "")),
            Row(
                "Difficulty:",
                SelectBox("new_difficulty", DIFFICULTY_RATINGS, "1"),
            ),
            Row("Description:", TextArea("new_description", "")),
            Button("Save Changes", "save_new"),
            Button("Cancel", "index"),
        ],
    )


 @route
 def save_new(
    state: State, new_name: str, new_difficulty: int, new_description: str
 ) -> Page:
    """
    Saves a new to-do item to the list. This will increase the count of total
    to-do items ever created, and use that as the unique ID for the new item.

    Args:
        state (State): The current state of the to-do application.
        new_name (str): The name of the new to-do item.
        new_difficulty (int): The difficulty level of the new to-do item.
        new_description (str): The description of the new to-do item.
    Returns:
        Page: The updated to-do list page.
    """
    state.count += 1
    new_todo = TodoItem(
        state.count,
        new_name,
        new_description,
        False,
        new_difficulty,
    )
    state.todos.append(new_todo)
    return index(state)


 start_server(
    State(
        1, [TodoItem(0, "Write todo list", "Write a few items to get done.", False, 1)]
    )
 )
	from drafter import *
	from dataclasses import dataclass

	add_website_css(
	".comment-line",
	"display: flex; justify-content: space-between; align-items: center; border-bottom: 1px dashed #ccc;",
	)


	@dataclass
	class Line:
	"""
	A line of code with an optional comment.
	Attributes:
	original (str): The original line of code.
	comment (str): The comment associated with the line of code.
	index (int): The line number in the original text.
	"""

	original: str
	comment: str
	index: int


	@dataclass
	class State:
	"""
	The state of the code commenter application.

	Attributes:
	comments (list[Line]): A list of Line objects representing the code lines and their comments.
	original_text (str): The original text of the code being commented on.
	"""

	comments: list[Line]
	original_text: str


	def parse_lines(text: str) -> list[Line]:
	"""
	Parses the input text into a list of Line objects.

	Args:
	text (str): The input text to parse.
	Returns:
	list[Line]: A list of Line objects.
	"""
	lines = []
	for i, line in enumerate(text.split("\n")):
	lines.append(Line(line.rstrip(), "", i))
	return lines


	@route
	def index(state: State) -> Page:
	"""
	Display the main page of the code commenter application.

	Args:
	state (State): The current state of the application.
	Returns:
	Page: The rendered main page.
	"""
	return Page(
	state,
	[
	Header("Code Commenter"),
	"Upload a file or type some code to get started.",
	FileUpload("code_file"),
	TextArea("text_box", state.original_text),
	Button("Start", "start_commenting"),
	],
	)


	@route
	def error_page(message: str) -> Page:
	"""
	Display an error page with the given message.

	Args:
	message (str): The error message to display.
	Returns:
	Page: The rendered error page.
	"""
	return Page(
	None,
	[
	Header("Error"),
	f"Error: {message}",
	Button("Back", "index"),
	],
	)


	@route
	def start_commenting(state: State, code_file: str = "", text_box: str = "") -> Page:
	"""
	Starts the commenting process by parsing the input text or file.

	Args:
	state (State): The current state of the application.
	code_file (str): The content of the uploaded file (if any).
	text_box (str): The content of the text area (if any).
	Returns:
	Page: The page displaying the code lines for commenting.
	"""
	if code_file:
	text = code_file
	elif text_box:
	text = text_box
	else:
	return error_page("Please upload a file or enter some text.")

	lines = parse_lines(text)
	state.comments = lines
	state.original_text = text

	return page_commenter(state)


	@route
	def page_commenter(state: State) -> Page:
	"""
	Displays the page for commenting on code lines.

	Args:
	state (State): The current state of the application.
	Returns:
	Page: The page displaying the code lines for commenting.
	"""
	content = [Header("Code Commenter")]
	for line in state.comments:
	if line.original:
	content.append(
	Div(
	line.original,
	Button("💬", "comment", Argument("index", line.index)),
	classes="comment-line",
	)
	)
	else:
	content.append(Div(classes="comment-line", style_height="1.5em"))
	if line.comment:
	content.append(Div(small_font(line.comment), classes="comment-line"))

	content.append(Button("Reset", "index"))

	return Page(state, content)


	@route
	def comment(state: State, index: int) -> Page:
	"""
	Displays the comment box for a specific line of code.

	Args:
	state (State): The current state of the application.
	index (int): The index of the line to comment on.
	Returns:
	Page: The page displaying the comment box for the specified line.
	"""
	comment = state.comments[index]
	return Page(
	state,
	[
	Header("Add Comment"),
	PreformattedText(comment.original),
	TextArea("comment_box", comment.comment),
	Button(
	"Save Comment",
	"save_comment",
	arguments=Argument("index", index),
	),
	Button("Back", "page_commenter"),
	],
	)


	@route
	def save_comment(state: State, index: int, comment_box: str) -> Page:
	"""
	Saves the comment for a specific line of code.

	Args:
	state (State): The current state of the application.
	index (int): The index of the line to save the comment for.
	comment_box (str): The content of the comment box.
	Returns:
	Page: The updated page displaying the code lines for commenting.
	"""
	state.comments[index].comment = comment_box
	return page_commenter(state)


	start_server(State([], ""))
	from dataclasses import dataclass
	from drafter import *

	# The path to the food data file.
	FOOD_DATA_FILE = "food_simple.tsv"


	@dataclass
	class State:
	"""
	Represents the state of the food lookup application.

	Attributes:
	food_items (list[int]): A list of food item IDs that the user has selected.
	"""

	food_items: list[int]


	@dataclass
	class Food:
	"""
	Represents a food item with its details.

	Attributes:
	category (str): The category of the food item.
	name (str): The name of the food item.
	id (int): The unique identifier of the food item.
	protein (float): The protein content of the food item in grams.
	"""

	category: str
	name: str
	id: int
	protein: float


	def parse_food(line: str) -> Food:
	"""
	Parses a line from the food_simple.tsv file and returns a Food object.

	Args:
	line (str): A line from the food_simple.tsv file.
	Returns:
	Food: A Food object with the parsed details.
	"""
	pieces = line.strip().split("\t")
	category = pieces[0]
	name = pieces[1]
	food_id = int(pieces[2])
	protein = float(pieces[3])
	return Food(category, name, food_id, protein)


	def load_foods() -> list[Food]:
	"""
	Loads food items from the food_simple.tsv file.

	Returns:
	list[Food]: A list of Food objects loaded from the file.
	"""
	food_items = []
	with open(FOOD_DATA_FILE) as file:
	for line in file:
	food_items.append(parse_food(line))
	return food_items


	# Load the food items once at the start of the program.
	FOODS = load_foods()


	def find_foods(foods: list[Food], query: str) -> list[Food]:
	"""
	Finds food items that match the given query. Ignores capitalization.
	As long as the query is a substring of the food name, it is considered a match.

	Args:
	foods (list[Food]): A list of Food objects to search.
	query (str): The search query string.
	Returns:
	list[Food]: A list of Food objects that match the query.
	"""
	results = []
	query_lower = query.lower()
	for food in foods:
	if query_lower in food.name.lower():
	results.append(food)
	return results


	def get_food(foods: list[Food], food_ids: list[int]) -> list[Food]:
	"""
	Retrieves food items that match the given list of food IDs.

	Args:
	foods (list[Food]): A list of Food objects to search.
	food_ids (list[int]): A list of food IDs to look for.
	Returns:
	list[Food]: A list of Food objects that match the given food IDs.
	"""
	selected_foods = []
	for food in foods:
	if food.id in food_ids:
	selected_foods.append(food)
	return selected_foods


	@route
	def index(state: State):
	"""
	The main page of the food lookup application, where users can search for foods
	and see their protein content. Also lists the foods the user has selected, and
	shows the total protein content of those foods.

	Args:
	state (State): The current state of the application.
	Returns:
	Page: The main page of the application.
	"""
	selected_foods = get_food(FOODS, state.food_items)
	total_protein_value = total_protein(selected_foods)
	return Page(
	state,
	[
	Header("Food Lookup"),
	"Find foods by name and see their protein content.",
	TextBox("query"),
	Button("Search", "search"),
	Table(selected_foods),
	"Total protein:",
	str(total_protein_value),
	],
	)


	def total_protein(foods: list[Food]) -> float:
	"""
	Calculates the total protein content of a list of food items.

	Args:
	foods (list[Food]): A list of Food objects.
	Returns:
	float: The total protein content of the food items.
	"""
	total = 0.0
	for food in foods:
	total += food.protein
	return total


	def no_food_found_page(state: State) -> Page:
	"""
	Displays a page indicating that no food items were found for the given search query.

	Args:
	state (State): The current state of the application.
	Returns:
	Page: A page indicating that no food items were found.
	"""
	return Page(
	state,
	[
	Header("No results found"),
	"Try a different search term.",
	Button("Back", "index"),
	],
	)


	def make_food_button(food: Food) -> PageContent:
	"""
	Creates a button for a food item that can be added to the user's selected foods.
	Also shows the category and protein content of the food item.

	Args:
	food (Food): The food item to create a button for.
	Returns:
	Button: A button that, when clicked, will add the food item to the user's selected foods.
	"""
	return Row(
	Button(food.name, "add_food", arguments=[Argument("food_id", food.id)]),
	food.category + " - " + str(food.protein) + "g protein",
	)


	@route
	def search(state: State, query: str):
	"""
	Searches for food items that match the given query and displays the results.
	If no results are found, an error message is displayed.

	Args:
	state (State): The current state of the application.
	query (str): The search query string.
	Returns:
	Page: A page displaying the search results or an error message.
	"""
	results = find_foods(FOODS, query)
	if not results:
	return no_food_found_page(state)
	buttons = []
	for food in results:
	buttons.append(make_food_button(food))
	return Page(
	state,
	[
	Header(f"Search results for '{query}'"),
	BulletedList(buttons),
	Button("Back", "index"),
	],
	)


	@route
	def add_food(state: State, food_id: int):
	"""
	Adds a food item to the user's selected foods.

	Args:
	state (State): The current state of the application.
	food_id (int): The ID of the food item to add.
	Returns:
	Page: The main page of the application with the updated selected foods.
	"""
	if food_id not in state.food_items:
	state.food_items.append(food_id)

	return index(state)


	start_server(State([]))
	from drafter import *
	from dataclasses import dataclass
	from random import choice, shuffle, seed


	@dataclass
	class Tile:
	"""
	Represents a tile on the game board.

	Attributes:
	text (str): The text displayed on the tile (e.g., ghost, treat, or empty).
	flipped (bool): Whether the tile has been flipped or not.
	x (int): The x-coordinate of the tile on the grid.
	y (int): The y-coordinate of the tile on the grid.
	"""

	text: str
	flipped: bool
	x: int
	y: int


	@dataclass
	class State:
	"""
	Represents the state of the game.

	Attributes:
	grid (list[list[Tile]]): The game board represented as a grid of tiles.
	seed (int): The seed value used for randomizing the game board.
	score (int): The current score of the player.
	size (int): The size of the game board (size x size).
	ghosts (int): The total number of ghosts hidden on the board.
	"""

	grid: list[list[Tile]]
	seed: int
	score: int
	size: int
	ghosts: int


	GHOST = "👻"
	EMPTY = "⬜"
	TREAT = "🍬"


	def make_ghost_grid(seed_value: int, size: int, ghosts: int) -> list[list[Tile]]:
	"""
	Generates a game board with ghosts and treats.

	Args:
	seed_value (int): The seed value for randomization.
	size (int): The size of the grid (size x size).
	ghosts (int): The number of ghosts to place on the board.
	Returns:
	list[list[Tile]]: The generated game board as a grid of tiles.
	"""
	seed(seed_value)
	grid = make_empty_grid(size)
	positions = choose_ghost_spots(grid, ghosts)
	fill_in_board(grid, positions)
	return grid


	def make_empty_grid(size: int) -> list[list[Tile]]:
	"""
	Creates an empty game board of the specified size.

	Args:
	size (int): The size of the grid (size x size).
	Returns:
	list[list[Tile]]: An empty grid of tiles.
	"""
	grid = []
	for y in range(size):
	row = []
	for x in range(size):
	row.append(Tile(EMPTY, False, x, y))
	grid.append(row)
	return grid


	def choose_ghost_spots(grid: list[list[Tile]], ghosts: int) -> list[list[int]]:
	"""
	Randomly selects positions on the grid to place ghosts.

	Args:
	grid (list[list[Tile]]): The game board grid.
	ghosts (int): The number of ghosts to place.
	Returns:
	list[list[int]]: A list of [x, y] positions for the ghosts.
	The inner list will always have length 2.
	"""
	size = len(grid)
	ys = list(range(size))
	xs = list(range(size))
	shuffle(xs)
	shuffle(ys)
	positions = []
	for ghost in range(ghosts):
	positions.append([xs.pop(), ys.pop()])
	return positions


	def add_treat_if_empty(grid: list[list[Tile]], x: int, y: int):
	"""
	Adds a treat to the specified position on the grid if it is empty.

	Args:
	grid (list[list[Tile]]): The game board grid.
	x (int): The x-coordinate of the position.
	y (int): The y-coordinate of the position.
	"""
	if x < 0 or y < 0 or y >= len(grid) or x >= len(grid):
	return
	if grid[y][x].text == EMPTY:
	grid[y][x].text = TREAT


	def fill_in_board(grid: list[list[Tile]], positions: list[tuple[int, int]]):
	"""
	Fills in the game board with ghosts and treats based on the specified ghost positions.

	Args:
	grid (list[list[Tile]]): The game board grid.
	positions (list[tuple[int, int]]): A list of [x, y]
	positions where ghosts should be placed.
	"""
	for x, y in positions:
	grid[y][x].text = GHOST
	add_treat_if_empty(grid, x + 1, y)
	add_treat_if_empty(grid, x - 1, y)
	add_treat_if_empty(grid, x, y + 1)
	add_treat_if_empty(grid, x, y - 1)
	add_treat_if_empty(grid, x + 1, y + 1)
	add_treat_if_empty(grid, x - 1, y - 1)
	add_treat_if_empty(grid, x + 1, y - 1)
	add_treat_if_empty(grid, x - 1, y + 1)


	@route
	def index(state: State) -> Page:
	"""
	The main page of the game, where players can start a new game.

	Args:
	state (State): The current state of the game.
	Returns:
	Page: The main game page.
	"""
	return Page(
	state,
	[
	Header("Ghost Hunt"),
	"Find all the ghosts by flipping tiles!",
	Button("New Game", "new_game"),
	],
	)


	@route
	def new_game(state: State) -> Page:
	"""
	Starts a new game by initializing the game state.

	Args:
	state (State): The current state of the game.
	Returns:
	Page: The game page with the new game state.
	"""
	state.grid = make_ghost_grid(state.seed, state.size, state.ghosts)
	state.score = 0
	return play_game(state)


	def make_tile_button(tile: Tile) -> Button:
	"""
	Creates a button for a tile that can be flipped.

	Args:
	tile (Tile): The tile to create a button for.
	Returns:
	Button: A button that, when clicked, will flip the tile.
	"""
	return Button(
	"",
	"flip_tile",
	arguments=[Argument("x", tile.x), Argument("y", tile.y)],
	)


	def draw_grid(grid: list[list[Tile]]) -> list[list[PageContent]]:
	"""
	Draws the game board grid, showing flipped tiles and buttons for unflipped tiles.

	Args:
	grid (list[list[Tile]]): The game board grid.
	Returns:
	list[list[PageContent]]: A grid representation where flipped tiles show their text
	and unflipped tiles are represented as buttons.
	"""
	display = []
	for row in grid:
	display_row = []
	for tile in row:
	if tile.flipped:
	display_row.append(tile.text)
	else:
	display_row.append(make_tile_button(tile))
	display.append(display_row)
	return display


	@route
	def play_game(state: State) -> Page:
	"""
	Plays the game by displaying the current state of the grid.

	Args:
	state (State): The current state of the game.
	Returns:
	Page: The game page showing the current grid.
	"""
	grid_display = draw_grid(state.grid)
	return Page(
	state,
	[
	"Press a button to look for ghosts.",
	"Candy means a ghost is nearby!",
	Table(grid_display),
	],
	)


	@route
	def flip_tile(state: State, x: int, y: int) -> Page:
	"""
	Flips a tile at the specified coordinates and updates the game state.

	Args:
	state (State): The current state of the game.
	x (int): The x-coordinate of the tile to flip.
	y (int): The y-coordinate of the tile to flip.
	Returns:
	Page: The updated game page after flipping the tile.
	"""
	tile = state.grid[y][x]
	tile.flipped = True
	if tile.text == GHOST:
	state.score += 1
	if state.score == state.ghosts:
	return game_won(state)
	return play_game(state)


	@route
	def game_won(state: State) -> Page:
	"""
	Displays the game won page when all ghosts have been found.

	Args:
	state (State): The current state of the game.
	Returns:
	Page: The game won page.
	"""
	return Page(
	state,
	[
	Header("You found all the ghosts!"),
	GHOST * state.ghosts,
	"Congratulations!",
	Button("Play Again", "new_game"),
	],
	)


	start_server(State([], 42, 0, 5, 3))
	from drafter import *


	@dataclass
	class TodoItem:
	"""
	An individual list item that should be done.

	Attributes:
	id (int): A unique identifier for the to-do item.
	name (str): The name of the to-do item.
	description (str): A detailed description of the to-do item.
	completed (bool): A boolean indicating whether the to-do item has been completed.
	difficulty (int): An integer rating (1-3) indicating the difficulty of the to-do item.
	"""

	id: int
	name: str
	description: str
	completed: bool
	difficulty: int


	@dataclass
	class State:
	"""
	The state of the to-do application, containing a list of to-do items.

	Attributes:
	count (int): The total number of to-do items that have ever been created. Used to assign unique IDs.
	todos (list[TodoItem]): A list of TodoItem objects representing the to-do items.
	"""

	count: int
	todos: list[TodoItem]


	@route
	def index(state: State) -> Page:
	"""
	Display the main to-do list page.

	Args:
	state (State): The current state of the to-do application.

	Returns:
	Page: The rendered to-do list page.
	"""
	current_items = make_todo_list(state.todos)

	return Page(
	state,
	[
	Header("To-Do List"),
	"Add and manage your to-do items.",
	Button("Add New To-Do", "add_todo"),
	Div(current_items),
	],
	)


	def make_todo_toggle(completed: bool, target_id: Argument) -> Button:
	"""
	Creates a button to toggle the completion status of a to-do item.

	Args:
	completed (bool): The current completion status of the to-do item.
	target_id (Argument): The unique ID of the to-do item.
	Returns:
	Button: A button that displays a checked or unchecked box based on the completion status.
	"""
	if completed:
	return Button("☑️", "toggle_complete", target_id)
	else:
	return Button("🔲", "toggle_complete", target_id)


	def make_todo_list(todos: list[TodoItem]) -> PageContent:
	"""
	Generates a page content displaying a list of to-do items.

	Args:
	todos (list[TodoItem]): A list of TodoItem objects representing the to-do items.

	Returns:
	PageContent: A page content object containing either a message indicating no to-do items,
	or a table displaying each to-do item with its name, difficulty, description, and action buttons
	for toggling completion, removing, and editing the item.
	"""
	if not todos:
	return Div("No to-do items yet.")

	items = []
	for todo in todos:
	difficulty = "⭐" * todo.difficulty
	target_id = Argument("target_id", todo.id)
	items.append(
	[
	make_todo_toggle(todo.completed, target_id),
	Div(
	todo.name,
	difficulty,
	LineBreak(),
	small_font(Text(todo.description)),
	),
	Button("Remove", "remove_todo", target_id),
	Button("Edit", "edit_todo", target_id),
	]
	)
	return Table(items)


	def lookup_todo_item(todos: list[TodoItem], target_id: int) -> TodoItem:
	"""
	Looks up a to-do item by its unique ID.

	Args:
	todos (list[TodoItem]): A list of TodoItem objects representing the to-do items.
	target_id (int): The unique ID of the to-do item to look up.

	Returns:
	TodoItem: The to-do item with the specified ID.
	"""
	for todo in todos:
	if todo.id == target_id:
	return todo
	return None


	@route
	def toggle_complete(state: State, target_id: int) -> Page:
	"""
	Toggles the completion status of a to-do item.

	Args:
	state (State): The current state of the to-do application.
	target_id (int): The unique ID of the to-do item to toggle.

	Returns:
	Page: The updated to-do list page.
	"""
	todo = lookup_todo_item(state.todos, target_id)
	if todo:
	todo.completed = not todo.completed
	return index(state)


	@route
	def remove_todo(state: State, target_id: int) -> Page:
	"""
	Removes a to-do item from the list.

	Args:
	state (State): The current state of the to-do application.
	target_id (int): The unique ID of the to-do item to remove.

	Returns:
	Page: The updated to-do list page.
	"""
	new_todos = []
	for todo in state.todos:
	if todo.id != target_id:
	new_todos.append(todo)
	state.todos = new_todos
	return index(state)


	DIFFICULTY_RATINGS = ["1", "2", "3"]


	@route
	def edit_todo(state: State, target_id: int) -> Page:
	"""
	Displays the edit page for a specific to-do item.

	Args:
	state (State): The current state of the to-do application.
	target_id (int): The unique ID of the to-do item to edit.
	Returns:
	Page: The edit page for the specified to-do item.
	"""
	editing = lookup_todo_item(state.todos, target_id)
	return Page(
	state,
	[
	Header("Edit:"),
	Row("Name:", TextBox("new_name", editing.name)),
	Row(
	"Difficulty:",
	SelectBox(
	"new_difficulty", DIFFICULTY_RATINGS, str(editing.difficulty)
	),
	),
	Row("Description:", TextArea("new_description", editing.description)),
	Button("Save Changes", "save_changes", Argument("target_id", target_id)),
	Button("Cancel", "index"),
	],
	)


	@route
	def save_changes(
	state: State,
	new_name: str,
	new_difficulty: int,
	new_description: str,
	target_id: int,
	) -> Page:
	"""Saves the changes made to a to-do item.

	Args:
	state (State): The current state of the to-do application.
	new_name (str): The new name for the to-do item.
	new_difficulty (int): The new difficulty level for the to-do item.
	new_description (str): The new description for the to-do item.
	target_id (int): The unique ID of the to-do item to update.

	Returns:
	Page: The updated to-do list page.
	"""
	todo = lookup_todo_item(state.todos, target_id)
	if todo:
	todo.name = new_name
	todo.difficulty = new_difficulty
	todo.description = new_description

	return index(state)


	@route
	def add_todo(state: State) -> Page:
	"""
	Displays the page to add a new to-do item.
	Args:
	state (State): The current state of the to-do application.
	Returns:
	Page: The page to add a new to-do item.
	"""
	return Page(
	state,
	[
	Header("Create New Todo"),
	Row("Name:", TextBox("new_name", "")),
	Row(
	"Difficulty:",
	SelectBox("new_difficulty", DIFFICULTY_RATINGS, "1"),
	),
	Row("Description:", TextArea("new_description", "")),
	Button("Save Changes", "save_new"),
	Button("Cancel", "index"),
	],
	)


	@route
	def save_new(
	state: State, new_name: str, new_difficulty: int, new_description: str
	) -> Page:
	"""
	Saves a new to-do item to the list. This will increase the count of total
	to-do items ever created, and use that as the unique ID for the new item.

	Args:
	state (State): The current state of the to-do application.
	new_name (str): The name of the new to-do item.
	new_difficulty (int): The difficulty level of the new to-do item.
	new_description (str): The description of the new to-do item.
	Returns:
	Page: The updated to-do list page.
	"""
	state.count += 1
	new_todo = TodoItem(
	state.count,
	new_name,
	new_description,
	False,
	new_difficulty,
	)
	state.todos.append(new_todo)
	return index(state)


	start_server(
	State(
	1, [TodoItem(0, "Write todo list", "Write a few items to get done.", False, 1)]
	)
	)