Panel de Portafolio
Resumen
Agrega y analiza datos a través de múltiples proyectos de construcción para obtener visibilidad a nivel de portafolio. Realiza un seguimiento de KPIs, identifica tendencias, compara el rendimiento de los proyectos y respalda las decisiones estratégicas de asignación de recursos.
Marco de Análisis de Portafolio
┌─────────────────────────────────────────────────────────────────┐
│ PANEL DE PORTAFOLIO │
├─────────────────────────────────────────────────────────────────┤
│ │
│ PROYECTO A PROYECTO B PROYECTO C PROYECTO D │
│ ↓ ↓ ↓ ↓ │
│ ┌─────────────────────────────────────────────┐ │
│ │ AGREGACIÓN DE DATOS │ │
│ │ Costo | Cronograma | Seguridad | Calidad | Riesgo │ │
│ └─────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────┐ │
│ │ KPIs DEL PORTAFOLIO │ │
│ │ 📊 Valor Total 📈 % A Tiempo │ │
│ │ 💰 % Dentro de Presupuesto 🛡️ Tasa de Seguridad │ │
│ │ ⚠️ Puntuación de Riesgo 📋 Utilización de Recursos │ │
│ └─────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
Implementación Técnica
from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple
from datetime import datetime, timedelta
from enum import Enum
import statistics
class EstadoProyecto(Enum):
PLANIFICACION = "planning"
ACTIVO = "active"
EN_PAUSA = "on_hold"
COMPLETADO = "complete"
CANCELADO = "cancelled"
class EstadoSalud(Enum):
VERDE = "green" # En camino
AMARILLO = "yellow" # En riesgo
ROJO = "red" # Crítico
GRIS = "grey" # No iniciado/en pausa
@dataclass
class MetricasProyecto:
project_id: str
project_name: str
status: EstadoProyecto
contract_value: float
percent_complete: float
# Cronograma
planned_start: datetime
planned_end: datetime
actual_start: Optional[datetime]
forecast_end: datetime
schedule_variance_days: int = 0
# Costo
budget: float
actual_cost: float
forecast_cost: float
cost_variance: float = 0.0
cpi: float = 1.0
spi: float = 1.0
# Seguridad
recordable_incidents: int = 0
total_hours: float = 0
trir: float = 0.0
# Calidad
defects_open: int = 0
rework_cost: float = 0.0
# Riesgo
risk_score: float = 0.0
critical_risks: int = 0
@property
def health(self) -> EstadoSalud:
"""Determina la salud general del proyecto."""
if self.status in [EstadoProyecto.EN_PAUSA, EstadoProyecto.CANCELADO]:
return EstadoSalud.GRIS
# Crítico si está significativamente por encima del presupuesto/cronograma
if self.cpi < 0.85 or self.spi < 0.85 or self.critical_risks > 3:
return EstadoSalud.ROJO
# En riesgo si está moderadamente fuera de lo previsto
if self.cpi < 0.95 or self.spi < 0.95 or self.critical_risks > 0:
return EstadoSalud.AMARILLO
return EstadoSalud.VERDE
@dataclass
class ResumenPortafolio:
report_date: datetime
total_projects: int
active_projects: int
total_contract_value: float
total_budget: float
total_actual_cost: float
total_forecast_cost: float
# Rendimiento
avg_cpi: float
avg_spi: float
on_budget_pct: float
on_schedule_pct: float
# Seguridad
portfolio_trir: float
total_incidents: int
# Distribución de salud
green_count: int
yellow_count: int
red_count: int
# Tendencias
cost_trend: str
schedule_trend: str
@dataclass
class ComparacionProyectos:
metric: str
projects: Dict[str, float]
avg: float
best: Tuple[str, float]
worst: Tuple[str, float]
class PanelPortafolio:
"""Analítica de portafolio multiproyecto."""
# Umbrales de salud
UMBRALES = {
"cpi_advertencia": 0.95,
"cpi_critico": 0.85,
"spi_advertencia": 0.95,
"spi_critico": 0.85,
"trir_advertencia": 2.0,
"puntuacion_riesgo_advertencia": 7.0
}
def __init__(self, nombre_portafolio: str):
self.nombre_portafolio = nombre_portafolio
self.proyectos: Dict[str, MetricasProyecto] = {}
self.capturas: List[Dict] = [] # Datos históricos
def agregar_proyecto(self, metricas: MetricasProyecto):
"""Agrega o actualiza un proyecto en el portafolio."""
self.proyectos[metricas.project_id] = metricas
def importar_proyectos(self, datos_proyectos: List[Dict]) -> int:
"""Importa múltiples proyectos desde una lista de datos."""
contador = 0
for p in datos_proyectos:
metricas = MetricasProyecto(
project_id=p['id'],
project_name=p['name'],
status=EstadoProyecto(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)
)
# Calcular métricas derivadas
metricas.cost_variance = metricas.budget - metricas.actual_cost
metricas.schedule_variance_days = (metricas.planned_end - metricas.forecast_end).days
if metricas.total_hours > 0:
metricas.trir = (metricas.recordable_incidents * 200000) / metricas.total_hours
self.agregar_proyecto(metricas)
contador += 1
return contador
def obtener_proyectos_activos(self) -> List[MetricasProyecto]:
"""Obtiene la lista de proyectos activos."""
return [p for p in self.proyectos.values()
if p.status == EstadoProyecto.ACTIVO]
def calcular_resumen_portafolio(self) -> ResumenPortafolio:
"""Calcula métricas resumen a nivel de portafolio."""
activos = self.obtener_proyectos_activos()
todos_proyectos = list(self.proyectos.values())
if not todos_proyectos:
return None
# Totales
total_contrato = sum(p.contract_value for p in todos_proyectos)
total_presupuesto = sum(p.budget for p in todos_proyectos)
total_real = sum(p.actual_cost for p in todos_proyectos)
total_pronosticado = sum(p.forecast_cost for p in todos_proyectos)
# Promedios de rendimiento (ponderados por presupuesto)
if total_presupuesto > 0:
avg_cpi = sum(p.cpi * p.budget for p in activos) / sum(p.budget for p in activos) if activos else 1.0
avg_spi = sum(p.spi * p.budget for p in activos) / sum(p.budget for p in activos) if activos else 1.0
else:
avg_cpi = avg_spi = 1.0
# Porcentajes dentro de presupuesto/cronograma
dentro_presupuesto = len([p for p in activos if p.cpi >= 0.95])
dentro_cronograma = len([p for p in activos if p.spi >= 0.95])
pct_presupuesto = (dentro_presupuesto / len(activos) * 100) if activos else 100
pct_cronograma = (dentro_cronograma / len(activos) * 100) if activos else 100
# Métricas de seguridad
total_incidentes = sum(p.recordable_incidents for p in todos_proyectos)
total_horas = sum(p.total_hours for p in todos_proyectos)
trir_portafolio = (total_incidentes * 200000 / total_horas) if total_horas > 0 else 0
# Distribución de salud
verdes = len([p for p in activos if p.health == EstadoSalud.VERDE])
amarillos = len([p for p in activos if p.health == EstadoSalud.AMARILLO])
rojos = len([p for p in activos if p.health == EstadoSalud.ROJO])
# Tendencias (comparar con la captura anterior si está disponible)
tendencia_costo = "estable"
tendencia_cronograma = "estable"
if self.capturas:
prev = self.capturas[-1]
if avg_cpi > prev.get('avg_cpi', 1.0):
tendencia_costo = "mejorando"
elif avg_cpi < prev.get('avg_cpi', 1.0):
tendencia_costo = "empeorando"
if avg_spi > prev.get('avg_spi', 1.0):
tendencia_cronograma = "mejorando"
elif avg_spi < prev.get('avg_spi', 1.0):
tendencia_cronograma = "empeorando"
return ResumenPortafolio(
report_date=datetime.now(),
total_projects=len(todos_proyectos),
active_projects=len(activos),
total_contract_value=total_contrato,
total_budget=total_presupuesto,
total_actual_cost=total_real,
total_forecast_cost=total_pronosticado,
avg_cpi=avg_cpi,
avg_spi=avg_spi,
on_budget_pct=pct_presupuesto,
on_schedule_pct=pct_cronograma,
portfolio_trir=trir_portafolio,
total_incidents=total_incidentes,
green_count=verdes,
yellow_count=amarillos,
red_count=rojos,
cost_trend=tendencia_costo,
schedule_trend=tendencia_cronograma
)
def comparar_proyectos(self, metrica: str) -> ComparacionProyectos:
"""Compara proyectos según una métrica específica."""
activos = self.obtener_proyectos_activos()
if not activos:
return None
mapa_metricas = {
"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 metrica not in mapa_metricas:
raise ValueError(f"Métrica desconocida: {metrica}")
obtener_valor = mapa_metricas[metrica]
valores = {p.project_name: obtener_valor(p) for p in activos}
promedio = statistics.mean(valores.values())
# Mejor/peor depende de la métrica (CPI más alto es bueno, TRIR más bajo es bueno)
if metrica in ["trir", "risk_score"]:
mejor = min(valores.items(), key=lambda x: x[1])
peor = max(valores.items(), key=lambda x: x[1])
else:
mejor = max(valores.items(), key=lambda x: x[1])
peor = min(valores.items(), key=lambda x: x[1])
return ComparacionProyectos(
metric=metrica,
projects=valores,
avg=promedio,
best=mejor,
worst=peor
)
def obtener_proyectos_en_riesgo(self) -> List[MetricasProyecto]:
"""Obtiene los proyectos que necesitan atención."""
return [p for p in self.obtener_proyectos_activos()
if p.health in [EstadoSalud.AMARILLO, EstadoSalud.ROJO]]
def obtener_principales_riesgos(self, limite: int = 10) -> List[Dict]:
"""Obtiene los principales riesgos en todo el portafolio."""
riesgos = []
for p in self.obtener_proyectos_activos():
if p.risk_score > 0:
riesgos.append({
"project": p.project_name,
"risk_score": p.risk_score,
"critical_risks": p.critical_risks,
"cpi": p.cpi,
"spi": p.spi
})
return sorted(riesgos, key=lambda x: -x['risk_score'])[:limite]
def pronosticar_necesidades_efectivo(self, meses: int = 6) -> List[Dict]:
"""Pronostica las necesidades de efectivo en todo el portafolio."""
pronosticos = []
for mes in range(1, meses + 1):
fecha_mes = datetime.now() + timedelta(days=mes * 30)
gasto_mes = 0
for p in self.obtener_proyectos_activos():
# Proyección lineal simple basada en el trabajo restante
restante = p.forecast_cost - p.actual_cost
meses_restantes = max(1, (p.forecast_end - datetime.now()).days / 30)
quema_mensual = restante / meses_restantes
gasto_mes += quema_mensual
pronosticos.append({
"month": fecha_mes.strftime("%Y-%m"),
"projected_spend": gasto_mes
})
return pronosticos
def guardar_captura(self):
"""Guarda el estado actual para el análisis de tendencias."""
resumen = self.calcular_resumen_portafolio()
if resumen:
self.capturas.append({
"date": datetime.now(),
"avg_cpi": resumen.avg_cpi,
"avg_spi": resumen.avg_spi,
"on_budget_pct": resumen.on_budget_pct,
"on_schedule_pct": resumen.on_schedule_pct,
"total_forecast": resumen.total_forecast_cost
})
def generar_reporte(self) -> str:
"""Genera un informe del panel de portafolio."""
resumen = self.calcular_resumen_portafolio()
if not resumen:
return "No hay proyectos en el portafolio"
lineas = [
"# Panel de Portafolio",
"",
f"**Portafolio:** {self.nombre_portafolio}",
f"**Fecha del Informe:** {resumen.report_date.strftime('%Y-%m-%d')}",
"",
"## Resumen Ejecutivo",
"",
"| Métrica | Valor |",
"|--------|-------|",
f"| Total de Proyectos | {resumen.total_projects} ({resumen.active_projects} activos) |",
f"| Valor Total del Contrato | ${resumen.total_contract_value:,.0f} |",
f"| Presupuesto Total | ${resumen.total_budget:,.0f} |",
f"| Costo Real Hasta la Fecha | ${resumen.total_actual_cost:,.0f} |",
f"| Pronóstico al Finalizar | ${... [truncado para traducción]}```
## Funcionalidades Clave
- **Agregación de Datos**: Importa y consolida métricas de múltiples proyectos
- **Indicadores de Salud**: Clasifica automáticamente los proyectos en Verde, Amarillo, Rojo o Gris
- **Comparación de Rendimiento**: Compara proyectos lado a lado utilizando CPI, SPI, TRIR y más
- **Análisis de Riesgos**: Identifica proyectos en riesgo crítico y calcula las principales exposiciones del portafolio
- **Pronóstico de Efectivo**: Predice las necesidades mensuales de efectivo en todo el portafolio
- **Análisis de Tendencias**: Guarda capturas históricas para realizar un seguimiento de la mejora o declive del portafolio
- **Generación de Informes**: Produce informes de portafolio con formato Markdown para compartirlos fácilmente