claudient 0.1.0

package/skills/backend/python/nl/fastapi.md

@@ -0,0 +1,244 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../fastapi.md).
+
+# FastAPI Skill
+
+## Wanneer te activeren
+- Een Python REST- of async API bouwen met FastAPI
+- Pydantic aanvraag/respons-modellen definiëren
+- Dependency injection instellen met `Depends`
+- Async route-handlers schrijven met SQLAlchemy of async DB-drivers
+- Middleware toevoegen (CORS, auth, logging, rate limiting)
+- Achtergrondtaken of Celery-workers configureren
+- OpenAPI-documentatie aanpassen (tags, beschrijvingen, respons-schema's)
+- Integratietests schrijven met `TestClient` of `AsyncClient`
+- Een multi-module FastAPI-project structureren
+
+## Wanneer NIET te gebruiken
+- Django/DRF-projecten — gebruik de Django skill
+- Alleen-synchrone codebases waarbij async overhead niet gerechtvaardigd is
+- Eenvoudige scripts die geen HTTP nodig hebben — gebruik gewone Python
+- gRPC of GraphQL API's — ander transport en schemalag
+
+## Instructies
+
+### Projectstructuur
+```
+app/
+├── main.py              # FastAPI app factory
+├── core/
+│   ├── config.py        # Instellingen via pydantic-settings
+│   └── security.py      # JWT, hashing-hulpprogramma's
+├── api/
+│   ├── deps.py          # Gedeelde Depends()-functies
+│   └── v1/
+│       ├── router.py    # APIRouter-aggregator
+│       └── endpoints/
+│           ├── users.py
+│           └── items.py
+├── models/              # SQLAlchemy ORM-modellen
+├── schemas/             # Pydantic aanvraag/respons-schema's
+├── crud/                # DB-operatiefuncties (niet ORM, niet HTTP)
+└── db/
+    ├── session.py       # AsyncSession-fabriek
+    └── base.py          # Declaratieve basisimport
+```
+
+### App factory
+```python
+# main.py
+from fastapi import FastAPI
+from app.api.v1.router import api_router
+from app.core.config import settings
+
+def create_app() -> FastAPI:
+    app = FastAPI(
+        title=settings.PROJECT_NAME,
+        openapi_url=f"{settings.API_V1_STR}/openapi.json",
+        docs_url="/docs" if settings.ENVIRONMENT != "production" else None,
+    )
+    app.include_router(api_router, prefix=settings.API_V1_STR)
+    return app
+
+app = create_app()
+```
+
+### Instellingen met pydantic-settings
+```python
+# core/config.py
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    PROJECT_NAME: str = "MyAPI"
+    API_V1_STR: str = "/api/v1"
+    DATABASE_URL: str
+    SECRET_KEY: str
+    ENVIRONMENT: str = "development"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+settings = Settings()
+```
+
+### Async SQLAlchemy-sessieafhankelijkheid
+```python
+# db/session.py
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker
+
+engine = create_async_engine(settings.DATABASE_URL, echo=False)
+AsyncSessionLocal = async_sessionmaker(engine, expire_on_commit=False)
+
+# api/deps.py
+async def get_db() -> AsyncIterator[AsyncSession]:
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+```
+
+### Route-handlers
+```python
+# api/v1/endpoints/users.py
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.api.deps import get_db, get_current_user
+from app.crud import user as crud_user
+from app.schemas.user import UserCreate, UserResponse
+
+router = APIRouter(prefix="/users", tags=["users"])
+
+@router.post("/", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
+async def create_user(
+    payload: UserCreate,
+    db: AsyncSession = Depends(get_db),
+) -> UserResponse:
+    if await crud_user.get_by_email(db, email=payload.email):
+        raise HTTPException(status_code=400, detail="Email already registered")
+    return await crud_user.create(db, obj_in=payload)
+```
+
+### Dependency injection voor auth
+```python
+# api/deps.py
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import JWTError, jwt
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/v1/auth/token")
+
+async def get_current_user(
+    token: str = Depends(oauth2_scheme),
+    db: AsyncSession = Depends(get_db),
+) -> User:
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            raise credentials_exception
+    except JWTError:
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+    user = await crud_user.get(db, id=user_id)
+    if user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+```
+
+### Achtergrondtaken
+```python
+# Gebruik FastAPI's BackgroundTasks voor lichtgewicht fire-and-forget (geen resultaat nodig)
+@router.post("/send-email")
+async def send_email_endpoint(
+    payload: EmailPayload,
+    background_tasks: BackgroundTasks,
+):
+    background_tasks.add_task(send_email, payload.to, payload.subject, payload.body)
+    return {"status": "queued"}
+
+# Gebruik Celery voor: herhaalpogingen, resultaattracking, planning, cross-service taken
+```
+
+### CORS-middleware
+```python
+from fastapi.middleware.cors import CORSMiddleware
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.ALLOWED_ORIGINS,  # Nooit ["*"] in productie
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+```
+
+### Aangepaste uitzonderingshandlers
+```python
+from fastapi.responses import JSONResponse
+
+@app.exception_handler(ValueError)
+async def value_error_handler(request: Request, exc: ValueError) -> JSONResponse:
+    return JSONResponse(status_code=422, content={"detail": str(exc)})
+```
+
+### Testen
+```python
+# tests/conftest.py
+import pytest
+from httpx import AsyncClient, ASGITransport
+from app.main import app
+
+@pytest.fixture
+async def client() -> AsyncIterator[AsyncClient]:
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as ac:
+        yield ac
+
+# tests/test_users.py
+@pytest.mark.asyncio
+async def test_create_user(client: AsyncClient, db_session):
+    resp = await client.post("/api/v1/users/", json={"email": "a@b.com", "password": "secret"})
+    assert resp.status_code == 201
+    assert resp.json()["email"] == "a@b.com"
+```
+
+### Veelvoorkomende Pydantic-patronen
+```python
+from pydantic import BaseModel, EmailStr, field_validator, model_validator
+
+class UserCreate(BaseModel):
+    email: EmailStr
+    password: str
+
+    @field_validator("password")
+    @classmethod
+    def password_strength(cls, v: str) -> str:
+        if len(v) < 8:
+            raise ValueError("Password must be at least 8 characters")
+        return v
+
+class UserResponse(BaseModel):
+    id: int
+    email: EmailStr
+
+    model_config = {"from_attributes": True}  # vervangt orm_mode = True
+```
+
+## Voorbeeld
+
+**Gebruiker:** Bouw een FastAPI-endpoint om een blogbericht aan te maken, geauthenticeerd met JWT, opgeslagen in PostgreSQL met SQLAlchemy async.
+
+**Verwachte structuur:**
+- `schemas/post.py` — `PostCreate(BaseModel)`, `PostResponse(BaseModel)` met `from_attributes=True`
+- `models/post.py` — `Post` ORM-model met `id`, `title`, `body`, `author_id` (FK naar User), `created_at`
+- `crud/post.py` — `create(db, *, obj_in, author_id)` async-functie
+- `api/v1/endpoints/posts.py` — `POST /posts/` met `Depends(get_current_user)` en `Depends(get_db)`
+- `api/v1/router.py` — posts-router opnemen
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. [uitbreiden.com](https://uitbreiden.com/)

package/skills/data-ml/dbt-data-pipelines.md

@@ -0,0 +1,155 @@
+# dbt Data Pipelines Skill
+
+## When to activate
+- Writing dbt models (staging, intermediate, mart layers)
+- Configuring dbt sources, refs, and dependencies
+- Writing dbt tests (schema tests, singular tests, custom generic tests)
+- Setting up dbt project structure for a new data warehouse
+- Writing dbt macros for reusable SQL logic
+- Configuring dbt documentation and freshness checks
+- Debugging dbt compilation errors or failed model runs
+- Setting up dbt with BigQuery, Snowflake, Redshift, or DuckDB
+
+## When NOT to use
+- Raw ETL pipelines without a warehouse (use Airflow, Prefect, or Dagster instead)
+- Real-time streaming data (dbt is batch-only)
+- Pandas/Polars in-memory transformations (use the pandas-polars skill)
+- Data ingestion (dbt transforms, it doesn't ingest)
+
+## Instructions
+
+### Project layer architecture
+Always separate models into three layers:
+```
+models/
+├── staging/          ← 1:1 with source tables. Light cleaning only. No joins.
+│   ├── stg_orders.sql
+│   └── stg_customers.sql
+├── intermediate/     ← Business logic. Joins allowed. Not exposed to BI tools.
+│   └── int_orders_with_customers.sql
+└── marts/            ← Final business entities. Exposed to BI. Aggregations live here.
+    ├── finance/
+    │   └── fct_revenue.sql
+    └── marketing/
+        └── dim_customers.sql
+```
+
+**Staging rules:**
+- Rename columns to project conventions (snake_case)
+- Cast types explicitly
+- No business logic — no joins, no aggregations
+- Prefix with `stg_`
+
+**Mart rules:**
+- `fct_` prefix for fact tables (events, transactions)
+- `dim_` prefix for dimension tables (customers, products)
+- Always document in schema.yml
+
+### Model configuration
+```sql
+-- models/marts/finance/fct_revenue.sql
+{{
+  config(
+    materialized='incremental',
+    unique_key='order_id',
+    on_schema_change='fail'
+  )
+}}
+
+with orders as (
+    select * from {{ ref('int_orders_with_customers') }}
+    {% if is_incremental() %}
+    where created_at > (select max(created_at) from {{ this }})
+    {% endif %}
+)
+
+select
+    order_id,
+    customer_id,
+    amount,
+    created_at
+from orders
+```
+
+**Materialization choices:**
+- `view`: default — good for staging and intermediate models
+- `table`: for expensive queries queried frequently
+- `incremental`: for large fact tables that grow over time
+- `ephemeral`: CTEs, not materialized — use for simple transformations called once
+
+### Testing — required on every mart model
+```yaml
+# models/marts/finance/schema.yml
+version: 2
+
+models:
+  - name: fct_revenue
+    description: "One row per completed order"
+    columns:
+      - name: order_id
+        description: "Primary key"
+        tests:
+          - unique
+          - not_null
+      - name: customer_id
+        tests:
+          - not_null
+          - relationships:
+              to: ref('dim_customers')
+              field: customer_id
+      - name: amount
+        tests:
+          - not_null
+          - dbt_utils.accepted_range:
+              min_value: 0
+```
+
+Minimum tests on every mart model: `unique` + `not_null` on primary key, `not_null` on critical foreign keys.
+
+### Sources configuration
+```yaml
+# models/staging/sources.yml
+version: 2
+
+sources:
+  - name: raw_stripe
+    database: raw
+    schema: stripe
+    freshness:
+      warn_after: {count: 12, period: hour}
+      error_after: {count: 24, period: hour}
+    loaded_at_field: _ingested_at
+    tables:
+      - name: charges
+        description: "Raw Stripe charges from Fivetran"
+```
+
+Always set `freshness` on sources — stale source data is a silent failure.
+
+### Macros for reusable logic
+```sql
+-- macros/cents_to_dollars.sql
+{% macro cents_to_dollars(column_name) %}
+    ({{ column_name }} / 100.0)::numeric(10, 2)
+{% endmacro %}
+
+-- Usage in model
+select
+    {{ cents_to_dollars('amount_cents') }} as amount_dollars
+from orders
+```
+
+## Example
+
+**User:** Create staging and mart models for Stripe payments data (charges, refunds) with tests and freshness checks.
+
+**Expected output:**
+- `models/staging/stripe/sources.yml` — source with freshness check on `_ingested_at`
+- `models/staging/stripe/stg_stripe_charges.sql` — rename, cast, no joins
+- `models/staging/stripe/stg_stripe_refunds.sql` — same pattern
+- `models/marts/finance/fct_payments.sql` — join charges + refunds, net amount, incremental materialization
+- `models/marts/finance/schema.yml` — `unique` + `not_null` on `charge_id`, relationship test on `customer_id`
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. Building data pipelines for AI or analytics products? [uitbreiden.com](https://uitbreiden.com/)

package/skills/data-ml/de/dbt-data-pipelines.md

@@ -0,0 +1,157 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../dbt-data-pipelines.md).
+
+# dbt Data Pipelines Skill
+
+## Wann aktivieren
+- dbt-Modelle schreiben (Staging-, Intermediate-, Mart-Layer)
+- dbt Sources, Refs und Abhängigkeiten konfigurieren
+- dbt-Tests schreiben (Schema-Tests, singuläre Tests, benutzerdefinierte generische Tests)
+- dbt-Projektstruktur für ein neues Data Warehouse einrichten
+- dbt-Makros für wiederverwendbare SQL-Logik schreiben
+- dbt-Dokumentation und Frische-Prüfungen konfigurieren
+- dbt-Kompilierungsfehler oder fehlgeschlagene Modell-Ausführungen debuggen
+- dbt mit BigQuery, Snowflake, Redshift oder DuckDB einrichten
+
+## Wann NICHT verwenden
+- Rohe ETL-Pipelines ohne Warehouse (stattdessen Airflow, Prefect oder Dagster verwenden)
+- Echtzeit-Streaming-Daten (dbt ist nur für Batch-Verarbeitung)
+- Pandas/Polars-In-Memory-Transformationen (Pandas-Polars Skill verwenden)
+- Datenaufnahme (dbt transformiert, nimmt keine Daten auf)
+
+## Anweisungen
+
+### Projektschicht-Architektur
+Modelle immer in drei Layer aufteilen:
+```
+models/
+├── staging/          ← 1:1 mit Quelltabellen. Nur leichte Bereinigung. Keine Joins.
+│   ├── stg_orders.sql
+│   └── stg_customers.sql
+├── intermediate/     ← Geschäftslogik. Joins erlaubt. Nicht BI-Tools ausgesetzt.
+│   └── int_orders_with_customers.sql
+└── marts/            ← Finale Business-Entitäten. BI ausgesetzt. Aggregationen hier.
+    ├── finance/
+    │   └── fct_revenue.sql
+    └── marketing/
+        └── dim_customers.sql
+```
+
+**Staging-Regeln:**
+- Spalten nach Projektkonventionen umbenennen (snake_case)
+- Typen explizit casten
+- Keine Geschäftslogik — keine Joins, keine Aggregationen
+- Präfix `stg_`
+
+**Mart-Regeln:**
+- `fct_`-Präfix für Faktentabellen (Ereignisse, Transaktionen)
+- `dim_`-Präfix für Dimensionstabellen (Kunden, Produkte)
+- Immer in schema.yml dokumentieren
+
+### Modellkonfiguration
+```sql
+-- models/marts/finance/fct_revenue.sql
+{{
+  config(
+    materialized='incremental',
+    unique_key='order_id',
+    on_schema_change='fail'
+  )
+}}
+
+with orders as (
+    select * from {{ ref('int_orders_with_customers') }}
+    {% if is_incremental() %}
+    where created_at > (select max(created_at) from {{ this }})
+    {% endif %}
+)
+
+select
+    order_id,
+    customer_id,
+    amount,
+    created_at
+from orders
+```
+
+**Materialisierungsauswahl:**
+- `view`: Standard — gut für Staging- und Intermediate-Modelle
+- `table`: für teure Abfragen, die häufig abgefragt werden
+- `incremental`: für große Faktentabellen, die im Laufe der Zeit wachsen
+- `ephemeral`: CTEs, nicht materialisiert — für einfache Transformationen verwenden, die einmal aufgerufen werden
+
+### Tests — erforderlich für jedes Mart-Modell
+```yaml
+# models/marts/finance/schema.yml
+version: 2
+
+models:
+  - name: fct_revenue
+    description: "Eine Zeile pro abgeschlossener Bestellung"
+    columns:
+      - name: order_id
+        description: "Primärschlüssel"
+        tests:
+          - unique
+          - not_null
+      - name: customer_id
+        tests:
+          - not_null
+          - relationships:
+              to: ref('dim_customers')
+              field: customer_id
+      - name: amount
+        tests:
+          - not_null
+          - dbt_utils.accepted_range:
+              min_value: 0
+```
+
+Minimale Tests bei jedem Mart-Modell: `unique` + `not_null` auf dem Primärschlüssel, `not_null` auf kritischen Fremdschlüsseln.
+
+### Sources-Konfiguration
+```yaml
+# models/staging/sources.yml
+version: 2
+
+sources:
+  - name: raw_stripe
+    database: raw
+    schema: stripe
+    freshness:
+      warn_after: {count: 12, period: hour}
+      error_after: {count: 24, period: hour}
+    loaded_at_field: _ingested_at
+    tables:
+      - name: charges
+        description: "Rohe Stripe-Charges von Fivetran"
+```
+
+Immer `freshness` auf Sources setzen — veraltete Quelldaten sind ein stiller Fehler.
+
+### Makros für wiederverwendbare Logik
+```sql
+-- macros/cents_to_dollars.sql
+{% macro cents_to_dollars(column_name) %}
+    ({{ column_name }} / 100.0)::numeric(10, 2)
+{% endmacro %}
+
+-- Verwendung im Modell
+select
+    {{ cents_to_dollars('amount_cents') }} as amount_dollars
+from orders
+```
+
+## Beispiel
+
+**Benutzer:** Staging- und Mart-Modelle für Stripe-Zahlungsdaten (Charges, Refunds) mit Tests und Frische-Prüfungen erstellen.
+
+**Erwartete Ausgabe:**
+- `models/staging/stripe/sources.yml` — Source mit Frische-Prüfung auf `_ingested_at`
+- `models/staging/stripe/stg_stripe_charges.sql` — umbenennen, casten, keine Joins
+- `models/staging/stripe/stg_stripe_refunds.sql` — gleiches Muster
+- `models/marts/finance/fct_payments.sql` — Charges + Refunds zusammenführen, Nettobetrag, inkrementelle Materialisierung
+- `models/marts/finance/schema.yml` — `unique` + `not_null` auf `charge_id`, Beziehungstest auf `customer_id`
+
+---
+
+> **Mit uns arbeiten:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir bauen KI-Produkte und B2B-Lösungen mit Entwickler-Communities. Datenpipelines für KI- oder Analytics-Produkte aufbauen? [uitbreiden.com](https://uitbreiden.com/)

package/skills/data-ml/de/pandas-polars.md

@@ -0,0 +1,147 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../pandas-polars.md).
+
+# Pandas / Polars Skill
+
+## Wann aktivieren
+- Tabellarische Daten in Python bereinigen, transformieren oder aggregieren
+- DataFrames zusammenführen, verknüpfen oder umstrukturieren
+- Datenvalidierung oder Qualitätsprüfungen schreiben
+- Zwischen Formaten konvertieren (CSV, Parquet, JSON, Excel)
+- Ein neues Dataset profilieren oder erkunden
+- Langsamen Pandas-Code für große Datensätze optimieren
+- Pandas-Code nach Polars migrieren, um die Performance zu verbessern
+
+## Wann NICHT verwenden
+- SQL in einer Datenbank (Transformationen in die Datenbank auslagern, wenn die Daten bereits dort sind)
+- Spark/verteiltes Computing (PySpark Skill für Datensätze > verfügbarer RAM verwenden)
+- dbt-Modelle (SQL-basierte Transformationen in einem Warehouse)
+- NumPy-Array-Operationen auf nicht-tabellarischen Daten
+
+## Anweisungen
+
+### Pandas — Performance-Regeln
+```python
+import pandas as pd
+import numpy as np
+
+# Niemals iterrows() verwenden — stattdessen vektorisieren
+# Schlecht:
+for idx, row in df.iterrows():
+    df.at[idx, 'tax'] = row['price'] * 0.2
+
+# Gut:
+df['tax'] = df['price'] * 0.2
+
+# .loc für labelbasierte Zugriffe, .iloc für positionsbasierte
+# Niemals ohne Zuweisung verketten — verursacht SettingWithCopyWarning
+df.loc[df['status'] == 'active', 'flag'] = True
+
+# Kategorischer Datentyp für Zeichenkettenspalten mit geringer Kardinalität (große Speichereinsparung)
+df['country'] = df['country'].astype('category')
+
+# Numerische Typen für weniger Speicherverbrauch herunterstufen
+df['quantity'] = pd.to_numeric(df['quantity'], downcast='integer')
+df['price'] = pd.to_numeric(df['price'], downcast='float')
+```
+
+### Pandas — Aggregation und Groupby
+```python
+# Groupby mit mehreren Aggregationen
+summary = (
+    df.groupby(['region', 'category'])
+    .agg(
+        total_revenue=('revenue', 'sum'),
+        order_count=('order_id', 'nunique'),
+        avg_order_value=('revenue', 'mean'),
+    )
+    .reset_index()
+    .sort_values('total_revenue', ascending=False)
+)
+```
+
+### Pandas — Zusammenführen
+```python
+# how= immer explizit angeben — niemals auf den Standard (inner) verlassen
+result = pd.merge(
+    orders,
+    customers,
+    on='customer_id',
+    how='left',      # explizit
+    validate='m:1',  # validiert Kardinalität — wirft Fehler bei Verletzung
+    suffixes=('_order', '_customer')
+)
+```
+
+### Polars — wann statt Pandas verwenden
+Polars verwenden, wenn:
+- Datensatz > 1M Zeilen (Polars ist für viele Operationen 5–100x schneller)
+- Lazy Evaluation benötigt wird (Abfrageoptimierung vor der Ausführung)
+- Parallelismus wichtig ist (Polars verwendet standardmäßig alle CPU-Kerne)
+
+```python
+import polars as pl
+
+# Lazy API — Abfragen werden vor der Ausführung optimiert
+result = (
+    pl.scan_parquet("orders.parquet")   # Lazy Scan — noch keine Daten geladen
+    .filter(pl.col("status") == "completed")
+    .group_by(["region", "category"])
+    .agg([
+        pl.col("revenue").sum().alias("total_revenue"),
+        pl.col("order_id").n_unique().alias("order_count"),
+        pl.col("revenue").mean().alias("avg_order_value"),
+    ])
+    .sort("total_revenue", descending=True)
+    .collect()   # Jetzt ausführen
+)
+```
+
+### Polars — Ausdrücke (keine verkettete Indizierung)
+```python
+# Polars: kein SettingWithCopyWarning, keine verkettete Indizierung
+df = df.with_columns([
+    (pl.col("price") * 0.2).alias("tax"),
+    pl.col("name").str.to_uppercase().alias("name_upper"),
+    pl.when(pl.col("quantity") > 10)
+      .then(pl.lit("bulk"))
+      .otherwise(pl.lit("standard"))
+      .alias("order_type"),
+])
+```
+
+### Datenvalidierungsmuster
+```python
+def validate_orders(df: pd.DataFrame) -> None:
+    assert df['order_id'].notna().all(), "order_id has nulls"
+    assert df['order_id'].is_unique, "order_id has duplicates"
+    assert (df['amount'] >= 0).all(), "amount has negative values"
+    assert df['status'].isin(['pending', 'completed', 'cancelled']).all(), "invalid status values"
+    assert pd.to_datetime(df['created_at'], errors='coerce').notna().all(), "created_at has invalid dates"
+```
+
+### Formatkonvertierung
+```python
+# Lesen
+df = pd.read_parquet("data.parquet", columns=['id', 'name', 'amount'])  # Spaltenauswahl beim Lesen
+df = pd.read_csv("data.csv", dtype={'id': str}, parse_dates=['created_at'])
+
+# Schreiben — immer Parquet gegenüber CSV für große Datensätze bevorzugen
+df.to_parquet("output.parquet", index=False, compression='snappy')
+```
+
+## Beispiel
+
+**Benutzer:** Eine rohe Bestellungs-CSV bereinigen: Datentypen korrigieren, Duplikate entfernen, Nullwerte behandeln, abgeleitete Spalten hinzufügen (revenue_after_tax, order_size_bucket) und eine validierte Parquet-Datei ausgeben.
+
+**Erwartete Ausgabe:**
+- Lesen mit explizitem `dtype=` und `parse_dates=`
+- Doppelte `order_id`-Zeilen löschen (letzte behalten)
+- Nullwerte füllen: `quantity` → 0, `discount` → 0.0, Zeilen löschen, bei denen `customer_id` null ist
+- Ableiten: `revenue_after_tax = price * quantity * (1 - discount) * 0.8`
+- Einteilung: `order_size_bucket` = 'small'/<100, 'medium'/100–1000, 'large'/>1000
+- Mit Assertions vor dem Schreiben validieren
+- In Parquet mit Snappy-Komprimierung schreiben
+
+---
+
+> **Mit uns arbeiten:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir bauen KI-Produkte und B2B-Lösungen mit Entwickler-Communities. Datenpipelines oder KI-Datenprodukte aufbauen? [uitbreiden.com](https://uitbreiden.com/)