David-Li0406/meta-skill-evloving

Exigences pour les Sorties

Tous les fichiers Excel

Zéro Erreur de Formule

• Chaque modèle Excel DOIT être livré avec ZÉRO erreur de formule (#REF!, #DIV/0!, #VALUE!, #N/A, #NAME?)

Préserver les Modèles Existants (lors de la mise à jour de modèles)

• Étudier et correspondre EXACTEMENT au format, style et conventions existants lors de la modification des fichiers
• Ne jamais imposer un formatage standardisé sur des fichiers ayant des modèles établis
• Les conventions du modèle existant priment TOUJOURS sur ces directives

Modèles Financiers

Normes de Codage Couleur

Sauf indication contraire de l'utilisateur ou du modèle existant

Conventions de Couleur Standard de l'Industrie

• Texte bleu (RGB: 0,0,255) : Entrées codées en dur et chiffres que les utilisateurs modifieront pour les scénarios
• Texte noir (RGB: 0,0,0) : TOUTES les formules et calculs
• Texte vert (RGB: 0,128,0) : Liens provenant d'autres feuilles de calcul du même classeur
• Texte rouge (RGB: 255,0,0) : Liens externes vers d'autres fichiers
• Arrière-plan jaune (RGB: 255,255,0) : Hypothèses clés nécessitant une attention ou cellules à mettre à jour

Normes de Formatage des Nombres

Règles de Format Obligatoires

• Années : Formater comme chaînes de texte (par exemple, "2024" et non "2 024")
• Monnaie : Utiliser le format $#,##0 ; TOUJOURS spécifier les unités dans les en-têtes ("Revenu ($M)")
• Zéros : Utiliser le formatage des nombres pour afficher tous les zéros comme "-", y compris les pourcentages (par exemple, "$#,##0;($#,##0);-")
• Pourcentages : Par défaut, format 0,0% (une décimale)
• Multiples : Formater comme 0,0x pour les multiples d'évaluation (EV/EBITDA, P/E)
• Nombres négatifs : Utiliser des parenthèses (123) et non un moins -123

Règles de Construction des Formules

Placement des Hypothèses

• Placer TOUTES les hypothèses (taux de croissance, marges, multiples, etc.) dans des cellules d'hypothèses séparées
• Utiliser des références de cellule au lieu de valeurs codées en dur dans les formules
• Exemple : Utiliser =B5*(1+$B$6) au lieu de =B5*1,05

Prévention des Erreurs de Formule

• Vérifier que toutes les références de cellule sont correctes
• Rechercher les erreurs de décalage dans les plages
• Assurer la cohérence des formules sur toutes les périodes de projection
• Tester avec des cas limites (valeurs nulles, nombres négatifs)
• Vérifier l'absence de références circulaires non intentionnelles

Exigences de Documentation pour les Valeurs Codées en Dur

• Commenter ou ajouter dans les cellules à côté (si en fin de tableau). Format : "Source : [Système/Document], [Date], [Référence spécifique], [URL si applicable]"
• Exemples :
  • "Source : 10-K de la société, FY2024, Page 45, Note sur les revenus, [URL SEC EDGAR]"
  • "Source : 10-Q de la société, Q2 2025, Annexe 99.1, [URL SEC EDGAR]"
  • "Source : Terminal Bloomberg, 15/08/2025, AAPL US Equity"
  • "Source : FactSet, 20/08/2025, Écran des estimations consensuelles"

Création, édition et analyse de XLSX

Aperçu

Un utilisateur peut vous demander de créer, éditer ou analyser le contenu d'un fichier .xlsx. Vous disposez de différents outils et workflows pour différentes tâches.

Exigences Importantes

LibreOffice Requis pour le Recalcul des Formules : Vous pouvez supposer que LibreOffice est installé pour recalculer les valeurs des formules à l'aide du script recalc.py. Le script configure automatiquement LibreOffice lors de la première exécution.

Lecture et analyse des données

Analyse de données avec pandas

Pour l'analyse de données, la visualisation et les opérations de base, utilisez pandas qui offre des capacités puissantes de manipulation de données :

import pandas as pd

# Lire Excel
df = pd.read_excel('file.xlsx')  # Défaut : première feuille
toutes_les_feuilles = pd.read_excel('file.xlsx', sheet_name=None)  # Toutes les feuilles en dict

# Analyser
df.head()      # Aperçu des données
df.info()      # Informations sur les colonnes
df.describe()  # Statistiques

# Écrire Excel
df.to_excel('output.xlsx', index=False)

Workflows pour les Fichiers Excel

CRITIQUE : Utiliser des Formules, Pas de Valeurs Codées en Dur

Toujours utiliser des formules Excel au lieu de calculer des valeurs en Python et de les coder en dur. Cela garantit que la feuille de calcul reste dynamique et modifiable.

❌ MAUVAIS - Codage en Dur des Valeurs Calculées

# Mauvais : Calcul en Python et codage en dur du résultat
total = df['Ventes'].sum()
feuille['B10'] = total  # Code en dur 5000

# Mauvais : Calcul du taux de croissance en Python
croissance = (df.iloc[-1]['Revenu'] - df.iloc[0]['Revenu']) / df.iloc[0]['Revenu']
feuille['C5'] = croissance  # Code en dur 0,15

# Mauvais : Calcul Python de la moyenne
moyenne = sum(valeurs) / len(valeurs)
feuille['D20'] = moyenne  # Code en dur 42,5

✅ CORRECT - Utilisation de Formules Excel

# Bon : Laisser Excel calculer la somme
feuille['B10'] = '=SUM(B2:B9)'

# Bon : Taux de croissance sous forme de formule Excel
feuille['C5'] = '=(C4-C2)/C2'

# Bon : Moyenne utilisant la fonction Excel
feuille['D20'] = '=AVERAGE(D2:D19)'

Ceci s'applique à TOUS les calculs - totaux, pourcentages, ratios, différences, etc. La feuille de calcul doit pouvoir recalculer lorsque les données sources changent.

Workflow Courant

1. Choisir l'outil : pandas pour les données, openpyxl pour les formules/formatage
2. Créer/Charger : Créer un nouveau classeur ou charger un fichier existant
3. Modifier : Ajouter/modifier des données, formules et formatage
4. Enregistrer : Écrire dans le fichier
5. Recalculer les formules (OBLIGATOIRE SI UTILISATION DE FORMULES) : Utiliser le script recalc.py

   python recalc.py sortie.xlsx
   

6. Vérifier et corriger les erreurs éventuelles :
   • Le script renvoie du JSON avec les détails des erreurs
   • Si status est errors_found, vérifier error_summary pour les types et emplacements d'erreurs spécifiques
   • Corriger les erreurs identifiées et recalculer à nouveau
   • Erreurs courantes à corriger :
     • #REF! : Références de cellule invalides
     • #DIV/0! : Division par zéro
     • #VALUE! : Type de données erroné dans la formule
     • #NAME? : Nom de formule non reconnu

Création de nouveaux fichiers Excel

# Utilisation d'openpyxl pour les formules et le formatage
from openpyxl import Workbook
from openpyxl.styles import Font, PatternFill, Alignment

wb = Workbook()
feuille = wb.active

# Ajouter des données
feuille['A1'] = 'Bonjour'
feuille['B1'] = 'Monde'
feuille.append(['Ligne', 'de', 'données'])

# Ajouter une formule
feuille['B2'] = '=SUM(A1:A10)'

# Formatage
feuille['A1'].font = Font(bold=True, color='FF0000')
feuille['A1'].fill = PatternFill('solid', start_color='FFFF00')
feuille['A1'].alignment = Alignment(horizontal='center')

# Largeur de colonne
feuille.column_dimensions['A'].width = 20

wb.save('sortie.xlsx')

Modification de fichiers Excel existants

# Utilisation d'openpyxl pour préserver les formules et le formatage
from openpyxl import load_workbook

# Charger un fichier existant
wb = load_workbook('existant.xlsx')
feuille = wb.active  # ou wb['NomFeuille'] pour une feuille spécifique

# Travailler avec plusieurs feuilles
for nom_feuille in wb.sheetnames:
    feuille = wb[nom_feuille]
    print(f"Feuille : {nom_feuille}")

# Modifier des cellules
feuille['A1'] = 'Nouvelle Valeur'
feuille.insert_rows(2)  # Insérer une ligne à la position 2
feuille.delete_cols(3)  # Supprimer la colonne 3

# Ajouter une nouvelle feuille
nouvelle_feuille = wb.create_sheet('NouvelleFeuille')
nouvelle_feuille['A1'] = 'Données'

wb.save('modifie.xlsx')

Recalcul des formules

Les fichiers Excel créés ou modifiés par openpyxl contiennent des formules sous forme de chaînes de caractères mais pas de valeurs calculées. Utilisez le script recalc.py fourni pour recalculer les formules :

python recalc.py <fichier_excel> [temps_attente_secondes]

Exemple :

python recalc.py sortie.xlsx 30

Le script :

• Configure automatiquement la macro LibreOffice lors de la première exécution
• Recalcule toutes les formules dans toutes les feuilles
• Scanne TOUTES les cellules pour les erreurs Excel (#REF!, #DIV/0!, etc.)
• Renvoie du JSON avec les emplacements et les comptes d'erreurs détaillés
• Fonctionne à la fois sur Linux et macOS

Liste de Vérification de la Validation des Formules

Vérifications rapides pour s'assurer que les formules fonctionnent correctement :

Vérification Essentielle

• Tester 2-3 références échantillons : Vérifier qu'elles extraient les valeurs correctes avant de construire le modèle complet
• Correspondance des colonnes : Confirmer que les colonnes Excel correspondent (par exemple, colonne 64 = BL, pas BK)
• Décalage de ligne : Se rappeler que les lignes Excel commencent à l'index 1 (ligne 5 du DataFrame = ligne 6 d'Excel)

Pièges Courants

• Gestion des NaN : Vérifier les valeurs nulles avec pd.notna()
• Colonnes à l'extrême droite : Les données d'exercice sont souvent dans les colonnes 50+
• Correspondances multiples : Rechercher toutes les occurrences, pas seulement la première
• Division par zéro : Vérifier les dénominateurs avant d'utiliser / dans les formules (#DIV/0!)
• Références erronées : Vérifier que toutes les références de cellule pointent vers les cellules prévues (#REF!)
• Références inter-feuilles : Utiliser le format correct (Feuille1!A1) pour lier les feuilles

Stratégie de Test des Formules

• Commencer petit : Tester les formules sur 2-3 cellules avant de les appliquer largement
• Vérifier les dépendances : S'assurer que toutes les cellules référencées dans les formules existent
• Tester les cas limites : Inclure des valeurs nulles, négatives et très grandes

Interprétation de la Sortie de recalc.py

Le script renvoie du JSON avec les détails des erreurs :

{
  "status": "success",           // ou "errors_found"
  "total_errors": 0,              // Nombre total d'erreurs
  "total_formulas": 42,           // Nombre de formules dans le fichier
  "error_summary": {              // Présent uniquement si des erreurs sont trouvées
    "#REF!": {
      "count": 2,
      "locations": ["Feuille1!B5", "Feuille1!C10"]
    }
  }
}

Bonnes Pratiques

Sélection de Bibliothèque

• pandas : Idéal pour l'analyse de données, les opérations en masse et l'exportation simple de données
• openpyxl : Idéal pour le formatage complexe, les formules et les fonctionnalités spécifiques à Excel

Travailler avec openpyxl

• Les indices de cellule sont basés sur 1 (ligne=1, colonne=1 fait référence à la cellule A1)
• Utiliser data_only=True pour lire les valeurs calculées : load_workbook('fichier.xlsx', data_only=True)
• Attention : Si ouvert avec data_only=True et enregistré, les formules sont remplacées par des valeurs et définitivement perdues
• Pour les grands fichiers : Utiliser read_only=True pour la lecture ou write_only=True pour l'écriture
• Les formules sont préservées mais pas évaluées - utiliser recalc.py pour mettre à jour les valeurs

Travailler avec pandas

• Spécifier les types de données pour éviter les problèmes d'inférence : pd.read_excel('fichier.xlsx', dtype={'id': str})
• Pour les grands fichiers, lire des colonnes spécifiques : pd.read_excel('fichier.xlsx', usecols=['A', 'C', 'E'])
• Gérer correctement les dates : pd.read_excel('fichier.xlsx', parse_dates=['colonne_date'])

Directives de Style de Code

IMPORTANT : Lors de la génération de code Python pour les opérations Excel :

• Écrire un code Python minimal et concis sans commentaires inutiles
• Éviter les noms de variables verbeux et les opérations redondantes
• Éviter les instructions print inutiles

Pour les fichiers Excel eux-mêmes :

• Ajouter des commentaires aux cellules avec des formules complexes ou des hypothèses importantes
• Documenter les sources de données pour les valeurs codées en dur
• Inclure des notes pour les calculs clés et les sections du modèle