🚀 Auto-deploy from GitHub Actions - 2026-02-28 23:08:07

.env.example

@@ -0,0 +1,40 @@
+# ==============================================
+# NeonDB Configuration
+# ==============================================
+# Get your connection string from: https://console.neon.tech
+# Format: postgresql://user:password@host/database?sslmode=require
+NEON_DB="postgresql://user:password@ep-xyz-123.us-east-2.aws.neon.tech/neondb?sslmode=require"
+
+# ==============================================
+# HuggingFace Configuration (Optional - for local testing)
+# ==============================================
+# Only needed if you want to test HF deployment locally
+# Get your token from: https://huggingface.co/settings/tokens
+HF_TOKEN="hf_xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+HF_USERNAME="your-username"
+SPACE_NAME="job-tracker"
+
+# ==============================================
+# Application Configuration (Optional)
+# ==============================================
+# Uncomment and modify if needed
+
+# Application name
+# APP_NAME="Job Tracker"
+
+# Debug mode (development only)
+# DEBUG=False
+
+# Session timeout (minutes)
+# SESSION_TIMEOUT=30
+
+# Max file upload size (MB)
+# MAX_UPLOAD_SIZE=10
+
+# ==============================================
+# Notes
+# ==============================================
+# 1. Copy this file to .env and fill in your values
+# 2. NEVER commit .env to git (it's in .gitignore)
+# 3. For production, set NEON_DB in HuggingFace Space secrets
+# 4. For GitHub Actions, set HF_TOKEN, HF_USERNAME, SPACE_NAME in GitHub Secrets

.gitignore

@@ -0,0 +1,32 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+.venv/
+
+# Secrets
+.env
+*.pem
+*.key
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Streamlit
+.streamlit/secrets.toml
+
+# Tests
+.coverage
+htmlcov/
+.pytest_cache/

.streamlit/config.toml

@@ -0,0 +1,11 @@
+[theme]
+primaryColor = "#4CAF50"
+backgroundColor = "#FFFFFF"
+secondaryBackgroundColor = "#F0F2F6"
+textColor = "#262730"
+font = "sans serif"
+
+[server]
+headless = true
+port = 7860
+enableCORS = false

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Dépendances système si besoin (ex: pour psycopg2)
+RUN apt-get update && apt-get install -y \
+    gcc \
+    postgresql-client \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copie des requirements
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copie du code
+COPY . .
+
+# Port Streamlit par défaut
+EXPOSE 7860
+
+# Healthcheck (optionnel mais propre)
+HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health || exit 1
+
+# Commande de lancement
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Albert ROMANO
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,12 @@
 ---
-title: Job Tracker
-emoji: 🐠
-colorFrom: green
-colorTo: indigo
-sdk: docker
+title: Job Application Tracker
+emoji: 📊
+colorFrom: blue
+colorTo: green
+sdk: docker  # ← IMPORTANT si tu utilises Dockerfile
 pinned: false
-license: mit
-short_description: 'job-tracker for aapplication '
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Job Application Tracker
+
+Track your job applications with ease.

app.py

@@ -0,0 +1,136 @@
+import streamlit as st
+from utils.auth import login, logout, register, is_logged_in
+from database.db_connection import init_database
+
+# Configuration de la page
+st.set_page_config(
+    page_title="Job Tracker",
+    page_icon="📊",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Initialisation de la base de données
+try:
+    init_database()
+except Exception as e:
+    st.error(f"Erreur d'initialisation de la base de données : {e}")
+
+# Initialisation du session_state
+if 'logged_in' not in st.session_state:
+    st.session_state['logged_in'] = False
+if 'user_id' not in st.session_state:
+    st.session_state['user_id'] = None
+if 'username' not in st.session_state:
+    st.session_state['username'] = None
+
+# ============ PAGE DE LOGIN/REGISTER ============
+
+if not is_logged_in():
+    st.title("🔐 Job Application Tracker")
+    st.markdown("### Bienvenue ! Connectez-vous ou créez un compte")
+    
+    tab1, tab2 = st.tabs(["Se connecter", "Créer un compte"])
+    
+    # Tab Login
+    with tab1:
+        st.subheader("Connexion")
+        login_username = st.text_input("Nom d'utilisateur", key="login_user")
+        login_password = st.text_input("Mot de passe", type="password", key="login_pass")
+        
+        if st.button("Se connecter", type="primary"):
+            if login_username and login_password:
+                if login(login_username, login_password):
+                    st.success(f"Bienvenue {login_username} !")
+                    st.rerun()
+                else:
+                    st.error("Identifiants incorrects")
+            else:
+                st.warning("Veuillez remplir tous les champs")
+    
+    # Tab Register
+    with tab2:
+        st.subheader("Créer un compte")
+        register_username = st.text_input("Nom d'utilisateur", key="register_user")
+        register_password = st.text_input("Mot de passe", type="password", key="register_pass")
+        register_password_confirm = st.text_input("Confirmer le mot de passe", type="password", key="register_pass_confirm")
+        
+        if st.button("Créer mon compte", type="primary"):
+            if register_username and register_password and register_password_confirm:
+                if register_password != register_password_confirm:
+                    st.error("Les mots de passe ne correspondent pas")
+                elif len(register_password) < 6:
+                    st.error("Le mot de passe doit contenir au moins 6 caractères")
+                else:
+                    success, message = register(register_username, register_password)
+                    if success:
+                        st.success(message)
+                        st.info("Vous pouvez maintenant vous connecter !")
+                    else:
+                        st.error(message)
+            else:
+                st.warning("Veuillez remplir tous les champs")
+
+# ============ PAGE PRINCIPALE (si connecté) ============
+
+else:
+    # Sidebar avec infos user et logout
+    with st.sidebar:
+        st.markdown(f"### 👤 {st.session_state['username']}")
+        st.markdown("---")
+        
+        if st.button("🚪 Se déconnecter", type="secondary"):
+            logout()
+            st.rerun()
+        
+        st.markdown("---")
+        st.markdown("### Navigation")
+        st.info("Utilisez les pages dans le menu ci-dessus pour :\n- 📝 Ajouter une candidature\n- 📊 Voir vos candidatures")
+    
+    # Page d'accueil
+    st.title("📊 Job Application Tracker")
+    st.markdown("### Bienvenue sur votre tableau de bord")
+    
+    st.success("✅ Vous êtes connecté(e)")
+    
+    st.markdown("""
+    ### Comment utiliser l'application ?
+    
+    1. **📝 Nouvelle candidature** : Ajoutez vos candidatures avec toutes les informations importantes
+    2. **📊 Mes candidatures** : Consultez, modifiez et suivez l'évolution de vos candidatures
+    
+    ---
+    
+    #### Fonctionnalités disponibles :
+    - ✅ Suivi de vos candidatures
+    - ✅ Gestion des statuts (En attente, Relancé, Refusé, Accepté)
+    - ✅ Tri et filtrage
+    - ✅ Modification et suppression
+    
+    """)
+    
+    # Statistiques rapides (optionnel)
+    from database.queries import get_user_applications
+    
+    try:
+        applications = get_user_applications(st.session_state['user_id'])
+        
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.metric("Total candidatures", len(applications))
+        
+        with col2:
+            en_attente = len([app for app in applications if app['status'] == 'En attente'])
+            st.metric("En attente", en_attente)
+        
+        with col3:
+            acceptees = len([app for app in applications if app['status'] == 'Accepté'])
+            st.metric("Acceptées", acceptees)
+        
+        with col4:
+            refusees = len([app for app in applications if app['status'] == 'Refusé'])
+            st.metric("Refusées", refusees)
+    
+    except Exception as e:
+        st.error(f"Erreur lors du chargement des statistiques : {e}")

database/db_connection.py

@@ -0,0 +1,48 @@
+import os
+from sqlalchemy import create_engine, text
+from sqlalchemy.orm import sessionmaker
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Récupération de la connection string
+DATABASE_URL = os.getenv("NEON_DB")
+
+# Création de l'engine SQLAlchemy
+engine = create_engine(DATABASE_URL, echo=False)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+def get_db_session():
+    """Retourne une session SQLAlchemy"""
+    return SessionLocal()
+
+def init_database():
+    """Initialise les tables si elles n'existent pas"""
+    with engine.connect() as conn:
+        # Table users
+        conn.execute(text("""
+            CREATE TABLE IF NOT EXISTS users (
+                user_id SERIAL PRIMARY KEY,
+                username VARCHAR(50) UNIQUE NOT NULL,
+                password_hash VARCHAR(255) NOT NULL,
+                created_at TIMESTAMP DEFAULT NOW()
+            );
+        """))
+        
+        # Table applications
+        conn.execute(text("""
+            CREATE TABLE IF NOT EXISTS applications (
+                app_id SERIAL PRIMARY KEY,
+                user_id INT REFERENCES users(user_id) ON DELETE CASCADE,
+                company VARCHAR(255) NOT NULL,
+                description TEXT,
+                application_date DATE NOT NULL,
+                end_date DATE,
+                expected_delay_days INT,
+                status VARCHAR(50) DEFAULT 'En attente',
+                created_at TIMESTAMP DEFAULT NOW(),
+                updated_at TIMESTAMP DEFAULT NOW()
+            );
+        """))
+        
+        conn.commit()

database/init.py

@@ -0,0 +1,27 @@
+"""
+Script d'initialisation de la base de données NeonDB
+À lancer UNE SEULE FOIS avant le premier déploiement
+"""
+import os
+from dotenv import load_dotenv
+from db_connection import init_database
+
+load_dotenv()
+
+if __name__ == "__main__":
+    print("🔧 Initialisation de la base de données NeonDB...")
+    
+    # Vérification de la connection string
+    if not os.getenv("NEON_DB"):
+        print("❌ Erreur: NEON_DB n'est pas défini dans le fichier .env")
+        exit(1)
+    
+    try:
+        init_database()
+        print("✅ Tables créées avec succès !")
+        print("   - Table 'users' créée")
+        print("   - Table 'applications' créée")
+        print("\n🎉 Base de données prête à l'emploi !")
+    except Exception as e:
+        print(f"❌ Erreur lors de l'initialisation : {e}")
+        exit(1)

database/queries.py

@@ -0,0 +1,121 @@
+from database.db_connection import get_db_session
+from sqlalchemy import text
+
+# ============ USER QUERIES ============
+
+def create_user(username, password_hash):
+    """Crée un nouvel utilisateur"""
+    session = get_db_session()
+    try:
+        result = session.execute(
+            text("INSERT INTO users (username, password_hash) VALUES (:username, :password_hash) RETURNING user_id"),
+            {"username": username, "password_hash": password_hash}
+        )
+        user_id = result.fetchone()[0]
+        session.commit()
+        return user_id
+    except Exception as e:
+        session.rollback()
+        raise e
+    finally:
+        session.close()
+
+def get_user_by_username(username):
+    """Récupère un user par son username"""
+    session = get_db_session()
+    try:
+        result = session.execute(
+            text("SELECT * FROM users WHERE username = :username"),
+            {"username": username}
+        )
+        user = result.fetchone()
+        return dict(user._mapping) if user else None
+    finally:
+        session.close()
+
+# ============ APPLICATION QUERIES ============
+
+def create_application(user_id, company, description, application_date, end_date, expected_delay_days):
+    """Crée une nouvelle candidature"""
+    session = get_db_session()
+    try:
+        result = session.execute(text("""
+            INSERT INTO applications 
+            (user_id, company, description, application_date, end_date, expected_delay_days)
+            VALUES (:user_id, :company, :description, :application_date, :end_date, :expected_delay_days)
+            RETURNING app_id
+        """), {
+            "user_id": user_id,
+            "company": company,
+            "description": description,
+            "application_date": application_date,
+            "end_date": end_date,
+            "expected_delay_days": expected_delay_days
+        })
+        app_id = result.fetchone()[0]
+        session.commit()
+        return app_id
+    except Exception as e:
+        session.rollback()
+        raise e
+    finally:
+        session.close()
+
+def get_user_applications(user_id):
+    """Récupère toutes les candidatures d'un user"""
+    session = get_db_session()
+    try:
+        result = session.execute(text("""
+            SELECT * FROM applications 
+            WHERE user_id = :user_id 
+            ORDER BY application_date DESC
+        """), {"user_id": user_id})
+        applications = [dict(row._mapping) for row in result.fetchall()]
+        return applications
+    finally:
+        session.close()
+
+def update_application(app_id, company, description, application_date, end_date, expected_delay_days, status):
+    """Met à jour une candidature"""
+    session = get_db_session()
+    try:
+        session.execute(text("""
+            UPDATE applications 
+            SET company = :company, 
+                description = :description, 
+                application_date = :application_date, 
+                end_date = :end_date, 
+                expected_delay_days = :expected_delay_days, 
+                status = :status, 
+                updated_at = NOW()
+            WHERE app_id = :app_id
+        """), {
+            "company": company,
+            "description": description,
+            "application_date": application_date,
+            "end_date": end_date,
+            "expected_delay_days": expected_delay_days,
+            "status": status,
+            "app_id": app_id
+        })
+        session.commit()
+    except Exception as e:
+        session.rollback()
+        raise e
+    finally:
+        session.close()
+
+def delete_application(app_id):
+    """Supprime une candidature"""
+    session = get_db_session()
+    try:
+        session.execute(
+            text("DELETE FROM applications WHERE app_id = :app_id"),
+            {"app_id": app_id}
+        )
+        session.commit()
+    except Exception as e:
+        session.rollback()
+        raise e
+    finally:
+        session.close()

pages/1_📝_Nouvelle_candidature.py

@@ -0,0 +1,112 @@
+import streamlit as st
+from datetime import date, timedelta
+from utils.auth import is_logged_in
+from database.queries import create_application
+
+# Configuration de la page
+st.set_page_config(
+    page_title="Nouvelle candidature",
+    page_icon="📝",
+    layout="wide"
+)
+
+# Vérification de l'authentification
+if not is_logged_in():
+    st.warning("⚠️ Veuillez vous connecter pour accéder à cette page")
+    st.stop()
+
+# ============ PAGE PRINCIPALE ============
+
+st.title("📝 Nouvelle candidature")
+st.markdown("### Ajoutez une nouvelle candidature à votre suivi")
+
+# Formulaire
+with st.form("new_application_form", clear_on_submit=True):
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        company = st.text_input(
+            "Entreprise *",
+            placeholder="Ex: Google, Jedha, RATP...",
+            help="Nom de l'entreprise"
+        )
+        
+        application_date = st.date_input(
+            "Date de candidature *",
+            value=date.today(),
+            help="Date à laquelle vous avez envoyé votre candidature"
+        )
+        
+        expected_delay_days = st.number_input(
+            "Délai de réponse attendu (jours)",
+            min_value=1,
+            max_value=365,
+            value=14,
+            help="Nombre de jours avant une relance"
+        )
+    
+    with col2:
+        description = st.text_area(
+            "Description / Notes",
+            placeholder="Poste, source de l'annonce, contact, notes personnelles...",
+            height=100,
+            help="Informations complémentaires sur cette candidature"
+        )
+        
+        end_date = st.date_input(
+            "Date de fin (optionnel)",
+            value=None,
+            help="Date de clôture de la candidature (si connue)"
+        )
+    
+    st.markdown("---")
+    
+    submitted = st.form_submit_button("✅ Enregistrer la candidature", type="primary", use_container_width=True)
+    
+    if submitted:
+        # Validation
+        if not company:
+            st.error("⚠️ Le nom de l'entreprise est obligatoire")
+        elif not application_date:
+            st.error("⚠️ La date de candidature est obligatoire")
+        else:
+            try:
+                # Création de la candidature
+                app_id = create_application(
+                    user_id=st.session_state['user_id'],
+                    company=company,
+                    description=description,
+                    application_date=application_date,
+                    end_date=end_date,
+                    expected_delay_days=expected_delay_days
+                )
+                
+                st.success(f"✅ Candidature chez **{company}** enregistrée avec succès !")
+                st.balloons()
+                
+                # Info sur la date de relance
+                relance_date = application_date + timedelta(days=expected_delay_days)
+                st.info(f"📅 Date de relance suggérée : **{relance_date.strftime('%d/%m/%Y')}**")
+                
+            except Exception as e:
+                st.error(f"❌ Erreur lors de l'enregistrement : {e}")
+
+# ============ SECTION AIDE ============
+
+st.markdown("---")
+
+with st.expander("💡 Conseils pour bien suivre vos candidatures"):
+    st.markdown("""
+    **Bonnes pratiques :**
+    
+    - 📋 **Description détaillée** : Notez le poste exact, le lien vers l'annonce, le nom du recruteur
+    - ⏰ **Délai réaliste** : 7-14 jours pour une startup, 14-30 jours pour une grande entreprise
+    - 🔔 **Relance** : Passé le délai, n'hésitez pas à relancer poliment
+    - 📊 **Statut** : Mettez à jour régulièrement le statut dans "Mes candidatures"
+    
+    **Exemples de notes utiles :**
+    - "Candidature via LinkedIn - Contact : Jean Dupont (RH)"
+    - "Référé par Marie (ancienne collègue)"
+    - "Poste : Data Scientist Senior - Ref: DS-2025-01"
+    - "Entretien téléphonique prévu le 25/02"
+    """)

pages/2_📊_Mes_candidatures.py

@@ -0,0 +1,194 @@
+import streamlit as st
+import pandas as pd
+from datetime import date, timedelta
+from utils.auth import is_logged_in
+from queries import get_user_applications, update_application, delete_application
+
+# Configuration de la page
+st.set_page_config(
+    page_title="Mes candidatures",
+    page_icon="📊",
+    layout="wide"
+)
+
+# Vérification de l'authentification
+if not is_logged_in():
+    st.warning("⚠️ Veuillez vous connecter pour accéder à cette page")
+    st.stop()
+
+# ============ PAGE PRINCIPALE ============
+
+st.title("📊 Mes candidatures")
+st.markdown("### Vue d'ensemble de toutes vos candidatures")
+
+# Chargement des candidatures
+try:
+    applications = get_user_applications(st.session_state['user_id'])
+except Exception as e:
+    st.error(f"❌ Erreur lors du chargement des candidatures : {e}")
+    st.stop()
+
+# ============ STATISTIQUES ============
+
+if applications:
+    col1, col2, col3, col4 = st.columns(4)
+    
+    total = len(applications)
+    en_attente = len([app for app in applications if app['status'] == 'En attente'])
+    relance = len([app for app in applications if app['status'] == 'Relancé'])
+    accepte = len([app for app in applications if app['status'] == 'Accepté'])
+    refuse = len([app for app in applications if app['status'] == 'Refusé'])
+    
+    with col1:
+        st.metric("📋 Total", total)
+    with col2:
+        st.metric("⏳ En attente", en_attente)
+    with col3:
+        st.metric("✅ Acceptées", accepte)
+    with col4:
+        st.metric("❌ Refusées", refuse)
+    
+    st.markdown("---")
+
+# ============ FILTRES ============
+
+if applications:
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        status_filter = st.multiselect(
+            "Filtrer par statut",
+            options=["En attente", "Relancé", "Accepté", "Refusé"],
+            default=["En attente", "Relancé", "Accepté", "Refusé"]
+        )
+    
+    with col2:
+        search_company = st.text_input("🔍 Rechercher une entreprise", placeholder="Nom de l'entreprise...")
+    
+    with col3:
+        sort_by = st.selectbox(
+            "Trier par",
+            options=["Date de candidature (récent)", "Date de candidature (ancien)", "Entreprise (A-Z)", "Statut"]
+        )
+    
+    st.markdown("---")
+
+# ============ AFFICHAGE DES CANDIDATURES ============
+
+if not applications:
+    st.info("📭 Aucune candidature enregistrée pour le moment")
+    st.markdown("👉 Rendez-vous sur la page **Nouvelle candidature** pour commencer !")
+else:
+    # Filtrage
+    filtered_apps = [app for app in applications if app['status'] in status_filter]
+    
+    if search_company:
+        filtered_apps = [app for app in filtered_apps if search_company.lower() in app['company'].lower()]
+    
+    # Tri
+    if sort_by == "Date de candidature (récent)":
+        filtered_apps = sorted(filtered_apps, key=lambda x: x['application_date'], reverse=True)
+    elif sort_by == "Date de candidature (ancien)":
+        filtered_apps = sorted(filtered_apps, key=lambda x: x['application_date'])
+    elif sort_by == "Entreprise (A-Z)":
+        filtered_apps = sorted(filtered_apps, key=lambda x: x['company'])
+    elif sort_by == "Statut":
+        filtered_apps = sorted(filtered_apps, key=lambda x: x['status'])
+    
+    # Affichage
+    if not filtered_apps:
+        st.warning("Aucune candidature ne correspond à vos filtres")
+    else:
+        st.markdown(f"**{len(filtered_apps)} candidature(s) trouvée(s)**")
+        
+        for app in filtered_apps:
+            # Calcul de la date de relance suggérée
+            relance_date = app['application_date'] + timedelta(days=app['expected_delay_days'] or 14)
+            days_since_application = (date.today() - app['application_date']).days
+            
+            # Badge de statut
+            status_colors = {
+                "En attente": "🟡",
+                "Relancé": "🔵",
+                "Accepté": "🟢",
+                "Refusé": "🔴"
+            }
+            status_badge = status_colors.get(app['status'], "⚪")
+            
+            with st.expander(f"{status_badge} **{app['company']}** - {app['application_date'].strftime('%d/%m/%Y')}", expanded=False):
+                col1, col2 = st.columns([2, 1])
+                
+                with col1:
+                    st.markdown(f"**Description :**")
+                    st.text(app['description'] or "Aucune description")
+                    
+                    st.markdown(f"**📅 Date de candidature :** {app['application_date'].strftime('%d/%m/%Y')} ({days_since_application} jours)")
+                    
+                    if app['end_date']:
+                        st.markdown(f"**🏁 Date de fin :** {app['end_date'].strftime('%d/%m/%Y')}")
+                    
+                    st.markdown(f"**⏰ Délai attendu :** {app['expected_delay_days']} jours")
+                    st.markdown(f"**📆 Relance suggérée :** {relance_date.strftime('%d/%m/%Y')}")
+                    
+                    # Alerte si délai dépassé
+                    if app['status'] == "En attente" and date.today() > relance_date:
+                        days_overdue = (date.today() - relance_date).days
+                        st.warning(f"⚠️ Délai dépassé de {days_overdue} jour(s) - Pensez à relancer !")
+                
+                with col2:
+                    st.markdown("**Actions**")
+                    
+                    # Modification du statut
+                    new_status = st.selectbox(
+                        "Statut",
+                        options=["En attente", "Relancé", "Accepté", "Refusé"],
+                        index=["En attente", "Relancé", "Accepté", "Refusé"].index(app['status']),
+                        key=f"status_{app['app_id']}"
+                    )
+                    
+                    col_btn1, col_btn2 = st.columns(2)
+                    
+                    with col_btn1:
+                        if st.button("💾 Sauvegarder", key=f"save_{app['app_id']}", type="primary", use_container_width=True):
+                            try:
+                                update_application(
+                                    app_id=app['app_id'],
+                                    company=app['company'],
+                                    description=app['description'],
+                                    application_date=app['application_date'],
+                                    end_date=app['end_date'],
+                                    expected_delay_days=app['expected_delay_days'],
+                                    status=new_status
+                                )
+                                st.success("✅ Mis à jour !")
+                                st.rerun()
+                            except Exception as e:
+                                st.error(f"Erreur : {e}")
+                    
+                    with col_btn2:
+                        if st.button("🗑️ Supprimer", key=f"delete_{app['app_id']}", type="secondary", use_container_width=True):
+                            try:
+                                delete_application(app['app_id'])
+                                st.success("🗑️ Supprimée !")
+                                st.rerun()
+                            except Exception as e:
+                                st.error(f"Erreur : {e}")
+
+# ============ EXPORT ============
+
+if applications:
+    st.markdown("---")
+    
+    # Conversion en DataFrame pour export
+    df = pd.DataFrame(applications)
+    df['application_date'] = pd.to_datetime(df['application_date']).dt.strftime('%d/%m/%Y')
+    df['end_date'] = pd.to_datetime(df['end_date']).dt.strftime('%d/%m/%Y')
+    
+    csv = df.to_csv(index=False).encode('utf-8')
+    
+    st.download_button(
+        label="📥 Exporter en CSV",
+        data=csv,
+        file_name=f"candidatures_{st.session_state['username']}_{date.today()}.csv",
+        mime="text/csv"
+    )

requirements.txt

@@ -0,0 +1,13 @@
+streamlit
+sqlalchemy
+psycopg2-binary
+python-dotenv
+bcrypt
+pandas
+
+huggingface-hub
+
+# Dev dependencies (pour CI uniquement)
+pytest
+pytest-cov
+flake8

utils/auth.py

@@ -0,0 +1,40 @@
+import bcrypt
+import streamlit as st
+from database.queries import get_user_by_username, create_user
+
+def hash_password(password):
+    """Hash un mot de passe"""
+    return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+
+def verify_password(password, password_hash):
+    """Vérifie un mot de passe"""
+    return bcrypt.checkpw(password.encode('utf-8'), password_hash.encode('utf-8'))
+
+def login(username, password):
+    """Authentifie un utilisateur"""
+    user = get_user_by_username(username)
+    if user and verify_password(password, user['password_hash']):
+        st.session_state['logged_in'] = True
+        st.session_state['user_id'] = user['user_id']
+        st.session_state['username'] = user['username']
+        return True
+    return False
+
+def logout():
+    """Déconnecte l'utilisateur"""
+    st.session_state['logged_in'] = False
+    st.session_state['user_id'] = None
+    st.session_state['username'] = None
+
+def register(username, password):
+    """Enregistre un nouvel utilisateur"""
+    try:
+        password_hash = hash_password(password)
+        user_id = create_user(username, password_hash)
+        return True, "Compte créé avec succès !"
+    except Exception as e:
+        return False, f"Erreur: {str(e)}"
+
+def is_logged_in():
+    """Vérifie si l'utilisateur est connecté"""
+    return st.session_state.get('logged_in', False)