Upload 6 files

.dockerignore

@@ -0,0 +1,20 @@
+# Fichiers invisibles de versionnement et d'IDE
+.git
+.gitattributes
+.gitignore
+.DS_Store
+
+# Exclure le Dockerfile et le .dockerignore lui-même (bonne pratique)
+Dockerfile
+.dockerignore
+
+# Exclure les dossiers de cache Python
+__pycache__/
+*.pyc
+
+# Exclure les dossiers de développement/log
+venv/         # Si vous avez un environnement virtuel
+env/          # Si vous avez un autre nom d'environnement virtuel
+logs/         # Dossiers de logs
+tmp/          # Dossiers temporaires
+*.log

Dockerfile

@@ -0,0 +1,36 @@
+# Dockerfile
+
+# Utiliser une image Python officielle comme base
+FROM python:3.11-slim
+
+# Définir des variables d'environnement
+# Le port 5000 sera exposé et utilisé comme PORT par défaut dans app.py
+ENV PORT 7860 
+ENV FLASK_APP app.py
+
+# Créer un répertoire de travail
+WORKDIR /app
+
+# Créer un utilisateur non-root "user" avec l'UID 1000
+RUN useradd -m -u 1000 user
+
+# Copier les fichiers d'application et changer le propriétaire
+COPY --chown=user:user requirements.txt .
+COPY --chown=user:user app.py .
+COPY --chown=user:user auth_backend.py .
+COPY --chown=user:user git_storage.py .
+
+
+# Installer les dépendances
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Passer à l'utilisateur non-root
+USER user
+
+# Exposer le port par défaut (même si Hugging Face gère la redirection)
+EXPOSE 7860 
+
+# Commande pour démarrer l'application avec Gunicorn (recommandé pour la production)
+# L'application écoutera sur toutes les interfaces (0.0.0.0) sur le port 5000 (défini par ENV PORT)
+# --workers 4 est un bon point de départ, ajustez au besoin.
+CMD ["gunicorn", "--bind", "0.0.0.0:7860 ", "--workers", "4", "app:app"]

app.py

@@ -0,0 +1,120 @@
+# app.py
+
+from flask import Flask, request, jsonify, session, g, redirect, url_for
+from flask_cors import CORS
+from functools import wraps
+import os
+from dotenv import load_dotenv # <-- CONSERVÉ au cas où, mais n'est pas appelé
+
+# Charger les variables d'environnement du fichier .env
+# load_dotenv() # <-- SUPPRIMÉ pour utiliser directement les variables d'environnement du Space
+
+from auth_backend import register_user, login_user, get_user_by_id
+# Note: conversation_backend n'est pas utilisé ici, mais serait pour les routes de conversation
+
+app = Flask(__name__)
+
+# Configuration de la clé secrète pour les sessions
+# C'est important en production, assurez-vous de la définir dans .env ou comme Secret
+app.secret_key = os.environ.get("FLASK_SECRET_KEY", "super_secret_dev_key")
+
+# Permettre les requêtes cross-origin (CORS)
+CORS(app, supports_credentials=True)
+
+# Décorateur pour vérifier si l'utilisateur est connecté
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if 'user_id' not in session:
+            return jsonify({"status": "Error", "message": "Accès non autorisé. Veuillez vous connecter."}), 401
+        return f(*args, **kwargs)
+    return decorated_function
+
+# Route de vérification de l'état (Statut du service)
+@app.route('/', methods=['GET'])
+def index():
+    user_id = session.get('user_id')
+    is_logged_in = user_id is not None
+    user_status = "Connecté" if is_logged_in else "Déconnecté (Invité)"
+    
+    return jsonify({
+        "status": "OK",
+        "is_logged_in": is_logged_in,
+        "message": f"Bienvenue sur le Backend API ErnestMind. Statut de la session: {user_status}."
+    })
+
+# --- Routes d'Authentification ---
+@app.route('/api/register', methods=['POST'])
+def api_register():
+    data = request.get_json()
+    email = data.get('email')
+    password = data.get('password')
+
+    if not email or not password:
+        return jsonify({"status": "Error", "message": "Email et mot de passe sont requis."}), 400
+
+    user_id, message = register_user(email, password)
+
+    if user_id:
+        # Inscription réussie et connexion automatique
+        session['user_id'] = user_id
+        return jsonify({"status": "Success", "message": message, "user_id": user_id}), 201
+    else:
+        return jsonify({"status": "Error", "message": message}), 400
+
+@app.route('/api/login', methods=['POST'])
+def api_login():
+    data = request.get_json()
+    email = data.get('email')
+    password = data.get('password')
+
+    if not email or not password:
+        return jsonify({"status": "Error", "message": "Email et mot de passe sont requis."}), 400
+
+    user_id, message = login_user(email, password)
+
+    if user_id:
+        # Connexion réussie, définir la session
+        session['user_id'] = user_id
+        return jsonify({"status": "Success", "message": message, "user_id": user_id}), 200
+    else:
+        return jsonify({"status": "Error", "message": message}), 401 # 401 Unauthorized
+
+@app.route('/api/logout', methods=['POST'])
+def api_logout():
+    # Retirer l'utilisateur de la session
+    session.pop('user_id', None)
+    return jsonify({"status": "Success", "message": "Déconnexion réussie."}), 200
+
+# --- Routes Protégées (Exemple) ---
+@app.route('/api/profile', methods=['GET'])
+@login_required
+def api_profile():
+    user_id = session['user_id']
+    user_data = get_user_by_id(user_id)
+    
+    if user_data:
+        # On ne renvoie pas le mot de passe !
+        profile = {
+            "user_id": user_data["user_id"],
+            "email": user_data["email"],
+            "created_at": user_data["created_at"],
+            "message": "Bienvenue sur votre profil."
+        }
+        return jsonify({"status": "Success", "profile": profile}), 200
+    
+    # Cas où l'ID est dans la session mais l'utilisateur n'existe pas dans le JSON
+    session.pop('user_id', None)
+    return jsonify({"status": "Error", "message": "Profil introuvable, session réinitialisée."}), 404
+
+
+if __name__ == '__main__':
+    # Le port est configuré ici pour le développement
+    # Pour Hugging Face Spaces Docker, l'application doit écouter sur le port 7860
+    # ou celui spécifié par la variable d'environnement PORT, 
+    # qui peut être lue via os.environ.get("PORT", 7860) ou similaire.
+    # Ici, nous conservons la logique initiale avec 5000 par défaut 
+    # et nous laisserons le Dockerfile s'assurer que le port 5000 est exposé.
+    port = int(os.environ.get("PORT", 5000)) 
+    # Note: On utilise le mode debug qui est idéal pour le développement
+    app.run(debug=True, host='0.0.0.0', port=port)

auth_backend.py

@@ -0,0 +1,76 @@
+# auth_backend.py
+
+import json
+import uuid
+from datetime import datetime
+from werkzeug.security import generate_password_hash, check_password_hash
+from git_storage import (
+    load_users_data,
+    save_users_data,
+    create_user_data_structure,
+)
+
+# Fonction pour valider l'email
+def is_valid_email(email):
+    # Une validation simple
+    return "@" in email and "." in email
+
+# Fonction d'inscription de l'utilisateur
+def register_user(email, password):
+    # 1. Validation de base
+    if not is_valid_email(email) or len(password) < 8:
+        return None, "Email invalide ou mot de passe trop court (min 8 caractères)."
+
+    users = load_users_data()
+
+    # 2. Vérification de l'existence
+    if any(u.get("email") == email for u in users.values()):
+        return None, "Cet email est déjà enregistré."
+
+    # 3. Création du nouvel utilisateur
+    user_id = str(uuid.uuid4())
+    hashed_password = generate_password_hash(password)
+
+    new_user = {
+        "email": email,
+        "password_hash": hashed_password,
+        "user_id": user_id,
+        "created_at": datetime.now().isoformat()
+    }
+    users[user_id] = new_user
+
+    # 4. Sauvegarde et commit de users.json
+    success_save = save_users_data(users, commit_message=f"feat: New user registration for {email}")
+
+    if not success_save:
+        return None, "Erreur lors de la sauvegarde des données utilisateur (Hugging Face)."
+
+    # 5. Création de la structure de données et de la première conversation (si nécessaire)
+    # L'implémentation actuelle de create_user_data_structure crée un fichier vide.
+    # Vous pouvez ajouter ici la logique pour une première conversation si vous le souhaitez.
+    create_user_data_structure(user_id)
+    
+    # Retourne l'ID et un message de succès
+    return user_id, "Inscription réussie."
+
+# Fonction de connexion de l'utilisateur
+def login_user(email, password):
+    users = load_users_data()
+
+    # 1. Recherche de l'utilisateur par email
+    user = next((u for u in users.values() if u.get("email") == email), None)
+
+    if user is None:
+        return None, "Email ou mot de passe incorrect."
+
+    # 2. Vérification du mot de passe
+    if not check_password_hash(user["password_hash"], password):
+        return None, "Email ou mot de passe incorrect."
+
+    # 3. Connexion réussie
+    return user["user_id"], "Connexion réussie."
+
+# Fonction pour obtenir les données utilisateur par ID
+def get_user_by_id(user_id):
+    users = load_users_data()
+    return users.get(user_id)

git_storage.py

@@ -0,0 +1,100 @@
+# git_storage.py
+
+import json
+from huggingface_hub import HfApi, CommitOperationAdd
+from os import environ
+
+# Configuration du dépôt
+# L'ID du dépôt est maintenant directement dans le code.
+REPO_ID = "ernestmindres/ErnestMind_database"
+
+# L'API_TOKEN est lu directement depuis les secrets de l'environnement (Secret HF_TOKEN)
+API_TOKEN = environ.get("HF_TOKEN")
+
+# Initialisation de l'API Hugging Face
+api = HfApi(token=API_TOKEN)
+
+def load_users_data():
+    """Charge le fichier users.json depuis le dépôt."""
+    try:
+        # Télécharge et charge le fichier users.json
+        users_file = api.hf_hub_download(
+            repo_id=REPO_ID, 
+            filename="users.json",
+            repo_type="dataset"  # <-- CORRECTION: Spécifier le type de dépôt
+        )
+        with open(users_file, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as e:
+        # Si le fichier n'existe pas encore (premier lancement), on démarre avec un dictionnaire vide
+        if "Repository Not Found" in str(e) or "Cannot find file" in str(e):
+             print(f"Dépôt ou fichier users.json non trouvé (ce qui est normal au premier lancement): {e}")
+             return {}
+        print(f"Erreur lors du chargement des données utilisateurs: {e}") 
+        return {}
+
+
+# Chemin du fichier temporaire pour l'écriture locale (correction pour PermissionError)
+LOCAL_USERS_FILE_PATH = "/tmp/users.json"
+
+def save_users_data(users_data, commit_message="Update users data"):
+    """
+    Sauvegarde les données utilisateurs dans users.json 
+    et les commite sur le dépôt Hugging Face.
+    """
+    try:
+        # Écriture du fichier users.json en local dans le répertoire /tmp
+        with open(LOCAL_USERS_FILE_PATH, "w", encoding="utf-8") as f:
+            json.dump(users_data, f, indent=4)
+        
+        # Définition de l'opération de commit
+        operations = [
+            CommitOperationAdd(path_in_repo="users.json", path_or_fileobj=LOCAL_USERS_FILE_PATH)
+        ]
+        
+        # Commit sur le dépôt
+        api.create_commit(
+            repo_id=REPO_ID,
+            operations=operations,
+            commit_message=commit_message,
+            repo_type="dataset"  # <-- CORRECTION: Spécifier le type de dépôt
+        )
+        print(f"Fichier users.json commité avec succès. Message: '{commit_message}'")
+        return True
+    except Exception as e:
+        import traceback
+        print("---------- LOG D'ERREUR HUGGING FACE ----------")
+        print(f"Échec de l'opération de commit sur le dépôt {REPO_ID}.")
+        print(f"Erreur complète : {e}")
+        traceback.print_exc()
+        print("---------------------------------------------")
+        return False
+
+def create_user_data_structure(user_id):
+    """
+    Crée la structure initiale des conversations pour un nouvel utilisateur
+    dans le dépôt Hugging Face.
+    """
+    try:
+        # Crée un fichier 'conversations/<user_id>.json' vide
+        file_path = f"conversations/{user_id}.json"
+        
+        operations = [
+            CommitOperationAdd(
+                path_in_repo=file_path, 
+                path_or_fileobj=json.dumps({"conversations": {}}, indent=4)
+            )
+        ]
+
+        # Commit sur le dépôt
+        api.create_commit(
+            repo_id=REPO_ID,
+            operations=operations,
+            commit_message=f"feat: Add new user conversation file: {user_id}",
+            repo_type="dataset"  # <-- CORRECTION: Spécifier le type de dépôt
+        )
+        print(f"Structure de données pour l'utilisateur {user_id} créée.")
+        return True
+    except Exception as e:
+        print(f"Erreur lors de la création de la structure de données pour {user_id}: {e}")
+        return False

requirements.txt

@@ -0,0 +1,6 @@
+flask
+huggingface-hub
+bcrypt
+requests
+gunicorn
+Flask-CORS