Que fait Tableau de Bord de Portefeuille ?
Aperçu
Agrégez et analysez les données de plusieurs projets de construction pour une visibilité au niveau du portefeuille. Suivez les KPI, identifiez les tendances, comparez les performances des projets et soutenez l'allocation stratégique des ressources.
Cadre d'Analyse du Portefeuille
┌─────────────────────────────────────────────────────────────────┐
│ TABLEAU DE BORD DU PORTEFEUILLE │
├─────────────────────────────────────────────────────────────────┤
│ │
│ PROJET A PROJET B PROJET C PROJET D │
│ ↓ ↓ ↓ ↓ │
│ ┌─────────────────────────────────────────────┐ │
│ │ AGRÉGATION DE 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 Ress.│ │
│ └─────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
Implémentation 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 ProjectStatus(Enum):
PLANNING = "planning"
ACTIVE = "active"
ON_HOLD = "on_hold"
COMPLETE = "complete"
CANCELLED = "cancelled"
class HealthStatus(Enum):
GREEN = "green" # Sur la bonne voie
YELLOW = "yellow" # À risque
RED = "red" # Critique
GREY = "grey" # Non démarré/en pause
@dataclass
class ProjectMetrics:
project_id: str
project_name: str
status: ProjectStatus
contract_value: float
percent_complete: float
# Calendrier
planned_start: datetime
planned_end: datetime
actual_start: Optional[datetime]
forecast_end: datetime
schedule_variance_days: int = 0
# Coût
budget: float
actual_cost: float
forecast_cost: float
cost_variance: float = 0.0
cpi: float = 1.0
spi: float = 1.0
# Sécurité
recordable_incidents: int = 0
total_hours: float = 0
trir: float = 0.0
# Qualité
defects_open: int = 0
rework_cost: float = 0.0
# Risque
risk_score: float = 0.0
critical_risks: int = 0
@property
def health(self) -> HealthStatus:
"""Détermine la santé globale du projet."""
if self.status in [ProjectStatus.ON_HOLD, ProjectStatus.CANCELLED]:
return HealthStatus.GREY
# Critique si significativement hors budget/calendrier
if self.cpi < 0.85 or self.spi < 0.85 or self.critical_risks > 3:
return HealthStatus.RED
# À risque si modérément en retard
if self.cpi < 0.95 or self.spi < 0.95 or self.critical_risks > 0:
return HealthStatus.YELLOW
return HealthStatus.GREEN
@dataclass
class PortfolioSummary:
report_date: datetime
total_projects: int
active_projects: int
total_contract_value: float
total_budget: float
total_actual_cost: float
total_forecast_cost: float
# Performance
avg_cpi: float
avg_spi: float
on_budget_pct: float
on_schedule_pct: float
# Sécurité
portfolio_trir: float
total_incidents: int
# Répartition de la santé
green_count: int
yellow_count: int
red_count: int
# Tendances
cost_trend: str
schedule_trend: str
@dataclass
class ProjectComparison:
metric: str
projects: Dict[str, float]
avg: float
best: Tuple[str, float]
worst: Tuple[str, float]
class PortfolioDashboard:
"""Analyse multi-projets du portefeuille."""
# Seuils de santé
THRESHOLDS = {
"cpi_warning": 0.95,
"cpi_critical": 0.85,
"spi_warning": 0.95,
"spi_critical": 0.85,
"trir_warning": 2.0,
"risk_score_warning": 7.0
}
def __init__(self, portfolio_name: str):
self.portfolio_name = portfolio_name
self.projects: Dict[str, ProjectMetrics] = {}
self.snapshots: List[Dict] = [] # Données historiques
def add_project(self, metrics: ProjectMetrics):
"""Ajoute ou met à jour un projet dans le portefeuille."""
self.projects[metrics.project_id] = metrics
def import_projects(self, projects_data: List[Dict]) -> int:
"""Importe plusieurs projets à partir de données."""
count = 0
for p in projects_data:
metrics = ProjectMetrics(
project_id=p['id'],
project_name=p['name'],
status=ProjectStatus(p.get('status', 'active')),
contract_value=p['contract_value'],
percent_complete=p.get('percent_complete', 0),
planned_start=p['planned_start'],
planned_end=p['planned_end'],
actual_start=p.get('actual_start'),
forecast_end=p.get('forecast_end', p['planned_end']),
budget=p['budget'],
actual_cost=p.get('actual_cost', 0),
forecast_cost=p.get('forecast_cost', p['budget']),
cpi=p.get('cpi', 1.0),
spi=p.get('spi', 1.0),
recordable_incidents=p.get('incidents', 0),
total_hours=p.get('total_hours', 0),
risk_score=p.get('risk_score', 0),
critical_risks=p.get('critical_risks', 0)
)
# Calcul des métriques dérivées
metrics.cost_variance = metrics.budget - metrics.actual_cost
metrics.schedule_variance_days = (metrics.planned_end - metrics.forecast_end).days
if metrics.total_hours > 0:
metrics.trir = (metrics.recordable_incidents * 200000) / metrics.total_hours
self.add_project(metrics)
count += 1
return count
def get_active_projects(self) -> List[ProjectMetrics]:
"""Récupère la liste des projets actifs."""
return [p for p in self.projects.values()
if p.status == ProjectStatus.ACTIVE]
def calculate_portfolio_summary(self) -> PortfolioSummary:
"""Calcule les métriques récapitulatives du portefeuille."""
active = self.get_active_projects()
all_projects = list(self.projects.values())
if not all_projects:
return None
# Totaux
total_contract = sum(p.contract_value for p in all_projects)
total_budget = sum(p.budget for p in all_projects)
total_actual = sum(p.actual_cost for p in all_projects)
total_forecast = sum(p.forecast_cost for p in all_projects)
# Moyennes de performance (pondérées par le budget)
if total_budget > 0:
avg_cpi = sum(p.cpi * p.budget for p in active) / sum(p.budget for p in active) if active else 1.0
avg_spi = sum(p.spi * p.budget for p in active) / sum(p.budget for p in active) if active else 1.0
else:
avg_cpi = avg_spi = 1.0
# Pourcentages dans le budget/calendrier
on_budget = len([p for p in active if p.cpi >= 0.95])
on_schedule = len([p for p in active if p.spi >= 0.95])
on_budget_pct = (on_budget / len(active) * 100) if active else 100
on_schedule_pct = (on_schedule / len(active) * 100) if active else 100
# Métriques de sécurité
total_incidents = sum(p.recordable_incidents for p in all_projects)
total_hours = sum(p.total_hours for p in all_projects)
portfolio_trir = (total_incidents * 200000 / total_hours) if total_hours > 0 else 0
# Répartition de la santé
green = len([p for p in active if p.health == HealthStatus.GREEN])
yellow = len([p for p in active if p.health == HealthStatus.YELLOW])
red = len([p for p in active if p.health == HealthStatus.RED])
# Tendances (comparaison avec l'instantané précédent si disponible)
cost_trend = "stable"
schedule_trend = "stable"
if self.snapshots:
prev = self.snapshots[-1]
if avg_cpi > prev.get('avg_cpi', 1.0):
cost_trend = "amélioration"
elif avg_cpi < prev.get('avg_cpi', 1.0):
cost_trend = "dégradation"
if avg_spi > prev.get('avg_spi', 1.0):
schedule_trend = "amélioration"
elif avg_spi < prev.get('avg_spi', 1.0):
schedule_trend = "dégradation"
return PortfolioSummary(
report_date=datetime.now(),
total_projects=len(all_projects),
active_projects=len(active),
total_contract_value=total_contract,
total_budget=total_budget,
total_actual_cost=total_actual,
total_forecast_cost=total_forecast,
avg_cpi=avg_cpi,
avg_spi=avg_spi,
on_budget_pct=on_budget_pct,
on_schedule_pct=on_schedule_pct,
portfolio_trir=portfolio_trir,
total_incidents=total_incidents,
green_count=green,
yellow_count=yellow,
red_count=red,
cost_trend=cost_trend,
schedule_trend=schedule_trend
)
def compare_projects(self, metric: str) -> ProjectComparison:
"""Compare les projets selon une métrique spécifique."""
active = self.get_active_projects()
if not active:
return None
metric_map = {
"cpi": lambda p: p.cpi,
"spi": lambda p: p.spi,
"percent_complete": lambda p: p.percent_complete,
"cost_variance": lambda p: p.cost_variance,
"trir": lambda p: p.trir,
"risk_score": lambda p: p.risk_score
}
if metric not in metric_map:
raise ValueError(f"Métrique inconnue : {metric}")
getter = metric_map[metric]
values = {p.project_name: getter(p) for p in active}
avg = statistics.mean(values.values())
# Meilleur/pire dépend de la métrique (CPI élevé bon, TRIR bas bon)
if metric in ["trir", "risk_score"]:
best = min(values.items(), key=lambda x: x[1])
worst = max(values.items(), key=lambda x: x[1])
else:
best = max(values.items(), key=lambda x: x[1])
worst = min(values.items(), key=lambda x: x[1])
return ProjectComparison(
metric=metric,
projects=values,
avg=avg,
best=best,
worst=worst
)
def get_projects_at_risk(self) -> List[ProjectMetrics]:
"""Récupère les projets nécessitant une attention."""
return [p for p in self.get_active_projects()
if p.health in [HealthStatus.YELLOW, HealthStatus.RED]]
def get_top_risks(self, limit: int = 10) -> List[Dict]:
"""Récupère les principaux risques dans le portefeuille."""
risks = []
for p in self.get_active_projects():
if p.risk_score > 0:
risks.append({
"project": p.project_name,
"risk_score": p.risk_score,
"critical_risks": p.critical_risks,
"cpi": p.cpi,
"spi": p.spi
})
return sorted(risks, key=lambda x: -x['risk_score'])[:limit]
def forecast_cash_needs(self, months: int = 6) -> List[Dict]:
"""Prévoit les besoins de trésorerie dans le portefeuille."""
forecasts = []
for month in range(1, months + 1):
month_date = datetime.now() + timedelta(days=month * 30)
month_spend = 0
for p in self.get_active_projects():
# Projection linéaire simple basée sur le travail restant
remaining = p.forecast_cost - p.actual_cost
months_remaining = max(1, (p.forecast_end - datetime.now()).days / 30)
monthly_burn = remaining / months_remaining
month_spend += monthly_burn
forecasts.append({
"month": month_date.strftime("%Y-%m"),
"projected_spend": month_spend
})
return forecasts
def save_snapshot(self):
"""Enregistre l'état actuel pour l'analyse des tendances."""
summary = self.calculate_portfolio_summary()
if summary:
self.snapshots.append({
"date": datetime.now(),
"avg_cpi": summary.avg_cpi,
"avg_spi": summary.avg_spi,
"on_budget_pct": summary.on_budget_pct,
"on_schedule_pct": summary.on_schedule_pct,
"total_forecast": summary.total_forecast_cost
})
def generate_report(self) -> str:
"""Génère un rapport du tableau de bord du portefeuille."""
summary = self.calculate_portfolio_summary()
if not summary:
return "Aucun projet dans le portefeuille"
lines = [
"# Tableau de Bord du Portefeuille",
"",
f"**Portefeuille :** {self.portfolio_name}",
f"**Date du Rapport :** {summary.report_date.strftime('%Y-%m-%d')}",
"",
"## Résumé Exécutif",
"",
f"| Métrique | Valeur |",
f"|--------|-------|",
f"| Total Projets | {summary.total_projects} ({summary.active_projects} actifs) |",
f"| Valeur Totale des Contrats | ${summary.total_contract_value:,.0f} |",
f"| Budget Total | ${summary.total_budget:,.0f} |",
f"| Coût Réel à Ce Jour | ${summary.total_actual_cost:,.0f} |",
f"| Prévision à l'Achèvement | ${summary.total_forecast_cost:,.0f} |",
f"| IPC Moyen | {summary.avg_cpi:.2f} |",
f"| ISP Moyen | {summary.avg_spi:.2f} |",
"",
"## Santé du Portefeuille",
"",
f"| Indicateur | Valeur |",
f"|----------|-------|",
f"| 🟢 Sur la bonne voie | {summary.green_count} |",
f"| 🟡 À risque | {summary.yellow_count} |",
f"| 🔴 Critique | {summary.red_count} |",
f"| % dans le Budget | {summary.on_budget_pct:.1f}% |",
f"| % dans les Délais | {summary.on_schedule_pct:.1f}% |",
"",
"## Tendances",
"",
f"| Métrique | Tendance |",
f"|----------|--------|",
f"| Performance des Coûts | {summary.cost_trend} |",
f"| Performance du Calendrier | {summary.schedule_trend} |",
"",
"## Sécurité",
"",
f"| Métrique | Valeur |",
f"|----------|-------|",
f"| TRIR du Portefeuille | {summary.portfolio_trir:.2f} |",
f"| Total Incidents | {summary.total_incidents} |",
"",
"## Projets à Risque",
""
]
# Ajouter les détails des projets à risque
at_risk = self.get_projects_at_risk()
if at_risk:
lines.append(f"| Projet | Santé | IPC | ISP | Score de Risque |")
lines.append(f"|--------|-------|-----|-----|----------------|")
for p in at_risk:
health_icon = {
HealthStatus.YELLOW: "🟡",
HealthStatus.RED: "🔴"
}.get(p.health, "⚪")
lines.append(f"| {p.project_name} | {health_icon} {p.health.value} | {p.cpi:.2f} | {p.spi:.2f} | {p.risk_score:.1f} |")
else:
lines.append("Aucun projet n'est actuellement à risque.")
lines.append("")
lines.append("---")
lines.append(f"*Rapport généré par le Tableau de Bord du Portefeuille le {summary.report_date.strftime('%Y-%m-%d %H:%M')}*")
return "\n".join(lines)
Utilisation
# Initialiser le tableau de bord du portefeuille
dashboard = PortfolioDashboard("Construction Mega-Portfolio")
# Importer les données du projet
dashboard.import_projects(project_data)
# Générer un rapport
generated_report = dashboard.generate_report()
print(generated_report)
# Vérifier les tendances
dashboard.save_snapshot()
# Plus tard...
dashboard.import_projects(new_project_data)
summary = dashboard.calculate_portfolio_summary()
print(f"IPC : {summary.avg_cpi}, ISP : {summary.avg_spi}")
print(f"Tendance des coûts : {summary.cost_trend}")
Cette compétence est conçue pour être utilisée dans des environnements d'IA agentive pour fournir des analyses de portefeuille en temps réel. Elle s'intègre parfaitement dans les flux de travail où les données de projet sont disponibles sous forme structurée.