first commit

.dockerignore

@@ -0,0 +1,62 @@
+# Fichiers de développement
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.venv/
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Fichiers de données temporaires
+*.tmp
+*.temp
+
+# Fichiers de logs
+*.log
+
+# Fichiers de configuration locaux
+.env
+.env.local
+
+# Fichiers Git
+.git/
+.gitignore
+
+# Fichiers de documentation
+README.md
+*.md
+
+# Fichiers de tests
+tests/
+test_*.py
+*_test.py
+
+# Fichiers de développement
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Fichiers système
+.DS_Store
+Thumbs.db
+
+# Fichiers de cache
+.cache/
+.pytest_cache/
+
+# Fichiers de données brutes (garder seulement les données transformées)
+data/raw/
+ETL/
+
+# Fichiers Docker
+Dockerfile
+.dockerignore
+docker-compose.yml
+
+# Fichiers de déploiement
+build-and-run.sh
+README_DEPLOYMENT.md 

.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.env
+.venv
+env/
+venv/
+ENV/
+.idea/
+.vscode/
+*.xlsx
+!data/*.xlsx
+
+/component-template/

Dockerfile

@@ -1,21 +1,22 @@
-FROM python:3.9-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    software-properties-common \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+FROM python:3.9-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+COPY streamlit_app/ ./streamlit_app/
+COPY data/ ./data/
+
+RUN pip3 install -r requirements.txt
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "streamlit_app/main.py", "--server.port=8501", "--server.address=0.0.0.0"] 

README.md

@@ -1,19 +1,85 @@
----
-title: Stade U18
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+---
+title: Rugby Analytics - Stade Toulousain U18
+emoji: 🏉
+colorFrom: red
+colorTo: red
+sdk: docker
+app_port: 8501
+tags:
+  - streamlit
+  - rugby
+  - analytics
+  - sports
+pinned: false
+short_description: Application d'analyse des performances rugby
+---
+
+# 🏉 Rugby Analytics - Stade Toulousain U18
+
+Application d'analyse des performances des joueuses U18 du Stade Toulousain Rugby, développée avec Streamlit.
+
+## 📊 Fonctionnalités
+
+- **Analyse individuelle des joueuses** : Visualisation détaillée des performances par joueuse
+- **Comparaison de matchs** : Analyse comparative entre différents matchs
+- **Statistiques avancées** : Métriques de performance avec niveaux de qualité (0-3)
+- **Graphiques interactifs** : Visualisations Plotly pour une meilleure compréhension
+
+## 🎯 Types d'actions analysées
+
+- **DUEL** : Actions de contact et progression
+- **PASSE** : Qualité et précision des passes
+- **JAP** : Jeu au pied et stratégie
+- **PLAQUAGE** : Efficacité défensive
+- **RUCK** : Vitesse et qualité du ruck
+- **RÉCEPTION JAP** : Réception des jeux au pied
+
+## 🚀 Déploiement
+
+Cette application est déployée sur Hugging Face Spaces avec Docker.
+
+### Structure du projet
+
+```
+Rugby/
+├── streamlit_app/
+│   ├── main.py              # Point d'entrée principal
+│   ├── components/          # Composants Streamlit
+│   ├── analytics/           # Logique d'analyse
+│   ├── charts/             # Graphiques et visualisations
+│   └── utils/              # Utilitaires
+├── data/                   # Données transformées
+├── Dockerfile             # Configuration Docker
+└── requirements.txt       # Dépendances Python
+```
+
+## 🛠️ Technologies utilisées
+
+- **Streamlit** : Interface utilisateur
+- **Plotly** : Graphiques interactifs
+- **Pandas** : Manipulation des données
+- **SQLite** : Base de données
+- **Docker** : Conteneurisation
+
+## 📈 Métriques de performance
+
+Chaque action est évaluée sur une échelle de 0 à 3 :
+- **0** : Performance faible (erreur, perte de balle)
+- **1** : Performance moyenne (neutre)
+- **2** : Bonne performance (progression, gain)
+- **3** : Excellente performance (break, domination)
+
+## 🔍 Utilisation
+
+1. Sélectionnez une joueuse dans le carousel
+2. Choisissez un match spécifique
+3. Explorez les statistiques détaillées
+4. Analysez les graphiques de performance
+
+## 📞 Support
+
+Pour toute question ou suggestion, n'hésitez pas à ouvrir une issue sur le repository.
+
+---
+
+*Développé pour l'analyse des performances du Stade Toulousain Rugby U18* 🏉

requirements.txt

@@ -1,3 +1,14 @@
-altair
+fastapi
+uvicorn
 pandas
-streamlit
+matplotlib
+mplsoccer
+python-dotenv
+openpyxl
+streamlit
+plotly
+seaborn
+fuzzywuzzy
+python-levenshtein
+st_image_carousel
+st_circular_kpi

streamlit_app/.streamlit/config.toml

@@ -0,0 +1,18 @@
+[browser]
+showErrorDetails = false
+
+[client]
+showErrorDetails = false
+
+[server]
+runOnSave = true
+
+# Désactiver certains éléments
+[theme]
+primaryColor = "#1f4e79"
+backgroundColor = "#ffffff"
+secondaryBackgroundColor = "#f0f8ff"
+textColor = "#000000"
+
+[ui]
+hideTopBar = true

streamlit_app/analytics/__init__.py

@@ -0,0 +1 @@
+# Fichier vide pour faire du dossier un package Python 

streamlit_app/analytics/scoring.py

@@ -0,0 +1,106 @@
+import pandas as pd
+import streamlit as st
+
+@st.cache_data
+def calculate_player_scoring(df):
+    """
+    Calcule tous les niveaux de scoring des joueuses de rugby
+    
+    Args:
+        df: DataFrame avec les données brutes
+        
+    Returns:
+        dict: Contient tous les niveaux d'agrégation
+            - 'by_action': Scores détaillés par (match, joueuse, action)
+            - 'by_player_match': Scores par (match, joueuse) 
+            - 'by_match': Scores moyens par match
+            - 'global_average': Moyenne générale
+    """
+    
+    # Configuration
+    actions_interessees = [
+        "DUEL",
+        "PASSE",
+        "PLAQUAGE", 
+        "RUCK",
+        "JAP",
+        "RECEPTION JAP"
+    ]
+    
+    facteur_pond = 100/3
+    
+    # 1. Calcul du score pondéré par (match, joueuse, action)
+    df_grouped = df.groupby(
+        ["Match", "Prenom", "Nom", "Action"]
+    ).apply(
+        lambda g: pd.Series({
+            "score_pondere": (g["Niveau"] * g["Nb_actions"]).sum() / g["Nb_actions"].sum(),
+            "nb_total_actions": g["Nb_actions"].sum()
+        })
+    ).reset_index()
+
+    # Filtrage sur les actions intéressées 
+    score_actions = df_grouped[df_grouped["Action"].str.upper().isin(actions_interessees)]
+
+    # 2. Calcul de la note moyenne par (match, joueuse)
+    score_actions["note_match_joueuse"] = score_actions.groupby(
+        ["Match", "Prenom", "Nom"]
+    )["score_pondere"].transform("mean") * facteur_pond
+
+    score_match_joueuse = score_actions.drop_duplicates(
+        subset=["Match", "Prenom", "Nom"]
+    )[["Match", "Prenom", "Nom", "note_match_joueuse"]]
+
+    # 3. Calcul de la note moyenne par match
+    score_match = score_match_joueuse.groupby(["Match"]).apply(
+        lambda g: pd.Series({
+            "note_match_joueuse": g["note_match_joueuse"].mean()
+        })
+    ).reset_index()
+    
+    # 4. Métrique globale
+    global_average = round(score_match["note_match_joueuse"].mean(), 2)
+
+    return {
+        'by_action': score_actions,
+        'by_player_match': score_match_joueuse,
+        'by_match': score_match, 
+        'global_average': global_average
+    }
+
+@st.cache_data
+def get_global_score(df):
+    """
+    Retourne uniquement la métrique globale (pour usage immédiat)
+    """
+    scoring_data = calculate_player_scoring(df)
+    return scoring_data['global_average']
+
+@st.cache_data  
+def get_top_players(df, n_players=10):
+    """
+    Retourne le top N des joueuses par note moyenne
+    """
+    scoring_data = calculate_player_scoring(df)
+    
+    top_players = scoring_data['by_player_match'].groupby(['Prenom', 'Nom']).agg({
+        'note_match_joueuse': 'mean'
+    }).reset_index().sort_values('note_match_joueuse', ascending=False).head(n_players)
+    
+    return top_players
+
+@st.cache_data
+def get_match_scores(df):
+    """
+    Retourne les scores par match (pour charts futurs)
+    """
+    scoring_data = calculate_player_scoring(df)
+    return scoring_data['by_match']
+
+@st.cache_data  
+def get_player_match_scores(df):
+    """
+    Retourne les scores par joueuse-match (pour charts futurs)
+    """
+    scoring_data = calculate_player_scoring(df)
+    return scoring_data['by_player_match'] 

streamlit_app/assets/style.css

@@ -0,0 +1,282 @@
+/* ===============================
+   STREAMLIT UI CLEANUP
+   =============================== */
+
+/* Supprimer la barre supérieure complète */
+header[data-testid="stHeader"] {
+    display: none;
+}
+
+/* Supprimer le footer */
+footer {
+    display: none;
+}
+
+/* Supprimer le menu hamburger */
+#MainMenu {
+    display: none;
+}
+
+/* ===============================
+   PADDING ET SPACING PERSONNALISÉS
+   =============================== */
+
+/* Votre padding spécifique - MODIFIABLE ICI */
+.st-emotion-cache-1jicfl2 {
+    width: 100%;
+    padding: 2rem 1rem 2rem !important;  /* Réduire de 6rem à 2rem */
+    min-width: auto;
+    max-width: initial;
+}
+
+/* Réduire l'espacement général en haut */
+.stAppViewContainer .main .block-container {
+    padding-top: 1rem;
+    padding-bottom: 1rem;
+}
+
+/* Espacement pour le contenu principal */
+.main .block-container {
+    padding: 1rem 2rem;
+}
+
+/* ===============================
+   STYLES POUR L'APPLICATION RUGBY
+   =============================== */
+
+/* Titre principal */
+.main-header {
+    font-size: 2.5rem;
+    color: #CC0C13;
+    text-align: center;
+    margin-bottom: 2rem;
+    /* border-bottom: 3px solid #000000; */
+    padding-bottom: 3rem;
+    font-weight: bold;
+}
+
+/* Logo et header combinés */
+.rugby-header {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 1rem;
+    margin-bottom: 2rem;
+}
+
+.rugby-header img {
+    height: 60px;
+    width: auto;
+}
+
+/* Cartes métriques */
+.metric-card {
+    background: linear-gradient(135deg, #f0f8ff 0%, #e6f3ff 100%);
+    padding: 1.5rem;
+    border-radius: 15px;
+    border-left: 5px solid #1f4e79;
+    margin: 0.5rem 0;
+    box-shadow: 0 2px 10px rgba(31, 78, 121, 0.1);
+    transition: transform 0.2s ease;
+}
+
+.metric-card:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 20px rgba(31, 78, 121, 0.15);
+}
+
+/* ===============================
+   SIDEBAR PERSONNALISÉE
+   =============================== */
+
+/* Style pour la sidebar */
+.css-1d391kg {
+    background: linear-gradient(180deg, #f8f9fa 0%, #e9ecef 100%);
+}
+
+/* Titres dans la sidebar */
+.css-1d391kg h1, .css-1d391kg h2, .css-1d391kg h3 {
+    color: #1f4e79;
+    font-weight: bold;
+}
+
+/* ===============================
+   COMPOSANTS STREAMLIT
+   =============================== */
+
+/* Style pour les selectbox */
+.stSelectbox > div > div {
+    border: 2px solid #1f4e79;
+    border-radius: 10px;
+}
+
+/* Style pour les métriques Streamlit */
+[data-testid="metric-container"] {
+    background: white;
+    border: 1px solid #e0e0e0;
+    padding: 1rem;
+    border-radius: 10px;
+    box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+}
+
+/* Tables et dataframes */
+.stDataFrame {
+    border: none;
+}
+
+.stDataFrame > div {
+    border-radius: 10px;
+    overflow: hidden;
+}
+
+/* ===============================
+   BOUTONS PERSONNALISÉS
+   =============================== */
+
+/* Style par défaut pour tous les boutons (transparent) */
+.stButton > button {
+    background: transparent !important;
+    color: black !important;
+    border: none !important;
+    border-radius: 0 !important;
+    padding: 0.5rem 1rem !important;
+    font-weight: normal !important;
+    transition: all 0.3s ease !important;
+    box-shadow: none !important;
+}
+
+.stButton > button:hover {
+    background: rgba(40, 40, 40, 0.15) !important;
+    border-radius: 10px !important;
+    transform: translateX(5px) !important;
+}
+
+/* Style pour le bouton actif (page courante) - seulement quand il est focus/active */
+.stButton > button:focus,
+.stButton > button:active {
+    background: linear-gradient(135deg, #000000 0%, #252525 100%) !important;
+    color: white !important;
+    border: none !important;
+    border-radius: 10px !important;
+    padding: 0.5rem 1.5rem !important;
+    font-weight: bold !important;
+    box-shadow: 0 2px 8px rgba(204, 12, 19, 0.3) !important;
+}
+
+/* Supprimer le style rouge par défaut pour tous les boutons */
+.stButton > button {
+    background: transparent !important;
+    color: black !important;
+}
+
+/* Style spécial pour le bouton de la page courante via session state */
+.stButton > button[data-active="true"] {
+    background: linear-gradient(135deg, #000000 0%, #252525 100%) !important;
+    color: white !important;
+    border-radius: 10px !important;
+    font-weight: bold !important;
+    box-shadow: 0 2px 8px rgba(204, 12, 19, 0.3) !important;
+}
+
+/* ===============================
+   RESPONSIVE DESIGN
+   =============================== */
+
+@media (max-width: 768px) {
+    .main-header {
+        font-size: 2rem;
+    }
+    
+    .st-emotion-cache-1jicfl2 {
+        padding: 1rem 0.5rem 1rem !important;
+    }
+    
+    .rugby-header {
+        flex-direction: column;
+    }
+}
+
+/* ===============================
+   CLASSES UTILITAIRES
+   =============================== */
+
+.text-center {
+    text-align: center;
+}
+
+.text-rugby {
+    color: #1f4e79;
+}
+
+.bg-rugby {
+    background-color: #f0f8ff;
+}
+
+.border-rugby {
+    border: 2px solid #1f4e79;
+}
+
+/* Style personnalisé pour le titre avec logo */
+.rugby-header-custom {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 2rem;
+    padding: 1rem 0;
+    position: relative;
+}
+
+.rugby-header-custom .title-left {
+    flex: 1;
+    text-align: right;
+    padding-right: 4rem;
+}
+
+.rugby-header-custom .logo-center {
+    position: absolute;
+    left: 50%;
+    transform: translateX(-50%);
+    z-index: 1;
+}
+
+.rugby-header-custom .title-right {
+    flex: 1;
+    text-align: left;
+    padding-left: 2rem;
+}
+
+.title-left, .title-right {
+    font-size: 2.5rem;
+    color: #000000;
+    font-weight: bold;
+    text-transform: uppercase;
+}
+
+.logo-center {
+    height: 80px;
+    width: auto;
+    filter: drop-shadow(0 2px 4px rgba(0,0,0,0.1));
+}
+
+/* Responsive pour mobile */
+@media (max-width: 768px) {
+    .rugby-header-custom {
+        flex-direction: column;
+        gap: 1rem;
+        position: static;
+    }
+    
+    .rugby-header-custom .title-left,
+    .rugby-header-custom .title-right {
+        flex: none;
+        text-align: center;
+        padding: 0;
+        font-size: 1.8rem;
+    }
+    
+    .rugby-header-custom .logo-center {
+        position: static;
+        transform: none;
+        height: 60px;
+    }
+}

streamlit_app/charts/__init__.py

@@ -0,0 +1,36 @@
+"""Module de graphiques pour l'analyse rugby"""
+
+from .player_charts import (
+    create_top_players_chart,
+    create_player_profile_chart,
+    create_player_evolution_chart,
+    create_player_comparison_radar,
+    create_player_actions_pie,
+    create_player_level_distribution,
+    create_performance_heatmap,         # ← NOUVEAU
+    create_team_activity_heatmap,        # ← NOUVEAU
+    create_performance_comparison_chart,  # ← NOUVEAU
+    create_performance_violin_chart
+)
+
+from .match_charts import (
+    create_matches_ranking_chart,
+    create_match_comparison_chart,
+    create_matches_activity_chart,
+    create_actions_distribution_chart
+)
+
+__all__ = [
+    'create_top_players_chart',
+    'create_player_profile_chart', 
+    'create_player_evolution_chart',
+    'create_player_comparison_radar',
+    'create_player_actions_pie',
+    'create_player_level_distribution',
+    'create_performance_heatmap',       # ← NOUVEAU
+    'create_team_activity_heatmap',     # ← NOUVEAU
+    'create_matches_ranking_chart',
+    'create_match_comparison_chart',
+    'create_matches_activity_chart',
+    'create_actions_distribution_chart'
+]

streamlit_app/charts/config.py

@@ -0,0 +1,52 @@
+"""Configuration et constantes pour les graphiques"""
+
+# Couleurs Stade Toulousain
+COLORS = {
+    'primary': '#CC0C13',      # Rouge principal
+    'secondary': '#000000',    # Noir
+    'white': '#FFFFFF',        # Blanc
+    'light_red': 'rgba(204, 12, 19, 0.2)',
+    'gray': '#666666'
+}
+
+# Palette pour dégradés STANDARD (noir -> rouge)
+COLORSCALE = [[0, COLORS['secondary']], [1, COLORS['primary']]]
+
+# Palette pour dégradés HEATMAP (blanc -> rouge)
+COLORSCALE_HEATMAP = [[0, COLORS['white']], [1, COLORS['primary']]]
+
+# Palette inversée (rouge -> blanc) pour certains cas
+COLORSCALE_REVERSED = [[0, COLORS['primary']], [1, COLORS['white']]]
+
+# Couleurs discrètes
+DISCRETE_COLORS = [COLORS['primary'], COLORS['secondary'], COLORS['white'], COLORS['gray']]
+
+# Style de base réutilisable
+BASE_LAYOUT = {
+    'plot_bgcolor': 'rgba(248, 249, 250, 0.5)',
+    'paper_bgcolor': 'rgba(0,0,0,0)',
+    'font': dict(family='Arial', color=COLORS['secondary'], size=11)
+}
+
+def remove_colorscale_legend(fig):
+    """Fonction utilitaire pour enlever la colorscale de n'importe quel graphique"""
+    fig.update_traces(showscale=False)
+    return fig
+
+def apply_stade_style(fig, title=None, remove_colorbar=True):
+    """Applique le style Stade Toulousain avec option pour enlever la colorbar"""
+    
+    if remove_colorbar:
+        fig.update_traces(showscale=False)
+    
+    fig.update_layout(
+        **BASE_LAYOUT,
+        title={
+            'text': title,
+            'font': dict(color=COLORS['primary'], size=16, family='Arial Black'),
+            'x': 0.5,
+            'xanchor': 'center'
+        } if title else None
+    )
+    
+    return fig 

streamlit_app/charts/match_charts.py

@@ -0,0 +1,124 @@
+import pandas as pd
+import plotly.express as px
+from .config import COLORS, COLORSCALE, BASE_LAYOUT
+
+def create_matches_activity_chart(df):
+    """Graphique d'activité par match"""
+    
+    match_stats = df.groupby('Match').agg({
+        'Nb_actions': 'sum',
+        'Nom': 'nunique'
+    }).reset_index()
+    
+    match_stats.columns = ['Match', 'Total_actions', 'Nb_joueuses']
+    match_stats = match_stats.sort_values('Total_actions', ascending=True)
+    
+    fig = px.bar(
+        match_stats,
+        x='Total_actions',
+        y='Match',
+        orientation='h',
+        title="Activité totale par match",
+        color='Total_actions',
+        color_continuous_scale=COLORSCALE
+    )
+    
+    fig.update_layout(
+        **BASE_LAYOUT,
+        height=500,
+        coloraxis_showscale=False,
+        yaxis={
+            'categoryorder': 'total ascending',
+            'title': '',
+            'tickfont': dict(color=COLORS['secondary'], size=11)
+        },
+        xaxis={
+            'title': 'Nombre total d\'actions',
+            'tickfont': dict(color=COLORS['secondary'], size=11)
+        },
+        title={
+            'font': dict(color=COLORS['secondary'], size=16, family='Arial Black'),
+            'x': 0.5,
+            'xanchor': 'center'
+        }
+    )
+    
+    return fig
+
+def create_actions_distribution_chart(df):
+    """Distribution des types d'actions avec dégradé basé sur l'importance"""
+    
+    action_stats = df.groupby('Action')['Nb_actions'].sum().reset_index()
+    
+    # Calculer le pourcentage pour chaque action
+    total_actions = action_stats['Nb_actions'].sum()
+    action_stats['Pourcentage'] = (action_stats['Nb_actions'] / total_actions) * 100
+    
+    # Trier par importance (pourcentage décroissant)
+    action_stats = action_stats.sort_values('Pourcentage', ascending=False)
+    
+    # Créer un dégradé de couleurs basé sur l'importance
+    n_actions = len(action_stats)
+    colors = []
+    for i in range(n_actions):
+        # Dégradé de noir (moins important) à rouge (plus important)
+        ratio = i / (n_actions - 1) if n_actions > 1 else 0
+        color = f"rgba({204 * ratio + 0 * (1-ratio):.0f}, {12 * ratio + 0 * (1-ratio):.0f}, {19 * ratio + 0 * (1-ratio):.0f}, 1)"
+        colors.append(color)
+    
+    fig = px.pie(
+        action_stats,
+        values='Nb_actions',
+        names='Action',
+        title="Répartition des types d'actions",
+        color_discrete_sequence=colors
+    )
+    
+    fig.update_layout(
+        **BASE_LAYOUT,
+        title={
+            'font': dict(color=COLORS['secondary'], size=16, family='Arial Black'),
+            'x': 0.4,
+            'xanchor': 'center'
+        }
+    )
+    
+    # Ajouter des bordures blanches entre chaque part
+    fig.update_traces(
+        marker=dict(line=dict(color='white', width=2))
+    )
+    
+    return fig
+
+def create_matches_ranking_chart(df):
+    """Même fonction que create_matches_activity_chart pour compatibilité"""
+    return create_matches_activity_chart(df)
+
+def create_match_comparison_chart(df, match1, match2):
+    """Comparaison entre deux matchs - simple"""
+    
+    comparison_data = []
+    
+    for match in [match1, match2]:
+        match_data = df[df['Match'] == match]
+        stats = {
+            'Match': match,
+            'Total_actions': match_data['Nb_actions'].sum(),
+            'Nb_joueuses': match_data['Nom'].nunique()
+        }
+        comparison_data.append(stats)
+    
+    df_comparison = pd.DataFrame(comparison_data)
+    
+    fig = px.bar(
+        df_comparison,
+        x='Match',
+        y='Total_actions',
+        title=f"Comparaison {match1} vs {match2}",
+        color='Match',
+        color_discrete_sequence=[COLORS['primary'], COLORS['secondary']]
+    )
+    
+    fig.update_layout(**BASE_LAYOUT)
+    
+    return fig

streamlit_app/charts/player_charts.py

@@ -0,0 +1,519 @@
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from .config import COLORS, COLORSCALE, COLORSCALE_HEATMAP, BASE_LAYOUT, apply_stade_style
+
+def create_top_players_chart(df, n_players=10):
+    """Graphique complet du top des joueuses basé sur les notes moyennes"""
+    
+    from analytics.scoring import calculate_player_scoring
+    
+    # Calculer les notes moyennes par joueuse
+    scoring_data = calculate_player_scoring(df)['by_player_match']
+    top_players = scoring_data.groupby(['Prenom', 'Nom'])['note_match_joueuse'].mean().reset_index()
+    top_players['Nom_complet'] = top_players['Prenom'] + ' ' + top_players['Nom']
+    top_players = top_players.nlargest(n_players, 'note_match_joueuse')
+
+    # Créer le graphique AVEC son style
+    fig = px.bar(
+        top_players,
+        x='note_match_joueuse',
+        y='Nom_complet',
+        orientation='h',
+        title=f"Top {n_players} des joueuses par note moyenne",
+        color='note_match_joueuse',
+        color_continuous_scale=COLORSCALE
+    )
+    
+    # Style intégré directement
+    fig.update_layout(
+        **BASE_LAYOUT,
+        height=400,
+        coloraxis_showscale=False,
+        yaxis={
+            'categoryorder': 'total ascending',
+            'title': '',
+            'tickfont': dict(color=COLORS['secondary'], size=12)
+        },
+        xaxis={
+            'title': 'Note moyenne',
+            'tickfont': dict(color=COLORS['secondary'], size=11)
+        },
+        title={
+            'font': dict(color=COLORS['secondary'], size=16, family='Arial Black'),
+            'x': 0.5,
+            'xanchor': 'center'
+        },
+        xaxis_range=[top_players['note_match_joueuse'].min()-1, top_players['note_match_joueuse'].max()+1]
+    )
+    
+    # Axes
+    fig.update_xaxes(
+        showgrid=True,
+        gridcolor=COLORS['light_red'],
+        zeroline=True,
+        zerolinecolor=COLORS['primary']
+    )
+    
+    fig.update_yaxes(showgrid=False)
+    fig.update_xaxes(showgrid=False)
+    
+    return fig
+
+def create_player_actions_pie(df, player_name):
+    """Graphique en camembert des actions d'une joueuse"""
+    
+    player_data = df[df['Nom'].str.contains(player_name, case=False)]
+    if player_data.empty:
+        return None
+    
+    action_breakdown = player_data.groupby('Action')['Nb_actions'].sum().reset_index()
+    
+    fig = px.pie(
+        action_breakdown,
+        values='Nb_actions',
+        names='Action',
+        title=f"Actions de {player_name}",
+        color_discrete_sequence=[COLORS['primary'], COLORS['secondary'], COLORS['gray']]
+    )
+    
+    # Style spécifique au pie chart
+    fig.update_layout(
+        **BASE_LAYOUT,
+        title={
+            'font': dict(color=COLORS['secondary'], size=16, family='Arial Black'),
+            'x': 0.5,
+            'xanchor': 'center'
+        }
+    )
+    
+    fig.update_traces(
+        textfont_size=12,
+        textfont_color='white',
+        marker=dict(line=dict(color='white', width=2))
+    )
+    
+    return fig
+
+def create_player_level_distribution(df, player_name):
+    """Distribution des niveaux pour une joueuse"""
+    
+    player_data = df[df['Nom'].str.contains(player_name, case=False)]
+    if player_data.empty:
+        return None
+    
+    level_data = player_data.groupby('Niveau')['Nb_actions'].sum().reset_index()
+    level_data['Niveau_label'] = level_data['Niveau'].map({
+        0: '0', 1: '1', 2: '2', 3: '3'
+    })
+    
+    fig = px.bar(
+        level_data,
+        x='Niveau_label',
+        y='Nb_actions',
+        title=f"Niveau de performance - {player_name}",
+        color='Niveau',
+        color_continuous_scale=COLORSCALE
+    )
+    
+    fig.update_layout(
+        **BASE_LAYOUT,
+        xaxis={'title': 'Niveau de performance'},
+        yaxis={'title': 'Nombre d\'actions'},
+        title={
+            'font': dict(color=COLORS['secondary'], size=16, family='Arial Black'),
+            'x': 0.5,
+            'xanchor': 'center'
+        }
+    )
+    
+    return fig
+
+def create_player_profile_chart(df, player_name):
+    """Graphique de profil d'une joueuse - alias pour create_player_actions_pie"""
+    return create_player_actions_pie(df, player_name)
+
+def create_player_evolution_chart(df, player_name):
+    """Évolution d'une joueuse par match"""
+    
+    player_data = df[df['Nom'].str.contains(player_name, case=False)]
+    if player_data.empty:
+        return None
+    
+    evolution = player_data.groupby('Match')['Nb_actions'].sum().reset_index()
+    
+    fig = px.line(
+        evolution,
+        x='Match',
+        y='Nb_actions',
+        title=f"Évolution de {player_name}",
+        markers=True
+    )
+    
+    fig.update_traces(
+        line_color=COLORS['primary'],
+        marker_color=COLORS['primary'],
+        marker_size=8
+    )
+    
+    fig.update_layout(
+        **BASE_LAYOUT,
+        title={
+            'font': dict(color=COLORS['primary'], size=16, family='Arial Black'),
+            'x': 0.5,
+            'xanchor': 'center'
+        }
+    )
+    
+    return fig
+
+def create_player_comparison_radar(df, players_list):
+    """Graphique radar simple pour comparer des joueuses"""
+    
+    # Version simplifiée pour éviter les erreurs
+    if not players_list or len(players_list) == 0:
+        return None
+    
+    # Pour l'instant, retournons un graphique simple
+    player = players_list[0]
+    player_data = df[df['Nom'].str.contains(player, case=False)]
+    
+    if player_data.empty:
+        return None
+    
+    action_breakdown = player_data.groupby('Action')['Nb_actions'].sum().reset_index()
+    
+    fig = px.bar(
+        action_breakdown,
+        x='Action',
+        y='Nb_actions',
+        title=f"Profil de {player}",
+        color='Nb_actions',
+        color_continuous_scale=COLORSCALE
+    )
+    
+    fig.update_layout(**BASE_LAYOUT)
+    
+    return fig
+
+def create_performance_heatmap(df, n_players=15):
+    """Heatmap des performances - BLANC -> ROUGE uniquement"""
+    
+    # Préparer les données pour la heatmap
+    heatmap_data = df.groupby(['Nom', 'Match'])['Nb_actions'].sum().reset_index()
+    heatmap_pivot = heatmap_data.pivot(index='Nom', columns='Match', values='Nb_actions').fillna(0)
+    
+    # Limiter aux meilleures joueuses pour la lisibilité
+    top_players = df.groupby('Nom')['Nb_actions'].sum().nlargest(n_players).index
+    heatmap_pivot = heatmap_pivot.loc[top_players]
+    
+    # Créer la heatmap avec BLANC -> ROUGE ← CHANGEMENT ICI
+    fig = px.imshow(
+        heatmap_pivot,
+        aspect='auto',
+        title=f"Intensité d'activité - Top {n_players}",
+        color_continuous_scale=COLORSCALE_HEATMAP,  # ← BLANC -> ROUGE
+        labels={'color': 'Nb actions'}
+    )
+    
+    # ENLEVER LA COLORSCALE LEGEND
+    fig.update_traces(showscale=False)
+    
+    # Appliquer le style Stade Toulousain
+    fig.update_layout(
+        **BASE_LAYOUT,
+        height=600,
+        coloraxis_showscale=False,
+        title={
+            'font': dict(color=COLORS['secondary'], size=16, family='Arial Black'),
+            'x': 0.5,
+            'xanchor': 'center'
+        },
+        # Style des axes
+        xaxis={
+            'title': 'Matchs',
+            'tickfont': dict(color=COLORS['secondary'], size=10),
+            'tickangle': 45  # Incliner les noms de matchs pour la lisibilité
+        },
+        yaxis={
+            'title': 'Joueuses',
+            'tickfont': dict(color=COLORS['secondary'], size=10)
+        }
+    )
+    
+    # Personnaliser le hover
+    fig.update_traces(
+        hoverlabel=dict(
+            bgcolor=COLORS['primary'],
+            font_color='white',
+            font_size=12
+        )
+    )
+    
+    return fig
+
+def create_team_activity_heatmap(df):
+    """Heatmap par action/niveau - BLANC -> ROUGE uniquement"""
+    
+    # Préparer les données : Actions vs Niveaux
+    heatmap_data = df.groupby(['Action', 'Niveau'])['Nb_actions'].sum().reset_index()
+    heatmap_pivot = heatmap_data.pivot(index='Action', columns='Niveau', values='Nb_actions').fillna(0)
+    
+    # Renommer les colonnes pour plus de clarté
+    level_labels = {0: '0', 1: '1', 2: '2', 3: '3'}
+    heatmap_pivot.columns = [level_labels.get(col, f'Niveau {col}') for col in heatmap_pivot.columns]
+    
+    fig = px.imshow(
+        heatmap_pivot,
+        aspect='auto',
+        title="Intensité par action et niveau",
+        color_continuous_scale=COLORSCALE_HEATMAP
+    )
+    
+    # Style Stade Toulousain
+    fig.update_traces(showscale=False)
+    
+    fig.update_layout(
+        **BASE_LAYOUT,
+        height=400,
+        coloraxis_showscale=False,
+        title={
+            'font': dict(color=COLORS['secondary'], size=16, family='Arial Black'),
+            'x': 0.6,
+            'xanchor': 'center'
+        },
+        xaxis={
+            'title': '',
+            'tickfont': dict(color=COLORS['secondary'], size=11)
+        },
+        yaxis={
+            'title': '',
+            'tickfont': dict(color=COLORS['secondary'], size=11)
+        }
+    )
+    
+    fig.update_traces(
+        hoverlabel=dict(
+            bgcolor=COLORS['primary'],
+            font_color='white',
+            font_size=12
+        )
+    )
+    
+    return fig
+
+def create_performance_heatmap_advanced(df, n_players=15, match_filter=None, colorscale_type='stade'):
+    """Heatmap avancée avec options"""
+    
+    # Filtrer par matchs si spécifié
+    if match_filter:
+        df_filtered = df[df['Match'].isin(match_filter)]
+    else:
+        df_filtered = df
+    
+    # Préparer les données
+    heatmap_data = df_filtered.groupby(['Nom', 'Match'])['Nb_actions'].sum().reset_index()
+    heatmap_pivot = heatmap_data.pivot(index='Nom', columns='Match', values='Nb_actions').fillna(0)
+    
+    # Top joueuses
+    top_players = df_filtered.groupby('Nom')['Nb_actions'].sum().nlargest(n_players).index
+    heatmap_pivot = heatmap_pivot.loc[top_players]
+    
+    # Choisir la colorscale
+    if colorscale_type == 'stade':
+        colorscale = COLORSCALE
+    elif colorscale_type == 'reversed':
+        colorscale = [[0, COLORS['primary']], [1, COLORS['secondary']]]
+    else:
+        colorscale = COLORSCALE
+    
+    fig = px.imshow(
+        heatmap_pivot,
+        aspect='auto',
+        title=f"Heatmap personnalisée - {len(heatmap_pivot.index)} joueuses",
+        color_continuous_scale=colorscale
+    )
+    
+    # Style
+    fig.update_traces(showscale=False)
+    
+    fig.update_layout(
+        **BASE_LAYOUT,
+        coloraxis_showscale=False,
+        height=500,
+        title={
+            'font': dict(color=COLORS['secondary'], size=16, family='Arial Black'),
+            'x': 0.5,
+            'xanchor': 'center'
+        }
+    )
+    
+    return fig
+
+def create_performance_comparison_chart(df):
+    """Graphique combiné : barres (notes moyennes par action) + ligne (nombre d'actions) + points (meilleures/moins bonnes notes)"""
+    
+    from analytics.scoring import calculate_player_scoring
+    
+    # Calculer les données de scoring
+    scoring_data = calculate_player_scoring(df)['by_action']
+    avg_scores = scoring_data.groupby(['Match', 'Action'])['note_match_joueuse'].mean().reset_index()
+    
+    # Calculer la plage dynamique : min note globale -10 à max note globale +10
+    min_note = scoring_data['note_match_joueuse'].min()
+    max_note = scoring_data['note_match_joueuse'].max()
+    y_range = [50, 77]
+    
+    # Créer un graphique avec deux axes Y
+    fig = go.Figure()
+    
+    # Ajouter le graphique en barres sur l'axe Y gauche avec dégradé de couleurs
+    actions = avg_scores['Action'].unique()
+    n_actions = len(actions)
+    
+    for i, action in enumerate(actions):
+        action_data = avg_scores[avg_scores['Action'] == action]
+        # Calculer la couleur avec un dégradé de secondary (noir) à primary (rouge)
+        ratio = i / (n_actions - 1) if n_actions > 1 else 0
+        color = f"rgba({204 * ratio + 0 * (1-ratio):.0f}, {12 * ratio + 0 * (1-ratio):.0f}, {19 * ratio + 0 * (1-ratio):.0f}, 1)"
+        
+        fig.add_trace(
+            go.Bar(
+                x=action_data['Match'],
+                y=action_data['note_match_joueuse'],
+                name=action,
+                yaxis='y',
+                marker_color=color
+            )
+        )
+    
+    # Ajouter les meilleures notes par match sur l'axe Y droit
+    best_scores_with_names = scoring_data.loc[scoring_data.groupby(['Match'])['note_match_joueuse'].idxmax()][['Match', 'Prenom', 'Nom', 'note_match_joueuse']].reset_index(drop=True)
+    fig.add_trace(
+        go.Scatter(
+            x=best_scores_with_names['Match'],
+            y=best_scores_with_names['note_match_joueuse'],
+            name='Meilleure note par match',
+            yaxis='y2',
+            line=dict(width=0),
+            marker=dict(color='#2E8B57', size=12),
+            mode='markers+text',
+            text=best_scores_with_names['Prenom'] + ' ' + best_scores_with_names['Nom'],
+            textposition='top center',
+            textfont=dict(size=11, color='#2E8B57')
+        )
+    )
+    
+    # Configuration des axes
+    fig.update_layout(
+        legend=dict(
+            orientation="h",
+            yanchor="top",
+            y=-0.2,
+            xanchor="center",
+            x=0.5
+        ),
+        yaxis=dict(
+            title="Note moyenne par action",
+            range=y_range,
+            side='left'
+        ),
+        yaxis2=dict(
+            title="Meilleure note par match",
+            range=[50, 110],
+            side='right',
+            overlaying='y'
+        ),
+        barmode='group',
+        **BASE_LAYOUT
+    )
+    
+    return fig
+
+def create_performance_violin_chart(df):
+    """Graphique violin plot pour la distribution des notes par match"""
+    
+    from analytics.scoring import calculate_player_scoring
+    
+    # Calculer les données de scoring
+    scoring_data = calculate_player_scoring(df)['by_action']
+    
+        # Créer le violin plot
+    fig = px.violin(
+        scoring_data, 
+        x="Match", 
+        y="note_match_joueuse", 
+        box=True, 
+        color_discrete_sequence=[COLORS['primary'], COLORS['secondary'], COLORS['gray']]
+    )
+    
+    # Appliquer le style Stade Toulousain
+    fig.update_layout(
+        **BASE_LAYOUT,
+        height=500,
+        xaxis={
+            'title': 'Matchs',
+            'tickfont': dict(color=COLORS['secondary'], size=11),
+            'tickangle': 45
+        },
+        yaxis={
+            'title': 'Notes',
+            'tickfont': dict(color=COLORS['secondary'], size=11)
+        },
+    )
+    
+    # Personnaliser le hover, la boîte et la largeur des violins
+    fig.update_traces(
+        hoverlabel=dict(
+            bgcolor=COLORS['primary'],
+            font_color='white',
+            font_size=12
+        ),
+        box=dict(
+            fillcolor=COLORS['primary'],  # Couleur de remplissage de la boîte
+            # line=dict(color=COLORS['primary'])  # Couleur de la bordure de la boîte
+        ),
+        line=dict(
+            color=COLORS['secondary']
+        ),
+        width=1  # Contrôler la largeur des violins (0.1 à 1.0)
+    )
+    
+    # Ajouter les meilleures joueuses par match
+    best_scores_with_names = scoring_data.loc[scoring_data.groupby(['Match'])['note_match_joueuse'].idxmax()][['Match', 'Prenom', 'Nom', 'note_match_joueuse']].reset_index(drop=True)
+    
+    # Ajouter des points pour les meilleures notes
+    fig.add_trace(
+        go.Scatter(
+            x=best_scores_with_names['Match'],
+            y=best_scores_with_names['note_match_joueuse'],
+            mode='markers',
+            marker=dict(
+                color='#ffffff',  # Blanc pour les meilleures notes
+                size=10,
+                line=dict(color='#384454', width=2)  # Bordure noire pour plus de contraste
+            ),
+            name='Meilleure joueuse par match',
+            showlegend=False
+        )
+    )
+    
+    # Ajouter les noms des meilleures joueuses avec des annotations
+    for _, row in best_scores_with_names.iterrows():
+        fig.add_annotation(
+            x=row['Match'],
+            y=row['note_match_joueuse'],
+            text=row['Nom'],
+            showarrow=False,
+            yshift=30,  # Déplacer le texte plus haut
+            font=dict(
+                size=12,
+                color='#000000',
+                family='Arial Black'
+            ),
+            bgcolor='rgba(255, 255, 255, 0.8)',  # Fond blanc semi-transparent
+            # bordercolor='#000000',
+            borderwidth=1
+        )
+    
+    return fig

streamlit_app/components/dashboard.py

@@ -0,0 +1,96 @@
+import streamlit as st
+import pandas as pd
+import plotly.express as px 
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from charts import (
+    create_top_players_chart, 
+    create_actions_distribution_chart, 
+    create_matches_activity_chart,
+    create_performance_heatmap,        # ← NOUVEAU
+    create_team_activity_heatmap,       # ← NOUVEAU
+    create_performance_comparison_chart,  # ← NOUVEAU
+    create_performance_violin_chart
+)
+from analytics.scoring import *
+
+def show_dashboard(df):
+    """Affiche le tableau de bord principal"""
+
+    st.divider()
+    
+    # Métriques générales
+
+    metrics_config = [
+        {
+            "title": "Moy. note match",
+            "value": get_global_score(df),
+            "format": "{:,.2f}"
+        },
+        {
+            "title": "Total actions",
+            "value": df['Nb_actions'].sum(),
+            "format": "{:,.0f}"
+        },
+        {
+            "title": "Joueuses actives", 
+            "value": df['Nom'].nunique(),
+            "format": "{}"
+        },
+        {
+            "title": "Matchs analysés",
+            "value": df['Match'].nunique(), 
+            "format": "{}"
+        },
+        {
+            "title": "Moy. actions/joueuse",
+            "value": df.groupby(['Prenom', 'Nom'])['Nb_actions'].sum().mean(),
+            "format": "{:.0f}"
+        }
+    ]
+    
+    # Création des colonnes dynamiquement
+    cols = st.columns(len(metrics_config))
+    
+    # Affichage des métriques avec une boucle
+    for i, metric in enumerate(metrics_config):
+        with cols[i]:
+            formatted_value = metric["format"].format(metric["value"])
+            st.metric(metric["title"], formatted_value)
+
+    
+    st.divider()
+    
+
+
+    fig = create_performance_violin_chart(df)
+    # fig = create_performance_comparison_chart(df)
+    st.plotly_chart(fig, use_container_width=True)
+
+    # Graphiques principaux
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        fig = create_top_players_chart(df, n_players=15)
+        st.plotly_chart(fig, use_container_width=True)
+    
+    with col2:
+        fig = create_actions_distribution_chart(df)
+        st.plotly_chart(fig, use_container_width=True)
+        
+    # Graphiques pleine largeur
+    # col1, col2 = st.columns(2)
+    
+    # with col1:
+    #     fig = create_matches_activity_chart(df)
+    #     st.plotly_chart(fig, use_container_width=True)
+    
+    # with col2:
+    #     fig = create_team_activity_heatmap(df)
+    #     st.plotly_chart(fig, use_container_width=True)
+    
+    # st.divider()
+
+    # fig = create_performance_heatmap(df, n_players=15)
+    # st.plotly_chart(fig, use_container_width=True)
+    

streamlit_app/components/player_analysis.py

@@ -0,0 +1,507 @@
+import streamlit as st
+import pandas as pd
+from st_image_carousel import image_carousel
+from st_circular_kpi import circular_kpi
+import base64
+from analytics.scoring import get_player_match_scores
+import plotly.express as px
+
+
+def calculate_stats(df, column, agg_func='sum', round_digits=1):
+    """Calcule min, max, mean pour une colonne groupée par joueur"""
+    stats = df.groupby('Nom').agg({column: agg_func})
+    return {
+        'min': float(stats.min().round(round_digits).values[0]),
+        'max': float(stats.max().round(round_digits).values[0]),
+        'mean': float(stats.mean().round(round_digits).values[0])
+    }
+
+def show_player_analysis(df):
+    """Composant simple pour l'analyse des joueuses"""
+    
+    # Calcul des statistiques globales
+    actions_stats = calculate_stats(df, 'Nb_actions', 'sum')
+    matches_stats = calculate_stats(df, 'Match', 'nunique')
+    
+    # Calcul des moyennes par match
+    player_avg_stats = df.groupby('Nom').agg({
+        'Nb_actions': 'sum',
+        'Match': 'nunique'
+    }).assign(
+        avg_per_match=lambda x: x['Nb_actions'] / x['Match']
+    )
+    
+    avg_per_match_stats = {
+        'min': float(player_avg_stats['avg_per_match'].min()),
+        'max': float(player_avg_stats['avg_per_match'].max()),
+        'mean': float(player_avg_stats['avg_per_match'].mean().round(1))
+    }
+
+    # Créer un dictionnaire avec les noms uniques des joueurs
+    joueurs_images = [
+        {
+            "name": f"{row['Prenom']} {row['Nom']}",
+            "url": ""
+        }
+        for _, row in sorted(df[['Nom', 'Prenom']].drop_duplicates().iterrows(), 
+                           key=lambda x: (x[1]['Nom'], x[1]['Prenom']))
+    ]
+    
+    # Créer un dictionnaire avec les noms uniques des matchs
+    matchs_images = [
+        {
+            "name": match_name,
+            "url": ""
+        }
+        for match_name in sorted(df['Match'].unique())
+    ]
+
+    result = image_carousel(
+        images=joueurs_images,
+        selected_image=None,
+        background_color="#ffffff",
+        active_border_color="#000000",
+        active_glow_color="rgba(0, 0, 0, 0.7)",
+        fallback_background="#ffffff",
+        fallback_gradient_end="#ffffff",
+        text_color="#000000",
+        arrow_color="#31333f",
+        key="player_carousel"
+    )
+
+    # Liste des joueuses
+    if result and result.get('selected_image'):
+        selected_player = result['selected_image'].split(" ")[1]
+    else:
+        selected_player = None
+
+    # Tableau des données
+    if selected_player:
+        # Filtrer les données pour la joueuse sélectionnée
+        player_data = df[df['Nom'] == selected_player]
+        
+        # Créer une liste de matchs filtrée pour cette joueuse (seulement les matchs où elle a participé)
+        player_matches = player_data.groupby('Match')['Nb_actions'].sum()
+        player_matches = player_matches[player_matches > 0].index.tolist()  # Seulement les matchs avec des actions
+        
+        matchs_images_filtered = [
+            {
+                "name": match_name,
+                "url": ""
+            }
+            for match_name in sorted(player_matches)
+        ]
+        
+        # Statistiques du joueur
+        total_actions = player_data['Nb_actions'].sum()
+        nb_matchs = player_data['Match'].nunique()
+        avg_per_match = total_actions / nb_matchs if nb_matchs > 0 else 0
+
+                # Récupérer les scores de la joueuse sélectionnée
+        player_scores = get_player_match_scores(df)
+        player_scores_filtered = player_scores[
+            (player_scores['Prenom'] == player_data['Prenom'].iloc[0]) & 
+            (player_scores['Nom'] == selected_player)
+        ].sort_values('Match')
+        # st.write(player_scores_filtered)
+                
+        # Statistiques simples
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            circular_kpi(
+                value=total_actions,
+                label="Actions", 
+                range=(-10, actions_stats['max']),
+                min_value=actions_stats['min'],
+                max_value=actions_stats['max'],
+                mean_value=actions_stats['mean'],
+                color_scheme="blue_purple",
+                background_color="transparent",
+                key="actions_kpi"
+            )
+
+        with col2:
+            circular_kpi(
+                value=nb_matchs,
+                label="Matchs", 
+                range=(0, matches_stats['max']),
+                min_value=matches_stats['min'],
+                max_value=matches_stats['max'],
+                mean_value=matches_stats['mean'],
+                color_scheme="red",
+                background_color="transparent",
+                key="matches_kpi"
+            )
+            
+        with col3:
+            circular_kpi(
+                value=avg_per_match.round(1),
+                label="Moyenne actions par match", 
+                range=(0, avg_per_match_stats['max']),
+                min_value=avg_per_match_stats['min'],
+                max_value=avg_per_match_stats['max'],
+                mean_value=avg_per_match_stats['mean'],
+                color_scheme="green",
+                key="avg_per_match_kpi"
+            )
+        with col4:
+            # Calculer les statistiques globales sur les moyennes par joueuse
+            all_player_scores = get_player_match_scores(df)
+            # Calculer la moyenne par joueuse
+            player_averages = all_player_scores.groupby(['Prenom', 'Nom'])['note_match_joueuse'].mean().reset_index()
+            
+            global_score_stats = {
+                'min': float(player_averages['note_match_joueuse'].min().round(1)),
+                'max': float(player_averages['note_match_joueuse'].max().round(1)),
+                'mean': float(player_averages['note_match_joueuse'].mean().round(1))
+            }
+            
+            circular_kpi(
+                value=player_scores_filtered['note_match_joueuse'].mean().round(1),
+                label="Note moyenne", 
+                range=(0, 100),
+                min_value=global_score_stats['min'],
+                max_value=global_score_stats['max'],
+                mean_value=global_score_stats['mean'],
+                color_scheme="blue_purple",
+                key="note_moyenne_kpi"
+            )    
+            # st.metric("Note moyenne", f"{player_scores_filtered['note_match_joueuse'].mean():.1f}") #note de la joueuse moyenne sur tous les matchs
+        
+        
+        
+        if not player_scores_filtered.empty:
+            # Créer un graphique des scores par match
+            fig = px.line(
+                player_scores_filtered,
+                x='Match',
+                y='note_match_joueuse',
+                markers=True,
+                color_discrete_sequence=['black']  # Ligne noire
+            )
+            
+            fig.update_layout(
+                height=400,  # Moins haut
+                showlegend=False,
+                xaxis_title="",  # Pas de titre axe X
+                yaxis_title="Note"   # Pas de titre axe Y
+            )
+            
+            # Ajouter une ligne de moyenne
+            avg_score = player_scores_filtered['note_match_joueuse'].mean()
+            fig.add_hline(
+                y=avg_score,
+                line_dash="dash",
+                line_color="red",
+                annotation_text=f"Moyenne: {avg_score:.1f}",
+                annotation_position="top right"
+            )
+            
+            # Centrer le graphique
+            col1, col2, col3 = st.columns([1, 4, 2])
+            with col2:
+                st.plotly_chart(fig, use_container_width=False, key="scores_evolution_chart")
+        else:
+            st.info("Aucun score disponible pour cette joueuse.")
+        
+        st.divider()
+
+        # Définir les colonnes
+        col_stats, col_match = st.columns([4, 1])
+
+        with col_match:
+            result_match = image_carousel(
+                images=matchs_images_filtered,
+                selected_image=None,
+                background_color="#ffffff",
+                active_border_color="#000000",
+                active_glow_color="rgba(0, 0, 0, 0.7)",
+                fallback_background="#ffffff",
+                fallback_gradient_end="#ffffff",
+                text_color="#000000",
+                arrow_color="#31333f",
+                orientation="vertical",
+                key="match_carousel"
+            )
+            
+            # Récupérer le match sélectionné pour le filtrage
+            selected_match = None
+            if result_match and result_match.get('selected_image'):
+                selected_match = result_match['selected_image']
+            
+            
+        with col_stats:
+            
+            # Filtrer les données selon le match sélectionné
+            display_data = player_data
+            if selected_match:
+                # display_data = player_data[player_data['Match'] == selected_match]
+                display_data = player_data[player_data['Match'] == selected_match]
+            
+            # st.write(display_data)
+            # Recalculer les statistiques avec les données filtrées
+            filtered_total_actions = display_data['Nb_actions'].sum()
+            filtered_nb_matchs = display_data['Match'].nunique()
+            filtered_avg_per_match = filtered_total_actions / filtered_nb_matchs if filtered_nb_matchs > 0 else 0
+            
+            # Calculer les statistiques POUR CETTE JOUEUSE SEULEMENT
+            player_match_stats = player_data.groupby('Match')['Nb_actions'].sum()
+            player_actions_stats = {
+                'min': float(player_match_stats.min()),
+                'max': float(player_match_stats.max()),
+                'mean': float(player_match_stats.mean().round(1))
+            }
+            
+            
+            col_actions, col_matchs, col_avg_per_match = st.columns(3)
+            
+            with col_actions:
+                circular_kpi(
+                    value=filtered_total_actions,
+                    label="Actions", 
+                    range=(0, player_actions_stats['max']),
+                    min_value=player_actions_stats['min'],
+                    max_value=player_actions_stats['max'],
+                    mean_value=player_actions_stats['mean'],
+                    color_scheme="blue_purple",
+                    background_color="transparent",
+                    key="actions_kpi_by_match"
+                )
+            with col_matchs:
+                
+                # Calculer le nombre d'actions par niveau pour ce match
+                actions_by_level = display_data.groupby('Niveau')['Nb_actions'].sum().reset_index()
+                
+                # Créer un DataFrame avec tous les niveaux (0, 1, 2, 3) même s'ils n'existent pas
+                all_levels = pd.DataFrame({'Niveau': [0, 1, 2, 3]})
+                actions_by_level = all_levels.merge(actions_by_level, on='Niveau', how='left').fillna(0)
+                
+                fig = px.bar(
+                    actions_by_level,
+                    x='Niveau',
+                    y='Nb_actions',
+                    color='Niveau',
+                    color_discrete_map={
+                        0: '#ff6b6b',  # Rouge pour niveau 0
+                        1: '#4ecdc4',  # Turquoise pour niveau 1
+                        2: '#45b7d1',  # Bleu pour niveau 2
+                        3: '#96ceb4'   # Vert pour niveau 3
+                    }
+                )
+                
+                # Supprimer complètement la barre de couleur
+                fig.update_layout(
+                    showlegend=False,
+                    coloraxis_showscale=False,
+                    height=300  # Réduire la hauteur du graphique
+                )
+                
+                st.plotly_chart(fig, use_container_width=True, key="niveau_actions_chart")
+                # st.metric((display_data['Niveau']*display_data['Nb_actions']).sum()/display_data['Nb_actions'].sum())
+
+
+            with col_avg_per_match:
+                match_note = player_scores_filtered[player_scores_filtered['Match'] == selected_match]['note_match_joueuse'].mean().round(1)
+                circular_kpi(
+                    value=match_note,
+                    label="Note du match", 
+                    range=(0, 100)
+                )
+
+
+            # Boucle sur les types d'actions avec niveau non-null uniquement
+            # Filtrer d'abord les données avec niveau non-null
+            actions_with_level = display_data[display_data['Niveau'].notna()]
+            filtered_total_actions_by_action = actions_with_level.groupby('Action')['Nb_actions'].sum()
+            
+            # Calculer le score total du match (somme de tous les scores d'actions)
+            total_match_score = 0
+            for action, value in filtered_total_actions_by_action.items():
+                action_data = display_data[display_data['Action'] == action]
+                actions_by_level = action_data.groupby('Niveau')['Nb_actions'].sum().reset_index()
+                
+                # Créer un DataFrame avec tous les niveaux (0, 1, 2, 3) même s'ils n'existent pas
+                all_levels = pd.DataFrame({'Niveau': [0, 1, 2, 3]})
+                actions_by_level = all_levels.merge(actions_by_level, on='Niveau', how='left').fillna(0)
+                
+                # Calculer le score pour cette action
+                if actions_by_level['Nb_actions'].sum() > 0:
+                    score_action = (actions_by_level['Niveau']*actions_by_level['Nb_actions']).sum()/actions_by_level['Nb_actions'].sum()
+                    total_match_score += score_action
+            
+            # Multiplier par 100 pour obtenir le pourcentage
+            total_match_score = total_match_score
+            
+            # Dictionnaire des descriptions des niveaux par type d'action
+            level_descriptions = {
+                'DUEL': {
+                    0: 'RECULE/PERTE',
+                    1: 'N\'AVANCE PAS',
+                    2: 'AVANCE/PASSE',
+                    3: 'PLAGE CASSÉ'
+                },
+                'PASSE': {
+                    0: 'MANQUEE+PERTE',
+                    1: 'MANQUEE',
+                    2: 'PASSE COURSE/MAINS',
+                    3: 'PASSE COURSE+MAINS'
+                },
+                'JAP': {
+                    0: 'CONTRE/GOBÉ',
+                    1: 'REBOND',
+                    2: 'GAIN TERRAIN',
+                    3: 'GAIN TERRAIN+POS'
+                },
+                'PLAQUAGE': {
+                    0: 'MANQUÉ',
+                    1: 'SUBI',
+                    2: 'NEUTRE',
+                    3: 'DOMINANT'
+                },
+                'RUCK': {
+                    0: 'INSPECTEUR',
+                    1: 'LENT 5+S',
+                    2: 'RAPIDE 3-4S',
+                    3: 'TRÈS RAPIDE 1-2S'
+                },
+                'RECEPTION JAP': {
+                    0: 'REBOND/PERTE',
+                    1: 'REBOND',
+                    2: 'MAUVAIS GOBE',
+                    3: 'GOBE'
+                }
+            }
+            
+            for action, value in filtered_total_actions_by_action.items():
+                # Calculer les statistiques POUR CETTE JOUEUSE ET CE TYPE D'ACTION sur tous les matchs
+                player_action_stats = player_data.groupby(['Match', 'Action'])['Nb_actions'].sum().reset_index()
+                player_action_stats = player_action_stats[player_action_stats['Action'] == action]
+                
+                # Statistiques pour ce type d'action de cette joueuse
+                action_stats = {
+                    'min': float(player_action_stats['Nb_actions'].min()) if len(player_action_stats) > 0 else 0,
+                    'max': float(player_action_stats['Nb_actions'].max()) if len(player_action_stats) > 0 else 0,
+                    'mean': float(player_action_stats['Nb_actions'].mean().round(1)) if len(player_action_stats) > 0 else 0
+                }
+                
+                
+                # Créer 3 colonnes pour chaque type d'action avec niveau
+                col_action1, col_action2, col_action3 = st.columns(3)
+                
+                with col_action1:
+                    circular_kpi(
+                        value=value,
+                        label=f"{action}", 
+                        range=(0, action_stats['max']),
+                        min_value=action_stats['min'],
+                        max_value=action_stats['max'],
+                        mean_value=action_stats['mean'],
+                        color_scheme="blue_purple",
+                        background_color="transparent",
+                        key=f"actions_kpi_{action}"
+                    )
+
+                with col_action2:
+                    # Calculer le nombre d'actions par niveau pour cette action
+                    action_data = display_data[display_data['Action'] == action]
+                    actions_by_level = action_data.groupby('Niveau')['Nb_actions'].sum().reset_index()
+                    
+                    # Créer un DataFrame avec tous les niveaux (0, 1, 2, 3) même s'ils n'existent pas
+                    all_levels = pd.DataFrame({'Niveau': [0, 1, 2, 3]})
+                    actions_by_level = all_levels.merge(actions_by_level, on='Niveau', how='left').fillna(0)
+                    
+                    # Ajouter les descriptions des niveaux
+                    if action in level_descriptions:
+                        actions_by_level['Niveau_Desc'] = actions_by_level['Niveau'].map(level_descriptions[action])
+                    else:
+                        actions_by_level['Niveau_Desc'] = actions_by_level['Niveau'].astype(str)
+                    
+                    fig = px.bar(
+                        actions_by_level,
+                        x='Niveau_Desc',
+                        y='Nb_actions',
+                        color='Niveau',
+                        color_discrete_map={
+                            0: '#ff6b6b',  # Rouge pour niveau 0
+                            1: '#4ecdc4',  # Turquoise pour niveau 1
+                            2: '#45b7d1',  # Bleu pour niveau 2
+                            3: '#96ceb4'   # Vert pour niveau 3
+                        }
+                    )
+                    
+                    # Supprimer complètement la barre de couleur
+                    fig.update_layout(
+                        showlegend=False,
+                        coloraxis_showscale=False,
+                        height=300,  # Réduire la hauteur du graphique
+                        xaxis_title="",  # Pas de titre axe X
+                        yaxis_title=""   # Pas de titre axe Y
+                    )
+                    
+                    st.plotly_chart(fig, use_container_width=True, key=f"bar_chart_{action}")
+
+                with col_action3:
+                    # st.write(actions_by_level)
+
+                    # Calculer le score pour cette action spécifique
+                    score_action = (actions_by_level['Niveau']*actions_by_level['Nb_actions']).sum()/actions_by_level['Nb_actions'].sum()
+                    score_action_percent = score_action/total_match_score*100
+                    # st.write(actions_by_level)
+                    # st.write((actions_by_level['Niveau']*actions_by_level['Nb_actions']).sum())
+                    # st.write(actions_by_level['Nb_actions'].sum())
+                    # st.write((actions_by_level['Niveau']*actions_by_level['Nb_actions']).sum()/actions_by_level['Nb_actions'].sum())
+                    # st.write((actions_by_level['Niveau']*actions_by_level['Nb_actions']).sum()/actions_by_level['Nb_actions'].sum()*100/33)
+
+                    circular_kpi(
+                        value=score_action_percent.round(1),
+                        label=f"de la note", 
+                        range=(0, 100),
+                        unit="%",
+                        key=f"note_kpi_{action}"
+                    )
+
+            # Maintenant afficher les actions avec niveau null (sur la même ligne)
+            actions_without_level = display_data[display_data['Niveau'].isna()]
+            filtered_total_actions_by_action_null = actions_without_level.groupby('Action')['Nb_actions'].sum()
+            
+
+
+            st.divider()
+
+
+
+            
+            if len(filtered_total_actions_by_action_null) > 0:
+
+                # Créer autant de colonnes que d'actions sans niveau
+                num_null_actions = len(filtered_total_actions_by_action_null)
+                if num_null_actions > 0:
+                    # Créer les colonnes dynamiquement
+                    cols = st.columns(num_null_actions)
+                    
+                    for i, (action, value) in enumerate(filtered_total_actions_by_action_null.items()):
+                        # Calculer les statistiques POUR CETTE JOUEUSE ET CE TYPE D'ACTION sur tous les matchs
+                        player_action_stats = player_data.groupby(['Match', 'Action'])['Nb_actions'].sum().reset_index()
+                        player_action_stats = player_action_stats[player_action_stats['Action'] == action]
+                        
+                        # Statistiques pour ce type d'action de cette joueuse
+                        action_stats = {
+                            'min': float(player_action_stats['Nb_actions'].min()) if len(player_action_stats) > 0 else 0,
+                            'max': float(player_action_stats['Nb_actions'].max()) if len(player_action_stats) > 0 else 0,
+                            'mean': float(player_action_stats['Nb_actions'].mean().round(1)) if len(player_action_stats) > 0 else 0
+                        }
+                        
+                        # Afficher le KPI dans la colonne correspondante
+                        with cols[i]:
+                            circular_kpi(
+                                value=value,
+                                label=f"{action}", 
+                                range=(0, action_stats['max']),
+                                min_value=action_stats['min'],
+                                max_value=action_stats['max'],
+                                mean_value=action_stats['mean'],
+                                color_scheme="green",
+                                background_color="transparent",
+                                key=f"actions_kpi_null_{action}"
+                            )

streamlit_app/components/players_comparison.py

@@ -0,0 +1,10 @@
+import streamlit as st
+import pandas as pd
+
+def show_players_comparison(df):
+    """Composant simple pour comparer les matchs"""
+    
+
+
+    st.header("In progress...")
+    

streamlit_app/main.py

@@ -0,0 +1,65 @@
+import streamlit as st
+import pandas as pd
+import sqlite3
+from pathlib import Path
+import sys
+
+# Ajouter le répertoire parent au path pour les imports
+sys.path.append(str(Path(__file__).parent.parent))
+
+# Configuration de la page
+st.set_page_config(
+    page_title="U18 Féminine - Stade Toulousain",
+    page_icon="./assets/Logo_Stade_Toulousain_Rugby.png",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Charger les styles personnalisés
+from utils.styles import load_css, create_rugby_title
+
+# CHARGER LES STYLES CSS
+load_css()
+
+# Imports des composants
+from components.dashboard import show_dashboard
+from components.player_analysis import show_player_analysis
+from components.players_comparison import show_players_comparison
+from utils.data_loader import load_data
+
+def main():
+    # Titre principal
+    create_rugby_title("u18 féminine", "Stade Toulousain")
+
+    # Charger les données
+    try:
+        df = load_data()
+    except Exception as e:
+        st.error(f"Erreur lors du chargement des données : {e}")
+        st.stop()
+    
+
+    from streamlit_option_menu import option_menu
+
+    with st.sidebar:
+        selected = option_menu( None, 
+                ["Tableau de bord", 'Analyse individuelle', 'Comparaison des joueuses'], 
+                icons=None, default_index=1,
+                menu_icon="cast",
+                styles={
+                    "container": {"padding": "0!important", "background-color": "#fafafa"},
+                    "icon": {"display": "None"}, 
+                    "nav-link": {"font-size": "16px", "text-align": "left", "margin":"3px", "--hover-color": "#eee"},
+                    "nav-link-selected": {"background-color": "#000000"},
+                }
+            )
+    # Affichage des pages
+    if selected == "Tableau de bord":
+        show_dashboard(df)
+    elif selected == "Analyse individuelle":
+        show_player_analysis(df)
+    elif selected == "Comparaison des joueuses":
+        show_players_comparison(df)
+
+if __name__ == "__main__":
+    main()

streamlit_app/utils/chart_styles.py

@@ -0,0 +1,101 @@
+import plotly.express as px
+import plotly.graph_objects as go
+
+# Couleurs du Stade Toulousain
+STADE_COLORS = {
+    'primary': '#CC0C13',      # Rouge principal
+    'secondary': '#000000',    # Noir
+    'accent': '#FFFFFF',       # Blanc
+    'light_red': 'rgba(204, 12, 19, 0.2)',
+    'dark_gray': '#333333'
+}
+
+def get_stade_toulousain_colorscale():
+    """Palette de couleurs Stade Toulousain"""
+    return [[0, STADE_COLORS['secondary']], [1, STADE_COLORS['primary']]]
+
+def get_stade_toulousain_colors():
+    """Couleurs discrètes pour graphiques multiples"""
+    return [STADE_COLORS['primary'], STADE_COLORS['secondary'], 
+            STADE_COLORS['dark_gray'], STADE_COLORS['light_red']]
+
+def apply_stade_style(fig, title=None):
+    """Applique le style Stade Toulousain à n'importe quel graphique"""
+    
+    fig.update_layout(
+        # Fond et papier
+        plot_bgcolor='rgba(248, 249, 250, 0.5)',
+        paper_bgcolor='rgba(0,0,0,0)',
+        
+        # Police et couleurs
+        font=dict(family='Arial', color=STADE_COLORS['secondary'], size=11),
+        
+        # Titre
+        title=dict(
+            text=title,
+            font=dict(color=STADE_COLORS['primary'], size=16, family='Arial Black'),
+            x=0.5,
+            xanchor='center'
+        ) if title else None,
+        
+        # Barre de couleur
+        coloraxis_colorbar=dict(
+            tickfont=dict(color=STADE_COLORS['secondary'], size=10),
+            bgcolor='rgba(255,255,255,0.8)',
+            # bordercolor=STADE_COLORS['primary'],
+        )
+    )
+    
+    # Axes
+    fig.update_xaxes(
+        showgrid=True,
+        gridcolor=STADE_COLORS['light_red'],
+        gridwidth=1,
+        zeroline=True,
+        zerolinecolor=STADE_COLORS['primary'],
+        zerolinewidth=2,
+        tickfont=dict(color=STADE_COLORS['secondary'], size=11)
+    )
+    
+    fig.update_yaxes(
+        showgrid=False,
+        tickfont=dict(color=STADE_COLORS['secondary'], size=11)
+    )
+    
+    # Hover personnalisé
+    fig.update_traces(
+        hoverlabel=dict(
+            bgcolor=STADE_COLORS['primary'],
+            font_color='white',
+            font_size=12
+        )
+    )
+    
+    return fig
+
+def create_custom_bar_chart(data, x, y, title="", orientation='h', remove_y_title=True):
+    """Crée un graphique en barres avec le style Stade Toulousain"""
+    
+    fig = px.bar(
+        data,
+        x=x,
+        y=y,
+        orientation=orientation,
+        color=x if orientation=='h' else y,
+        color_continuous_scale=get_stade_toulousain_colorscale()
+    )
+    
+    # Appliquer le style
+    fig = apply_stade_style(fig, title)
+    
+    # Configuration spécifique pour les barres horizontales
+    if orientation == 'h':
+        fig.update_layout(
+            yaxis={
+                'categoryorder': 'total ascending',
+                'title': '' if remove_y_title else y
+            },
+            xaxis={'title': x.replace('_', ' ').title()}
+        )
+    
+    return fig

streamlit_app/utils/data_loader.py

@@ -0,0 +1,76 @@
+import pandas as pd
+import sqlite3
+import streamlit as st
+from pathlib import Path
+
+@st.cache_data
+def load_data():
+    """Charge les données depuis le fichier CSV"""
+    try:
+        data_path = Path(__file__).parent.parent.parent / "data/transformed/Rugby_Stats.csv"
+        df = pd.read_csv(data_path)
+        return df
+    except Exception as e:
+        st.error(f"Impossible de charger les données : {e}")
+        return pd.DataFrame()
+
+@st.cache_data
+def load_from_database():
+    """Charge les données depuis la base SQLite"""
+    try:
+        db_path = Path(__file__).parent.parent.parent / "data/transformed/Rugby_Stats.db"
+        conn = sqlite3.connect(db_path)
+        
+        query = '''
+        SELECT j.prenom, j.nom, m.nom_match, s.numero, a.nom_action, 
+               n.id_niveau, s.nb_actions
+        FROM Statistiques s
+        JOIN Joueuse j ON s.id_joueuse = j.id_joueuse
+        JOIN Match m ON s.id_match = m.id_match
+        JOIN Action a ON s.id_action = a.id_action
+        JOIN Niveau n ON s.id_niveau = n.id_niveau
+        '''
+        
+        df = pd.read_sql_query(query, conn)
+        conn.close()
+        return df
+    except Exception as e:
+        st.error(f"Impossible de charger depuis la base : {e}")
+        return pd.DataFrame()
+
+def get_database_stats():
+    """Retourne les statistiques générales de la base"""
+    try:
+        db_path = Path(__file__).parent.parent.parent / "data/transformed/Rugby_Stats.db"
+        conn = sqlite3.connect(db_path)
+        
+        # Nombre de joueuses
+        nb_joueuses = pd.read_sql_query("SELECT COUNT(*) as count FROM Joueuse", conn).iloc[0]['count']
+        
+        # Nombre de matchs
+        nb_matchs = pd.read_sql_query("SELECT COUNT(*) as count FROM Match", conn).iloc[0]['count']
+        
+        # Nombre total de statistiques
+        nb_stats = pd.read_sql_query("SELECT COUNT(*) as count FROM Statistiques", conn).iloc[0]['count']
+        
+        conn.close()
+        
+        return {
+            'nb_joueuses': nb_joueuses,
+            'nb_matchs': nb_matchs,
+            'nb_stats': nb_stats
+        }
+    except Exception as e:
+        return {'nb_joueuses': 0, 'nb_matchs': 0, 'nb_stats': 0}
+
+def get_player_stats(df, player_name=None):
+    """Retourne les statistiques d'une joueuse spécifique"""
+    if player_name:
+        return df[df['Nom'].str.contains(player_name, case=False, na=False)]
+    return df
+
+def get_match_stats(df, match_name=None):
+    """Retourne les statistiques d'un match spécifique"""
+    if match_name:
+        return df[df['Match'] == match_name]
+    return df

streamlit_app/utils/styles.py

@@ -0,0 +1,66 @@
+import streamlit as st
+from pathlib import Path
+
+def load_css():
+    """Charge le fichier CSS personnalisé"""
+    css_file = Path(__file__).parent.parent / "assets" / "style.css"
+    
+    try:
+        with open(css_file, 'r', encoding='utf-8') as f:
+            css_content = f.read()
+        
+        st.markdown(f"""
+        <style>
+        {css_content}
+        </style>
+        """, unsafe_allow_html=True)
+        
+    except FileNotFoundError:
+        st.warning("Fichier CSS non trouvé. Styles par défaut utilisés.")
+    except Exception as e:
+        st.error(f"Erreur lors du chargement du CSS : {e}")
+
+def load_logo():
+    """Charge le logo du Stade Toulousain"""
+    logo_path = Path(__file__).parent.parent / "assets" / "Logo_Stade_Toulousain_Rugby.png"
+    
+    if logo_path.exists():
+        return str(logo_path)
+    return None
+
+def create_rugby_title(left_text="u18 féminine", right_text="Stade Toulousain"):
+    """Crée un header titre avec logo centré"""
+    
+    # Charger le logo
+    logo_path = load_logo()
+    
+    if logo_path:
+        # Convertir le logo en base64 pour l'affichage
+        logo_base64 = get_base64_of_image(logo_path)
+        
+        st.markdown(f"""
+        <div class="rugby-header-custom">
+            <span class="title-left">{left_text}</span>
+            <img src="data:image/png;base64,{logo_base64}" class="logo-center" alt="Logo Stade Toulousain"/>
+            <span class="title-right">{right_text}</span>
+        </div>
+        """, unsafe_allow_html=True)
+    else:
+        # Fallback si le logo n'est pas trouvé
+        st.markdown(f'<h1 class="main-header">{left_text} - {right_text}</h1>', unsafe_allow_html=True)
+
+def get_base64_of_image(path):
+    """Convertit une image en base64 pour l'affichage"""
+    import base64
+    with open(path, "rb") as img_file:
+        return base64.b64encode(img_file.read()).decode()
+
+def create_metric_card(title, value, description=""):
+    """Crée une carte métrique personnalisée"""
+    st.markdown(f"""
+    <div class="metric-card">
+        <h3 style="margin: 0; color: #1f4e79;">{title}</h3>
+        <h2 style="margin: 0.5rem 0; color: #1f4e79; font-size: 2rem;">{value}</h2>
+        <p style="margin: 0; color: #666; font-size: 0.9rem;">{description}</p>
+    </div>
+    """, unsafe_allow_html=True)