Update app.py

app.py

@@ -1,218 +1,239 @@
-import streamlit as st
-import os
-import sys
-import subprocess
-import json
-import pandas as pd
-import plotly.express as px
-import shutil
-import tempfile
-from pathlib import Path
-
-# --- CONFIGURATION ---
-st.set_page_config(page_title="Coach Code Python", layout="wide")
-
-# Dictionnaire pédagogique mis à jour avec les lettres
-RUFF_CAT_MAP = {
-    "F": "Erreurs Logiques (F)",
-    "E": "Style PEP8 (E)",
-    "W": "Avertissements (W)",
-    "I": "Tri des Imports (I)",
-    "B": "Bugs Potentiels (B)",
-    "UP": "Modernisation (UP)",
-    "N": "Nommage (N)",
-    "D": "Documentation (D)",
-    "ANN": "Annotations de type (ANN)",
-    "T": "Tests & Debug (T)",
-    "A": "Built-ins (A)"
-}
-
-def remove_excessive_blank_lines(code):
-    """Supprime les lignes vides excessives (plus de 1 ligne vide consécutive)"""
-    lines = code.split('\n')
-    result = []
-    blank_count = 0
-    
-    for line in lines:
-        if line.strip() == '':
-            blank_count += 1
-            if blank_count <= 1:  # Garde max 1 ligne vide
-                result.append(line)
-        else:
-            blank_count = 0
-            result.append(line)
-    
-    return '\n'.join(result)
-
-
-def run_ruff(paths, fix=False, disable_docs=False, compact=False, unsafe=False):
-    """Exécute l'analyse et le formatage Ruff"""
-    ignore_list = []
-    
-    if compact:
-        ignore_list.extend(["E302", "E303", "E305", "E301", "E401", "W391"])
-    
-    if disable_docs:
-        ignore_list.extend(["D100", "D101", "D102", "D103", "D104", "D107"])
-
-    cmd_check = [
-        sys.executable, "-m", "ruff", "check", *paths,
-        "--output-format", "json",
-        "--select", "ALL",
-        "--isolated", "--no-cache",
-    ]
-    
-    if ignore_list:
-        cmd_check.extend(["--ignore", ",".join(ignore_list)])
-    
-    if fix:
-        cmd_check.append("--fix")
-        if unsafe:
-            cmd_check.append("--unsafe-fixes")
-
-    use_shell = os.name == 'nt'
-    result = subprocess.run(cmd_check, capture_output=True, text=True, encoding="utf-8", shell=use_shell)
-
-    if fix:
-        cmd_format = [sys.executable, "-m", "ruff", "format", *paths, "--isolated"]
-        subprocess.run(cmd_format, capture_output=True, shell=use_shell)
-
-    try:
-        return json.loads(result.stdout) if result.stdout.strip() else []
-    except:
-        return []
-    
-def get_stats(paths):
-    total_size, total_lines = 0, 0
-    for p in paths:
-        path_obj = Path(p)
-        files = [path_obj] if path_obj.is_file() else path_obj.rglob("*.py")
-        for f in files:
-            try:
-                content = f.read_text(errors='ignore')
-                total_size += f.stat().st_size
-                total_lines += len(content.splitlines())
-            except: continue
-    return total_size, total_lines
-
-# --- SIDEBAR ---
-with st.sidebar:
-    st.title("🛡️ Configuration")
-    mode = st.radio("Source :", ["Fichier unique", "Plusieurs fichiers"], index=0)
-    
-    uploaded_files = []
-    if mode == "Fichier unique":
-        f = st.file_uploader("Fichier .py", type="py")
-        if f: uploaded_files = [f]
-    else:
-        f_list = st.file_uploader("Sélectionner fichiers", type="py", accept_multiple_files=True)
-        if f_list: uploaded_files = f_list
-
-    st.subheader("🛠️ Options de correction")
-    opt_docs = st.checkbox("Désactiver l'obligation des commentaires", value=True)
-    opt_compact = st.checkbox("Garder le code compact (sans espaces excessifs)", value=True)
-    opt_unsafe = st.checkbox("Activer les corrections forcées (modernisation)", value=True)
-
-    #st.divider()
-    btn_analyze = st.button("🚀 Analyser & Corriger", use_container_width=True)
-
-# --- ZONE CENTRALE ---
-st.title("🐍 Coach Code Python")
-
-if btn_analyze and uploaded_files:
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_workspace = Path(temp_dir)
-        work_paths, code_before, code_after = [], "", ""
-        
-        try:
-            for uploaded_file in uploaded_files:
-                file_path = temp_workspace / uploaded_file.name
-                file_data = uploaded_file.getvalue().decode("utf-8", errors="ignore")
-                if mode == "Fichier unique": code_before = file_data
-                file_path.write_text(file_data, encoding="utf-8")
-                work_paths.append(str(file_path))
-
-            s_init, l_init = get_stats(work_paths)
-            
-            # Analyse initiale
-            errors = run_ruff(work_paths, fix=False, disable_docs=opt_docs, compact=opt_compact, unsafe=opt_unsafe)
-            
-            # Correction
-            run_ruff(work_paths, fix=True, disable_docs=opt_docs, compact=opt_compact, unsafe=opt_unsafe)
-            
-            if opt_compact:
-                for path in work_paths:
-                    file_path = Path(path)
-                    content = file_path.read_text(encoding="utf-8")
-                    cleaned = remove_excessive_blank_lines(content)
-                    file_path.write_text(cleaned, encoding="utf-8")
-            
-            s_after, l_after = get_stats(work_paths)
-            
-            if mode == "Fichier unique":
-                code_after = Path(work_paths[0]).read_text(encoding="utf-8")
-
-            nb_err = len(errors)
-            score = max(0, min(100, 100 - (nb_err / (l_init if l_init > 0 else 1)) * 100))
-
-            m1, m2, m3, m4 = st.columns(4)
-            m1.metric("Qualité du Code", f"{score:.1f}/100")
-            m2.metric("Points corrigés", nb_err)
-            m3.metric("Lignes modifiées", l_init - l_after)
-            m4.metric("Gain de poids", f"{s_init - s_after} octets")
-
-            tabs = st.tabs(["📊 Statistiques", "📜 Rapport", "🔍 Comparatif"] if mode == "Fichier unique" else ["📊 Statistiques", "📜 Rapport"])
-
-            with tabs[0]:
-                if nb_err > 0:
-                    df = pd.DataFrame(errors)
-                    df['Cat_Code'] = df['code'].str[0]
-                    df['Catégorie'] = df['Cat_Code'].map(lambda x: RUFF_CAT_MAP.get(x, f"Autre ({x})"))
-
-                    c1, c2 = st.columns(2)
-                    with c1:
-                        counts = df['code'].value_counts().reset_index().sort_values('count', ascending=True)
-                        fig = px.bar(counts, x='count', y='code', orientation='h',
-                                     title="Fréquence par code d'erreur",
-                                     color='count', color_continuous_scale='Blues')
-                        st.plotly_chart(fig, use_container_width=True)
-                    with c2:
-                        cat_counts = df['Catégorie'].value_counts().reset_index().sort_values('count', ascending=False)
-                        fig2 = px.bar(cat_counts, x='count', y='Catégorie', orientation='h',
-                                      title="Problèmes par famille",
-                                      color='Catégorie', color_discrete_sequence=px.colors.qualitative.G10)
-                        fig2.update_layout(showlegend=False, yaxis={'categoryorder':'total ascending'})
-                        st.plotly_chart(fig2, use_container_width=True)
-                else:
-                    st.success("✨ Félicitations ! Ruff n'a trouvé aucune erreur.")
-
-            with tabs[1]:
-                if nb_err > 0:
-                    # --- TRANSFORMATION DES DONNÉES POUR LE TABLEAU ---
-                    report_data = []
-                    for err in errors:
-                        filename = Path(err['filename']).name
-                        line = err['location']['row']
-                        col = err['location']['column']
-                        
-                        report_data.append({
-                            "Code": err['code'],
-                            "Message": err['message'],
-                            "Localisation": f"{filename} (L:{line}, C:{col})"
-                        })
-                    
-                    st.dataframe(pd.DataFrame(report_data), use_container_width=True)
-
-            if mode == "Fichier unique":
-                with tabs[2]:
-                    col1, col2 = st.columns(2)
-                    col1.subheader("Version Originale")
-                    col1.code(code_before, language="python")
-                    col2.subheader("Version Corrigée")
-                    col2.code(code_after, language="python")
-
-        except Exception as e:
-            st.error(f"Erreur : {e}")
-        
-    if Path(".ruff_cache").exists():
+import streamlit as st
+import os
+import sys
+import subprocess
+import json
+import pandas as pd
+import plotly.express as px
+import shutil
+import tempfile
+from pathlib import Path
+
+# --- CONFIGURATION ---
+st.set_page_config(page_title="Coach Code Python", layout="wide")
+
+# Dictionnaire pédagogique mis à jour avec les lettres
+RUFF_CAT_MAP = {
+    "F": "Erreurs Logiques (F)",
+    "E": "Style PEP8 (E)",
+    "W": "Avertissements (W)",
+    "I": "Tri des Imports (I)",
+    "B": "Bugs Potentiels (B)",
+    "UP": "Modernisation (UP)",
+    "N": "Nommage (N)",
+    "D": "Documentation (D)",
+    "ANN": "Annotations de type (ANN)",
+    "T": "Tests & Debug (T)",
+    "A": "Built-ins (A)"
+}
+
+def remove_excessive_blank_lines(code):
+    """Supprime les lignes vides excessives (plus de 1 ligne vide consécutive)"""
+    lines = code.split('\n')
+    result = []
+    blank_count = 0
+    
+    for line in lines:
+        if line.strip() == '':
+            blank_count += 1
+            if blank_count <= 1:  # Garde max 1 ligne vide
+                result.append(line)
+        else:
+            blank_count = 0
+            result.append(line)
+    
+    return '\n'.join(result)
+
+
+def run_ruff(paths, fix=False, disable_docs=False, compact=False, unsafe=False):
+    """Exécute l'analyse et le formatage Ruff"""
+    ignore_list = []
+    
+    if compact:
+        ignore_list.extend(["E302", "E303", "E305", "E301", "E401", "W391"])
+    
+    if disable_docs:
+        ignore_list.extend(["D100", "D101", "D102", "D103", "D104", "D107"])
+
+    cmd_check = [
+        sys.executable, "-m", "ruff", "check", *paths,
+        "--output-format", "json",
+        "--select", "ALL",
+        "--isolated", "--no-cache",
+    ]
+    
+    if ignore_list:
+        cmd_check.extend(["--ignore", ",".join(ignore_list)])
+    
+    if fix:
+        cmd_check.append("--fix")
+        if unsafe:
+            cmd_check.append("--unsafe-fixes")
+
+    use_shell = os.name == 'nt'
+    result = subprocess.run(cmd_check, capture_output=True, text=True, encoding="utf-8", shell=use_shell)
+
+    # Debug: afficher stderr si présent
+    if result.stderr:
+        st.warning(f"Ruff stderr: {result.stderr}")
+    
+    # Debug: afficher le code de retour
+    if result.returncode not in [0, 1]:  # Ruff retourne 1 quand il y a des erreurs
+        st.error(f"Ruff return code: {result.returncode}")
+
+    if fix:
+        cmd_format = [sys.executable, "-m", "ruff", "format", *paths, "--isolated"]
+        subprocess.run(cmd_format, capture_output=True, shell=use_shell)
+
+    try:
+        return json.loads(result.stdout) if result.stdout.strip() else []
+    except Exception as e:
+        st.error(f"Erreur parsing JSON: {e}, stdout: {result.stdout[:200]}")
+        return []
+    
+def get_stats(paths):
+    total_size, total_lines = 0, 0
+    for p in paths:
+        path_obj = Path(p)
+        files = [path_obj] if path_obj.is_file() else path_obj.rglob("*.py")
+        for f in files:
+            try:
+                content = f.read_text(errors='ignore')
+                total_size += f.stat().st_size
+                total_lines += len(content.splitlines())
+            except: continue
+    return total_size, total_lines
+
+# --- SIDEBAR ---
+with st.sidebar:
+    st.title("🛡️ Configuration")
+    mode = st.radio("Source :", ["Fichier unique", "Plusieurs fichiers"], index=0)
+    
+    uploaded_files = []
+    if mode == "Fichier unique":
+        f = st.file_uploader("Fichier .py", type="py")
+        if f: uploaded_files = [f]
+    else:
+        f_list = st.file_uploader("Sélectionner fichiers", type="py", accept_multiple_files=True)
+        if f_list: uploaded_files = f_list
+
+    st.subheader("🛠️ Options de correction")
+    opt_docs = st.checkbox("Désactiver l'obligation des commentaires", value=True)
+    opt_compact = st.checkbox("Garder le code compact (sans espaces excessifs)", value=True)
+    opt_unsafe = st.checkbox("Activer les corrections forcées (modernisation)", value=True)
+
+    #st.divider()
+    btn_analyze = st.button("🚀 Analyser & Corriger", use_container_width=True)
+
+# --- ZONE CENTRALE ---
+st.title("🐍 Coach Code Python")
+
+if btn_analyze and uploaded_files:
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_workspace = Path(temp_dir)
+        work_paths, code_before, code_after = [], "", ""
+        
+        try:
+            for uploaded_file in uploaded_files:
+                file_path = temp_workspace / uploaded_file.name
+                file_data = uploaded_file.getvalue().decode("utf-8", errors="ignore")
+                if mode == "Fichier unique": code_before = file_data
+                file_path.write_text(file_data, encoding="utf-8")
+                work_paths.append(str(file_path))
+
+            s_init, l_init = get_stats(work_paths)
+            
+            # Debug: vérifier que les fichiers existent
+            st.info(f"Fichiers créés: {[str(p) for p in work_paths]}")
+            for wp in work_paths:
+                if Path(wp).exists():
+                    content = Path(wp).read_text(encoding="utf-8")
+                    st.info(f"Taille fichier {Path(wp).name}: {len(content)} caractères, {len(content.splitlines())} lignes")
+            
+            # Analyse initiale
+            errors = run_ruff(work_paths, fix=False, disable_docs=opt_docs, compact=opt_compact, unsafe=opt_unsafe)
+            
+            # Debug: afficher le nombre d'erreurs trouvées
+            st.info(f"Nombre d'erreurs détectées: {len(errors)}")
+            if errors:
+                st.info(f"Première erreur: {errors[0]}")
+            
+            # Correction
+            run_ruff(work_paths, fix=True, disable_docs=opt_docs, compact=opt_compact, unsafe=opt_unsafe)
+            
+            if opt_compact:
+                for path in work_paths:
+                    file_path = Path(path)
+                    content = file_path.read_text(encoding="utf-8")
+                    cleaned = remove_excessive_blank_lines(content)
+                    file_path.write_text(cleaned, encoding="utf-8")
+            
+            s_after, l_after = get_stats(work_paths)
+            
+            if mode == "Fichier unique":
+                code_after = Path(work_paths[0]).read_text(encoding="utf-8")
+
+            nb_err = len(errors)
+            score = max(0, min(100, 100 - (nb_err / (l_init if l_init > 0 else 1)) * 100))
+
+            m1, m2, m3, m4 = st.columns(4)
+            m1.metric("Qualité du Code", f"{score:.1f}/100")
+            m2.metric("Points corrigés", nb_err)
+            m3.metric("Lignes modifiées", l_init - l_after)
+            m4.metric("Gain de poids", f"{s_init - s_after} octets")
+
+            tabs = st.tabs(["📊 Statistiques", "📜 Rapport", "🔍 Comparatif"] if mode == "Fichier unique" else ["📊 Statistiques", "📜 Rapport"])
+
+            with tabs[0]:
+                if nb_err > 0:
+                    df = pd.DataFrame(errors)
+                    df['Cat_Code'] = df['code'].str[0]
+                    df['Catégorie'] = df['Cat_Code'].map(lambda x: RUFF_CAT_MAP.get(x, f"Autre ({x})"))
+
+                    c1, c2 = st.columns(2)
+                    with c1:
+                        counts = df['code'].value_counts().reset_index().sort_values('count', ascending=True)
+                        fig = px.bar(counts, x='count', y='code', orientation='h',
+                                     title="Fréquence par code d'erreur",
+                                     color='count', color_continuous_scale='Blues')
+                        st.plotly_chart(fig, use_container_width=True)
+                    with c2:
+                        cat_counts = df['Catégorie'].value_counts().reset_index().sort_values('count', ascending=False)
+                        fig2 = px.bar(cat_counts, x='count', y='Catégorie', orientation='h',
+                                      title="Problèmes par famille",
+                                      color='Catégorie', color_discrete_sequence=px.colors.qualitative.G10)
+                        fig2.update_layout(showlegend=False, yaxis={'categoryorder':'total ascending'})
+                        st.plotly_chart(fig2, use_container_width=True)
+                else:
+                    st.success("✨ Félicitations ! Ruff n'a trouvé aucune erreur.")
+
+            with tabs[1]:
+                if nb_err > 0:
+                    # --- TRANSFORMATION DES DONNÉES POUR LE TABLEAU ---
+                    report_data = []
+                    for err in errors:
+                        filename = Path(err['filename']).name
+                        line = err['location']['row']
+                        col = err['location']['column']
+                        
+                        report_data.append({
+                            "Code": err['code'],
+                            "Message": err['message'],
+                            "Localisation": f"{filename} (L:{line}, C:{col})"
+                        })
+                    
+                    st.dataframe(pd.DataFrame(report_data), use_container_width=True)
+
+            if mode == "Fichier unique":
+                with tabs[2]:
+                    col1, col2 = st.columns(2)
+                    col1.subheader("Version Originale")
+                    col1.code(code_before, language="python")
+                    col2.subheader("Version Corrigée")
+                    col2.code(code_after, language="python")
+
+        except Exception as e:
+            st.error(f"Erreur : {e}")
+        
+    if Path(".ruff_cache").exists():
         shutil.rmtree(".ruff_cache")