app

app/app.py

@@ -0,0 +1,46 @@
+import streamlit as st
+from utils.data_processing import load_data
+from components.layout import create_sidebar, create_main_layout
+from components.visualization import create_pizza_chart, display_metrics, get_max_values_for_ville
+import pandas as pd
+
+# Configuration de la page Streamlit
+st.set_page_config(
+    page_title="Statistiques Rugby",
+    page_icon="🏉",
+    layout="wide"
+)
+
+def main():
+    """Fonction principale de l'application"""
+    st.title("🏉 Analyse des Statistiques Rugby")
+    
+    # Chargement des données
+    data = load_data()
+    # Conversion des colonnes numériques
+    numeric_columns = data.select_dtypes(include=['object']).columns
+    for col in numeric_columns:
+        if col != 'name' and col != 'Ville':
+            data[col] = pd.to_numeric(data[col], errors='coerce')
+    
+    # Création de l'interface
+    selected_ville, selected_player = create_sidebar(data)
+    col1, col2 = create_main_layout(data, selected_ville)
+    
+    with col1:
+        st.subheader(f"Statistiques pour {selected_player} ({selected_ville})")
+        # Récupérer uniquement les valeurs maximales
+        max_values = get_max_values_for_ville(data, selected_ville)
+        fig = create_pizza_chart(data, selected_ville, selected_player, max_values)
+        if fig is not None:
+            st.pyplot(fig)
+    
+    with col2:
+        st.subheader("Valeurs maximales pour ce match")
+        if max_values:
+            display_metrics(max_values)
+        else:
+            st.warning("Aucune donnée maximale disponible")
+
+if __name__ == "__main__":
+    main()

app/components/charts.py

@@ -0,0 +1,75 @@
+
+
+def create_pizza_chart(final_df, selected_ville):
+    """Crée le graphique pizza pour une ville donnée"""
+    ville_data = final_df[final_df['Ville'] == selected_ville].iloc[0]
+    
+    params, values, slice_colors = [], [], []
+    max_values = {}
+    
+    # Calcul des valeurs maximales
+    for cat_name, cat_info in CATEGORIES.items():
+        cat_values = []
+        for subcat in cat_info['subcats'].keys():
+            if subcat in final_df.columns and pd.notna(ville_data[subcat]):
+                cat_values.append(float(ville_data[subcat]))
+        if cat_values:
+            max_values[cat_name] = max(cat_values)
+
+    # Préparation des données pour le graphique
+    for cat_name, cat_info in CATEGORIES.items():
+        for subcat, display_text in cat_info['subcats'].items():
+            params.append(display_text)
+            if subcat in final_df.columns and pd.notna(ville_data[subcat]):
+                value = float(ville_data[subcat])
+                max_val = max_values[cat_name]
+                normalized_value = (value / max_val * 100) if max_val > 0 else 0
+                values.append(round(normalized_value, 2))
+            else:
+                values.append(0)
+            slice_colors.append(cat_info['color'])
+
+    # Création du graphique
+    text_colors = ["#000000"] * len(params)
+    fig, ax = plt.subplots(figsize=CHART_CONFIG["figsize"])
+    
+    # Créer un dictionnaire de configuration sans figsize pour PyPizza
+    pizza_config = {k: v for k, v in CHART_CONFIG.items() if k != "figsize"}
+    
+    baker = PyPizza(
+        params=params,
+        **pizza_config
+    )
+
+    fig, ax = baker.make_pizza(
+        values,
+        figsize=(10, 10),
+        color_blank_space="same",
+        slice_colors=slice_colors,
+        value_colors=text_colors,
+        value_bck_colors=slice_colors,
+        blank_alpha=0.4,
+        kwargs_slices=dict(
+            edgecolor="#F2F2F2",
+            zorder=2,
+            linewidth=1
+        ),
+        kwargs_params=dict(
+            color="#000000",
+            fontsize=8,
+            va="center"
+        ),
+        kwargs_values=dict(
+            color="#000000",
+            fontsize=8,
+            zorder=3,
+            bbox=dict(
+                edgecolor="#000000",
+                facecolor="white",
+                boxstyle="round,pad=0.2",
+                lw=1
+            )
+        )
+    )
+
+    return fig, max_values

app/components/layout.py

@@ -0,0 +1,35 @@
+import streamlit as st
+from difflib import get_close_matches
+
+def create_sidebar(data):
+    """Crée la barre latérale avec les contrôles"""
+    with st.sidebar:
+        st.header("Configuration")
+        
+        # Sélection de la ville
+        selected_ville = st.selectbox(
+            "Sélectionner une ville",
+            options=data['Ville'].unique()
+        )
+        
+        # Filtrer les joueurs pour la ville sélectionnée
+        ville_players = data[data['Ville'] == selected_ville]['name'].unique()
+        
+        # Sélection du joueur
+        selected_player = st.selectbox(
+            "Sélectionner un joueur",
+            options=ville_players
+        )
+        
+    return selected_ville, selected_player
+
+def create_main_layout(data, selected_ville):
+    """Crée la disposition principale de l'application"""
+    # Affichage des données brutes dans un expander
+    with st.expander("Voir les données brutes"):
+        st.dataframe(data[data['Ville'] == selected_ville])
+    
+    # Création des colonnes pour l'affichage
+    col1, col2 = st.columns([3, 4])
+    
+    return col1, col2

app/components/visualization.py

@@ -0,0 +1,209 @@
+import matplotlib.pyplot as plt
+from mplsoccer import PyPizza
+import pandas as pd
+from config.config import CATEGORIES, CHART_CONFIG
+
+import matplotlib.pyplot as plt
+from mplsoccer import PyPizza
+import pandas as pd
+import streamlit as st
+from config.config import CATEGORIES, CHART_CONFIG
+
+
+def create_pizza_chart(final_df, selected_ville, selected_player, max_values):
+    try:
+        from urllib.request import urlopen
+        from PIL import Image
+        import matplotlib.image as image
+        
+        player_data = final_df[(final_df['Ville'] == selected_ville) & 
+                             (final_df['name'] == selected_player)]
+        
+        if player_data.empty:
+            st.warning(f"Aucune donnée trouvée pour {selected_player} dans {selected_ville}")
+            return None
+            
+        player_data = player_data.iloc[0]
+        
+        params, values, slice_colors = [], [], []
+        min_ranges, max_ranges = [], []
+        
+        # Préparation des données pour le graphique
+        for cat_name, cat_info in CATEGORIES.items():
+            for subcat, display_text in cat_info['subcats'].items():
+                params.append(display_text)
+                if subcat in final_df.columns and pd.notna(player_data[subcat]):
+                    value = float(player_data[subcat])
+                    values.append(value)
+                    min_ranges.append(0)
+                    max_ranges.append(max_values[cat_name][subcat])
+                else:
+                    values.append(0)
+                    min_ranges.append(0)
+                    max_ranges.append(100)
+                slice_colors.append(cat_info['color'])
+
+        # Création du graphique
+        text_colors = ["#000000"] * len(params)
+        fig, ax = plt.subplots(figsize=CHART_CONFIG["figsize"])
+        
+        pizza_config = {k: v for k, v in CHART_CONFIG.items() if k != "figsize"}
+        pizza_config['inner_circle_size'] = 30  # Augmenter la taille du cercle intérieur
+
+        baker = PyPizza(
+            params=params,
+            min_range=min_ranges,
+            max_range=max_ranges,
+            **pizza_config
+        )
+
+        fig, ax = baker.make_pizza(
+            values,
+            figsize=(10, 10),
+            color_blank_space="same",
+            slice_colors=slice_colors,
+            value_colors=text_colors,
+            value_bck_colors=slice_colors,
+            blank_alpha=0.4,
+            kwargs_slices=dict(
+                edgecolor="#F2F2F2",
+                zorder=2,
+                linewidth=1
+            ),
+            kwargs_params=dict(
+                color="#000000",
+                fontsize=8,
+                va="center"
+            ),
+            kwargs_values=dict(
+                color="#000000",
+                fontsize=8,
+                zorder=3,
+                bbox=dict(
+                    edgecolor="#000000",
+                    facecolor="white",
+                    boxstyle="round,pad=0.2",
+                    lw=1
+                )
+            )
+        )
+
+        # Ajouter l'image au centre
+        try:
+            # Charger et ajouter le logo au centre
+            logo_url = "https://upload.wikimedia.org/wikipedia/fr/thumb/0/01/Logo_Stade_Toulousain_Rugby.svg/775px-Logo_Stade_Toulousain_Rugby.svg.png?20180529221555"
+            logo = Image.open(urlopen(logo_url))
+            
+            # Créer un nouvel axe pour l'image
+            ax_image = fig.add_axes([0.4478, 0.4315, 0.13, 0.127], zorder=2)
+            ax_image.imshow(logo)
+            ax_image.axis('off')
+        except Exception as e:
+            st.warning(f"Impossible de charger l'image: {str(e)}")
+
+        return fig
+        
+    except Exception as e:
+        st.error(f"Erreur lors de la création du graphique: {str(e)}")
+        return None
+
+def get_max_values_for_ville(final_df, selected_ville):
+    """Calcule les valeurs maximales pour une ville donnée"""
+    # Filtrer les données pour la ville sélectionnée et exclure "GENERAL"
+    ville_data = final_df[(final_df['Ville'] == selected_ville) & 
+                         (final_df['name'] != "GENERAL")]
+    max_values = {}
+    
+    for cat_name, cat_info in CATEGORIES.items():
+        cat_values = {}  # Utiliser un dictionnaire pour stocker les max par sous-catégorie
+        for subcat in cat_info['subcats'].keys():
+            if subcat in final_df.columns:
+                values = ville_data[subcat].dropna()
+                if not values.empty:
+                    cat_values[subcat] = max(values.astype(float))
+        if cat_values:
+            max_values[cat_name] = cat_values
+    
+    return max_values
+
+def display_metrics(max_values):
+    """Affiche les valeurs maximales par catégorie de manière esthétique en deux colonnes"""
+    
+    st.markdown("""
+        <style>
+        div[data-testid="stVerticalBlock"] div[style*="flex-direction: column"] div[data-testid="stVerticalBlock"] {
+            background-color: white;
+            padding: 20px;
+            border-radius: 10px;
+            box-shadow: 2px 2px 10px rgba(0,0,0,0.1);
+            margin-bottom: 20px;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+    
+    # Diviser les catégories en deux groupes
+    categories = list(max_values.items())
+    mid = (len(categories) + 1) // 2
+    
+    # Créer deux colonnes principales
+    col_left, col_right = st.columns(2)
+    
+    # Remplir la colonne gauche
+    with col_left:
+        for cat_name, subcats in categories[:mid]:
+            cat_color = CATEGORIES[cat_name]['color']
+            with st.container():
+                st.markdown(f"""
+                    <h3 style='
+                        color: {cat_color};
+                        font-size: 20px;
+                        padding-bottom: 10px;
+                        border-bottom: 2px solid {cat_color};
+                        margin-bottom: 15px;
+                    '>
+                        {cat_name}
+                    </h3>
+                """, unsafe_allow_html=True)
+                
+                for subcat, value in subcats.items():
+                    st.markdown(f"""
+                        <div style='display: flex; justify-content: space-between; padding: 5px 0;'>
+                            <span style='color: #666; font-size: 16px;'>
+                                {CATEGORIES[cat_name]['subcats'][subcat].replace(chr(10), ' ')}
+                            </span>
+                            <span style='color: #333; font-weight: bold; font-size: 16px;'>
+                                {value}
+                            </span>
+                        </div>
+                    """, unsafe_allow_html=True)
+                st.markdown("<br>", unsafe_allow_html=True)
+    
+    # Remplir la colonne droite
+    with col_right:
+        for cat_name, subcats in categories[mid:]:
+            cat_color = CATEGORIES[cat_name]['color']
+            with st.container():
+                st.markdown(f"""
+                    <h3 style='
+                        color: {cat_color};
+                        font-size: 20px;
+                        padding-bottom: 10px;
+                        border-bottom: 2px solid {cat_color};
+                        margin-bottom: 15px;
+                    '>
+                        {cat_name}
+                    </h3>
+                """, unsafe_allow_html=True)
+                
+                for subcat, value in subcats.items():
+                    st.markdown(f"""
+                        <div style='display: flex; justify-content: space-between; padding: 5px 0;'>
+                            <span style='color: #666; font-size: 16px;'>
+                                {CATEGORIES[cat_name]['subcats'][subcat].replace(chr(10), ' ')}
+                            </span>
+                            <span style='color: #333; font-weight: bold; font-size: 16px;'>
+                                {value}
+                            </span>
+                        </div>
+                    """, unsafe_allow_html=True)
+                st.markdown("<br>", unsafe_allow_html=True)

app/config/__init__.py

@@ -0,0 +1 @@
+from .config import CATEGORIES, CHART_CONFIG, ERROR_MESSAGES, DATA_DIR, EXCEL_PATH

app/config/config.py

@@ -0,0 +1,96 @@
+import os
+from pathlib import Path
+
+# Chemins des fichiers
+DATA_DIR = Path("./data")  # Conversion en objet Path
+EXCEL_PATH = DATA_DIR / "stats.xlsx"
+
+# Ajout d'un print pour debug
+print(f"Chemin du fichier Excel: {EXCEL_PATH}")
+
+# Vérification et création du dossier data s'il n'existe pas
+DATA_DIR.mkdir(exist_ok=True)
+
+
+# Ajout d'un print pour debug
+print(f"Chemin du fichier Excel: {EXCEL_PATH}")
+
+# Vérification et création du dossier data s'il n'existe pas
+DATA_DIR.mkdir(exist_ok=True)
+
+# Configuration des catégories et leurs couleurs
+CATEGORIES = {
+    'Duel': {
+        'color': "#1A78CF",
+        'subcats': {
+            'Duel_0': 'Duel\nPerdu',
+            'Duel_1.0': 'Duel\nNeutre',
+            'Duel_2.0': 'Duel\nGagné',
+            'Duel_3.0': 'Duel\nDécisif',
+        }
+    },
+    'Passe': {
+        'color': "#FF9300",
+        'subcats': {
+            'Passe_0': 'Passe\nPerdue',
+            'Passe_1.0': 'Passe\nNeutre',
+            'Passe_2.0': 'Passe\nGagnée',
+            'Passe_3.0': 'Passe\nDécisive',
+        }
+    },
+    'Plaquage': {
+        'color': "#D70232",
+        'subcats': {
+            'Plaquage_0': 'Plaquage\nPerdu',
+            'Plaquage_1.0': 'Plaquage\nNeutre',
+            'Plaquage_2.0': 'Plaquage\nGagné',
+            'Plaquage_3.0': 'Plaquage\nDécisif',
+        }
+    },
+    'Ruck': {
+        'color': "#2ECC71",
+        'subcats': {
+            'Ruck_0': 'Ruck\nPerdu',
+            'Ruck_1.0': 'Ruck\nNeutre',
+            'Ruck_2.0': 'Ruck\nGagné',
+            'Ruck_3.0': 'Ruck\nDécisif',
+        }
+    },
+    'JAP': {
+        'color': "#9B59B6",
+        'subcats': {
+            'JAP_0': 'JAP\nPerdu',
+            'JAP_1.0': 'JAP\nNeutre',
+            'JAP_2.0': 'JAP\nGagné',
+            'JAP_3.0': 'JAP\nDécisif',
+        }
+    },
+    'Reception JAP': {
+        'color': "#F1C40F",
+        'subcats': {
+            'Réception JAP_0': 'Récep\nPerdue',
+            'Réception JAP_1.0': 'Récep\nNeutre',
+            'Réception JAP_2.0': 'Récep\nGagnée',
+            'Réception JAP_3.0': 'Récep\nDécisive',
+        }
+    }
+}
+
+# Configuration du graphique
+CHART_CONFIG = {
+    "background_color": "#EBEBE9",
+    "straight_line_color": "#EBEBE9",
+    "straight_line_lw": 1,
+    "last_circle_lw": 0,
+    "other_circle_lw": 0,
+    "inner_circle_size": 20,
+    "straight_line_limit": 100,
+    "figsize": (10, 10)
+}
+
+# Messages d'erreur
+ERROR_MESSAGES = {
+    "data_load": "Impossible de charger les données",
+    "file_not_found": "Le fichier de données n'a pas été trouvé",
+    "data_processing": "Erreur lors du traitement des données"
+}

app/utils/data_processing.py

@@ -0,0 +1,77 @@
+import pandas as pd
+import streamlit as st
+from config.config import EXCEL_PATH
+
+
+def clean_dataframe(df):
+    # Récupérer les catégories principales (ligne 0)
+    categories = df.iloc[0]
+    # Récupérer les sous-catégories (ligne 2)
+    sub_categories = df.iloc[2]
+    
+    # Créer un dictionnaire pour stocker les nouvelles colonnes
+    new_columns = {}
+    current_category = None
+    
+    # Parcourir toutes les colonnes pour créer les nouveaux noms
+    for i, (cat, subcat) in enumerate(zip(categories, sub_categories)):
+        if pd.notna(cat):
+            current_category = cat
+        if pd.notna(subcat) and current_category is not None:
+            new_name = f"{current_category}_{subcat}"
+            new_columns[df.columns[i]] = new_name
+    
+    # Garder la colonne 'name' telle quelle
+    new_columns[df.columns[0]] = 'name'
+    
+    # Renommer les colonnes
+    df = df.rename(columns=new_columns)
+    
+    # Supprimer les trois premières lignes et réinitialiser l'index
+    df = df.iloc[3:].reset_index(drop=True)
+    
+    # Supprimer les lignes où le nom est vide ou NaN
+    df = df.dropna(subset=['name']).reset_index(drop=True)
+    
+    # Extraire le numéro et nettoyer le nom AVANT d'ajouter la colonne Ville
+    df['numero'] = df['name'].str.extract(r'^(\d+)').fillna('')
+    df['name'] = df['name'].str.replace(r'^\d+\s*-\s*', '', regex=True).str.strip()
+    
+    # Ne garder que les colonnes nécessaires
+    columns_to_keep = ['numero', 'name'] + [col for col in df.columns if '_' in str(col)]
+    df = df[columns_to_keep]
+    
+    return df
+
+@st.cache_data
+def load_data():
+    """Charge et prépare les données depuis le fichier Excel"""
+    try:
+        if not EXCEL_PATH.exists():
+            st.error(f"Le fichier Excel n'a pas été trouvé à l'emplacement : {EXCEL_PATH}")
+            st.info("Veuillez placer votre fichier stats.xlsx dans le dossier 'data'")
+            return None
+            
+        all_sheets = pd.read_excel(EXCEL_PATH, sheet_name=None)
+        clean_data = []
+        
+        for ville, df in all_sheets.items():
+            if ville != "Promedio partidos":
+                clean_df = clean_dataframe(df)
+                if not clean_df.empty:
+                    clean_df['Ville'] = ville
+                    clean_data.append(clean_df)
+        
+        # st.write(clean_data)
+
+        if not clean_data:
+            st.warning("Aucune donnée trouvée")
+            return None
+            
+        return pd.concat(clean_data, ignore_index=True)
+        
+    except Exception as e:
+        st.error(f"Erreur lors du chargement des données: {str(e)}")
+        return None
+    
+