Tableau de bord de portefeuille
Vue d'ensemble
Agrégez et analysez les données sur plusieurs projets de construction pour une visibilité au niveau du portefeuille. Suivez les KPI, identifiez les tendances, comparez les performances des projets et soutenez les décisions stratégiques d'allocation des ressources.
Cadre d'analyse du portefeuille
┌─────────────────────────────────────────────────────────────────┐
│ TABLEAU DE BORD DU PORTEFEUILLE │
├─────────────────────────────────────────────────────────────────┤
│ │
│ PROJET A PROJET B PROJET C PROJET D │
│ ↓ ↓ ↓ ↓ │
│ ┌─────────────────────────────────────────────┐ │
│ │ AGRÉGATION DES DONNÉES │ │
│ │ Coût | Calendrier | Sécurité | Qualité | Risque │
│ └─────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────┐ │
│ │ KPI DU PORTEFEUILLE │ │
│ │ 📊 Valeur totale 📈 % dans les délais │ │
│ │ 💰 % dans le budget 🛡️ Taux de sécurité │ │
│ │ ⚠️ Score de risque 📋 Utilisation des ressources │ │
│ └─────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
Mise en œuvre technique
from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple
from datetime import datetime, timedelta
from enum import Enum
import statistics
class StatutProjet(Enum):
PLANIFICATION = "planification"
ACTIF = "actif"
EN_SUSPENS = "en_suspens"
TERMINE = "termine"
ANNULE = "annule"
class StatutSante(Enum):
VERT = "vert"
JAUNE = "jaune"
ROUGE = "rouge"
GRIS = "gris"
@dataclass
class MetriquesProjet:
id_projet: str
nom_projet: str
statut: StatutProjet
valeur_contrat: float
pourcentage_acheve: float
debut_prevue: datetime
fin_prevue: datetime
debut_reelle: Optional[datetime]
fin_previsionnelle: datetime
ecart_calendrier_jours: int = 0
budget: float
cout_reel: float
cout_previsionnel: float
ecart_cout: float = 0.0
ipc: float = 1.0
ical: float = 1.0
incidents_declarables: int = 0
heures_total: float = 0
trir: float = 0.0
defauts_ouverts: int = 0
cout_reprise: float = 0.0
score_risque: float = 0.0
risques_critiques: int = 0
@property
def sante(self) -> StatutSante:
"""Déterminer la santé globale du projet."""
if self.statut in [StatutProjet.EN_SUSPENS, StatutProjet.ANNULE]:
return StatutSante.GRIS
if self.ipc < 0.85 or self.ical < 0.85 or self.risques_critiques > 3:
return StatutSante.ROUGE
if self.ipc < 0.95 or self.ical < 0.95 or self.risques_critiques > 0:
return StatutSante.JAUNE
return StatutSante.VERT
@dataclass
class ResumePortefeuille:
date_rapport: datetime
total_projets: int
projets_actifs: int
valeur_contrat_total: float
budget_total: float
cout_reel_total: float
cout_previsionnel_total: float
ipc_moyen: float
ical_moyen: float
pourcentage_dans_budget: float
pourcentage_dans_delais: float
trir_portefeuille: float
total_incidents: int
nb_vert: int
nb_jaune: int
nb_rouge: int
tendance_cout: str
tendance_calendrier: str
@dataclass
class ComparaisonProjets:
metrique: str
projets: Dict[str, float]
moyenne: float
meilleur: Tuple[str, float]
pire: Tuple[str, float]
class TableauBordPortefeuille:
"""Analytique multi-projets du portefeuille."""
SEUILS = {
"avertissement_ipc": 0.95,
"critique_ipc": 0.85,
"avertissement_ical": 0.95,
"critique_ical": 0.85,
"avertissement_trir": 2.0,
"avertissement_score_risque": 7.0
}
def __init__(self, nom_portefeuille: str):
self.nom_portefeuille = nom_portefeuille
self.projets: Dict[str, MetriquesProjet] = {}
self.captures: List[Dict] = []
def ajouter_projet(self, metriques: MetriquesProjet):
"""Ajouter ou mettre à jour un projet dans le portefeuille."""
self.projets[metriques.id_projet] = metriques
def importer_projets(self, donnees_projets: List[Dict]) -> int:
"""Importer plusieurs projets à partir de données."""
compteur = 0
for p in donnees_projets:
metriques = MetriquesProjet(
id_projet=p['id'],
nom_projet=p['name'],
statut=StatutProjet(p.get('status', 'actif')),
valeur_contrat=p['contract_value'],
pourcentage_acheve=p.get('percent_complete', 0),
debut_prevue=p['planned_start'],
fin_prevue=p['planned_end'],
debut_reelle=p.get('actual_start'),
fin_previsionnelle=p.get('forecast_end', p['planned_end']),
budget=p['budget'],
cout_reel=p.get('actual_cost', 0),
cout_previsionnel=p.get('forecast_cost', p['budget']),
ipc=p.get('cpi', 1.0),
ical=p.get('spi', 1.0),
incidents_declarables=p.get('incidents', 0),
heures_total=p.get('total_hours', 0),
score_risque=p.get('risk_score', 0),
risques_critiques=p.get('critical_risks', 0)
)
metriques.ecart_cout = metriques.budget - metriques.cout_reel
metriques.ecart_calendrier_jours = (metriques.fin_prevue - metriques.fin_previsionnelle).days
if metriques.heures_total > 0:
metriques.trir = (metriques.incidents_declarables * 200000) / metriques.heures_total
self.ajouter_projet(metriques)
compteur += 1
return compteur
def obtenir_projets_actifs(self) -> List[MetriquesProjet]:
"""Obtenir la liste des projets actifs."""
return [p for p in self.projets.values()
if p.statut == StatutProjet.ACTIF]
def calculer_resume_portefeuille(self) -> ResumePortefeuille:
"""Calculer les métriques de résumé au niveau du portefeuille."""
actifs = self.obtenir_projets_actifs()
tous_les_projets = list(self.projets.values())
if not tous_les_projets:
return None
total_contrat = sum(p.valeur_contrat for p in tous_les_projets)
total_budget = sum(p.budget for p in tous_les_projets)
total_reel = sum(p.cout_reel for p in tous_les_projets)
total_previsionnel = sum(p.cout_previsionnel for p in tous_les_projets)
if total_budget > 0:
ipc_moyen = sum(p.ipc * p.budget for p in actifs) / sum(p.budget for p in actifs) if actifs else 1.0
ical_moyen = sum(p.ical * p.budget for p in actifs) / sum(p.budget for p in actifs) if actifs else 1.0
else:
ipc_moyen = ical_moyen = 1.0
dans_budget = len([p for p in actifs if p.ipc >= 0.95])
dans_delais = len([p for p in actifs if p.ical >= 0.95])
pourcentage_budget = (dans_budget / len(actifs) * 100) if actifs else 100
pourcentage_delais = (dans_delais / len(actifs) * 100) if actifs else 100
total_incidents = sum(p.incidents_declarables for p in tous_les_projets)
total_heures = sum(p.heures_total for p in tous_les_projets)
trir_portefeuille = (total_incidents * 200000 / total_heures) if total_heures > 0 else 0
vert = len([p for p in actifs if p.sante == StatutSante.VERT])
jaune = len([p for p in actifs if p.sante == StatutSante.JAUNE])
rouge = len([p for p in actifs if p.sante == StatutSante.ROUGE])
tendance_cout = "stable"
tendance_calendrier = "stable"
if self.captures:
prec = self.captures[-1]
if ipc_moyen > prec.get('avg_cpi', 1.0):
tendance_cout = "en amélioration"
elif ipc_moyen < prec.get('avg_cpi', 1.0):
tendance_cout = "en déclin"
if ical_moyen > prec.get('avg_spi', 1.0):
tendance_calendrier = "en amélioration"
elif ical_moyen < prec.get('avg_spi', 1.0):
tendance_calendrier = "en déclin"
return ResumePortefeuille(
date_rapport=datetime.now(),
total_projets=len(tous_les_projets),
projets_actifs=len(actifs),
valeur_contrat_total=total_contrat,
budget_total=total_budget,
cout_reel_total=total_reel,
cout_previsionnel_total=total_previsionnel,
ipc_moyen=ipc_moyen,
ical_moyen=ical_moyen,
pourcentage_dans_budget=pourcentage_budget,
pourcentage_dans_delais=pourcentage_delais,
trir_portefeuille=trir_portefeuille,
total_incidents=total_incidents,
nb_vert=vert,
nb_jaune=jaune,
nb_rouge=rouge,
tendance_cout=tendance_cout,
tendance_calendrier=tendance_calendrier
)
def comparer_projets(self, metrique: str) -> ComparaisonProjets:
"""Comparer les projets selon une métrique spécifique."""
actifs = self.obtenir_projets_actifs()
if not actifs:
return None
correspondance_metriques = {
"cpi": lambda p: p.ipc,
"spi": lambda p: p.ical,
"percent_complete": lambda p: p.pourcentage_acheve,
"cost_variance": lambda p: p.ecart_cout,
"trir": lambda p: p.trir,
"risk_score": lambda p: p.score_risque
}
if metrique not in correspondance_metriques:
raise ValueError(f"Métrique inconnue : {metrique}")
obteneur = correspondance_metriques[metrique]
valeurs = {p.nom_projet: obteneur(p) for p in actifs}
moyenne = statistics.mean(valeurs.values())
if metrique in ["trir", "risk_score"]:
meilleur = min(valeurs.items(), key=lambda x: x[1])
pire = max(valeurs.items(), key=lambda x: x[1])
else:
meilleur = max(valeurs.items(), key=lambda x: x[1])
pire = min(valeurs.items(), key=lambda x: x[1])
return ComparaisonProjets(
metrique=metrique,
projets=valeurs,
moyenne=moyenne,
meilleur=meilleur,
pire=pire
)
def obtenir_projets_a_risque(self) -> List[MetriquesProjet]:
"""Obtenir les projets qui nécessitent une attention."""
return [p for p in self.obtenir_projets_actifs()
if p.sante in [StatutSante.JAUNE, StatutSante.ROUGE]]
def obtenir_principaux_risques(self, limite: int = 10) -> List[Dict]:
"""Obtenir les principaux risques dans l'ensemble du portefeuille."""
risques = []
for p in self.obtenir_projets_actifs():
if p.score_risque > 0:
risques.append({
"projet": p.nom_projet,
"score_risque": p.score_risque,
"risques_critiques": p.risques_critiques,
"ipc": p.ipc,
"ical": p.ical
})
return sorted(risques, key=lambda x: -x['score_risque'])[:limite]
def prevoir_besoins_tresorerie(self, mois: int = 6) -> List[Dict]:
"""Prévoir les besoins de trésorerie dans l'ensemble du portefeuille."""
previsions = []
for mois_courant in range(1, mois + 1):
date_mois = datetime.now() + timedelta(days=mois_courant * 30)
depenses_mois = 0
for p in self.obtenir_projets_actifs():
restant = p.cout_previsionnel - p.cout_reel
mois_restants = max(1, (p.fin_previsionnelle - datetime.now()).days / 30)
taux_mensuel = restant / mois_restants
depenses_mois += taux_mensuel
previsions.append({
"mois": date_mois.strftime("%Y-%m"),
"depenses_prevues": depenses_mois
})
return previsions
def sauvegarder_capture(self):
"""Sauvegarder l'état actuel pour l'analyse des tendances."""
resume = self.calculer_resume_portefeuille()
if resume:
self.captures.append({
"date": datetime.now(),
"avg_cpi": resume.ipc_moyen,
"avg_spi": resume.ical_moyen,
"on_budget_pct": resume.pourcentage_dans_budget,
"on_schedule_pct": resume.pourcentage_dans_delais,
"total_forecast": resume.cout_previsionnel_total
})
def generer_rapport(self) -> str:
"""Générer le rapport du tableau de bord du portefeuille."""
resume = self.calculer_resume_portefeuille()
if not resume:
return "Aucun projet dans le portefeuille"
lignes = [
"# Tableau de bord du portefeuille",
"",
f"**Portefeuille :** {self.nom_portefeuille}",
f"**Date du rapport :** {resume.date_rapport.strftime('%Y-%m-%d')}",
"",
"## Résumé exécutif",
"",
"| Métrique | Valeur |",
"|--------|-------|",
f"| Total des projets | {resume.total_projets} ({resume.projets_actifs} actifs) |",
f"| Valeur totale des contrats | {resume.valeur_contrat_total:,.0f} € |",
f"| Budget total | {resume.budget_total:,.0f} € |",
f"| Coût réel à ce jour | {resume.cout_reel_total:,.0f} € |",
f"| Prévision à l'achèvement | {resume.cout_previsionnel_total:,.0f} € |",
f"| IPC moyen | {resume.ipc_moyen:.2f} |",
f"| ICAL moyen | {resume.ical_moyen:.2f} |",
f"| % dans le budget | {resume.pourcentage_dans_budget:.1f}% |",
f"| % dans les délais | {resume.pourcentage_dans_delais:.1f}% |",
f"| TRIR du portefeuille | {resume.trir_portefeuille:.1f} |",
f"| Total des incidents | {resume.total_incidents} |",
"",
"## Répartition de la santé",
"",
f"- 🟢 Vert (sur la bonne voie) : {resume.nb_vert}",
f"- 🟡 Jaune (à risque) : {resume.nb_jaune}",
f"- 🔴 Rouge (critique) : {resume.nb_rouge}",
"",
"## Tendances",
"",
f"- **Tendance des coûts :** {resume.tendance_cout}",
f"- **Tendance du calendrier :** {resume.tendance_calendrier}",
"",
"## Projets à risque",
"",
]
projets_a_risque = self.obtenir_projets_a_risque()
if projets_a_risque:
for p in projets_a_risque:
lignes.append(f"- **{p.nom_projet}** - Santé : {p.sante.value}, IPC : {p.ipc:.2f}, ICAL : {p.ical:.2f}")
else:
lignes.append("Aucun projet n'est actuellement à risque.")
lignes.extend([
"",
"## Principaux risques",
"",
])
principaux_risques = self.obtenir_principaux_risques()
if principaux_risques:
for risque in principaux_risques:
lignes.append(f"- **{risque['projet']}** - Score de risque : {risque['score_risque']:.2f}, Risques critiques : {risque['risques_critiques']}")
else:
lignes.append("Aucun risque significatif identifié.")
lignes.extend([
"",
"## Prévisions de trésorerie",
"",
"| Mois | Dépenses prévues |",
"|------|------------------|",
])
previsions = self.prevoir_besoins_tresorerie()
for prev in previsions:
lignes.append(f"| {prev['mois']} | {prev['projected_spend']:,.0f} € |")
lignes.append("")
lignes.append("---")
lignes.append("*Rapport généré automatiquement*")
return "\n".join(lignes)
if __name__ == "__main__":
portefeuille = TableauBordPortefeuille("Projets de construction régionaux")
donnees_projets = [
{
"id": "CON-001",
"name": "Développement du quartier Riverside",
"status": "active",
"contract_value": 50000000,
"percent_complete": 45,
"planned_start": datetime(2023, 6, 1),
"planned_end": datetime(2025, 12, 31),
"forecast_end": datetime(2026, 3, 15),
"budget": 48000000,
"actual_cost": 22000000,
"forecast_cost": 51000000,
"cpi": 0.92,
"spi": 0.88,
"incidents": 2,
"total_hours": 120000,
"risk_score": 6.5,
"critical_risks": 2
},
{
"id": "CON-002",
"name": "Pont de la baie Nord",
"status": "active",
"contract_value": 80000000,
"percent_complete": 60,
"planned_start": datetime(2022, 1, 1),
"planned_end": datetime(2024, 6, 30),
"actual_start": datetime(2022, 1, 15),
"forecast_end": datetime(2024, 8, 15),
"budget": 75000000,
"actual_cost": 44000000,
"forecast_cost": 78000000,
"cpi": 0.97,
"spi": 0.95,
"incidents": 1,
"total_hours": 200000,
"risk_score": 4.2,
"critical_risks": 0
},
{
"id": "CON-003",
"name": "Tunnel du centre-ville",
"status": "active",
"contract_value": 120000000,
"percent_complete": 30,
"planned_start": datetime(2024, 1, 1),
"planned_end": datetime(2026, 12, 31),
"actual_start": datetime(2024, 1, 15),
"forecast_end": datetime(2027, 6, 30),
"budget": 115000000,
"actual_cost": 40000000,
"forecast_cost": 125000000,
"cpi": 0.85,
"spi": 0.82,
"incidents": 3,
"total_hours": 150000,
"risk_score": 8.9,
"critical_risks": 4
}
]
portefeuille.importer_projets(donnees_projets)
rapport = portefeuille.generer_rapport()
print(rapport)
API de référence
Principales classes
| Classe | Description |
|---|
StatutProjet | Énumération des statuts de projet : planification, actif, en suspens, terminé, annulé |
StatutSante | Énumération de la santé du projet : vert (bon), jaune (à risque), rouge (critique), gris (inactif) |
MetriquesProjet | Métriques détaillées d'un projet individuel, y compris les coûts, le calendrier, la sécurité, la qualité et les risques |
ResumePortefeuille | Résumé du portefeuille calculé avec KPI agrégés |
ComparaisonProjets | Résultats de la comparaison entre projets pour une métrique spécifique |
TableauBordPortefeuille | Analyse principale du portefeuille multi-projets avec tous les calculs et la génération de rapports |
Principales méthodes
| Méthode | Retourne | Description |
|---|
ajouter_projet() | None | Ajouter ou mettre à jour un projet dans le portefeuille |
importer_projets() | int | Importer plusieurs projets à partir de dictionnaires de données |
calculer_resume_portefeuille() | ResumePortefeuille | Calculer les métriques de résumé du portefeuille, y compris les moyennes pondérées |
comparer_projets(metrique) | ComparaisonProjets | Comparer les projets par métrique spécifique avec les résultats les meilleurs/pires |
obtenir_projets_a_risque() | List[MetriquesProjet] | Obtenir les projets avec une santé jaune ou rouge |
obtenir_principaux_risques(limite) | List[Dict] | Obtenir les N premiers risques dans l'ensemble du portefeuille |
prevoir_besoins_tresorerie(mois) | List[Dict] | Prévoir les besoins de trésorerie mensuels pour les X prochains mois |
generer_rapport() | str | Générer un rapport complet au format markdown du tableau de bord |
Métriques de comparaison
ipc - Indice de performance des coûts (supérieur est meilleur)
ical - Indice de performance du calendrier (supérieur est meilleur)
pourcentage_acheve - Pourcentage d'avancement
ecart_cout - Écart de coût (budget - réel)
trir - Taux d'incidents enregistrables total (inférieur est meilleur)
score_risque - Score de risque global (inférieur est meilleur)