Upload 2 files

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.12-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PORT=8501
+
+WORKDIR /app
+
+# System deps
+RUN apt-get update -y && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for caching
+COPY requirements.txt /app/requirements.txt
+RUN python -m pip install --upgrade pip && \
+    pip install -r requirements.txt
+
+# Copy application
+COPY . /app
+
+EXPOSE 8501
+
+CMD ["streamlit", "run", "streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0", "--browser.gatherUsageStats=false"]
+
+

streamlit_app.py

@@ -0,0 +1,735 @@
+import io
+import os
+from datetime import datetime, date
+from typing import Dict, List, Optional, Tuple
+
+import pandas as pd
+import plotly.express as px
+import streamlit as st
+
+
+# -----------------------------
+# App Configuration
+# -----------------------------
+st.set_page_config(
+    page_title="Tableau de bord des inscriptions",
+    page_icon="🧭",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+
+# -----------------------------
+# Utilities
+# -----------------------------
+def try_parse_datetime(series: pd.Series) -> pd.Series:
+    """Attempt to parse a pandas Series as datetimes, returning original on failure."""
+    if pd.api.types.is_datetime64_any_dtype(series):
+        return series
+    try:
+        parsed = pd.to_datetime(series, errors="coerce")
+        if parsed.notna().sum() >= max(3, int(0.2 * len(parsed))):
+            return parsed
+    except Exception:
+        pass
+    return series
+
+
+def make_unique_columns(columns: List[str]) -> List[str]:
+    """Ensure column names are unique by appending suffixes (2), (3), ..."""
+    seen: Dict[str, int] = {}
+    unique_cols: List[str] = []
+    for name in columns:
+        base = str(name)
+        if base not in seen:
+            seen[base] = 1
+            unique_cols.append(base)
+        else:
+            seen[base] += 1
+            unique_cols.append(f"{base} ({seen[base]})")
+    return unique_cols
+
+
+def normalize_label(text: str) -> str:
+    t = str(text).lower().strip()
+    t = t.replace("\u00a0", " ").replace(" ", " ")
+    t = " ".join(t.split())
+    return t
+
+
+def find_column(df: pd.DataFrame, candidates: List[str]) -> Optional[str]:
+    """Return the first matching column by normalized name from candidates."""
+    norm_to_col = {normalize_label(c): c for c in df.columns}
+    for cand in candidates:
+        n = normalize_label(cand)
+        if n in norm_to_col:
+            return norm_to_col[n]
+    return None
+
+def infer_pandas_types(df: pd.DataFrame) -> Dict[str, str]:
+    """Return a mapping of column -> inferred logical type: 'categorical' | 'numeric' | 'date' | 'text'."""
+    type_map: Dict[str, str] = {}
+    for col in df.columns:
+        s = df[col]
+        if pd.api.types.is_datetime64_any_dtype(s):
+            type_map[col] = "date"
+        elif pd.api.types.is_bool_dtype(s):
+            type_map[col] = "categorical"
+        elif pd.api.types.is_numeric_dtype(s):
+            type_map[col] = "numeric"
+        else:
+            # try parse datetime heuristic
+            parsed = try_parse_datetime(s)
+            if pd.api.types.is_datetime64_any_dtype(parsed):
+                type_map[col] = "date"
+            else:
+                # if low cardinality, treat as categorical
+                nunique = s.astype(str).nunique(dropna=True)
+                type_map[col] = "categorical" if nunique <= max(50, len(s) * 0.05) else "text"
+    return type_map
+
+
+def dynamic_filters(df: pd.DataFrame, type_map: Dict[str, str]) -> pd.DataFrame:
+    """Render dynamic filters for all columns and return the filtered DataFrame."""
+    filtered = df.copy()
+    st.sidebar.markdown("### 🔎 Filtres dynamiques")
+    for col in filtered.columns:
+        logical = type_map.get(col, "text")
+        if logical == "numeric" and pd.api.types.is_numeric_dtype(filtered[col]):
+            series_num = pd.to_numeric(filtered[col], errors="coerce")
+            valid = series_num.dropna()
+            if valid.empty:
+                st.sidebar.caption(f"{col}: aucune valeur numérique exploitable")
+                continue
+            min_v = float(valid.min())
+            max_v = float(valid.max())
+            if min_v == max_v:
+                st.sidebar.caption(f"{col}: valeur unique {min_v}")
+                # Filtrage inutile car une seule valeur
+                continue
+            vmin, vmax = st.sidebar.slider(f"{col} (min-max)", min_value=min_v, max_value=max_v, value=(min_v, max_v))
+            filtered = filtered[(series_num >= vmin) & (series_num <= vmax)]
+        elif logical == "date":
+            parsed = try_parse_datetime(filtered[col])
+            if pd.api.types.is_datetime64_any_dtype(parsed):
+                dmin = parsed.min()
+                dmax = parsed.max()
+                start_end = st.sidebar.date_input(f"{col} (période)", value=(dmin.date() if pd.notna(dmin) else date.today(), dmax.date() if pd.notna(dmax) else date.today()))
+                if isinstance(start_end, tuple) and len(start_end) == 2:
+                    start, end = start_end
+                    mask = (parsed.dt.date >= start) & (parsed.dt.date <= end)
+                    filtered = filtered[mask]
+        else:
+            # categorical or text -> multiselect of unique values (with limit)
+            uniques = filtered[col].dropna().astype(str).unique().tolist()
+            uniques = sorted(uniques)[:200]
+            selected = st.sidebar.multiselect(f"{col}", options=uniques, default=[])
+            if selected:
+                filtered = filtered[filtered[col].astype(str).isin(selected)]
+    return filtered
+
+
+def apply_search(df: pd.DataFrame, query: str) -> pd.DataFrame:
+    if not query:
+        return df
+    q = query.strip().lower()
+    mask = pd.Series(False, index=df.index)
+    for col in df.columns:
+        col_values = df[col].astype(str).str.lower()
+        mask = mask | col_values.str.contains(q, na=False)
+    return df[mask]
+
+
+def to_excel_bytes(df: pd.DataFrame) -> bytes:
+    buffer = io.BytesIO()
+    with pd.ExcelWriter(buffer, engine="xlsxwriter") as writer:
+        df.to_excel(writer, index=False, sheet_name="inscriptions")
+    return buffer.getvalue()
+
+
+def kpi_card(label: str, value: str):
+    st.markdown(
+        f"""
+        <div class="card kpi">
+            <div class="card-label">{label}</div>
+            <div class="card-value">{value}</div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def chart_card(title: str, fig):
+    st.markdown(f"<div class=\"card\"><div class=\"card-title\">{title}</div>", unsafe_allow_html=True)
+    st.plotly_chart(fig, use_container_width=True, theme=None)
+    st.markdown("</div>", unsafe_allow_html=True)
+
+
+def inject_base_css():
+    with open(os.path.join("assets", "styles.css"), "r", encoding="utf-8") as f:
+        css = f.read()
+    st.markdown(f"<style>{css}</style>", unsafe_allow_html=True)
+
+
+def set_theme_variables(mode: str):
+    # Adjust CSS variables for light/dark for cards and text; Plotly handled via template
+    palette = {
+        "light": {
+            "--bg": "#f7f9fc",
+            "--card": "#ffffff",
+            "--text": "#0f172a",
+            "--muted": "#64748b",
+            "--primary": "#0ea5e9",
+            "--accent": "#10b981",
+            "--border": "#e5e7eb",
+        },
+        "dark": {
+            "--bg": "#0b1220",
+            "--card": "#111827",
+            "--text": "#e5e7eb",
+            "--muted": "#94a3b8",
+            "--primary": "#38bdf8",
+            "--accent": "#34d399",
+            "--border": "#1f2937",
+        },
+    }
+    colors = palette.get(mode, palette["light"])
+    styles = ":root{" + ";".join([f"{k}:{v}" for k, v in colors.items()]) + "}"
+    st.markdown(f"<style>{styles}</style>", unsafe_allow_html=True)
+
+
+def get_plotly_template(mode: str) -> str:
+    return "plotly_dark" if mode == "dark" else "plotly_white"
+
+
+# -----------------------------
+# Sidebar: Logo, Upload, Theme, Column mapping
+# -----------------------------
+def sidebar_controls() -> Tuple[Optional[pd.DataFrame], Dict[str, str], str, Dict[str, str], List[str]]:
+    st.sidebar.markdown("## ⚙️ Contrôles")
+
+    # Theme
+    mode = st.sidebar.radio("Thème", options=["clair", "sombre"], horizontal=True, index=0)
+    theme_mode = "dark" if mode == "sombre" else "light"
+    set_theme_variables(theme_mode)
+
+    # Logo (optional)
+    logo_path = os.path.join("assets", "logo.png")
+    if os.path.exists(logo_path):
+        st.sidebar.image(logo_path, use_column_width=True)
+
+    uploaded = st.sidebar.file_uploader("Importer un fichier Excel (.xlsx)", type=["xlsx"])
+
+    df: Optional[pd.DataFrame] = None
+    if uploaded is not None:
+        try:
+            # Read first sheet by default
+            df = pd.read_excel(uploaded, sheet_name=0)
+            # Strip column names
+            df.columns = [str(c).strip() for c in df.columns]
+            # Ensure unique column names
+            if pd.Index(df.columns).has_duplicates:
+                df.columns = make_unique_columns(list(df.columns))
+        except Exception as e:
+            st.sidebar.error(f"Erreur de lecture du fichier: {e}")
+
+    logical_types: Dict[str, str] = {}
+    coercions: Dict[str, str] = {}
+    unique_keys: List[str] = []
+    if df is not None and not df.empty:
+        st.sidebar.markdown("---")
+        st.sidebar.markdown("### 🧹 Nettoyage & types")
+        # Global cleaning options
+        trim_spaces = st.sidebar.checkbox("Supprimer les espaces autour du texte", value=True)
+        lower_case = st.sidebar.checkbox("Mettre le texte en minuscules", value=False)
+        drop_dupes = st.sidebar.checkbox("Supprimer les doublons", value=False)
+        dedup_subset_cols: List[str] = []
+        dedup_keep_choice = "first"
+        if drop_dupes:
+            dedup_subset_cols = st.sidebar.multiselect(
+                "Colonnes à considérer (vide = toutes)", options=list(df.columns), help="Sélectionnez les colonnes sur lesquelles détecter les doublons."
+            )
+            dedup_keep_choice = st.sidebar.selectbox(
+                "Conserver",
+                options=["first", "last", "none"],
+                index=0,
+                help="Quelle occurrence conserver pour chaque doublon détecté",
+            )
+        fillna_blank = st.sidebar.checkbox("Remplacer NaN texte par vide", value=True)
+
+        # Remove selected columns
+        drop_columns = st.sidebar.multiselect(
+            "Enlever des colonnes",
+            options=list(df.columns),
+            default=[],
+            help="Supprimer des champs du jeu de données avant l'analyse",
+            key="clean_drop_cols",
+        )
+        if drop_columns:
+            df.drop(columns=drop_columns, inplace=True, errors="ignore")
+
+        # Infer and allow override per column
+        inferred = infer_pandas_types(df)
+        for col in df.columns:
+            logical_types[col] = st.sidebar.selectbox(
+                f"Type pour {col}", options=["categorical", "numeric", "date", "text"], index=["categorical", "numeric", "date", "text"].index(inferred.get(col, "text"))
+            )
+            # Optional coercion
+            if logical_types[col] in ("numeric", "date"):
+                coercions[col] = logical_types[col]
+
+        # Apply cleaning
+        for col in df.columns:
+            if df[col].dtype == object:
+                if trim_spaces:
+                    df[col] = df[col].astype(str).str.strip()
+                if lower_case:
+                    df[col] = df[col].astype(str).str.lower()
+                if fillna_blank:
+                    df[col] = df[col].replace({pd.NA: "", None: ""})
+            # Coerce types
+            if coercions.get(col) == "numeric":
+                df[col] = pd.to_numeric(df[col], errors="coerce")
+            elif coercions.get(col) == "date":
+                df[col] = try_parse_datetime(df[col])
+
+        if drop_dupes:
+            keep_arg = None if dedup_keep_choice == "none" else dedup_keep_choice
+            df.drop_duplicates(subset=(dedup_subset_cols if dedup_subset_cols else None), keep=keep_arg, inplace=True)
+
+        # Unique person keys
+        st.sidebar.markdown("---")
+        st.sidebar.markdown("### 👤 Personne unique")
+        # Heuristic suggestions
+        hints = ["email", "e-mail", "mail", "id", "identifiant", "cin", "passport", "matricule", "phone", "téléphone", "telephone", "tel"]
+        suggested = [c for c in df.columns if any(h in c.lower() for h in hints)]
+        unique_keys = st.sidebar.multiselect(
+            "Champs d'unicité (sélection multiple)", options=list(df.columns), default=suggested, help="Sélectionnez les champs qui identifient de façon unique une personne."
+        )
+
+    return df, logical_types, theme_mode, coercions, unique_keys
+
+
+# -----------------------------
+# Main App
+# -----------------------------
+def main():
+    inject_base_css()
+
+    # Header
+    col_logo, col_title, col_right = st.columns([1, 3, 1])
+    with col_logo:
+        logo_path = os.path.join("assets", "logo.png")
+        if os.path.exists(logo_path):
+            st.image(logo_path, width=72)
+    with col_title:
+        st.markdown("<h1 style='text-align:center; margin-top: 0;'>Tableau de bord des inscriptions</h1>", unsafe_allow_html=True)
+    with col_right:
+        st.write("")
+
+    df, type_map, theme_mode, _, unique_keys = sidebar_controls()
+    plotly_template = get_plotly_template(theme_mode)
+
+    if df is None or df.empty:
+        st.markdown(
+            """
+            <div class="card">
+                <div class="card-title">Bienvenue 👋</div>
+                <p>Importez un fichier <b>.xlsx</b> contenant vos inscriptions pour commencer l'analyse.</p>
+                <ul>
+                    <li>Assurez-vous que les colonnes principales (pays, formation, statut, date) sont présentes.</li>
+                    <li>Vous pourrez mapper les colonnes dans la barre latérale.</li>
+                </ul>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+        return
+
+    # Filters (dynamic for all columns)
+    st.sidebar.markdown("---")
+    filtered_df = dynamic_filters(df, type_map)
+
+    # Optional unique-person filtering using selected keys
+    st.sidebar.markdown("### 👤 Filtrer par personne unique")
+    if 'unique_keys' not in locals():
+        unique_keys = []
+    if unique_keys:
+        person_filter = st.sidebar.checkbox("Activer le filtre d'unicité (drop_duplicates)", value=False, key="unique_filter_toggle")
+        keep_strategy = st.sidebar.selectbox("Conserver", options=["first", "last"], index=0, key="unique_filter_keep")
+        if person_filter:
+            try:
+                filtered_df = filtered_df.drop_duplicates(subset=unique_keys, keep=keep_strategy)
+            except Exception:
+                st.sidebar.warning("Impossible d'appliquer le filtre d'unicité. Vérifiez les champs choisis.")
+
+    # KPIs
+    total_count = len(filtered_df)
+    total_columns = filtered_df.shape[1]
+    total_missing = int(filtered_df.isna().sum().sum())
+    approx_dupes = int(filtered_df.duplicated().sum())
+
+    c1, c2, c3, c4 = st.columns(4)
+    with c1:
+        kpi_card("Lignes", f"{total_count:,}")
+    with c2:
+        kpi_card("Colonnes", f"{total_columns:,}")
+    with c3:
+        kpi_card("Valeurs manquantes", f"{total_missing:,}")
+    with c4:
+        kpi_card("Doublons (approx)", f"{approx_dupes:,}")
+
+    # Unique persons KPI (based on selected keys)
+    if unique_keys:
+        try:
+            uniq = (
+                filtered_df.dropna(subset=unique_keys)[unique_keys]
+                .astype(str)
+                .drop_duplicates()
+                .shape[0]
+            )
+        except Exception:
+            uniq = 0
+        c5, _ = st.columns([1, 3])
+        with c5:
+            kpi_card("Personnes uniques", f"{uniq:,}")
+
+    # Charts row 1: Program distribution, Country distribution
+    st.markdown("<div class=\"card\"><div class=\"card-title\">Répartitions clés</div>", unsafe_allow_html=True)
+    ctrl1, ctrl2, ctrl3 = st.columns([1,1,2])
+    with ctrl1:
+        topn = st.slider("Top N", min_value=3, max_value=50, value=10, step=1)
+    with ctrl2:
+        sort_dir = st.selectbox("Tri", options=["desc", "asc"], index=0)
+    with ctrl3:
+        st.caption("Appliqué aux graphiques de répartition ci-dessous")
+    charts_row_1 = st.columns(2)
+    # Choose any categorical column for distribution 1
+    cat_cols_all = [c for c in filtered_df.columns if type_map.get(c) in ("categorical", "text")]
+    if cat_cols_all and not filtered_df.empty:
+        dim1 = st.selectbox("Dimension 1 (répartition)", options=cat_cols_all, key="rep_dim1")
+        program_counts = (
+            filtered_df.groupby(dim1).size().reset_index(name="count").sort_values("count", ascending=(sort_dir=="asc"))
+            .head(topn)
+        )
+        fig_prog = px.bar(
+            program_counts,
+            x=dim1,
+            y="count",
+            template=plotly_template,
+            color_continuous_scale="Blues",
+        )
+        fig_prog.update_layout(margin=dict(l=10, r=10, t=10, b=10))
+        with charts_row_1[0]:
+            chart_card("Répartition (dimension 1)", fig_prog)
+
+    if cat_cols_all and not filtered_df.empty:
+        dim2 = st.selectbox("Dimension 2 (répartition)", options=[c for c in cat_cols_all], index=min(1, len(cat_cols_all)-1), key="rep_dim2")
+        country_counts = (
+            filtered_df.groupby(dim2).size().reset_index(name="count").sort_values("count", ascending=(sort_dir=="asc"))
+            .head(topn)
+        )
+        fig_country = px.pie(
+            country_counts,
+            names=dim2,
+            values="count",
+            template=plotly_template,
+            hole=0.35,
+        )
+        fig_country.update_layout(margin=dict(l=10, r=10, t=10, b=10))
+        with charts_row_1[1]:
+            chart_card("Répartition (dimension 2)", fig_country)
+    st.markdown("</div>", unsafe_allow_html=True)
+
+    # Charts row 2: Status distribution, Time series
+    charts_row_2 = st.columns(2)
+    if cat_cols_all and not filtered_df.empty:
+        dim3 = st.selectbox("Dimension 3", options=cat_cols_all, key="rep_dim3")
+        status_counts = (
+            filtered_df.groupby(dim3).size().reset_index(name="count").sort_values("count", ascending=False)
+        )
+        fig_status = px.bar(
+            status_counts,
+            x=dim3,
+            y="count",
+            template=plotly_template,
+            color=dim3,
+        )
+        fig_status.update_layout(showlegend=False, margin=dict(l=10, r=10, t=10, b=10))
+        with charts_row_2[0]:
+            chart_card("Répartition (dimension 3)", fig_status)
+
+    # date_cols = [c for c in filtered_df.columns if type_map.get(c) == "date"]
+    
+
+    # Charts row 3: Numeric histogram (user-selectable)
+    # numeric_cols = [c for c in filtered_df.columns if pd.api.types.is_numeric_dtype(filtered_df[c])]
+    
+
+    # Ad-hoc analysis builder
+    st.markdown("<div class=\"card\"><div class=\"card-title\">Zone d’analyse</div>", unsafe_allow_html=True)
+    cat_cols = [c for c in filtered_df.columns if type_map.get(c) in ("categorical", "text")]
+    if cat_cols:
+        ac1, ac2, ac3 = st.columns([2,1,1])
+        with ac1:
+            dim_col = st.selectbox("Dimension", options=cat_cols)
+        with ac2:
+            chart_type = st.selectbox("Type de graphique", options=["Barres", "Camembert"], index=0)
+        with ac3:
+            topn_dim = st.slider("Top N (dimension)", 3, 50, 10)
+
+        agg = filtered_df.groupby(dim_col).size().reset_index(name="count").sort_values("count", ascending=False).head(topn_dim)
+        if chart_type == "Barres":
+            fig = px.bar(agg, x=dim_col, y="count", template=plotly_template)
+        else:
+            fig = px.pie(agg, names=dim_col, values="count", template=plotly_template, hole=0.35)
+        st.plotly_chart(fig, use_container_width=True, theme=None)
+    st.markdown("</div>", unsafe_allow_html=True)
+
+
+    # Drilldown option (simple): filtrer sur une dimension/valeur
+    dd_cols = cat_cols
+    dd1, dd2 = st.columns([1,2])
+    with dd1:
+        dd_dim = st.selectbox("Drilldown - dimension", options=[None] + dd_cols)
+    if dd_dim:
+        values = [x for x in filtered_df[dd_dim].dropna().astype(str).unique()]
+        with dd2:
+            dd_val = st.selectbox("Valeur", options=[None] + values)
+        if dd_val:
+            filtered_df = filtered_df[filtered_df[dd_dim].astype(str) == dd_val]
+
+    search_query = st.text_input("Recherche globale")
+    df_searched = apply_search(filtered_df, search_query)
+    st.dataframe(df_searched, use_container_width=True, hide_index=True)
+
+    # Downloads
+    csv_bytes = df_searched.to_csv(index=False).encode("utf-8-sig")
+    xlsx_bytes = to_excel_bytes(df_searched)
+    dc1, dc2 = st.columns(2)
+    with dc1:
+        st.download_button(
+            "Télécharger CSV",
+            data=csv_bytes,
+            file_name="inscriptions_filtrees.csv",
+            mime="text/csv",
+            use_container_width=True,
+        )
+    with dc2:
+        st.download_button(
+            "Télécharger Excel",
+            data=xlsx_bytes,
+            file_name="inscriptions_filtrees.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            use_container_width=True,
+        )
+    st.markdown("</div>", unsafe_allow_html=True)
+
+    # Universal Chart Builder
+    st.markdown("<div class=\"card\"><div class=\"card-title\">Constructeur de graphiques</div>", unsafe_allow_html=True)
+    chart_types = [
+        "Barres",
+        "Barres empilées",
+        "Lignes",
+        "Aires",
+        "Camembert",
+        "Histogramme",
+        "Nuage de points",
+        "Boîte (Box)",
+        "Violon",
+    ]
+    cA, cB, cC = st.columns([1.2, 1, 1])
+    with cA:
+        chosen_chart = st.selectbox("Type de graphique", options=chart_types, key="ub_chart_type")
+    with cB:
+        agg_choice = st.selectbox("Agrégat", options=["count", "sum", "mean", "median", "min", "max"], index=0, key="ub_agg")
+    with cC:
+        topn_builder = st.number_input("Top N (optionnel)", min_value=0, value=0, step=1, help="0 pour désactiver")
+
+    all_cols = list(filtered_df.columns)
+    num_cols = [c for c in all_cols if pd.api.types.is_numeric_dtype(filtered_df[c])]
+    date_cols_any = [c for c in all_cols if pd.api.types.is_datetime64_any_dtype(try_parse_datetime(filtered_df[c]))]
+    cat_cols_any = [c for c in all_cols if c not in num_cols]
+
+    def aggregate_df(df_src: pd.DataFrame, x_col: Optional[str], y_col: Optional[str], color_col: Optional[str]) -> pd.DataFrame:
+        if agg_choice == "count":
+            if x_col is not None and y_col is None:
+                return df_src.groupby([x_col, color_col] if color_col else [x_col]).size().reset_index(name="value")
+            elif x_col is None and y_col is not None:
+                return df_src.groupby([y_col, color_col] if color_col else [y_col]).size().reset_index(name="value")
+            elif x_col is not None and y_col is not None:
+                return df_src.groupby([x_col, y_col]).size().reset_index(name="value")
+            else:
+                return pd.DataFrame({"value": [len(df_src)]})
+        else:
+            agg_func = agg_choice
+            measure = y_col if (y_col in num_cols) else (x_col if (x_col in num_cols) else (num_cols[0] if num_cols else None))
+            if measure is None:
+                return df_src.groupby([x_col, color_col] if color_col else [x_col]).size().reset_index(name="value") if x_col else pd.DataFrame({"value": [len(df_src)]})
+            group_keys = [k for k in [x_col, color_col] if k]
+            out = df_src.groupby(group_keys, dropna=False)[measure].agg(agg_func).reset_index(name="value")
+            return out
+
+    if chosen_chart in ("Barres", "Barres empilées"):
+        x = st.selectbox("Axe X (cat/date)", options=cat_cols_any, key="ub_bar_x")
+        color = st.selectbox("Couleur (optionnel)", options=[None] + cat_cols_any, key="ub_bar_color")
+        measure = st.selectbox("Mesure (numérique ou count)", options=["(count)"] + num_cols, key="ub_bar_measure")
+        data = aggregate_df(filtered_df, x, None if measure == "(count)" else measure, color)
+        if topn_builder and topn_builder > 0 and x in data.columns:
+            data = data.sort_values("value", ascending=False).groupby(x).head(1).head(int(topn_builder))
+        if chosen_chart == "Barres":
+            fig = px.bar(data, x=x, y="value", color=color, template=plotly_template, barmode="group")
+        else:
+            fig = px.bar(data, x=x, y="value", color=color, template=plotly_template, barmode="relative")
+        st.plotly_chart(fig, use_container_width=True, theme=None)
+    elif chosen_chart in ("Lignes", "Aires"):
+        x = st.selectbox("Axe X (date recommandé)", options=date_cols_any or cat_cols_any, key="ub_line_x")
+        color = st.selectbox("Couleur (optionnel)", options=[None] + cat_cols_any, key="ub_line_color")
+        measure = st.selectbox("Mesure (numérique ou count)", options=["(count)"] + num_cols, key="ub_line_measure")
+        data = aggregate_df(filtered_df, x, None if measure == "(count)" else measure, color)
+        if chosen_chart == "Lignes":
+            fig = px.line(data, x=x, y="value", color=color, template=plotly_template)
+        else:
+            fig = px.area(data, x=x, y="value", color=color, template=plotly_template)
+        st.plotly_chart(fig, use_container_width=True, theme=None)
+    elif chosen_chart == "Camembert":
+        names = st.selectbox("Noms (catégorie)", options=cat_cols_any, key="ub_pie_names")
+        measure = st.selectbox("Mesure (numérique ou count)", options=["(count)"] + num_cols, key="ub_pie_measure")
+        if measure == "(count)":
+            data = filtered_df.groupby(names).size().reset_index(name="value")
+        else:
+            data = filtered_df.groupby(names)[measure].sum().reset_index(name="value")
+        fig = px.pie(data, names=names, values="value", template=plotly_template, hole=0.35)
+        st.plotly_chart(fig, use_container_width=True, theme=None)
+    elif chosen_chart == "Histogramme":
+        x = st.selectbox("Colonne numérique", options=num_cols, key="ub_hist_x")
+        bins = st.slider("Nb de bacs (bins)", 5, 100, 30)
+        fig = px.histogram(filtered_df, x=x, nbins=bins, template=plotly_template)
+        st.plotly_chart(fig, use_container_width=True, theme=None)
+    elif chosen_chart == "Nuage de points":
+        x = st.selectbox("X (numérique)", options=num_cols, key="ub_scatter_x")
+        y = st.selectbox("Y (numérique)", options=[c for c in num_cols if c != x], key="ub_scatter_y")
+        color = st.selectbox("Couleur (optionnel)", options=[None] + cat_cols_any, key="ub_scatter_color")
+        fig = px.scatter(filtered_df, x=x, y=y, color=color, template=plotly_template)
+        st.plotly_chart(fig, use_container_width=True, theme=None)
+    elif chosen_chart == "Boîte (Box)":
+        y = st.selectbox("Y (numérique)", options=num_cols, key="ub_box_y")
+        x = st.selectbox("X (catégorie optionnel)", options=[None] + cat_cols_any, key="ub_box_x")
+        fig = px.box(filtered_df, x=x, y=y, template=plotly_template)
+        st.plotly_chart(fig, use_container_width=True, theme=None)
+    elif chosen_chart == "Violon":
+        y = st.selectbox("Y (numérique)", options=num_cols, key="ub_violin_y")
+        x = st.selectbox("X (catégorie optionnel)", options=[None] + cat_cols_any, key="ub_violin_x")
+        fig = px.violin(filtered_df, x=x, y=y, template=plotly_template, box=True, points="outliers")
+        st.plotly_chart(fig, use_container_width=True, theme=None)
+    st.markdown("</div>", unsafe_allow_html=True)
+
+    # Decision Maker View (field-aware, optional)
+    st.markdown("<div class=\"card\"><div class=\"card-title\">Vue Décideur (si champs disponibles)</div>", unsafe_allow_html=True)
+    # Candidate fields based on provided list
+    col_email = find_column(filtered_df, ["Email"]) or find_column(filtered_df, ["E-mail"])
+    col_gender = find_column(filtered_df, ["Genre", "Autre genre (Veuillez préciser) : "])
+    col_nat = find_column(filtered_df, ["Nationalité"])
+    col_country = find_column(filtered_df, ["Pays de résidence"]) or find_column(filtered_df, ["D’où préférez-vous participer à l'événement ?"])
+    col_role = find_column(filtered_df, ["Votre profession / statut", "Autre profession (veuillez préciser)"])
+    col_aff = find_column(filtered_df, ["Affiliation", "Autre affiliation (Veuillez préciser) : "])
+    col_particip = find_column(filtered_df, ["Avez-vous déjà participé à un événement Indaba X Togo ?"])
+    col_mode_formation = find_column(filtered_df, ["Comment voulez-vous participer aux formations ?"])
+    col_what_do = find_column(filtered_df, ["Que voulez-vous faire ?"])
+    col_skills = {
+        "Python": find_column(filtered_df, ["Quel est votre niveau en  [Python]", "Quel est votre niveau en [Python]"]),
+        "Numpy": find_column(filtered_df, ["Quel est votre niveau en  [Numpy]", "Quel est votre niveau en [Numpy]"]),
+        "Pandas": find_column(filtered_df, ["Quel est votre niveau en  [Pandas]", "Quel est votre niveau en [Pandas]"]),
+        "Scikit Learn": find_column(filtered_df, ["Quel est votre niveau en  [Scikit Learn]", "Quel est votre niveau en [Scikit Learn]"]),
+        "Pytorch": find_column(filtered_df, ["Quel est votre niveau en  [Pytorch]", "Quel est votre niveau en [Pytorch]"]),
+        "Deep Learning": find_column(filtered_df, ["Quel est votre niveau en  [Deep Learning]", "Quel est votre niveau en [Deep Learning]"]),
+    }
+
+    # KPIs for decision maker
+    kcols = st.columns(4)
+    with kcols[0]:
+        kpi_card("Inscriptions", f"{len(filtered_df):,}")
+    with kcols[1]:
+        if col_email:
+            uniq_people = filtered_df[col_email].astype(str).str.strip().str.lower().dropna().nunique()
+            kpi_card("Personnes uniques (email)", f"{uniq_people:,}")
+        else:
+            kpi_card("Personnes uniques", "-")
+    with kcols[2]:
+        if col_country and col_country in filtered_df.columns:
+            kpi_card("Pays (distincts)", f"{filtered_df[col_country].astype(str).nunique():,}")
+        else:
+            kpi_card("Pays (distincts)", "-")
+    with kcols[3]:
+        if col_role and col_role in filtered_df.columns:
+            kpi_card("Profils (distincts)", f"{filtered_df[col_role].astype(str).nunique():,}")
+        else:
+            kpi_card("Profils (distincts)", "-")
+
+    # Row 1 charts: Gender, Country
+    dm1 = st.columns(2)
+    if col_gender and col_gender in filtered_df.columns and not filtered_df.empty:
+        gcounts = filtered_df.groupby(col_gender).size().reset_index(name="count").sort_values("count", ascending=False)
+        fig_g = px.pie(gcounts, names=col_gender, values="count", template=get_plotly_template(theme_mode), hole=0.35)
+        with dm1[0]:
+            chart_card("Répartition par genre", fig_g)
+    if col_country and col_country in filtered_df.columns and not filtered_df.empty:
+        ccounts = filtered_df.groupby(col_country).size().reset_index(name="count").sort_values("count", ascending=False).head(15)
+        fig_c = px.bar(ccounts, x=col_country, y="count", template=get_plotly_template(theme_mode))
+        with dm1[1]:
+            chart_card("Top 15 pays de résidence", fig_c)
+
+    # Row 2: Participation history and roles
+    dm2 = st.columns(2)
+    if col_particip and col_particip in filtered_df.columns and not filtered_df.empty:
+        pcounts = filtered_df.groupby(col_particip).size().reset_index(name="count")
+        fig_p = px.bar(pcounts, x=col_particip, y="count", template=get_plotly_template(theme_mode))
+        with dm2[0]:
+            chart_card("A déjà participé ?", fig_p)
+    if col_role and col_role in filtered_df.columns and not filtered_df.empty:
+        rcounts = filtered_df.groupby(col_role).size().reset_index(name="count").sort_values("count", ascending=False).head(15)
+        fig_r = px.bar(rcounts, x=col_role, y="count", template=get_plotly_template(theme_mode))
+        with dm2[1]:
+            chart_card("Professions / Statuts (Top 15)", fig_r)
+
+    # Row 2b: Formations participation mode and intentions
+    dm2b = st.columns(2)
+    if col_mode_formation and col_mode_formation in filtered_df.columns and not filtered_df.empty:
+        mcounts = (
+            filtered_df.groupby(col_mode_formation).size().reset_index(name="count").sort_values("count", ascending=False)
+        )
+        fig_m = px.bar(mcounts, x=col_mode_formation, y="count", template=get_plotly_template(theme_mode))
+        with dm2b[0]:
+            chart_card("Mode de participation aux formations", fig_m)
+    if col_what_do and col_what_do in filtered_df.columns and not filtered_df.empty:
+        wcounts = (
+            filtered_df.groupby(col_what_do).size().reset_index(name="count").sort_values("count", ascending=False).head(15)
+        )
+        fig_w = px.bar(wcounts, x=col_what_do, y="count", template=get_plotly_template(theme_mode))
+        with dm2b[1]:
+            chart_card("Intentions: Que voulez-vous faire ? (Top 15)", fig_w)
+
+    # Row 3: Skills radar-like bars
+    skill_pairs = [(name, col) for name, col in col_skills.items() if col]
+    if skill_pairs:
+        sm = []
+        for name, col in skill_pairs:
+            # Map text levels to ordered scale if needed
+            s = filtered_df[col].astype(str).str.strip().str.lower()
+            order = ["débutant", "intermédiaire", "avancé", "expert"]
+            s = s.where(s.isin(order), s)
+            d = s.value_counts().reindex(order).fillna(0).rename_axis("niveau").reset_index(name="count")
+            d["skill"] = name
+            sm.append(d)
+        if sm:
+            skill_df = pd.concat(sm, ignore_index=True)
+            fig_skill = px.bar(skill_df, x="skill", y="count", color="niveau", barmode="group", template=get_plotly_template(theme_mode))
+            chart_card("Niveaux par compétence", fig_skill)
+
+    st.markdown("</div>", unsafe_allow_html=True)
+
+
+if __name__ == "__main__":
+    main()
+
+