Anhang 4: Web APIs, Pydantic, Dash und Python Decorators

@app.get("/profiles/{profile_id}")
def get_profile(profile_id: int):  # FastAPI validiert, dass profile_id ein int ist
    ...

# api/main.py
from fastapi import FastAPI

app = FastAPI()

# In-Memory-Speicher für jetzt (Sie ersetzen das später mit Datenbank)
profiles = [
    {"id": 1, "name": "default", "x_coordinates": [0, 10, 20], "y_coordinates": [0, 5, 2]}
]

@app.get("/profiles")
def list_profiles():
    """Gibt alle Straßenprofile zurück."""
    return profiles

@app.get("/profiles/{profile_id}")
def get_profile(profile_id: int):
    """Gibt ein bestimmtes Straßenprofil nach ID zurück."""
    for profile in profiles:
        if profile["id"] == profile_id:
            return profile
    return {"error": "Profil nicht gefunden"}

@app.post("/profiles")
def create_profile(profile: dict):
    """Erstellt ein neues Straßenprofil."""
    profile["id"] = len(profiles) + 1
    profiles.append(profile)
    return profile

# In Ihrer Dash-App
import requests

# Alle Profile für das Dropdown abrufen
response = requests.get("http://localhost:8000/profiles")
profiles = response.json()  # [{"id": 1, "name": "default", ...}, ...]

# Neues Profil aus hochgeladenem JSON erstellen
new_profile = {
    "name": "mountain_road",
    "x_coordinates": [0, 10, 20],
    "y_coordinates": [0, 5, 8]
}
response = requests.post("http://localhost:8000/profiles", json=new_profile)
created = response.json()

from pydantic import BaseModel

class RoadProfile(BaseModel):
    name: str
    x_coordinates: list[float]
    y_coordinates: list[float]

# Das funktioniert
profile = RoadProfile(
    name="mountain",
    x_coordinates=[0.0, 10.0, 20.0],
    y_coordinates=[0.0, 5.0, 8.0]
)

# Das schlägt mit klarer Fehlermeldung fehl
profile = RoadProfile(
    name=123,  # Sollte String sein!
    x_coordinates=[0.0, 10.0],
    y_coordinates=[0.0, 5.0]
)
# ValidationError: name - Input should be a valid string

from pydantic import BaseModel, Field
from typing import List

class RoadProfile(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    x_coordinates: List[float] = Field(..., min_length=2)
    y_coordinates: List[float] = Field(..., min_length=2)

# Leerer Name - schlägt fehl!
RoadProfile(name="", x_coordinates=[0, 10], y_coordinates=[0, 5])
# ValidationError: name - String should have at least 1 character

# Nur ein Punkt - schlägt fehl!
RoadProfile(name="road", x_coordinates=[0], y_coordinates=[0])
# ValidationError: x_coordinates - List should have at least 2 items

from pydantic import BaseModel, Field, model_validator
from typing import List

class RoadProfile(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    x_coordinates: List[float] = Field(..., min_length=2)
    y_coordinates: List[float] = Field(..., min_length=2)

    @model_validator(mode='after')
    def check_coordinate_lengths(self):
        if len(self.x_coordinates) != len(self.y_coordinates):
            raise ValueError(
                f"x_coordinates ({len(self.x_coordinates)} Punkte) und "
                f"y_coordinates ({len(self.y_coordinates)} Punkte) müssen die gleiche Länge haben"
            )
        return self

RoadProfile(
    name="bad_road",
    x_coordinates=[0, 10, 20],
    y_coordinates=[0, 5]  # Nur 2 Punkte!
)
# ValidationError: x_coordinates (3 Punkte) und y_coordinates (2 Punkte) müssen die gleiche Länge haben

from fastapi import FastAPI
from pydantic import BaseModel, Field, model_validator
from typing import List

app = FastAPI()

class RoadProfileCreate(BaseModel):
    """Schema zum Erstellen eines neuen Straßenprofils."""
    name: str = Field(..., min_length=1, max_length=100)
    x_coordinates: List[float] = Field(..., min_length=2)
    y_coordinates: List[float] = Field(..., min_length=2)

    @model_validator(mode='after')
    def check_coordinate_lengths(self):
        if len(self.x_coordinates) != len(self.y_coordinates):
            raise ValueError("x- und y-Koordinaten müssen die gleiche Länge haben")
        return self

class RoadProfileResponse(BaseModel):
    """Schema für Straßenprofil-Antworten (enthält ID)."""
    id: int
    name: str
    x_coordinates: List[float]
    y_coordinates: List[float]

@app.post("/profiles", response_model=RoadProfileResponse)
def create_profile(profile: RoadProfileCreate):
    # FastAPI validiert 'profile' automatisch mit Pydantic!
    # Bei Validierungsfehler gibt FastAPI einen 422-Fehler mit Details zurück

    # Ihre Datenbanklogik hier...
    new_id = save_to_database(profile)

    return RoadProfileResponse(
        id=new_id,
        name=profile.name,
        x_coordinates=profile.x_coordinates,
        y_coordinates=profile.y_coordinates
    )

from typing import Optional

class RoadProfile(BaseModel):
    name: str
    description: Optional[str] = None  # Optional, Standardwert None
    created_at: str = Field(default_factory=lambda: datetime.now().isoformat())

class Coordinates(BaseModel):
    x: List[float]
    y: List[float]

class RoadProfile(BaseModel):
    name: str
    coordinates: Coordinates  # Verschachteltes Model

class RoadProfile(BaseModel):
    name: str
    x_coords: List[float] = Field(..., alias="x_coordinates")

    class Config:
        populate_by_name = True  # Akzeptiert sowohl 'x_coords' als auch 'x_coordinates'

profile = RoadProfile(name="test", x_coordinates=[0, 10], y_coordinates=[0, 5])

# In Dictionary konvertieren
profile.model_dump()
# {'name': 'test', 'x_coordinates': [0.0, 10.0], 'y_coordinates': [0.0, 5.0]}

# In JSON-String konvertieren
profile.model_dump_json()
# '{"name":"test","x_coordinates":[0.0,10.0],"y_coordinates":[0.0,5.0]}'

from dash import Dash, html, dcc

app = Dash(__name__)

app.layout = html.Div([
    html.H1("Road Profile Viewer"),           # <h1>Road Profile Viewer</h1>

    dcc.Dropdown(                              # <select>...</select>
        id="profile-dropdown",
        options=[
            {"label": "Default", "value": 1},
            {"label": "Mountain", "value": 2}
        ],
        value=1
    ),

    dcc.Graph(id="profile-graph")              # <div> mit Plotly-Chart
])

import plotly.graph_objects as go
from dash import Dash, dcc, html, callback, Output, Input

app = Dash(__name__)

app.layout = html.Div([
    dcc.Dropdown(
        id="profile-dropdown",
        options=[{"label": "Default", "value": 1}],
        value=1
    ),
    dcc.Graph(id="profile-graph")
])

@callback(
    Output("profile-graph", "figure"),
    Input("profile-dropdown", "value")
)
def update_graph(profile_id):
    # Profildaten abrufen (von API in Ihrem Projekt)
    x = [0, 10, 20, 30]
    y = [0, 5, 8, 3]

    # Plotly-Figur erstellen
    fig = go.Figure()
    fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name='Straßenprofil'))
    fig.update_layout(title="Straßenprofil", xaxis_title="Entfernung", yaxis_title="Höhe")

    return fig

if __name__ == "__main__":
    app.run(debug=True)

# pages/home.py
from dash import html, dcc, register_page

register_page(__name__, path="/")

layout = html.Div([
    html.H1("Road Profile Viewer"),
    dcc.Dropdown(id="profile-dropdown"),
    dcc.Graph(id="profile-graph"),
    dcc.Link("Zum Upload", href="/upload")
])

# pages/upload.py
from dash import html, dcc, register_page

register_page(__name__, path="/upload")

layout = html.Div([
    html.H1("Straßenprofil hochladen"),
    dcc.Upload(
        id="upload-data",
        children=html.Div(["Drag and Drop oder ", html.A("Dateien auswählen")]),
    ),
    html.Div(id="preview-container"),
    html.Button("Profil speichern", id="save-button"),
    dcc.Link("Zurück zum Viewer", href="/")
])

# app.py
from dash import Dash, page_container

app = Dash(__name__, use_pages=True)
app.layout = page_container

if __name__ == "__main__":
    app.run(debug=True)

@callback(
    Output("profile-graph", "figure"),
    Input("profile-dropdown", "value")
)
def update_graph(selected_profile):
    ...

@app.get("/profiles")
def list_profiles():
    return profiles

@callback(Output("graph", "figure"), Input("dropdown", "value"))
def update_graph(value):
    ...

def greet(name):
    return f"Hallo, {name}!"

say_hello = greet  # Keine Klammern = Referenz auf Funktion, nicht Aufruf
print(say_hello("Alice"))  # "Hallo, Alice!"

def apply_twice(func, value):
    return func(func(value))

def add_one(x):
    return x + 1

result = apply_twice(add_one, 5)  # add_one(add_one(5)) = 7

def create_multiplier(factor):
    def multiply(x):
        return x * factor
    return multiply  # Innere Funktion zurückgeben

double = create_multiplier(2)
triple = create_multiplier(3)

print(double(5))  # 10
print(triple(5))  # 15

def greet(name):
    print(f"greet wurde aufgerufen mit: {name}")  # Manuelles Logging
    return f"Hallo, {name}!"

def farewell(name):
    print(f"farewell wurde aufgerufen mit: {name}")  # Duplikat!
    return f"Auf Wiedersehen, {name}!"

def log_calls(func):
    def wrapper(*args, **kwargs):
        print(f"{func.__name__} wurde aufgerufen mit args={args}, kwargs={kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} gab zurück: {result}")
        return result
    return wrapper

def greet(name):
    return f"Hallo, {name}!"

greet = log_calls(greet)  # greet durch umhüllte Version ersetzen

greet("Alice")
# Ausgabe:
# greet wurde aufgerufen mit args=('Alice',), kwargs={}
# greet gab zurück: Hallo, Alice!

@log_calls
def greet(name):
    return f"Hallo, {name}!"

# Das ist EXAKT äquivalent zu:
# def greet(name):
#     return f"Hallo, {name}!"
# greet = log_calls(greet)

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hallo!")

say_hello()
# Ausgabe:
# Hallo!
# Hallo!
# Hallo!

from fastapi import FastAPI

app = FastAPI()

@app.get("/profiles")
def list_profiles():
    return [{"id": 1, "name": "default"}]

class SimpleFastAPI:
    def __init__(self):
        self.routes = {}

    def get(self, path):
        def decorator(func):
            self.routes[("GET", path)] = func
            return func
        return decorator

    def post(self, path):
        def decorator(func):
            self.routes[("POST", path)] = func
            return func
        return decorator

app = SimpleFastAPI()

@app.get("/profiles")
def list_profiles():
    return [{"id": 1}]

@app.post("/profiles")
def create_profile(data):
    return {"id": 2, **data}

# Jetzt enthält app.routes:
# {
#   ("GET", "/profiles"): list_profiles,
#   ("POST", "/profiles"): create_profile
# }

@callback(
    Output("graph", "figure"),
    Input("dropdown", "value")
)
def update_graph(value):
    ...

class SimpleDash:
    def __init__(self):
        self.callbacks = []

    def callback(self, output, *inputs):
        def decorator(func):
            self.callbacks.append({
                "function": func,
                "output": output,
                "inputs": inputs
            })
            return func
        return decorator

app = SimpleDash()

@app.callback(Output("graph", "figure"), Input("dropdown", "value"))
def update_graph(value):
    return create_figure(value)

# Jetzt enthält app.callbacks Informationen darüber, wann update_graph aufgerufen wird

class RoadProfile:
    def __init__(self, x_coords, y_coords):
        self._x = x_coords
        self._y = y_coords

    @property
    def num_points(self):
        return len(self._x)

profile = RoadProfile([0, 10, 20], [0, 5, 8])
print(profile.num_points)  # 3 (keine Klammern nötig!)

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

MathUtils.add(2, 3)  # 5 (keine Instanz nötig)

class RoadProfile:
    def __init__(self, name, x, y):
        self.name = name
        self.x = x
        self.y = y

    @classmethod
    def from_json(cls, json_data):
        return cls(
            json_data["name"],
            json_data["x_coordinates"],
            json_data["y_coordinates"]
        )

data = {"name": "test", "x_coordinates": [0, 10], "y_coordinates": [0, 5]}
profile = RoadProfile.from_json(data)

import time
from functools import wraps

def log_endpoint(func):
    @wraps(func)  # Bewahrt Funktionsname und Docstring
    def wrapper(*args, **kwargs):
        start = time.time()
        print(f"→ {func.__name__} aufgerufen")

        try:
            result = func(*args, **kwargs)
            elapsed = time.time() - start
            print(f"← {func.__name__} zurückgegeben in {elapsed:.3f}s")
            return result
        except Exception as e:
            print(f"✗ {func.__name__} warf {type(e).__name__}: {e}")
            raise

    return wrapper

# Verwendung in FastAPI
@app.get("/profiles")
@log_endpoint
def list_profiles():
    return profiles

# Bei Aufruf:
# → list_profiles aufgerufen
# ← list_profiles zurückgegeben in 0.001s

@app.get("/profiles")  # Wird zweites angewendet
@log_endpoint          # Wird erstes angewendet
def list_profiles():
    ...

# Äquivalent zu:
# list_profiles = app.get("/profiles")(log_endpoint(list_profiles))

# Dash-Callback wird durch Datei-Upload ausgelöst
@callback(Output("preview-graph", "figure"), Input("upload-data", "contents"))
def preview_upload(contents):
    if contents is None:
        return {}

    # Base64-Inhalt vom Upload dekodieren
    content_string = contents.split(",")[1]
    decoded = base64.b64decode(content_string)
    data = json.loads(decoded)

    # Vorschau-Graph anzeigen
    return create_figure(data["x_coordinates"], data["y_coordinates"])

@callback(Output("save-message", "children"), Input("save-button", "n_clicks"), State("upload-data", "contents"))
def save_profile(n_clicks, contents):
    if n_clicks is None:
        return ""

    # Hochgeladene Daten parsen
    data = parse_upload(contents)

    # An FastAPI senden
    response = requests.post(f"{API_URL}/profiles", json=data)

    if response.status_code == 200:
        return "Profil erfolgreich gespeichert!"
    else:
        return f"Fehler: {response.json()['detail']}"

@app.post("/profiles", response_model=RoadProfileResponse)
def create_profile(profile: RoadProfileCreate):
    # Pydantic hat bereits validiert:
    # - Name ist 1-100 Zeichen
    # - x und y haben mindestens 2 Punkte
    # - x und y haben gleiche Länge

    # In Datenbank speichern
    db_profile = db.create_profile(profile)
    return db_profile

@callback(Output("profile-dropdown", "options"), Input("save-button", "n_clicks"))
def refresh_dropdown(_):
    # Aktualisierte Liste von API abrufen
    response = requests.get(f"{API_URL}/profiles")
    profiles = response.json()

    return [{"label": p["name"], "value": p["id"]} for p in profiles]

from pydantic import BaseModel, Field, field_validator, model_validator

class Example(BaseModel):
    # Grundlegende Einschränkungen
    name: str = Field(..., min_length=1, max_length=100)
    count: int = Field(..., ge=0, le=1000)  # >= 0, <= 1000
    items: List[str] = Field(..., min_length=1)

    # Feld-Level-Validierung
    @field_validator('name')
    @classmethod
    def name_must_not_contain_spaces(cls, v):
        if ' ' in v:
            raise ValueError('darf keine Leerzeichen enthalten')
        return v

    # Model-Level-Validierung (nach allen Feldern)
    @model_validator(mode='after')
    def check_something(self):
        # Zugriff auf self.name, self.count, etc.
        return self

# Einfacher Decorator (keine Argumente)
def my_decorator(func):
    def wrapper(*args, **kwargs):
        # Vorher
        result = func(*args, **kwargs)
        # Nachher
        return result
    return wrapper

@my_decorator
def my_function():
    pass

# Decorator mit Argumenten
def my_decorator(arg1, arg2):
    def decorator(func):
        def wrapper(*args, **kwargs):
            # arg1, arg2 hier verwenden
            return func(*args, **kwargs)
        return wrapper
    return decorator

@my_decorator("value1", "value2")
def my_function():
    pass