Méthodologie tracé de la balance des comptes

Cette page retrace les différentes étapes effectuées pour récupérer les informations des comptes de la copropriété et de tracer la courbe de la balance du compte de la résidence Augusta.

Les opérations suivantes sont effectuées:

1. Téléchargement des relevés de compte bancaire de la résidence sur le site “Gérer ma copro”. Chacun des documents téléchargés est au format pdf: opération manuelle
2. Pour chaque relevé extraction des tableaux au format xlsx avec chatgpt et insertion dans une feuille du fichier releves_bancaires.xlsx
3. génération d’un fichier excel image de releves_bancaires-balancees.xlsx avec ajout de la balance courante sur chaque feuille ainsi que un fichier concaténant l’ensemble des opérations sur une seule feuille: operations_concatenees.xlsx. On utilise le script python script.py donné par chatgpt
4. Génération de la courbe de la balance du compte en fonction du temps avec le script python genegraphe.py donné par chatgpt: balance.jpg

Script de génération de la balance

import pandas as pd
import numpy as np
import os
from openpyxl import load_workbook

def clean_to_number(x):
    try:
        return float(str(x).replace('\u202f','').replace('\xa0','').replace(' ', '').replace(',', '.'))
    except Exception:
        return np.nan

repertoire_travail = os.path.dirname(os.path.abspath(__file__))
fichier_entree = os.path.join(repertoire_travail, "releves_bancaires.xlsx")
fichier_sortie_concatenation = os.path.join(repertoire_travail, "operations_concatenees.xlsx")
fichier_sortie_balances = os.path.join(repertoire_travail, "releves_bancaires-balancees.xlsx")

wb = load_workbook(filename=fichier_entree, data_only=True)
sheet_names = [ws.title for ws in wb.worksheets]

all_data = []

for sheet in sheet_names:
    df = pd.read_excel(fichier_entree, sheet_name=sheet, dtype=str)
    df.columns = [str(c).strip() for c in df.columns]
    df = df.reset_index(drop=True)
    
    # Nettoyage des valeurs numériques
    df['Débit'] = pd.to_numeric(
        df.get('Débit', pd.Series(['0'] * len(df)))
          .astype(str)
          .str.replace('\u202f', '').str.replace('\xa0', '')
          .str.replace(' ', '').str.replace(',', '.'),
        errors='coerce').fillna(0)
    df['Crédit'] = pd.to_numeric(
        df.get('Crédit', pd.Series(['0'] * len(df)))
          .astype(str)
          .str.replace('\u202f', '').str.replace('\xa0', '')
          .str.replace(' ', '').str.replace(',', '.'),
        errors='coerce').fillna(0)
    
    # Utilise colonne F ("b") pour le calcul
    b_col = 'b' if 'b' in df.columns else df.columns[5]
    b_vals = df[b_col].apply(clean_to_number)

    balances = []
    for idx, row in df.iterrows():
        b_val = b_vals.iloc[idx]
        if not np.isnan(b_val):
            balance = b_val
        elif idx == 0:
            balance = np.nan
        else:
            prev_balance = balances[-1]
            if np.isnan(prev_balance):
                balance = np.nan
            else:
                balance = prev_balance + row['Crédit'] - row['Débit']
        balances.append(balance)

    df['balance'] = balances
    df['Mois'] = sheet
    all_data.append(df.copy())

# Concaténé : on garde uniquement les transactions avec une "date d'opération" présente
all_months = pd.concat(all_data[::-1], ignore_index=True)
# Identifie la colonne date d'opération (prend la première correspondance)
date_col = None
for candidate in ["Date opé.", "Dateopé.", "Date opé", "Date_opé", "Date\nopé/", "Dateopé"]:
    if candidate in all_months.columns:
        date_col = candidate
        break

if not date_col:
    print("Colonnes disponibles :", all_months.columns.tolist())
    raise ValueError("Aucune colonne date d'opération trouvée !")

filtered = all_months[all_months[date_col].astype(str).str.strip().str.len() >= 6]
filtered.to_excel(fichier_sortie_concatenation, index=False)

with pd.ExcelWriter(fichier_sortie_balances, engine='openpyxl') as writer:
    for df, sheet_name in zip(all_data, sheet_names):
        df.drop(columns=["Mois"], errors='ignore').to_excel(writer, index=False, sheet_name=sheet_name)

print("Traitement terminé : balance calculée, concaténé filtré sur les lignes avec date d'opération.")

Script de génération de la courbe de la balance

import pandas as pd
import matplotlib.pyplot as plt
import os

# Paramètres fichiers
repertoire_travail = os.path.dirname(os.path.abspath(__file__))
fichier_entree = os.path.join(repertoire_travail, "operations_concatenees.xlsx")
fichier_sortie = os.path.join(repertoire_travail, "balance.jpg")

# Lecture des données
df = pd.read_excel(fichier_entree, dtype=str)
df['balance'] = pd.to_numeric(df['balance'], errors='coerce')
df['Dateopé.'] = pd.to_datetime(df['Dateopé.'], errors='coerce')

# Filtrage des lignes valides uniquement
df = df.dropna(subset=['Dateopé.', 'balance'])
df = df.sort_values(by='Dateopé.')

# Tracé du graphique
plt.figure(figsize=(12,6))
plt.plot(df['Dateopé.'], df['balance'], marker='o', linestyle='-', color='navy')
plt.xlabel("Date de l'opération")
plt.ylabel("Balance (€)")
plt.title("Évolution du solde du compte bancaire")
plt.grid(True)
plt.tight_layout()
plt.savefig(fichier_sortie, format="jpg", dpi=200)
plt.close()

print(f"Graphique enregistré : {fichier_sortie}")