git_storage.py

# git_storage.py

import json
from huggingface_hub import HfApi, CommitOperationAdd
from os import environ
from huggingface_hub.errors import HfHubHTTPError # <-- AJOUTER CET IMPORT

# Configuration du dépôt
REPO_ID = "ernestmindres/ernestmind_user_data"

# L'API_TOKEN est lu directement depuis les secrets de l'environnement (Secret HF_TOKEN)
# Nous le laissons ici, mais nous allons le vérifier dans les fonctions.
API_TOKEN = environ.get("HF_TOKEN")

# NOTE: Nous allons rendre les fonctions save/create plus robustes en 
# recréant l'objet HfApi si nécessaire ou en vérifiant le token.

# Initialisation de l'API Hugging Face
# Ceci est conservé pour la lecture (load), mais nous allons être plus prudents pour l'écriture.
api = HfApi(token=API_TOKEN)


def get_authenticated_api():
    """Vérifie le jeton et retourne un objet HfApi."""
    # Re-lire la variable d'environnement au cas où elle serait chargée plus tard
    current_token = environ.get("HF_TOKEN")
    if not current_token:
        raise ValueError("Erreur d'authentification: Le secret HF_TOKEN est manquant ou non chargé dans l'environnement.")
    return HfApi(token=current_token)


def load_users_data():
    """Charge le fichier users.json depuis le dépôt."""
    # ... (pas de changement ici, la lecture est conservée telle quelle, car elle fonctionne)
    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:
        # ... (reste inchangé)
        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:
        # 1. Utiliser une API authentifiée
        authenticated_api = get_authenticated_api() # <-- APPEL À LA VÉRIFICATION DU TOKEN
        
        # 2. É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)
        
        # 3. Définition de l'opération de commit
        operations = [
            CommitOperationAdd(path_in_repo="users.json", path_or_fileobj=LOCAL_USERS_FILE_PATH)
        ]
        
        # 4. Commit sur le dépôt
        authenticated_api.create_commit( # <-- UTILISATION DE L'API AUTHENTIFIÉE
            repo_id=REPO_ID,
            operations=operations,
            commit_message=commit_message,
            repo_type="dataset" #
        )
        print(f"Fichier users.json commité avec succès. Message: '{commit_message}'")
        return True
    except HfHubHTTPError as e: # <-- MEILLEURE GESTION POUR LES ERREURS HF
        print(f"ERREUR HTTP HUGGING FACE (401/404/403) : {e}")
        return False
    except ValueError as e: # <-- GESTION DE L'ERREUR DE TOKEN MANQUANT
        print(f"ERREUR CRITIQUE DE CONFIGURATION : {e}")
        return False
    except Exception as e:
        # Log d'erreur général pour les autres problèmes (réseau, disque, etc.)
        import traceback
        print("---------- LOG D'ERREUR HUGGING FACE (GÉNÉRAL) ----------")
        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:
        # 1. Utiliser une API authentifiée
        authenticated_api = get_authenticated_api() # <-- APPEL À LA VÉRIFICATION DU TOKEN
        
        # ... (le reste de la logique de création de fichier)
        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
        authenticated_api.create_commit( # <-- UTILISATION DE L'API AUTHENTIFIÉE
            repo_id=REPO_ID,
            operations=operations,
            commit_message=f"feat: Add new user conversation file: {user_id}",
            repo_type="dataset"  #
        )
        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