User Interfaces in Python

# Abhängigkeiten in diesem Notebook:
!uv venv
!uv sync --quiet
!uv pip install --quiet textual pyside6 pygame-ce fastapi streamlit altair polars httpx

!uv run coffee_tracker.py

%%writefile coffee_cli.py
import argparse
import sys
from datetime import datetime
from coffee_tracker import CaffeineTracker

def main() -> None:
    parser = argparse.ArgumentParser(description="Koffein-Tracker Kommandozeile")
    subparsers = parser.add_subparsers(dest="command", help="Verfügbare Befehle")
    
    # Subcommand: add
    parser_add = subparsers.add_parser("add", help="Fügt eine Koffeineinnahme hinzu")
    parser_add.add_argument("--name", type=str, required=True, help="Name des Getränks")
    parser_add.add_argument("--amount", type=float, required=True, help="Koffeinmenge in mg")
    parser_add.add_argument("--time", type=str, default=None, help="ISO-Zeitstempel (Standard: Jetzt)")
    
    # Subcommand: level
    parser_level = subparsers.add_parser("level", help="Berechnet den aktuellen Spiegel")
    parser_level.add_argument("--at", type=str, default=None, help="ISO-Zeitstempel (Standard: Jetzt)")

    args = parser.parse_args()
    
    # Zustand initialisieren (In einer echten Anwendung: Laden aus Datei/DB)
    tracker = CaffeineTracker()

    if args.command == "add":
        try:
            dt = datetime.fromisoformat(args.time) if args.time else datetime.now()
            tracker.add_entry(dt, args.name, args.amount)
            print(f"✅ {args.amount}mg '{args.name}' für {dt.strftime('%H:%M')} Uhr registriert.")
        except ValueError:
            print("❌ Fehler: Das Datum muss im ISO-Format vorliegen (z.B. 2026-05-22T08:00:00).", file=sys.stderr)
            sys.exit(1)
            
    elif args.command == "level":
        try:
            target_time = datetime.fromisoformat(args.at) if args.at else datetime.now()
            level = tracker.calculate_level_at(target_time)
            print(f"☕ Berechneter Koffeinspiegel: {level:.2f} mg")
        except ValueError:
            print("❌ Fehler: Ungültiges Datumsformat.", file=sys.stderr)
            sys.exit(1)
    else:
        parser.print_help()

if __name__ == "__main__":
    main()

# Erfolgreicher Aufruf
!uv run python coffee_cli.py add --name "Espresso" --amount 60

# Fehlerhafter Aufruf provozieren (Abgefangene Exception)
!uv run python coffee_cli.py level --at "heute abend"

%%writefile textual_ui.py
from datetime import datetime
from textual.app import App, ComposeResult
from textual.widgets import Header, Footer, Button, DataTable, Input

class CaffeineTuiApp(App[None]):
    """
    Eine asynchrone, ereignisgesteuerte TUI-Applikation.
    Zeigt die Entkopplung: UI-Komponenten rufen die logischen Methoden auf.
    """
    CSS = """
    Screen {
        layout: vertical;
        padding: 1;
    }
    DataTable {
        height: 60%;
        border: solid green;
    }
    Input {
        margin: 1 0;
    }
    """

    BINDINGS = [("q", "quit", "Beenden")]

    def compose(self) -> ComposeResult:
        yield Header(show_clock=True)
        yield DataTable()
        yield Input(placeholder="Getränkename eingeben...", id="input_name")
        yield Input(placeholder="Koffeinmenge (mg)...", id="input_amount")
        yield Button("Eintrag hinzufügen", variant="success", id="btn_add")
        yield Footer()

    def on_mount(self) -> None:
        table = self.query_one(DataTable)
        table.add_columns("Zeit", "Getränk", "Menge (mg)")
        # Hier würden im echten Betrieb bestehende Werte aus `tracker.get_entries()` geladen

    def on_button_pressed(self, event: Button.Pressed) -> None:
        if event.button.id == "btn_add":
            name = self.query_one("#input_name", Input).value
            amount = self.query_one("#input_amount", Input).value
            
            # Validierung & Delegation an Business-Logik
            print(f"[TUI EVENT] -> UI-Eingabe abgefangen: {name}, {amount}mg")
            # tracker.add_entry(datetime.now(), name, float(amount))
            
            # UI-Refreshes laufen asynchron im Event-Loop
            table = self.query_one(DataTable)
            table.add_row(datetime.now().strftime("%H:%M:%S"), name, f"{amount} mg")

if __name__ == "__main__":
    CaffeineTuiApp().run()

%%writefile coffee_gui.py
import sys
from datetime import datetime
#from PyQt6.QtWidgets import (QApplication, QWidget, QVBoxLayout, QHBoxLayout, 
#                             QLineEdit, QPushButton, QLabel, QMessageBox)
from PySide6.QtWidgets import (QApplication, QWidget, QVBoxLayout, QHBoxLayout,
                             QLineEdit, QPushButton, QLabel, QMessageBox)
from coffee_tracker import CaffeineTracker

class CaffeineWindow(QWidget):
    def __init__(self) -> None:
        super().__init__()
        self.tracker = CaffeineTracker()
        self.init_ui()

    def init_ui(self) -> None:
        self.setWindowTitle('Koffein-Tracker GUI')
        self.setGeometry(100, 100, 350, 150)

        # Layout-Manager instanziieren
        main_layout = QVBoxLayout()
        input_layout = QHBoxLayout()

        # UI-Widgets erstellen
        self.input_amount = QLineEdit()
        self.input_amount.setPlaceholderText("Menge in mg (z.B. 80)")
        
        self.btn_add = QPushButton("Eintragen / Berechnen")
        self.lbl_result = QLabel("Aktueller Spiegel: 0.00 mg")

        # Layout kompilieren
        input_layout.addWidget(self.input_amount)
        input_layout.addWidget(self.btn_add)
        
        main_layout.addLayout(input_layout)
        main_layout.addWidget(self.lbl_result)
        self.setLayout(main_layout)

        # Signal & Slot Registrierung
        self.btn_add.clicked.connect(self.handle_add_click)

    def handle_add_click(self) -> None:
        """Slot-Methode: Wird asynchron durch den Event-Loop bei Klick aufgerufen."""
        amount_str = self.input_amount.text()
        try:
            amount = float(amount_str)
            now = datetime.now()
            
            # Delegation an die Business-Logik
            self.tracker.add_entry(now, "GUI-Eintrag", amount)
            level = self.tracker.calculate_level_at(now)
            
            # UI aktualisieren
            self.lbl_result.setText(f"Aktueller Spiegel: {level:.2f} mg")
            self.input_amount.clear()
        except ValueError:
            QMessageBox.warning(self, "Eingabefehler", "Bitte eine numerische Menge eingeben.")

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = CaffeineWindow()
    window.show()
    sys.exit(app.exec())

%%writefile coffee_pygame.py
import os

# Pygame anweisen, kein echtes Fenster zu öffnen, um Headless-Execution im Notebook zu erlauben
os.environ.setdefault("SDL_VIDEODRIVER", "dummy")
print("Video driver:", os.environ.get("SDL_VIDEODRIVER"))

DEFAULT_MAX_TICKS = 5
STR_MAX_TICKS = os.environ.get("COFFEE_MAX_TICKS", DEFAULT_MAX_TICKS)
try:
    MAX_TICKS = int(STR_MAX_TICKS)
except ValueError:
    MAX_TICKS = DEFAULT_MAX_TICKS

import pygame
import sys

def simulate_game_loop() -> None:
    pygame.init()
    screen = pygame.display.set_mode((400, 300))
    clock = pygame.time.Clock()
    
    # Zustand der physikalischen Simulation (Koffeinspiegel in mg)
    caffeine_level = 120.0
    half_life_seconds = 5.0  # Beschleunigte Simulation für das Spiel
    
    running = True
    ticks = 0
    
    print(f"Starte deterministischen Game-Loop (Simulation läuft für {MAX_TICKS} Frames)...")

    step = max(1, MAX_TICKS // 10) # Output nicht zu oft, das ist die Hilfsvariable
    
    while running and ticks < MAX_TICKS:
        # 1. INPUT EVENT PROCESSING
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
                
        # 2. STATE UPDATE (Physikalischer exponentieller Zerfall pro Tick)
        dt = clock.tick(60) / 1000.0  # vergangene Zeit in Sekunden
        decay_factor = 0.5 ** (dt / half_life_seconds)
        caffeine_level *= decay_factor
        
        # 3. RENDERING (Zeichnen der Schichten)
        screen.fill((30, 30, 30))  # Hintergrund
        
        # Berechne Balkenbreite proportional zum Zustand
        bar_width = int(min(caffeine_level, 400))
        pygame.draw.rect(screen, (240, 140, 40), (10, 100, bar_width, 40))

        # 4. Buffer austauschen (damit man auch etwas sieht)
        pygame.display.flip()
        
        if(ticks % step == 0):
            print(f"  Frame {ticks:4d} - Berechneter Koffein-Pegel: {caffeine_level:8.4f} mg -> Render-Breite: {bar_width:4d}px")
        ticks += 1
        
    pygame.quit()

simulate_game_loop()

!uv run python coffee_pygame.py

%%writefile fastapi_ui.py
from fastapi import FastAPI
from pydantic import BaseModel, Field
from datetime import datetime

app = FastAPI(title="Caffeine Tracker API", version="1.0.0")

# Pydantic-Modell definiert die erwartete Struktur inklusive Validierung zur Laufzeit
class CaffeineWebRequest(BaseModel):
    drink_name: str = Field(..., min_length=1, max_length=50, examples=["Filterkaffee"])
    amount_mg: float = Field(..., gt=0, description="Koffeinmenge muss strikt positiv sein.")
    timestamp: datetime = Field(default_factory=datetime.now)

@app.post("/entries", status_code=201)
async def create_entry(request: CaffeineWebRequest):
    """
    Asynchroner Endpunkt zur Registrierung einer Einnahme.
    Pydantic stellt sicher: Wenn dieser Code betreten wird, sind alle Typen valide!
    """
    # Hier fände die Delegation an das Backend statt:
    # tracker.add_entry(request.timestamp, request.drink_name, request.amount_mg)
    return {
        "status": "success",
        "saved": {
            "drink": request.drink_name,
            "mg": request.amount_mg,
            "recorded_at": request.timestamp.isoformat()
        }
    }

print("FastAPI-Routing und Pydantic-Validierungsmodelle erfolgreich initialisiert und Tschüss.")

!uv run fastapi_ui.py

%%writefile test_api.py
from fastapi import FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel
from datetime import datetime

# 1. API-Definition (würde in der Praxis aus main.py importiert)
app = FastAPI()

class CaffeineRequest(BaseModel):
    name: str
    amount: float
    time: datetime

@app.post("/entries")
def add_entry(req: CaffeineRequest):
    # Dummy-Rückgabe (hier würde tracker.add_entry gekoppelt)
    return {"status": "ok", "recorded_mg": req.amount}

# 2. Test-Konfiguration
client = TestClient(app)

def test_valid_post_request() -> None:
    """Testet den korrekten Durchstich (Status 200)."""
    response = client.post(
        "/entries",
        json={"name": "Filterkaffee", "amount": 150.0, "time": datetime.now().isoformat()}
    )
    assert response.status_code == 200
    assert response.json()["recorded_mg"] == 150.0
    print("✅ Validierungs-Test: Akzeptierte Eingabe erfolgreich geprüft.")

def test_pydantic_type_rejection() -> None:
    """Prüft, ob Pydantic ungültige Typen vor Erreichen der Logik blockiert."""
    response = client.post(
        "/entries",
        json={"name": "Mate", "amount": "viel zu viel", "time": "gestern"}
    )
    # FastAPI/Pydantic wirft automatisch 422 (Unprocessable Entity)
    assert response.status_code == 422
    print("✅ Rejection-Test: Fehlerhafte Datentypen mit HTTP 422 abgeblockt.")

if __name__ == "__main__":
    test_valid_post_request()
    test_pydantic_type_rejection()

!uv run python test_api.py

#Cleanup:
!rm -f textual_ui.py coffee_cli.py coffee_gui.py coffee_pygame.py fastapi_ui.py test_api.py