Upload 4 files

IMport des fichiers

Dockerfile

@@ -1,20 +1,34 @@
-FROM python:3.13.5-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    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"]
+# syntax = docker/dockerfile:1.4
+FROM python:3.12-slim
+
+# Installe les dépendances système nécessaires
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    g++ \
+    libjpeg62-turbo-dev \
+    zlib1g-dev \
+    libpng-dev \
+    libfreetype6-dev \
+    libopenjp2-7-dev \
+    libtiff5-dev \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copie requirements en premier (meilleur cache)
+COPY requirements.txt .
+
+# Installe tout (sans cache pour réduire la taille finale)
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copie le code
+COPY app.py .
+
+# Port + commande obligatoire pour HF Spaces
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health || exit 1
+
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0", "--server.enableCORS=false", "--server.enableXsrfProtection=false"]

README.md

@@ -1,19 +1,57 @@
----
-title: Coach Code Python
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Assess your Python programming skills
----
-
-# 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: Coach Code Python
+emoji: 🐍
+colorFrom: green
+colorTo: green
+sdk: docker
+app_port: 8501
+pinned: false
+---
+
+# 🐍 Coach Code Python
+
+Application Streamlit pour analyser et corriger automatiquement votre code Python avec Ruff.
+
+## Fonctionnalités
+
+- **Analyse de code** : Détection automatique de tous les problèmes de qualité
+- **Correction automatique** : Applique les corrections recommandées par Ruff
+- **Support multi-fichiers** : Analysez un fichier unique ou plusieurs fichiers simultanément
+- **Visualisations interactives** : Graphiques des erreurs par catégorie
+- **Comparaison avant/après** : Visualisez les modifications apportées au code
+- **Options configurables** :
+  - Désactiver l'obligation des commentaires (docstrings)
+  - Garder le code compact (sans espaces excessifs)
+  - Activer les corrections forcées (modernisation du code)
+
+## Catégories d'analyse
+
+- **F** : Erreurs Logiques
+- **E** : Style PEP8
+- **W** : Avertissements
+- **I** : Tri des Imports
+- **B** : Bugs Potentiels
+- **UP** : Modernisation
+- **N** : Nommage
+- **D** : Documentation
+- **ANN** : Annotations de type
+- **T** : Tests & Debug
+- **A** : Built-ins
+
+## Utilisation
+
+1. Sélectionnez votre mode (fichier unique ou plusieurs fichiers)
+2. Uploadez votre/vos fichier(s) Python (.py)
+3. Configurez les options de correction selon vos besoins
+4. Cliquez sur "🚀 Analyser & Corriger"
+5. Consultez les résultats dans les différents onglets :
+   - **📊 Statistiques** : Graphiques des erreurs détectées
+   - **📜 Rapport** : Liste détaillée de tous les problèmes
+   - **🔍 Comparatif** : Code avant/après (mode fichier unique)
+
+## Métriques affichées
+
+- **Qualité du Code** : Score sur 100 basé sur le nombre d'erreurs
+- **Points corrigés** : Nombre total de problèmes détectés
+- **Lignes modifiées** : Différence de lignes de code
+- **Gain de poids** : Réduction de la taille du fichier en octets

app.py

@@ -0,0 +1,220 @@
+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():
+        shutil.rmtree(".ruff_cache")
+else:
+    st.info("👈 Veuillez sélectionner un ou plusieurs fichiers Python dans la barre latérale pour commencer l'analyse.")

requirements.txt

@@ -1,3 +1,4 @@
-altair
-pandas
-streamlit
+streamlit==1.40.2
+pandas==2.2.3
+plotly==5.24.1
+ruff==0.8.4