Update app.py

app.py

@@ -1,188 +1,225 @@
-import pandas as pd
 import duckdb
 import polars as pl
 import pyarrow.csv as pv
-import pyarrow.parquet as pq
+
 import time
 import os
-
-
 import tempfile
 import matplotlib.pyplot as plt
+import numpy as np
 
 # === DEBUG + TEST RAPIDE ===
 print("=== APP STARTING ===")
-st.success("App démarrée avec succès !")
+
 
 # === CONFIG PAGE ===
 st.set_page_config(
-    page_title="⚡ Speed Loader Benchmark",
-    page_icon="⚡",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# === CSS POUR BOUTONS ÉGAUX + BEAUX ===
-st.markdown("""
-<style>
-    .stButton > button {
-        height: 7rem !important;
-        font-size: 1.1rem !important;
-        font-weight: bold;
-        border-radius: 12px;
-        border: 2px solid #e0e0e0;
         background: linear-gradient(145deg, #f5f5f5, #e0e0e0);
         box-shadow: 4px 4px 8px #cbced1, -4px -4px 8px #ffffff;
         transition: all 0.3s;
+        white-space: pre-line;
+        text-align: center;
     }
     .stButton > button:hover {
         border: 2px solid #4CAF50;
-        transform: translateY(-2px);
-        box-shadow: 0 10px 20px rgba(0,0,0,0.1);
-    }
     .stButton > button:active {
         transform: translateY(2px);
     }
+    .benchmark-btn {
+        height: 4rem !important;
+        font-size: 1rem !important;
+    }
 </style>
 """, unsafe_allow_html=True)
 
-# === FONCTIONS DE CHARGEMENT ===
-def load_with_pandas(path):
+# === FONCTIONS DE CHARGEMENT (CORRIGÉES POUR newlines_in_values) ===
+def load_with_pandas(file_path):
     start = time.time()
-    df = pd.read_csv(path)
+    df = pd.read_csv(file_path)
     return df, time.time() - start
 
-def load_with_polars(path):
+def load_with_polars(file_path):
     start = time.time()
-    df = pl.read_csv(path)
-    return df.to_pandas(), time.time() - start
+    df = pl.read_csv(file_path, infer_schema_length=10000).to_pandas()
+    return df, time.time() - start
 
-def load_with_duckdb(path):
+def load_with_duckdb(file_path):
     start = time.time()
-    df = duckdb.read_csv(path).df()
+    df = duckdb.read_csv(file_path).df()
     return df, time.time() - start
 
-def load_with_pyarrow(path):
+def load_with_pyarrow(file_path):
     start = time.time()
-    table = pv.read_csv(path)
+    # CORRECTION: Active newlines_in_values pour gérer les sauts de ligne dans les cellules
+    parse_options = pv.ParseOptions(newlines_in_values=True)
+    table = pv.read_csv(file_path, parse_options=parse_options)
     df = table.to_pandas()
     return df, time.time() - start
 
-# === SIDEBAR ===
+# === INITIALISATION SESSION STATE ===
+if 'file_path' not in st.session_state:
+    st.session_state.file_path = None
+if 'file_name' not in st.session_state:
+    st.session_state.file_name = None
+if 'temp_file' not in st.session_state:
+    st.session_state.temp_file = None
+
+# === SIDEBAR AVEC TOUS LES BOUTONS ===
 st.sidebar.markdown("# ⚡ Speed Benchmark")
 st.sidebar.markdown("### 🧪 Fichiers de test (~30 Mo)")
 
-col1, col2 = st.sidebar.columns(2)
-
-with col1:
-    if st.button("🧑‍💻 Faker\nText", use_container_width=True, type="secondary"):
         if os.path.exists("faker_text.csv"):
             st.session_state.file_path = "faker_text.csv"
             st.session_state.file_name = "faker_text.csv"
+            st.rerun()
         else:
-            st.sidebar.error("faker_text.csv manquant")
+            st.sidebar.error("❌ faker_text.csv manquant")
 
 with col2:
     if st.button("🔢 Numeric\nOnly", use_container_width=True, type="secondary"):
         if os.path.exists("numeric_only.csv"):
             st.session_state.file_path = "numeric_only.csv"
             st.session_state.file_name = "numeric_only.csv"
+            st.rerun()
         else:
-            st.sidebar.error("numeric_only.csv manquant")
+            st.sidebar.error("❌ numeric_only.csv manquant")
 
 st.sidebar.markdown("---")
 
+# Uploader dans sidebar
 uploaded_file = st.sidebar.file_uploader(
     "📁 Ou chargez votre fichier",
     type=["csv", "parquet", "txt"],
-    help="CSV, Parquet"
 )
 
 if uploaded_file is not None:
-    bytes_data = uploaded_file.read()
-    with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(uploaded_file.name)[1]) as tmp:
-        tmp.write(bytes_data)
-        st.session_state.file_path = tmp.name
-        st.session_state.file_name = uploaded_file.name
-        st.session_state.temp_file = tmp.name  # pour nettoyage
-    st.sidebar.success(f"Chargé : {uploaded_file.name}")
-
-# === MAIN TITLE ===
+    try:
+        bytes_data = uploaded_file.read()
+        suffix = os.path.splitext(uploaded_file.name)[1]
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+            tmp.write(bytes_data)
+            st.session_state.file_path = tmp.name
+            st.session_state.file_name = uploaded_file.name
+            st.session_state.temp_file = tmp.name
+        st.sidebar.success(f"✅ Chargé : {uploaded_file.name} ({uploaded_file.size / (1024*1024):.1f} Mo)")
+        st.rerun()
+    except Exception as e:
+        st.sidebar.error(f"❌ Erreur upload : {str(e)}")
+
+# === MAIN CONTENT ===
 st.title("⚡ Comparaison de vitesse de chargement")
-st.markdown("**Qui est le plus rapide en 2025 ?**")
+st.markdown("**Pandas vs Polars vs DuckDB vs PyArrow** - Qui gagne en 2025 ?")
 
-if 'file_path' not in st.session_state:
-    st.info("👈 Choisissez un fichier de test ou uploadez le vôtre")
+if st.session_state.file_path is None:
+    st.info("👈 **Choisissez un fichier** dans la barre latérale (boutons de test ou upload)")
     st.stop()
 
 file_path = st.session_state.file_path
 file_name = st.session_state.file_name
 
-st.markdown(f"### 📊 Fichier sélectionné : `{file_name}`")
+st.markdown(f"### 📊 Fichier actif : `{file_name}`")
 
-if st.button("🚀 Lancer le benchmark complet", type="primary", use_container_width=True):
-    st.markdown("### ⏱️ Résultats en direct")
+# === BOUTONS DE LANCEMENT DANS LA SIDEBAR ===
+st.sidebar.markdown("### 🚀 Lancer le test")
+run_benchmark = st.sidebar.button("⚡ Benchmark Complet", use_container_width=True, type="primary", help="Teste tous les moteurs")
 
+if run_benchmark:
+    st.markdown("### ⏱️ Résultats en direct")
+    
     results = []
-
+    errors = []
+    
     # === 1. Pandas ===
-    with st.spinner("Pandas (référence)..."):
-        df, t = load_with_pandas(file_path)
-        results.append(("🐼 Pandas", t))
-        st.success(f"Pandas → {t:.3f}s")
+    with st.spinner("🐼 Pandas (baseline)..."):
+        try:
+            df, t = load_with_pandas(file_path)
+            results.append(("🐼 Pandas", t, len(df)))
+            st.success(f"✅ Pandas → {t:.3f}s | {len(df):,} lignes")
+        except Exception as e:
+            errors.append(("🐼 Pandas", str(e)))
+            st.error(f"❌ Pandas : {str(e)}")
 
     # === 2. Polars ===
-    with st.spinner("Polars (le roi)..."):
-        df, t = load_with_polars(file_path)
-        results.append(("⚡ Polars", t))
-        st.success(f"Polars → {t:.3f}s")
+    with st.spinner("⚡ Polars (le challenger)..."):
+        try:
+            df, t = load_with_polars(file_path)
+            results.append(("⚡ Polars", t, len(df)))
+            st.success(f"✅ Polars → {t:.3f}s | {len(df):,} lignes")
+        except Exception as e:
+            errors.append(("⚡ Polars", str(e)))
+            st.error(f"❌ Polars : {str(e)}")
 
     # === 3. DuckDB ===
-    with st.spinner("DuckDB (SQL power)..."):
-        df, t = load_with_duckdb(file_path)
-        results.append(("🦆 DuckDB", t))
-        st.success(f"DuckDB → {t:.3f}s")
+    with st.spinner("🦆 DuckDB (SQL magic)..."):
+        try:
+            df, t = load_with_duckdb(file_path)
+            results.append(("🦆 DuckDB", t, len(df)))
+            st.success(f"✅ DuckDB → {t:.3f}s | {len(df):,} lignes")
+        except Exception as e:
+            errors.append(("🦆 DuckDB", str(e)))
+            st.error(f"❌ DuckDB : {str(e)}")
 
     # === 4. PyArrow ===
-    with st.spinner("PyArrow (C++ speed)..."):
-        df, t = load_with_pyarrow(file_path)
-        results.append(("🏹 PyArrow", t))
-        st.success(f"PyArrow → {t:.3f}s")
-
-    # === Nettoyage temp file si upload ===
-    if hasattr(st.session_state, 'temp_file'):
-
-
-
-
+    with st.spinner("🏹 PyArrow (C++ power)..."):
+        try:
+            df, t = load_with_pyarrow(file_path)
+            results.append(("🏹 PyArrow", t, len(df)))
+            st.success(f"✅ PyArrow → {t:.3f}s | {len(df):,} lignes")
+        except Exception as e:
+            errors.append(("🏹 PyArrow", str(e)))
+            st.error(f"❌ PyArrow : {str(e)}")
+
+    # === NETTOYAGE TEMP FILE ===
+    if st.session_state.temp_file:
         try:
             os.unlink(st.session_state.temp_file)
-
+            st.session_state.temp_file = None
         except:
             pass
 
-
-
-    # === GRAPHIQUE FINAL ===
-    results_df = pd.DataFrame(results, columns=["Moteur", "Temps (s)"]).sort_values("Temps (s)")
-
-    fig, ax = plt.subplots(figsize=(10, 6))
-    colors = ["#FF6B6B", "#4ECDC4", "#45B7D1", "#96CEB4"]
-    bars = ax.barh(results_df["Moteur"], results_df["Temps (s)"], color=colors)
-
-    for i, bar in enumerate(bars):
-        width = bar.get_width()
-        ax.text(width + max(results_df["Temps (s)"]) * 0.01, bar.get_y() + bar.get_height()/2,
-                f'{width:.3f}s', va='center', fontweight='bold', fontsize=12)
-
-    ax.set_xlabel("Temps de chargement (secondes)", fontsize=12)
-    ax.set_title(f"🏆 Vainqueur : {results_df.iloc[0]['Moteur']} ({results_df.iloc[0]['Temps (s)']:.3f}s)", 
-                 fontsize=16, fontweight="bold", color="#1A5F7A")
-    ax.invert_yaxis()
-    ax.grid(axis='x', alpha=0.3)
-
-    st.pyplot(fig)
-    plt.close(fig)
-
-    st.balloons()
-    st.markdown("### 🔥 **Polars gagne 99% du temps en 2025 !**")
+    # === AFFICHAGE ERREURS SI IL Y EN A ===
+    if errors:
+        st.error("⚠️ Erreurs rencontrées :")
+        for lib, err in errors:
+            st.write(f"**{lib}** : {err}")
+
+    # === GRAPHIQUE FINAL (SEULEMENT SI RÉSULTATS VALIDES) ===
+    if results:
+        results_df = pd.DataFrame(results, columns=["Moteur", "Temps (s)", "Lignes"]).sort_values("Temps (s)")
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            st.metric("🏆 Vainqueur", results_df.iloc[0]["Moteur"])
+            st.metric("Temps min", f"{results_df.iloc[0]['Temps (s)']:.3f}s")
+        
+        with col2:
+            st.metric("📊 Fichier", f"{len(results_df.iloc[0]['Lignes']):,} lignes")
+            st.metric("Moteurs testés", len(results_df))
+
+        fig, ax = plt.subplots(figsize=(10, 6))
+        colors = ["#FF6B6B", "#4ECDC4", "#45B7D1", "#96CEB4"]
+        bars = ax.barh(results_df["Moteur"], results_df["Temps (s)"], color=colors)
+
+        max_time = results_df["Temps (s)"].max()
+        for i, bar in enumerate(bars):
+            width = bar.get_width()
+            ax.text(width + max_time * 0.01, bar.get_y() + bar.get_height()/2,
+                    f'{width:.3f}s', va='center', fontweight='bold', fontsize=12)
+
+        ax.set_xlabel("Temps de chargement (secondes)", fontsize=12)
+        ax.set_title(f"🏆 {results_df.iloc[0]['Moteur']} domine ! ({results_df.iloc[0]['Temps (s)']:.3f}s)", 
+                     fontsize=16, fontweight="bold", color="#1A5F7A")
+        ax.invert_yaxis()
+        ax.grid(axis='x', alpha=0.3)
+
+        st.pyplot(fig)
+        plt.close(fig)
+
+        # === BALLOONS POUR LA JOIE ===
+        st.balloons()
+
+        st.markdown("### 🔥 **Insights 2025 : Polars explose souvent Pandas ×3-5 !**")
+
+# === FOOTER ===
+st.markdown("---")
+st.markdown("*App benchmarkée sur Hugging Face Spaces - Décembre 2025*")