Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,4 +1,4 @@
-# streamlit_app_enhanced.py
+# codex_app_improved.py
 import streamlit as st
 import requests
 from bs4 import BeautifulSoup
@@ -7,25 +7,32 @@ import pandas as pd
 from datetime import datetime
 import urllib.parse
 import time
+import plotly.express as px
+import plotly.graph_objects as go
 
 # --- Configuration ---
 CODEX_CATEGORIES = {
     'codes': {
         'name': 'Codes de Pratique (CXC)',
         'url': 'https://www.fao.org/fao-who-codexalimentarius/codex-texts/codes-of-practice/fr/',
-        'prefix': 'CXC'
+        'prefix': 'CXC',
+        'icon': '📋',
+        'color': '#FF6B6B'
     },
     'standards': {
         'name': 'Normes (CXS)',
         'url': 'https://www.fao.org/fao-who-codexalimentarius/codex-texts/list-standards/fr/',
-        'prefix': 'CXS'
+        'prefix': 'CXS',
+        'icon': '⚖️',
+        'color': '#4ECDC4'
     },
     'guidelines': {
         'name': 'Directives (CXG)',
         'url': 'https://www.fao.org/fao-who-codexalimentarius/codex-texts/guidelines/fr/',
-        'prefix': 'CXG'
+        'prefix': 'CXG',
+        'icon': '📖',
+        'color': '#45B7D1'
     }
-    # 'misc' peut être ajouté si nécessaire
 }
 
 HEADERS = {
@@ -33,12 +40,94 @@ HEADERS = {
 }
 TIMEOUT = 30
 BASE_URL = "https://www.fao.org"
-# --- Fin Configuration ---
 
 # Configuration de la page
-st.set_page_config(page_title="Codex Alimentarius Monitor", page_icon="📋", layout="wide")
+st.set_page_config(
+    page_title="Codex Alimentarius Monitor", 
+    page_icon="🔬", 
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
 
-@st.cache_data(ttl=1800) # 30 minutes
+# CSS personnalisé pour améliorer le design
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        padding: 2rem;
+        border-radius: 10px;
+        margin-bottom: 2rem;
+        color: white;
+        text-align: center;
+    }
+    .metric-container {
+        background: white;
+        padding: 1.5rem;
+        border-radius: 10px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        text-align: center;
+        margin-bottom: 1rem;
+    }
+    .category-card {
+        background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 5px solid;
+        margin-bottom: 1rem;
+        transition: transform 0.2s;
+    }
+    .category-card:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 8px rgba(0,0,0,0.15);
+    }
+    .document-card {
+        background: white;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border: 1px solid #e0e0e0;
+        margin-bottom: 1rem;
+        transition: all 0.2s;
+    }
+    .document-card:hover {
+        box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+        border-color: #667eea;
+    }
+    .status-badge {
+        padding: 0.25rem 0.75rem;
+        border-radius: 20px;
+        font-size: 0.8rem;
+        font-weight: bold;
+        margin: 0.25rem;
+        display: inline-block;
+    }
+    .badge-new {
+        background-color: #d4edda;
+        color: #155724;
+        border: 1px solid #c3e6cb;
+    }
+    .badge-updated {
+        background-color: #cce5ff;
+        color: #004085;
+        border: 1px solid #b3d9ff;
+    }
+    .badge-category {
+        background-color: #f8f9fa;
+        color: #495057;
+        border: 1px solid #dee2e6;
+    }
+    .filter-section {
+        background: #f8f9fa;
+        padding: 1rem;
+        border-radius: 10px;
+        margin-bottom: 1rem;
+    }
+    .sidebar .stSelectbox > div > div > div {
+        background-color: white;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+@st.cache_data(ttl=1800)
 def extract_documents_from_url(url, category_key):
     """
     Fonction pour extraire les documents d'une catégorie Codex.
@@ -46,7 +135,6 @@ def extract_documents_from_url(url, category_key):
     """
     category_info = CODEX_CATEGORIES[category_key]
     category_name = category_info['name']
-    st.info(f"Extraction de {category_name}...")
     
     documents = []
     seen_codes = set()
@@ -58,19 +146,15 @@ def extract_documents_from_url(url, category_key):
 
         tables = soup.find_all('table')
         if not tables:
-            st.warning(f"Aucun tableau trouvé pour {category_name}.")
             return documents
 
         for table in tables:
             rows = table.find_all('tr')
             for row in rows:
                 cells = row.find_all(['td', 'th'])
-                # Vérifier s'il y a au moins 5 cellules (données + cellule PDF)
                 if len(cells) >= 5:
-                    # Extraire les données de base (cellules 1 à 4)
                     cell_texts = [cell.get_text(strip=True) for cell in cells[:4]]
                     code_candidate = cell_texts[0] if cell_texts else ""
-                    # Pattern pour le préfixe de la catégorie
                     prefix = category_info['prefix']
                     code_match = re.match(rf'^({prefix})\s+([\w\-R]*\d+(?:-\d+)?[R]?)$', code_candidate)
                     
@@ -90,29 +174,21 @@ def extract_documents_from_url(url, category_key):
                             except ValueError:
                                 year = 0
 
-                            # --- EXTRACTION DU LIEN PDF DIRECTEMENT DU HREF ---
-                            # Le lien PDF est dans la 5ème cellule (index 4)
+                            # Extraction du lien PDF
                             pdf_cell = cells[4]
                             pdf_url = None
-
-                            # Trouver le premier lien <a> dans cette cellule qui contient 'pdf'
                             link_tag = pdf_cell.find('a', href=re.compile(r'.*\.pdf', re.IGNORECASE))
                             if link_tag:
                                 href = link_tag.get('href')
                                 if href:
-                                    # 1. Décoder les entités HTML (&amp; -> &)
                                     decoded_href = urllib.parse.unquote(href)
-                                    
-                                    # 2. Construire l'URL absolue
                                     pdf_url = urllib.parse.urljoin(BASE_URL, decoded_href)
 
-                            # Si aucun lien PDF n'a été trouvé, lien de recherche
                             if not pdf_url:
                                 pdf_url = f"https://www.fao.org/fao-who-codexalimentarius/search/en/?q={full_code.replace(' ', '%20')}"
 
-                            # --- Logique de nouveauté ---
-                            is_new = year >= datetime.now().year - 1 # Considéré nouveau si dans les 2 dernières années
-                            is_updated = year == datetime.now().year # Mis à jour cette année
+                            is_new = year >= datetime.now().year - 1
+                            is_updated = year == datetime.now().year
 
                             documents.append({
                                 'code': full_code,
@@ -123,151 +199,411 @@ def extract_documents_from_url(url, category_key):
                                 'category_name': category_name,
                                 'pdf_url': pdf_url,
                                 'is_new': is_new,
-                                'is_updated': is_updated
+                                'is_updated': is_updated,
+                                'icon': category_info['icon'],
+                                'color': category_info['color']
                             })
-        st.success(f"Extraction terminée pour {category_name}. {len(documents)} documents trouvés.")
+        
         return documents
 
     except Exception as e:
         st.error(f"Erreur lors de l'extraction de {category_name} : {e}")
         return []
 
+def create_dashboard_metrics(df):
+    """Créer des métriques pour le dashboard"""
+    if df.empty:
+        return
+        
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.markdown("""
+        <div class="metric-container">
+            <h2 style="color: #667eea; margin: 0;">📊</h2>
+            <h3 style="margin: 0.5rem 0;">{}</h3>
+            <p style="color: #666; margin: 0;">Total Documents</p>
+        </div>
+        """.format(len(df)), unsafe_allow_html=True)
+    
+    with col2:
+        new_docs = len(df[df['is_new']])
+        st.markdown("""
+        <div class="metric-container">
+            <h2 style="color: #28a745; margin: 0;">✨</h2>
+            <h3 style="margin: 0.5rem 0;">{}</h3>
+            <p style="color: #666; margin: 0;">Nouveaux</p>
+        </div>
+        """.format(new_docs), unsafe_allow_html=True)
+    
+    with col3:
+        updated_docs = len(df[df['is_updated']])
+        st.markdown("""
+        <div class="metric-container">
+            <h2 style="color: #17a2b8; margin: 0;">🔄</h2>
+            <h3 style="margin: 0.5rem 0;">{}</h3>
+            <p style="color: #666; margin: 0;">Mis à jour</p>
+        </div>
+        """.format(updated_docs), unsafe_allow_html=True)
+    
+    with col4:
+        categories = df['category_name'].nunique()
+        st.markdown("""
+        <div class="metric-container">
+            <h2 style="color: #ffc107; margin: 0;">📂</h2>
+            <h3 style="margin: 0.5rem 0;">{}</h3>
+            <p style="color: #666; margin: 0;">Catégories</p>
+        </div>
+        """.format(categories), unsafe_allow_html=True)
+
+def create_category_overview(df):
+    """Créer un aperçu des catégories"""
+    if df.empty:
+        return
+        
+    st.subheader("📋 Aperçu par Catégorie")
+    
+    category_stats = df.groupby(['category_name', 'category']).agg({
+        'code': 'count',
+        'is_new': 'sum',
+        'is_updated': 'sum'
+    }).reset_index()
+    
+    for _, row in category_stats.iterrows():
+        category_key = row['category']
+        category_info = CODEX_CATEGORIES[category_key]
+        
+        st.markdown(f"""
+        <div class="category-card" style="border-left-color: {category_info['color']};">
+            <div style="display: flex; justify-content: space-between; align-items: center;">
+                <div>
+                    <h4 style="margin: 0; color: #333;">
+                        {category_info['icon']} {row['category_name']}
+                    </h4>
+                    <p style="margin: 0.5rem 0; color: #666;">
+                        {int(row['code'])} documents • 
+                        {int(row['is_new'])} nouveaux • 
+                        {int(row['is_updated'])} mis à jour
+                    </p>
+                </div>
+                <div style="font-size: 2rem; opacity: 0.3;">
+                    {category_info['icon']}
+                </div>
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+
+def create_visualization(df):
+    """Créer des visualisations"""
+    if df.empty:
+        return
+        
+    st.subheader("📊 Visualisations")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Graphique par catégorie
+        category_counts = df.groupby(['category_name']).size().reset_index(name='count')
+        fig_pie = px.pie(
+            category_counts, 
+            values='count', 
+            names='category_name',
+            title="Répartition par Catégorie",
+            color_discrete_sequence=['#FF6B6B', '#4ECDC4', '#45B7D1']
+        )
+        fig_pie.update_layout(height=400)
+        st.plotly_chart(fig_pie, use_container_width=True)
+    
+    with col2:
+        # Graphique par année
+        year_counts = df[df['year'] > 2000].groupby('year').size().reset_index(name='count')
+        fig_bar = px.bar(
+            year_counts, 
+            x='year', 
+            y='count',
+            title="Documents par Année",
+            color='count',
+            color_continuous_scale='viridis'
+        )
+        fig_bar.update_layout(height=400)
+        st.plotly_chart(fig_bar, use_container_width=True)
+
+def display_documents_grid(df):
+    """Afficher les documents dans une grille"""
+    if df.empty:
+        st.info("Aucun document trouvé avec les filtres sélectionnés.")
+        return
+    
+    # Pagination
+    docs_per_page = 10
+    total_pages = (len(df) - 1) // docs_per_page + 1
+    
+    if 'current_page' not in st.session_state:
+        st.session_state.current_page = 1
+    
+    col1, col2, col3 = st.columns([1, 2, 1])
+    with col2:
+        page = st.selectbox(
+            "Page", 
+            range(1, total_pages + 1), 
+            index=st.session_state.current_page - 1,
+            key="page_selector"
+        )
+        st.session_state.current_page = page
+    
+    # Documents pour la page actuelle
+    start_idx = (page - 1) * docs_per_page
+    end_idx = start_idx + docs_per_page
+    page_docs = df.iloc[start_idx:end_idx]
+    
+    st.markdown(f"**Affichage de {start_idx + 1}-{min(end_idx, len(df))} sur {len(df)} documents**")
+    
+    for _, doc in page_docs.iterrows():
+        # Badges de statut
+        badges_html = f"<span class='status-badge badge-category'>{doc['icon']} {doc['category_name']}</span>"
+        if doc['is_new']:
+            badges_html += "<span class='status-badge badge-new'>✨ NOUVEAU</span>"
+        if doc['is_updated']:
+            badges_html += "<span class='status-badge badge-updated'>🔄 MIS À JOUR</span>"
+        
+        st.markdown(f"""
+        <div class="document-card">
+            <div style="display: flex; justify-content: space-between; align-items: start;">
+                <div style="flex: 1;">
+                    <div style="margin-bottom: 0.5rem;">
+                        {badges_html}
+                    </div>
+                    <h4 style="margin: 0.5rem 0; color: #333;">
+                        {doc['code']} - {doc['title']}
+                    </h4>
+                    <p style="color: #666; margin: 0;">
+                        🏢 Comité: {doc['committee']} • 📅 Année: {doc['year']}
+                    </p>
+                </div>
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        col1, col2 = st.columns([3, 1])
+        with col2:
+            st.link_button(
+                "📄 Télécharger PDF",
+                doc['pdf_url'],
+                type="primary",
+                use_container_width=True
+            )
+
 # Initialisation de l'état de session
 if 'documents' not in st.session_state:
     st.session_state.documents = []
     st.session_state.last_update = None
 
-# --- Interface Utilisateur ---
-st.title("📋 Moniteur Codex Alimentarius Amélioré")
-st.markdown("Extraction et affichage des documents CXC, CXS et CXG avec liens de téléchargement.")
+# Interface utilisateur principale
+st.markdown("""
+<div class="main-header">
+    <h1 style="margin: 0;">🔬 Codex Alimentarius Monitor</h1>
+    <p style="margin: 0.5rem 0 0 0; opacity: 0.9;">
+        Exploration et suivi des normes alimentaires internationales
+    </p>
+</div>
+""", unsafe_allow_html=True)
 
-# Barre latérale
+# Barre latérale améliorée
 with st.sidebar:
-    st.header("🎛️ Contrôles")
+    st.markdown("### 🎛️ Centre de Contrôle")
     
-    if st.button("🔄 Charger/Mettre à jour les Documents", type="primary"):
-        with st.spinner("Extraction en cours..."):
-            all_documents = []
-            progress_bar = st.progress(0)
-            status_text = st.empty()
-            
-            for i, (cat_key, cat_info) in enumerate(CODEX_CATEGORIES.items()):
-                status_text.info(f"Extraction de {cat_info['name']}...")
-                docs = extract_documents_from_url(cat_info['url'], cat_key)
-                all_documents.extend(docs)
-                progress_bar.progress((i + 1) / len(CODEX_CATEGORIES))
-                time.sleep(0.5) # Petite pause
-            
-            status_text.empty()
-            st.session_state.documents = all_documents
-            st.session_state.last_update = datetime.now()
-            st.success("✅ Chargement terminé!")
-
-    if st.session_state.last_update:
-        st.caption(f"Dernière mise à jour : {st.session_state.last_update.strftime('%d/%m/%Y à %H:%M:%S')}")
+    # Section de chargement des données
+    with st.container():
+        st.markdown("#### 📊 Données")
+        if st.button("🔄 Actualiser les Documents", type="primary", use_container_width=True):
+            with st.spinner("🔍 Extraction en cours..."):
+                all_documents = []
+                progress_bar = st.progress(0)
+                status_container = st.container()
+                
+                for i, (cat_key, cat_info) in enumerate(CODEX_CATEGORIES.items()):
+                    with status_container:
+                        st.info(f"{cat_info['icon']} Extraction de {cat_info['name']}...")
+                    docs = extract_documents_from_url(cat_info['url'], cat_key)
+                    all_documents.extend(docs)
+                    progress_bar.progress((i + 1) / len(CODEX_CATEGORIES))
+                    time.sleep(0.5)
+                
+                st.session_state.documents = all_documents
+                st.session_state.last_update = datetime.now()
+                status_container.empty()
+                st.success("✅ Données actualisées!")
 
+        if st.session_state.last_update:
+            st.caption(f"🕒 Dernière mise à jour: {st.session_state.last_update.strftime('%d/%m/%Y à %H:%M')}")
+    
     st.divider()
-    st.header("🔍 Filtres")
     
+    # Filtres avancés
     if st.session_state.documents:
-        df_all = pd.DataFrame(st.session_state.documents)
+        st.markdown("#### 🔍 Filtres Avancés")
         
-        # Filtre par catégorie
-        categories = ['Toutes'] + list(df_all['category_name'].unique())
-        selected_category = st.selectbox("Catégorie:", categories)
+        with st.container():
+            df_all = pd.DataFrame(st.session_state.documents)
+            
+            # Filtre par catégorie avec icônes
+            categories = ['🌐 Toutes les catégories'] + [f"{CODEX_CATEGORIES[cat]['icon']} {name}" 
+                         for cat, name in df_all.groupby('category')['category_name'].first().items()]
+            selected_category = st.selectbox("Catégorie:", categories)
+
+            # Filtre par comité
+            committees = ['🏢 Tous les comités'] + sorted([f"🏢 {c}" for c in df_all['committee'].unique()])
+            selected_committee = st.selectbox("Comité:", committees)
 
-        # Filtre par comité
-        committees = ['Tous'] + sorted(df_all['committee'].unique())
-        selected_committee = st.selectbox("Comité:", committees)
+            # Filtres de statut
+            col1, col2 = st.columns(2)
+            with col1:
+                filter_new = st.checkbox("✨ Nouveaux")
+            with col2:
+                filter_updated = st.checkbox("🔄 Mis à jour")
 
-        # Filtre par nouveauté
-        st.subheader("Statut")
-        filter_new = st.checkbox("Nouveaux (2 dernières années)")
-        filter_updated = st.checkbox("Mis à jour cette année")
+            # Filtre par année
+            years = sorted(df_all[df_all['year'] > 0]['year'].unique(), reverse=True)
+            if years:
+                year_range = st.select_slider(
+                    "📅 Période:",
+                    options=years,
+                    value=(years[-1], years[0])
+                )
 
-        # Recherche textuelle
-        search_term = st.text_input("🔍 Recherche (code ou titre):")
+            # Recherche textuelle
+            search_term = st.text_input("🔍 Recherche:", placeholder="Code ou titre...")
 
-        # Application des filtres
-        filtered_df = df_all.copy()
+            # Application des filtres
+            filtered_df = df_all.copy()
 
-        if selected_category != 'Toutes':
-            filtered_df = filtered_df[filtered_df['category_name'] == selected_category]
+            if not selected_category.startswith('🌐'):
+                cat_name = selected_category.split(' ', 1)[1]
+                filtered_df = filtered_df[filtered_df['category_name'] == cat_name]
 
-        if selected_committee != 'Tous':
-            filtered_df = filtered_df[filtered_df['committee'] == selected_committee]
+            if not selected_committee.startswith('🏢 Tous'):
+                committee_name = selected_committee.split(' ', 1)[1]
+                filtered_df = filtered_df[filtered_df['committee'] == committee_name]
 
-        if filter_new:
-            filtered_df = filtered_df[filtered_df['is_new']]
+            if filter_new:
+                filtered_df = filtered_df[filtered_df['is_new']]
 
-        if filter_updated:
-            filtered_df = filtered_df[filtered_df['is_updated']]
+            if filter_updated:
+                filtered_df = filtered_df[filtered_df['is_updated']]
 
-        if search_term:
-            filtered_df = filtered_df[
-                filtered_df['title'].str.contains(search_term, case=False, na=False) |
-                filtered_df['code'].str.contains(search_term, case=False, na=False)
-            ]
-        
-        # Stocker le DataFrame filtré dans st.session_state pour l'utiliser ailleurs
-        st.session_state.filtered_df = filtered_df
-    else:
-        st.info("Chargez les documents pour activer les filtres.")
+            if 'year_range' in locals() and years:
+                filtered_df = filtered_df[
+                    (filtered_df['year'] >= year_range[0]) & 
+                    (filtered_df['year'] <= year_range[1])
+                ]
 
-# Afficher les documents
+            if search_term:
+                filtered_df = filtered_df[
+                    filtered_df['title'].str.contains(search_term, case=False, na=False) |
+                    filtered_df['code'].str.contains(search_term, case=False, na=False)
+                ]
+
+            st.session_state.filtered_df = filtered_df
+            
+            st.markdown(f"**📊 {len(filtered_df)} documents trouvés**")
+
+# Contenu principal
 if st.session_state.documents:
     df_display = st.session_state.get('filtered_df', pd.DataFrame(st.session_state.documents))
-    
-    # Trier par année (desc) puis code
     df_display = df_display.sort_values(by=['year', 'code'], ascending=[False, True]).reset_index(drop=True)
     
-    st.divider()
-    st.subheader(f"📚 Documents ({len(df_display)} trouvés)")
+    # Onglets pour différentes vues
+    tab1, tab2, tab3, tab4 = st.tabs(["📊 Dashboard", "📋 Aperçu", "📈 Analyses", "📄 Documents"])
     
-    # Affichage dans des "cartes" pour chaque document
-    for index, doc in df_display.iterrows():
-        with st.container(border=True):
-            col1, col2 = st.columns([3, 1])
+    with tab1:
+        create_dashboard_metrics(df_display)
+        create_category_overview(df_display)
+    
+    with tab2:
+        st.subheader("📋 Résumé Exécutif")
+        if not df_display.empty:
+            col1, col2 = st.columns(2)
+            with col1:
+                st.markdown("##### 📊 Statistiques Générales")
+                st.write(f"• **Total documents**: {len(df_display)}")
+                st.write(f"• **Nouveaux documents**: {len(df_display[df_display['is_new']])}")
+                st.write(f"• **Mis à jour cette année**: {len(df_display[df_display['is_updated']])}")
+                st.write(f"• **Période couverte**: {df_display['year'].min()} - {df_display['year'].max()}")
+            
+            with col2:
+                st.markdown("##### 🏢 Top 5 Comités")
+                top_committees = df_display['committee'].value_counts().head().reset_index()
+                for _, row in top_committees.iterrows():
+                    st.write(f"• **{row['committee']}**: {row['count']} documents")
+    
+    with tab3:
+        create_visualization(df_display)
+    
+    with tab4:
+        st.subheader(f"📄 Documents ({len(df_display)} résultats)")
+        display_documents_grid(df_display)
+        
+        # Options d'export
+        if not df_display.empty:
+            st.divider()
+            st.subheader("💾 Exporter les Données")
+            col1, col2, col3 = st.columns(3)
             
             with col1:
-                # Titre et code
-                badge_html = f"<strong>{doc['code']}</strong> "
-                if doc['is_new']:
-                    badge_html += "<span style='background-color: #90EE90; color: black; padding: 2px 6px; border-radius: 4px; font-size: 0.8em; margin-left: 5px;'>NOUVEAU</span>"
-                if doc['is_updated']:
-                     badge_html += "<span style='background-color: #87CEEB; color: black; padding: 2px 6px; border-radius: 4px; font-size: 0.8em; margin-left: 5px;'>MIS À JOUR</span>"
-                badge_html += f" <span style='background-color: #D3D3D3; color: black; padding: 2px 6px; border-radius: 4px; font-size: 0.8em; margin-left: 5px;'>{doc['category_name']}</span>"
-                st.markdown(badge_html, unsafe_allow_html=True)
-                
-                st.markdown(f"**{doc['title']}**")
-                st.caption(f"🏢 Comité: {doc['committee']} | 📅 Année: {doc['year']}")
+                csv = df_display.to_csv(index=False, sep=';')
+                st.download_button(
+                    label="📊 Télécharger CSV",
+                    data=csv,
+                    file_name=f"codex_documents_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                    mime="text/csv",
+                    use_container_width=True
+                )
             
             with col2:
-                # Lien de téléchargement
-                st.link_button("📄 Télécharger le PDF", doc['pdf_url'], type="primary", use_container_width=True)
+                json_str = df_display.to_json(orient='records', indent=2)
+                st.download_button(
+                    label="📋 Télécharger JSON",
+                    data=json_str,
+                    file_name=f"codex_documents_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
+                    mime="application/json",
+                    use_container_width=True
+                )
             
-            st.divider()
-
-    # Option d'export
-    st.divider()
-    st.subheader("💾 Exporter les données filtrées")
-    col1, col2 = st.columns(2)
-    with col1:
-        csv = df_display.to_csv(index=False, sep=';')
-        st.download_button(
-            label="📄 Télécharger en CSV",
-            data=csv,
-            file_name=f"codex_documents_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
-            mime="text/csv",
-        )
-    with col2:
-        json_str = df_display.to_json(orient='records', indent=2)
-        st.download_button(
-            label="📋 Télécharger en JSON",
-            data=json_str,
-            file_name=f"codex_documents_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
-            mime="application/json",
-        )
+            with col3:
+                # Export Excel (nécessiterait openpyxl)
+                st.button("📈 Exporter Excel", disabled=True, help="Fonctionnalité à venir")
 
 else:
-    st.info("👈 Cliquez sur le bouton 'Charger/Mettre à jour les Documents' dans la barre latérale pour démarrer.")
+    # Page d'accueil avec instructions
+    col1, col2, col3 = st.columns([1, 2, 1])
+    with col2:
+        st.markdown("""
+        <div style="text-align: center; padding: 3rem; background: #f8f9fa; border-radius: 10px; margin: 2rem 0;">
+            <h2 style="color: #667eea;">🚀 Commencer l'Exploration</h2>
+            <p style="color: #666; margin: 1rem 0;">
+                Cliquez sur le bouton "Actualiser les Documents" dans la barre latérale 
+                pour charger les dernières données du Codex Alimentarius.
+            </p>
+            <div style="margin: 2rem 0;">
+                <p style="font-size: 3rem; margin: 0;">📊</p>
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        # Informations sur l'application
+        with st.expander("ℹ️ À propos de cette application"):
+            st.markdown("""
+            **Codex Alimentarius Monitor** vous permet de:
+            
+            - 📊 **Explorer** les normes alimentaires internationales
+            - 🔍 **Rechercher** et filtrer les documents par catégorie, comité, année
+            - 📈 **Visualiser** les tendances et statistiques
+            - 📄 **Télécharger** les documents PDF officiels
+            - 💾 **Exporter** les données pour analyse externe
+            
+            **Catégories disponibles:**
+            - 📋 **Codes de Pratique (CXC)** - Procédures et bonnes pratiques
+            - ⚖️ **Normes (CXS)** - Standards alimentaires officiels  
+            - 📖 **Directives (CXG)** - Lignes directrices et recommandations
+            """)