claudient 0.1.0

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

@@ -0,0 +1,157 @@
+> 🇫🇷 This is the French translation. [English version](../dbt-data-pipelines.md).
+
+# Compétence dbt Data Pipelines
+
+## Quand activer
+- Rédiger des modèles dbt (couches staging, intermediate, mart)
+- Configurer les sources, refs et dépendances dbt
+- Rédiger des tests dbt (tests de schéma, tests singuliers, tests génériques personnalisés)
+- Configurer la structure d'un projet dbt pour un nouvel entrepôt de données
+- Rédiger des macros dbt pour de la logique SQL réutilisable
+- Configurer la documentation et les contrôles de fraîcheur dbt
+- Déboguer des erreurs de compilation dbt ou des runs de modèles en échec
+- Configurer dbt avec BigQuery, Snowflake, Redshift, ou DuckDB
+
+## Quand NE PAS utiliser
+- Pipelines ETL bruts sans entrepôt (utiliser Airflow, Prefect, ou Dagster à la place)
+- Données en streaming temps réel (dbt est uniquement batch)
+- Transformations en mémoire Pandas/Polars (utiliser la compétence pandas-polars)
+- Ingestion de données (dbt transforme, il n'ingère pas)
+
+## Instructions
+
+### Architecture en couches du projet
+Toujours séparer les modèles en trois couches :
+```
+models/
+├── staging/          ← 1:1 avec les tables sources. Nettoyage léger seulement. Pas de jointures.
+│   ├── stg_orders.sql
+│   └── stg_customers.sql
+├── intermediate/     ← Logique métier. Jointures autorisées. Pas exposé aux outils BI.
+│   └── int_orders_with_customers.sql
+└── marts/            ← Entités métier finales. Exposées au BI. Les agrégations sont ici.
+    ├── finance/
+    │   └── fct_revenue.sql
+    └── marketing/
+        └── dim_customers.sql
+```
+
+**Règles pour le staging :**
+- Renommer les colonnes selon les conventions du projet (snake_case)
+- Caster les types explicitement
+- Pas de logique métier — pas de jointures, pas d'agrégations
+- Préfixer avec `stg_`
+
+**Règles pour les marts :**
+- Préfixe `fct_` pour les tables de faits (événements, transactions)
+- Préfixe `dim_` pour les tables de dimensions (clients, produits)
+- Toujours documenter dans schema.yml
+
+### Configuration des modèles
+```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
+```
+
+**Choix de matérialisation :**
+- `view` : par défaut — bon pour les modèles staging et intermediate
+- `table` : pour les requêtes coûteuses interrogées fréquemment
+- `incremental` : pour les grandes tables de faits qui croissent au fil du temps
+- `ephemeral` : CTEs, pas matérialisés — à utiliser pour les transformations simples appelées une seule fois
+
+### Tests — requis sur chaque modèle mart
+```yaml
+# models/marts/finance/schema.yml
+version: 2
+
+models:
+  - name: fct_revenue
+    description: "Une ligne par commande complétée"
+    columns:
+      - name: order_id
+        description: "Clé primaire"
+        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
+```
+
+Tests minimum sur chaque modèle mart : `unique` + `not_null` sur la clé primaire, `not_null` sur les clés étrangères critiques.
+
+### Configuration des sources
+```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: "Charges Stripe brutes depuis Fivetran"
+```
+
+Toujours définir `freshness` sur les sources — les données sources périmées sont un échec silencieux.
+
+### Macros pour la logique réutilisable
+```sql
+-- macros/cents_to_dollars.sql
+{% macro cents_to_dollars(column_name) %}
+    ({{ column_name }} / 100.0)::numeric(10, 2)
+{% endmacro %}
+
+-- Utilisation dans un modèle
+select
+    {{ cents_to_dollars('amount_cents') }} as amount_dollars
+from orders
+```
+
+## Exemple
+
+**Utilisateur :** Créer des modèles staging et mart pour les données de paiements Stripe (charges, remboursements) avec tests et contrôles de fraîcheur.
+
+**Sortie attendue :**
+- `models/staging/stripe/sources.yml` — source avec contrôle de fraîcheur sur `_ingested_at`
+- `models/staging/stripe/stg_stripe_charges.sql` — renommer, caster, pas de jointures
+- `models/staging/stripe/stg_stripe_refunds.sql` — même pattern
+- `models/marts/finance/fct_payments.sql` — joindre charges + remboursements, montant net, matérialisation incrémentale
+- `models/marts/finance/schema.yml` — `unique` + `not_null` sur `charge_id`, test de relation sur `customer_id`
+
+---
+
+> **Travaillez avec nous :** Claudient est soutenu par [Uitbreiden](https://uitbreiden.com/) — nous construisons des produits IA et des solutions B2B avec des communautés de développeurs. Vous construisez des pipelines de données pour des produits IA ou analytiques ? [uitbreiden.com](https://uitbreiden.com/)

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

@@ -0,0 +1,147 @@
+> 🇫🇷 This is the French translation. [English version](../pandas-polars.md).
+
+# Compétence Pandas / Polars
+
+## Quand activer
+- Nettoyer, transformer ou agréger des données tabulaires en Python
+- Fusionner, joindre ou remodeler des DataFrames
+- Rédiger des validations ou des contrôles de qualité de données
+- Convertir entre des formats (CSV, Parquet, JSON, Excel)
+- Profiler ou explorer un nouveau jeu de données
+- Optimiser du code Pandas lent pour de grands jeux de données
+- Migrer du code Pandas vers Polars pour les performances
+
+## Quand NE PAS utiliser
+- SQL dans une base de données (pousser les transformations vers la base quand les données y sont déjà)
+- Spark/calcul distribué (utiliser la compétence PySpark pour les jeux de données > RAM disponible)
+- Modèles dbt (transformations SQL dans un entrepôt de données)
+- Opérations sur des tableaux NumPy pour des données non tabulaires
+
+## Instructions
+
+### Pandas — règles de performance
+```python
+import pandas as pd
+import numpy as np
+
+# Ne jamais utiliser iterrows() — vectoriser à la place
+# Mauvais :
+for idx, row in df.iterrows():
+    df.at[idx, 'tax'] = row['price'] * 0.2
+
+# Bon :
+df['tax'] = df['price'] * 0.2
+
+# Utiliser .loc pour l'accès par label, .iloc pour l'accès par position
+# Ne jamais chaîner sans assignation — cause SettingWithCopyWarning
+df.loc[df['status'] == 'active', 'flag'] = True
+
+# Type catégoriel pour les colonnes de chaînes à faible cardinalité (énorme économie mémoire)
+df['country'] = df['country'].astype('category')
+
+# Réduire les types numériques pour économiser la mémoire
+df['quantity'] = pd.to_numeric(df['quantity'], downcast='integer')
+df['price'] = pd.to_numeric(df['price'], downcast='float')
+```
+
+### Pandas — agrégation et groupby
+```python
+# Groupby avec plusieurs agrégations
+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 — fusion
+```python
+# Toujours spécifier how= explicitement — ne jamais se fier au défaut (inner)
+result = pd.merge(
+    orders,
+    customers,
+    on='customer_id',
+    how='left',      # explicite
+    validate='m:1',  # valide la cardinalité — lève une exception si violée
+    suffixes=('_order', '_customer')
+)
+```
+
+### Polars — quand l'utiliser à la place de Pandas
+Utiliser Polars quand :
+- Jeu de données > 1M lignes (Polars est 5–100x plus rapide pour de nombreuses opérations)
+- Vous avez besoin d'évaluation paresseuse (optimisation des requêtes avant exécution)
+- Le parallélisme est important (Polars utilise tous les cœurs CPU par défaut)
+
+```python
+import polars as pl
+
+# API Lazy — les requêtes sont optimisées avant exécution
+result = (
+    pl.scan_parquet("orders.parquet")   # Scan paresseux — aucune donnée chargée encore
+    .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()   # Exécuter maintenant
+)
+```
+
+### Polars — expressions (pas d'indexation chaînée)
+```python
+# Polars : pas de SettingWithCopyWarning, pas d'indexation chaînée
+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"),
+])
+```
+
+### Pattern de validation des données
+```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"
+```
+
+### Conversion de format
+```python
+# Lecture
+df = pd.read_parquet("data.parquet", columns=['id', 'name', 'amount'])  # Sélection de colonnes à la lecture
+df = pd.read_csv("data.csv", dtype={'id': str}, parse_dates=['created_at'])
+
+# Écriture — toujours utiliser Parquet plutôt que CSV pour les grands jeux de données
+df.to_parquet("output.parquet", index=False, compression='snappy')
+```
+
+## Exemple
+
+**Utilisateur :** Nettoyer un CSV de commandes brutes : corriger les types, supprimer les doublons, gérer les valeurs nulles, ajouter des colonnes dérivées (revenue_after_tax, order_size_bucket) et produire un fichier Parquet validé.
+
+**Sortie attendue :**
+- Lecture avec `dtype=` et `parse_dates=` explicites
+- Supprimer les lignes `order_id` en doublon (garder la dernière)
+- Remplir les nulls : `quantity` → 0, `discount` → 0.0, supprimer les lignes où `customer_id` est null
+- Dériver : `revenue_after_tax = price * quantity * (1 - discount) * 0.8`
+- Bucket : `order_size_bucket` = 'small'/<100, 'medium'/100–1000, 'large'/>1000
+- Valider avec des assertions avant l'écriture
+- Écrire en Parquet avec compression snappy
+
+---
+
+> **Travaillez avec nous :** Claudient est soutenu par [Uitbreiden](https://uitbreiden.com/) — nous construisons des produits IA et des solutions B2B avec des communautés de développeurs. Vous construisez des pipelines de données ou des produits IA basés sur des données ? [uitbreiden.com](https://uitbreiden.com/)

package/skills/data-ml/fr/pytorch-tensorflow.md

@@ -0,0 +1,171 @@
+> 🇫🇷 This is the French translation. [English version](../pytorch-tensorflow.md).
+
+# Compétence PyTorch / TensorFlow
+
+## Quand activer
+- Rédiger des boucles d'entraînement de réseaux de neurones avec PyTorch
+- Construire et entraîner des modèles Keras/TensorFlow
+- Implémenter des fonctions de perte personnalisées ou des architectures de modèles
+- Configurer l'entraînement GPU avec la gestion des devices
+- Rédiger des data loaders et des pipelines de prétraitement pour l'entraînement de modèles
+- Implémenter l'évaluation de modèles, le checkpointing et l'arrêt anticipé
+- Déboguer des pertes NaN, des gradients explosifs ou une instabilité d'entraînement
+- Porter des modèles entre PyTorch et TensorFlow
+
+## Quand NE PAS utiliser
+- Tâches scikit-learn (classification, régression, clustering sur des données tabulaires) — pas du deep learning
+- Manipulation de données Pandas/Polars avant l'étape de modélisation
+- Fine-tuning Hugging Face avec l'API trainer (workflow différent)
+- Déploiements d'inférence uniquement sans code d'entraînement
+
+## Instructions
+
+### Boucle d'entraînement PyTorch — structure standard
+```python
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+
+def train(model, train_loader, val_loader, epochs, lr, device):
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-2)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)
+    criterion = nn.CrossEntropyLoss()
+
+    best_val_loss = float('inf')
+
+    for epoch in range(epochs):
+        # Entraînement
+        model.train()
+        train_loss = 0.0
+        for batch in train_loader:
+            inputs, targets = batch
+            inputs, targets = inputs.to(device), targets.to(device)
+
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            loss.backward()
+
+            # Écrêtage des gradients — toujours pour la stabilité
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+
+            optimizer.step()
+            train_loss += loss.item()
+
+        # Validation
+        model.eval()
+        val_loss = 0.0
+        with torch.no_grad():
+            for batch in val_loader:
+                inputs, targets = batch
+                inputs, targets = inputs.to(device), targets.to(device)
+                outputs = model(inputs)
+                val_loss += criterion(outputs, targets).item()
+
+        scheduler.step()
+
+        # Sauvegarder le meilleur modèle
+        if val_loss < best_val_loss:
+            best_val_loss = val_loss
+            torch.save(model.state_dict(), 'best_model.pt')
+
+        print(f"Epoch {epoch+1}/{epochs} | Train: {train_loss/len(train_loader):.4f} | Val: {val_loss/len(val_loader):.4f}")
+```
+
+### Gestion des devices
+```python
+# Toujours sélectionner le device explicitement
+device = torch.device('cuda' if torch.cuda.is_available() else
+                       'mps' if torch.backends.mps.is_available() else
+                       'cpu')
+model = model.to(device)
+```
+Ne jamais coder en dur `'cuda'` — toujours vérifier la disponibilité.
+
+### Structure de modèle personnalisé
+```python
+class MyModel(nn.Module):
+    def __init__(self, input_dim, hidden_dim, output_dim, dropout=0.3):
+        super().__init__()
+        self.network = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden_dim, output_dim)
+        )
+
+    def forward(self, x):
+        return self.network(x)
+```
+Préférer `nn.Sequential` pour les réseaux feedforward simples ; utiliser la surcharge de `forward()` pour les branchements complexes.
+
+### Débogage de l'instabilité d'entraînement
+1. **Perte NaN** → vérifier log(0) dans la perte, des entrées explosives, ou une division par zéro dans le prétraitement
+2. **Gradients explosifs** → ajouter `clip_grad_norm_` (déjà dans le template ci-dessus)
+3. **Gradients qui disparaissent** → vérifier les fonctions d'activation (éviter sigmoid/tanh dans les réseaux profonds), utiliser des connexions résiduelles
+4. **Perte qui ne diminue pas** → réduire le LR de 10x, vérifier le mélange du data loader, vérifier que les labels sont corrects
+5. **GPU OOM** → réduire la taille de batch, utiliser le gradient checkpointing, utiliser la précision mixte
+
+### Entraînement en précision mixte (PyTorch)
+```python
+from torch.cuda.amp import autocast, GradScaler
+
+scaler = GradScaler()
+
+for batch in train_loader:
+    optimizer.zero_grad()
+    with autocast():
+        outputs = model(inputs)
+        loss = criterion(outputs, targets)
+    scaler.scale(loss).backward()
+    scaler.unscale_(optimizer)
+    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+    scaler.step(optimizer)
+    scaler.update()
+```
+
+### TensorFlow/Keras — structure standard
+```python
+import tensorflow as tf
+
+model = tf.keras.Sequential([
+    tf.keras.layers.Dense(256, activation='relu'),
+    tf.keras.layers.Dropout(0.3),
+    tf.keras.layers.Dense(10, activation='softmax')
+])
+
+model.compile(
+    optimizer=tf.keras.optimizers.AdamW(learning_rate=1e-3, weight_decay=1e-2),
+    loss='sparse_categorical_crossentropy',
+    metrics=['accuracy']
+)
+
+callbacks = [
+    tf.keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True),
+    tf.keras.callbacks.ModelCheckpoint('best_model.keras', save_best_only=True),
+    tf.keras.callbacks.ReduceLROnPlateau(patience=3, factor=0.5)
+]
+
+history = model.fit(
+    train_dataset,
+    validation_data=val_dataset,
+    epochs=100,
+    callbacks=callbacks
+)
+```
+
+## Exemple
+
+**Utilisateur :** Construire un classificateur de texte PyTorch pour l'analyse de sentiment (binaire) avec embedding, LSTM et dropout.
+
+**Sortie attendue :**
+- `SentimentLSTM(nn.Module)` — couche d'embedding, LSTM, dropout, tête linéaire
+- `forward()` — gère les séquences packed ou les entrées paddées
+- Boucle d'entraînement avec écrêtage des gradients, validation par epoch, checkpoint du meilleur modèle
+- `device` auto-détecté (CUDA/MPS/CPU)
+- Séparation train/val via `DataLoader` avec mélange uniquement sur train
+
+---
+
+> **Travaillez avec nous :** Claudient est soutenu par [Uitbreiden](https://uitbreiden.com/) — nous construisons des produits IA et des solutions B2B avec des communautés de développeurs. Vous construisez des modèles ML ou des produits alimentés par l'IA ? [uitbreiden.com](https://uitbreiden.com/)

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

@@ -0,0 +1,157 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../dbt-data-pipelines.md).
+
+# dbt Data Pipelines Skill
+
+## Wanneer te activeren
+- dbt-modellen schrijven (staging-, intermediate-, mart-lagen)
+- dbt-sources, refs en afhankelijkheden configureren
+- dbt-tests schrijven (schema-tests, enkelvoudige tests, aangepaste generieke tests)
+- dbt-projectstructuur instellen voor een nieuw data warehouse
+- dbt-macro's schrijven voor herbruikbare SQL-logica
+- dbt-documentatie en versheidscontroles configureren
+- dbt-compilatiefouten of mislukte modeldraaiingen debuggen
+- dbt instellen met BigQuery, Snowflake, Redshift, of DuckDB
+
+## Wanneer NIET te gebruiken
+- Ruwe ETL-pipelines zonder een warehouse (gebruik in plaats daarvan Airflow, Prefect of Dagster)
+- Real-time streamingdata (dbt is alleen batch)
+- Pandas/Polars in-memory-transformaties (gebruik de pandas-polars skill)
+- Data-ingestie (dbt transformeert, het ingesteert niet)
+
+## Instructies
+
+### Projectlaagarchitectuur
+Scheid modellen altijd in drie lagen:
+```
+models/
+├── staging/          ← 1:1 met brontabellen. Alleen lichte opschoning. Geen joins.
+│   ├── stg_orders.sql
+│   └── stg_customers.sql
+├── intermediate/     ← Bedrijfslogica. Joins toegestaan. Niet blootgesteld aan BI-tools.
+│   └── int_orders_with_customers.sql
+└── marts/            ← Definitieve bedrijfsentiteiten. Blootgesteld aan BI. Aggregaties hier.
+    ├── finance/
+    │   └── fct_revenue.sql
+    └── marketing/
+        └── dim_customers.sql
+```
+
+**Staging-regels:**
+- Kolommen hernoemen naar projectconventies (snake_case)
+- Typen expliciet casten
+- Geen bedrijfslogica — geen joins, geen aggregaties
+- Prefix met `stg_`
+
+**Mart-regels:**
+- `fct_`-prefix voor facttabellen (gebeurtenissen, transacties)
+- `dim_`-prefix voor dimensietabellen (klanten, producten)
+- Altijd documenteren in schema.yml
+
+### Modelconfiguratie
+```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
+```
+
+**Materialisatiekeuzes:**
+- `view`: standaard — goed voor staging- en intermediate-modellen
+- `table`: voor dure queries die vaak worden bevraagd
+- `incremental`: voor grote facttabellen die in de loop der tijd groeien
+- `ephemeral`: CTE's, niet gematerialiseerd — gebruik voor eenvoudige transformaties die eenmaal worden aangeroepen
+
+### Testen — vereist op elk mart-model
+```yaml
+# models/marts/finance/schema.yml
+version: 2
+
+models:
+  - name: fct_revenue
+    description: "Eén rij per voltooide bestelling"
+    columns:
+      - name: order_id
+        description: "Primaire sleutel"
+        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 op elk mart-model: `unique` + `not_null` op primaire sleutel, `not_null` op kritieke externe sleutels.
+
+### Bronconfiguratie
+```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: "Ruwe Stripe-charges van Fivetran"
+```
+
+Stel altijd `freshness` in op bronnen — verouderde brondata is een stille fout.
+
+### Macro's voor herbruikbare logica
+```sql
+-- macros/cents_to_dollars.sql
+{% macro cents_to_dollars(column_name) %}
+    ({{ column_name }} / 100.0)::numeric(10, 2)
+{% endmacro %}
+
+-- Gebruik in model
+select
+    {{ cents_to_dollars('amount_cents') }} as amount_dollars
+from orders
+```
+
+## Voorbeeld
+
+**Gebruiker:** Maak staging- en mart-modellen voor Stripe-betalingsdata (charges, refunds) met tests en versheidscontroles.
+
+**Verwachte output:**
+- `models/staging/stripe/sources.yml` — bron met versheidscontrole op `_ingested_at`
+- `models/staging/stripe/stg_stripe_charges.sql` — hernoemen, casten, geen joins
+- `models/staging/stripe/stg_stripe_refunds.sql` — zelfde patroon
+- `models/marts/finance/fct_payments.sql` — join charges + refunds, nettobedrag, incrementele materialisatie
+- `models/marts/finance/schema.yml` — `unique` + `not_null` op `charge_id`, relatietest op `customer_id`
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. Datapipelines bouwen voor AI- of analyseproducten? [uitbreiden.com](https://uitbreiden.com/)