schedule generation endpoint

api/greedyoptim_api.py

@@ -19,6 +19,7 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from greedyOptim.scheduler import optimize_trainset_schedule, compare_optimization_methods
 from greedyOptim.models import OptimizationConfig, OptimizationResult
 from greedyOptim.error_handling import DataValidator
+from greedyOptim.schedule_generator import generate_schedule_from_result
 
 # Import DataService for synthetic data generation (optional)
 from DataService.enhanced_generator import EnhancedMetroDataGenerator
@@ -172,6 +173,74 @@ class ScheduleOptimizationResponse(BaseModel):
     warnings: Optional[List[str]] = None
 
 
+# New models for full schedule response
+class ServiceBlockResponse(BaseModel):
+    """Service block with timing details"""
+    block_id: str
+    departure_time: str
+    origin: str
+    destination: str
+    trip_count: int
+    estimated_km: float
+
+
+class TrainsetScheduleResponse(BaseModel):
+    """Complete schedule for a single trainset"""
+    trainset_id: str
+    status: str
+    readiness_score: float
+    daily_km_allocation: float
+    cumulative_km: float
+    assigned_duty: Optional[str] = None
+    priority_rank: Optional[int] = None
+    service_blocks: Optional[List[ServiceBlockResponse]] = None
+    stabling_bay: Optional[str] = None
+    standby_reason: Optional[str] = None
+    maintenance_type: Optional[str] = None
+    ibl_bay: Optional[str] = None
+    estimated_completion: Optional[str] = None
+    alerts: Optional[List[str]] = None
+
+
+class FleetSummaryResponse(BaseModel):
+    """Fleet summary statistics"""
+    total_trainsets: int
+    revenue_service: int
+    standby: int
+    maintenance: int
+    availability_percent: float
+
+
+class OptimizationMetricsResponse(BaseModel):
+    """Optimization metrics"""
+    fitness_score: float
+    method: str
+    mileage_variance_coefficient: float
+    total_planned_km: float
+    optimization_runtime_ms: int
+
+
+class AlertResponse(BaseModel):
+    """Schedule alert"""
+    trainset_id: str
+    severity: str
+    alert_type: str
+    message: str
+
+
+class FullScheduleResponse(BaseModel):
+    """Complete schedule response with service blocks and timing"""
+    schedule_id: str
+    generated_at: str
+    valid_from: str
+    valid_until: str
+    depot: str
+    trainsets: List[TrainsetScheduleResponse]
+    fleet_summary: FleetSummaryResponse
+    optimization_metrics: OptimizationMetricsResponse
+    alerts: List[AlertResponse]
+
+
 # ============================================================================
 # Helper Functions
 # ============================================================================
@@ -253,6 +322,78 @@ def convert_result_to_response(
     )
 
 
+def convert_schedule_result_to_response(schedule_result) -> FullScheduleResponse:
+    """Convert ScheduleResult to API FullScheduleResponse"""
+    from greedyOptim.models import ScheduleResult
+    
+    trainsets = []
+    for ts in schedule_result.trainsets:
+        service_blocks_resp = None
+        if ts.service_blocks:
+            service_blocks_resp = [
+                ServiceBlockResponse(
+                    block_id=sb.block_id,
+                    departure_time=sb.departure_time,
+                    origin=sb.origin,
+                    destination=sb.destination,
+                    trip_count=sb.trip_count,
+                    estimated_km=sb.estimated_km
+                )
+                for sb in ts.service_blocks
+            ]
+        
+        trainsets.append(TrainsetScheduleResponse(
+            trainset_id=ts.trainset_id,
+            status=ts.status.value if hasattr(ts.status, 'value') else ts.status,
+            readiness_score=ts.readiness_score,
+            daily_km_allocation=ts.daily_km_allocation,
+            cumulative_km=ts.cumulative_km,
+            assigned_duty=ts.assigned_duty,
+            priority_rank=ts.priority_rank,
+            service_blocks=service_blocks_resp,
+            stabling_bay=ts.stabling_bay,
+            standby_reason=ts.standby_reason,
+            maintenance_type=ts.maintenance_type.value if ts.maintenance_type and hasattr(ts.maintenance_type, 'value') else ts.maintenance_type,
+            ibl_bay=ts.ibl_bay,
+            estimated_completion=ts.estimated_completion,
+            alerts=ts.alerts
+        ))
+    
+    alerts = [
+        AlertResponse(
+            trainset_id=a.trainset_id,
+            severity=a.severity.value if hasattr(a.severity, 'value') else a.severity,
+            alert_type=a.alert_type,
+            message=a.message
+        )
+        for a in schedule_result.alerts
+    ]
+    
+    return FullScheduleResponse(
+        schedule_id=schedule_result.schedule_id,
+        generated_at=schedule_result.generated_at,
+        valid_from=schedule_result.valid_from,
+        valid_until=schedule_result.valid_until,
+        depot=schedule_result.depot,
+        trainsets=trainsets,
+        fleet_summary=FleetSummaryResponse(
+            total_trainsets=schedule_result.fleet_summary.total_trainsets,
+            revenue_service=schedule_result.fleet_summary.revenue_service,
+            standby=schedule_result.fleet_summary.standby,
+            maintenance=schedule_result.fleet_summary.maintenance,
+            availability_percent=schedule_result.fleet_summary.availability_percent
+        ),
+        optimization_metrics=OptimizationMetricsResponse(
+            fitness_score=schedule_result.optimization_metrics.fitness_score,
+            method=schedule_result.optimization_metrics.method,
+            mileage_variance_coefficient=schedule_result.optimization_metrics.mileage_variance_coefficient,
+            total_planned_km=schedule_result.optimization_metrics.total_planned_km,
+            optimization_runtime_ms=schedule_result.optimization_metrics.optimization_runtime_ms
+        ),
+        alerts=alerts
+    )
+
+
 # ============================================================================
 # API Endpoints
 # ============================================================================
@@ -265,7 +406,8 @@ async def root():
         "version": "2.0.0",
         "description": "Advanced train scheduling optimization",
         "endpoints": {
-            "POST /optimize": "Optimize schedule with custom data",
+            "POST /optimize": "Optimize schedule with custom data (returns trainset allocations)",
+            "POST /schedule": "Generate full schedule with service blocks and timing",
             "POST /compare": "Compare multiple optimization methods",
             "POST /generate-synthetic": "Generate synthetic test data",
             "POST /validate": "Validate input data structure",
@@ -398,6 +540,84 @@ async def optimize_schedule(request: ScheduleOptimizationRequest):
         )
 
 
+@app.post("/schedule", response_model=FullScheduleResponse)
+async def generate_full_schedule(request: ScheduleOptimizationRequest):
+    """
+    Generate complete schedule with service blocks and timing.
+    
+    This endpoint returns a full schedule with:
+    - Service blocks with departure times and routes
+    - Bay allocations
+    - Daily km assignments
+    - Fleet summary
+    - Alerts and warnings
+    
+    Use this endpoint when you need operational timetables, not just trainset allocations.
+    """
+    try:
+        import time
+        start_time = time.time()
+        
+        logger.info(f"Received full schedule request with {len(request.trainset_status)} trainsets, method: {request.method}")
+        
+        # Convert request to dict format
+        data = convert_pydantic_to_dict(request)
+        
+        # Validate data
+        validation_errors = DataValidator.validate_data(data)
+        if validation_errors:
+            raise HTTPException(
+                status_code=400,
+                detail={
+                    "error": "Data validation failed",
+                    "validation_errors": validation_errors,
+                    "message": "Please fix the data structure and try again"
+                }
+            )
+        
+        # Convert config
+        config = convert_config(request.config)
+        
+        # Run optimization
+        result = optimize_trainset_schedule(data, request.method, config)
+        
+        execution_time = time.time() - start_time
+        runtime_ms = int(execution_time * 1000)
+        
+        logger.info(f"Optimization completed in {execution_time:.3f}s, fitness: {result.fitness_score:.4f}")
+        
+        # Generate full schedule with service blocks
+        schedule_result = generate_schedule_from_result(
+            data=data,
+            optimization_result=result,
+            method=request.method,
+            runtime_ms=runtime_ms,
+            config=config,
+            date=request.date,
+            depot="Muttom_Depot"
+        )
+        
+        # Convert to response
+        response = convert_schedule_result_to_response(schedule_result)
+        
+        logger.info(f"Full schedule generated: {schedule_result.schedule_id}")
+        
+        return response
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Schedule generation error: {str(e)}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "error": "Schedule generation failed",
+                "message": str(e),
+                "type": type(e).__name__
+            }
+        )
+
+
 @app.post("/compare")
 async def compare_methods(request: CompareMethodsRequest):
     """
@@ -547,7 +767,7 @@ async def validate_data(request: ScheduleOptimizationRequest):
                 "message": "Data structure is valid",
                 "num_trainsets": len(request.trainset_status),
                 "num_certificates": len(request.fitness_certificates),
-                "num_job_cards": len(request.job_cards),
+                "num_job_cards": len(request.job_cards) if request.job_cards else 0,
                 "num_component_health": len(request.component_health)
             }
         

greedyOptim/__init__.py

@@ -16,7 +16,11 @@ Usage:
     result = optimize_trainset_schedule(data, method='ga', config=config)
 """
 
-from .models import OptimizationResult, OptimizationConfig, TrainsetConstraints
+from .models import (
+    OptimizationResult, OptimizationConfig, TrainsetConstraints,
+    ScheduleResult, ScheduleTrainset, ServiceBlock, FleetSummary,
+    OptimizationMetrics, ScheduleAlert, TrainStatus, MaintenanceType, AlertSeverity
+)
 from .evaluator import TrainsetSchedulingEvaluator
 from .genetic_algorithm import GeneticAlgorithmOptimizer
 from .advanced_optimizers import CMAESOptimizer, ParticleSwarmOptimizer, SimulatedAnnealingOptimizer
@@ -33,6 +37,7 @@ from .error_handling import (
     safe_optimize, DataValidator, OptimizationError,
     DataValidationError, ConstraintViolationError, ConfigurationError
 )
+from .schedule_generator import ScheduleGenerator, generate_schedule_from_result
 
 # Optional OR-Tools integration
 try:
@@ -55,6 +60,15 @@ __all__ = [
     'OptimizationResult',
     'OptimizationConfig', 
     'TrainsetConstraints',
+    'ScheduleResult',
+    'ScheduleTrainset',
+    'ServiceBlock',
+    'FleetSummary',
+    'OptimizationMetrics',
+    'ScheduleAlert',
+    'TrainStatus',
+    'MaintenanceType',
+    'AlertSeverity',
     'TrainsetSchedulingEvaluator',
     'GeneticAlgorithmOptimizer',
     'CMAESOptimizer',
@@ -73,7 +87,9 @@ __all__ = [
     'OptimizationError',
     'DataValidationError',
     'ConstraintViolationError',
-    'ConfigurationError'
+    'ConfigurationError',
+    'ScheduleGenerator',
+    'generate_schedule_from_result'
 ]
 
 # Add OR-Tools to exports if available

greedyOptim/error_handling.py

@@ -232,8 +232,10 @@ class DataValidator:
             if len(trainset_ids) < 10:
                 errors.append("Insufficient trainsets for optimization (minimum 10 required)")
             
+            # Count available trainsets (both legacy and new formats)
+            available_statuses = {'Available', 'In-Service', 'Standby', 'IN_SERVICE', 'STANDBY'}
             available_trainsets = sum(1 for record in data['trainset_status'] 
-                                    if record.get('operational_status') == 'Available')
+                                    if record.get('operational_status') in available_statuses)
             if available_trainsets < 15:
                 errors.append(f"Insufficient available trainsets for optimization ({available_trainsets} available, need at least 15)")
         

greedyOptim/models.py

@@ -1,8 +1,191 @@
 """
 Data models and dataclasses for the optimization system.
 """
-from dataclasses import dataclass
-from typing import Dict, List
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+from enum import Enum
+
+
+class TrainStatus(str, Enum):
+    """Train operational status for schedule output."""
+    REVENUE_SERVICE = "REVENUE_SERVICE"
+    STANDBY = "STANDBY"
+    MAINTENANCE = "MAINTENANCE"
+    OUT_OF_SERVICE = "OUT_OF_SERVICE"
+
+
+class MaintenanceType(str, Enum):
+    """Types of maintenance."""
+    SCHEDULED_INSPECTION = "SCHEDULED_INSPECTION"
+    PREVENTIVE = "PREVENTIVE"
+    CORRECTIVE = "CORRECTIVE"
+
+
+class AlertSeverity(str, Enum):
+    """Alert severity levels."""
+    LOW = "LOW"
+    MEDIUM = "MEDIUM"
+    HIGH = "HIGH"
+    CRITICAL = "CRITICAL"
+
+
+@dataclass
+class ServiceBlock:
+    """A service block represents a continuous operating period for a train."""
+    block_id: str
+    departure_time: str  # HH:MM format
+    origin: str
+    destination: str
+    trip_count: int
+    estimated_km: int
+    
+    def to_dict(self) -> Dict:
+        return {
+            'block_id': self.block_id,
+            'departure_time': self.departure_time,
+            'origin': self.origin,
+            'destination': self.destination,
+            'trip_count': self.trip_count,
+            'estimated_km': self.estimated_km
+        }
+
+
+@dataclass
+class ScheduleTrainset:
+    """Complete trainset information in the schedule."""
+    trainset_id: str
+    status: TrainStatus
+    readiness_score: float
+    daily_km_allocation: int
+    cumulative_km: int
+    
+    # For REVENUE_SERVICE
+    assigned_duty: Optional[str] = None
+    priority_rank: Optional[int] = None
+    service_blocks: List[ServiceBlock] = field(default_factory=list)
+    stabling_bay: Optional[str] = None
+    
+    # For STANDBY
+    standby_reason: Optional[str] = None
+    
+    # For MAINTENANCE
+    maintenance_type: Optional[MaintenanceType] = None
+    ibl_bay: Optional[str] = None
+    estimated_completion: Optional[str] = None
+    
+    # Alerts
+    alerts: List[str] = field(default_factory=list)
+    
+    def to_dict(self) -> Dict:
+        result = {
+            'trainset_id': self.trainset_id,
+            'status': self.status.value,
+            'readiness_score': self.readiness_score,
+            'daily_km_allocation': self.daily_km_allocation,
+            'cumulative_km': self.cumulative_km,
+            'alerts': self.alerts
+        }
+        if self.assigned_duty:
+            result['assigned_duty'] = self.assigned_duty
+        if self.priority_rank is not None:
+            result['priority_rank'] = self.priority_rank
+        if self.service_blocks:
+            result['service_blocks'] = [b.to_dict() for b in self.service_blocks]
+        if self.stabling_bay:
+            result['stabling_bay'] = self.stabling_bay
+        if self.standby_reason:
+            result['standby_reason'] = self.standby_reason
+        if self.maintenance_type:
+            result['maintenance_type'] = self.maintenance_type.value
+        if self.ibl_bay:
+            result['ibl_bay'] = self.ibl_bay
+        if self.estimated_completion:
+            result['estimated_completion'] = self.estimated_completion
+        return result
+
+
+@dataclass
+class FleetSummary:
+    """Summary statistics for the fleet."""
+    total_trainsets: int
+    revenue_service: int
+    standby: int
+    maintenance: int
+    availability_percent: float
+    
+    def to_dict(self) -> Dict:
+        return {
+            'total_trainsets': self.total_trainsets,
+            'revenue_service': self.revenue_service,
+            'standby': self.standby,
+            'maintenance': self.maintenance,
+            'availability_percent': self.availability_percent
+        }
+
+
+@dataclass
+class ScheduleAlert:
+    """Alert or warning in the schedule."""
+    trainset_id: str
+    severity: AlertSeverity
+    alert_type: str
+    message: str
+    
+    def to_dict(self) -> Dict:
+        return {
+            'trainset_id': self.trainset_id,
+            'severity': self.severity.value,
+            'alert_type': self.alert_type,
+            'message': self.message
+        }
+
+
+@dataclass
+class OptimizationMetrics:
+    """Metrics about the optimization."""
+    fitness_score: float
+    method: str
+    mileage_variance_coefficient: float
+    total_planned_km: int
+    optimization_runtime_ms: int
+    
+    def to_dict(self) -> Dict:
+        return {
+            'fitness_score': self.fitness_score,
+            'method': self.method,
+            'mileage_variance_coefficient': self.mileage_variance_coefficient,
+            'total_planned_km': self.total_planned_km,
+            'optimization_runtime_ms': self.optimization_runtime_ms
+        }
+
+
+@dataclass
+class ScheduleResult:
+    """Complete schedule result with all trainsets and service blocks."""
+    schedule_id: str
+    generated_at: str
+    valid_from: str
+    valid_until: str
+    depot: str
+    
+    trainsets: List[ScheduleTrainset]
+    fleet_summary: FleetSummary
+    optimization_metrics: OptimizationMetrics
+    alerts: List[ScheduleAlert] = field(default_factory=list)
+    
+    def to_dict(self) -> Dict:
+        """Convert to dictionary for JSON serialization and benchmarks."""
+        return {
+            'schedule_id': self.schedule_id,
+            'generated_at': self.generated_at,
+            'valid_from': self.valid_from,
+            'valid_until': self.valid_until,
+            'depot': self.depot,
+            'trainsets': [ts.to_dict() for ts in self.trainsets],
+            'fleet_summary': self.fleet_summary.to_dict(),
+            'optimization_metrics': self.optimization_metrics.to_dict(),
+            'alerts': [a.to_dict() for a in self.alerts]
+        }
 
 
 @dataclass

greedyOptim/schedule_generator.py

@@ -0,0 +1,376 @@
+"""
+Schedule Generator Module
+Converts optimization results into complete schedules with service blocks.
+"""
+import random
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional
+
+from .models import (
+    OptimizationResult, OptimizationConfig,
+    ScheduleResult, ScheduleTrainset, ServiceBlock, FleetSummary,
+    OptimizationMetrics, ScheduleAlert, TrainStatus, MaintenanceType, AlertSeverity
+)
+from .service_blocks import ServiceBlockGenerator
+from .evaluator import normalize_certificate_status, normalize_component_status
+
+
+# Depot configuration
+DEPOT_BAYS = [f"BAY-{str(i).zfill(2)}" for i in range(1, 16)]
+IBL_BAYS = [f"IBL-{str(i).zfill(2)}" for i in range(1, 6)]
+
+# Standby reasons
+STANDBY_REASONS = ["MILEAGE_BALANCING", "EMERGENCY_BACKUP", "PEAK_HOUR_RESERVE", "CREW_UNAVAILABLE"]
+
+
+class ScheduleGenerator:
+    """Generates complete schedules from optimization results."""
+    
+    def __init__(self, data: Dict, config: Optional[OptimizationConfig] = None):
+        """Initialize schedule generator.
+        
+        Args:
+            data: Input data with trainset_status, fitness_certificates, component_health
+            config: Optimization configuration
+        """
+        self.data = data
+        self.config = config or OptimizationConfig()
+        self.service_block_generator = ServiceBlockGenerator()
+        
+        # Build lookups
+        self._build_lookups()
+    
+    def _build_lookups(self):
+        """Build lookup dictionaries for quick access."""
+        self.status_map = {ts['trainset_id']: ts for ts in self.data['trainset_status']}
+        
+        # Fitness certificates
+        self.cert_map = {}
+        for cert in self.data.get('fitness_certificates', []):
+            ts_id = cert['trainset_id']
+            if ts_id not in self.cert_map:
+                self.cert_map[ts_id] = []
+            self.cert_map[ts_id].append(cert)
+        
+        # Component health
+        self.health_map = {}
+        for health in self.data.get('component_health', []):
+            ts_id = health['trainset_id']
+            if ts_id not in self.health_map:
+                self.health_map[ts_id] = []
+            self.health_map[ts_id].append(health)
+    
+    def generate_schedule(
+        self,
+        optimization_result: OptimizationResult,
+        method: str = "ga",
+        runtime_ms: int = 0,
+        date: Optional[str] = None,
+        depot: str = "Muttom_Depot"
+    ) -> ScheduleResult:
+        """Generate complete schedule from optimization result.
+        
+        Args:
+            optimization_result: Result from optimizer with trainset allocations
+            method: Optimization method used
+            runtime_ms: Optimization runtime in milliseconds
+            date: Schedule date (default: today)
+            depot: Depot name
+            
+        Returns:
+            Complete ScheduleResult with service blocks
+        """
+        if date is None:
+            date = datetime.now().strftime("%Y-%m-%d")
+        
+        now = datetime.now()
+        
+        # Generate schedule ID
+        schedule_id = f"SCH-{date.replace('-', '')}-{random.randint(100, 999)}"
+        
+        # Generate trainset schedules
+        trainsets = []
+        alerts = []
+        total_km = 0
+        mileages = []
+        
+        # Service trains
+        num_service = len(optimization_result.selected_trainsets)
+        for idx, ts_id in enumerate(optimization_result.selected_trainsets):
+            trainset, ts_alerts, km = self._generate_service_trainset(
+                ts_id, idx, num_service
+            )
+            trainsets.append(trainset)
+            alerts.extend(ts_alerts)
+            total_km += km
+            mileages.append(km)
+        
+        # Standby trains
+        for ts_id in optimization_result.standby_trainsets:
+            trainset, ts_alerts = self._generate_standby_trainset(ts_id)
+            trainsets.append(trainset)
+            alerts.extend(ts_alerts)
+        
+        # Maintenance trains
+        for ts_id in optimization_result.maintenance_trainsets:
+            trainset, ts_alerts = self._generate_maintenance_trainset(ts_id)
+            trainsets.append(trainset)
+            alerts.extend(ts_alerts)
+        
+        # Calculate fleet summary
+        fleet_summary = FleetSummary(
+            total_trainsets=len(trainsets),
+            revenue_service=len(optimization_result.selected_trainsets),
+            standby=len(optimization_result.standby_trainsets),
+            maintenance=len(optimization_result.maintenance_trainsets),
+            availability_percent=round(
+                (len(optimization_result.selected_trainsets) + len(optimization_result.standby_trainsets))
+                / max(1, len(trainsets)) * 100, 1
+            )
+        )
+        
+        # Calculate mileage variance
+        if len(mileages) > 1:
+            import statistics
+            mean_km = statistics.mean(mileages)
+            std_km = statistics.stdev(mileages)
+            variance_coeff = std_km / mean_km if mean_km > 0 else 0
+        else:
+            variance_coeff = 0
+        
+        # Optimization metrics
+        opt_metrics = OptimizationMetrics(
+            fitness_score=optimization_result.fitness_score,
+            method=method,
+            mileage_variance_coefficient=round(variance_coeff, 3),
+            total_planned_km=total_km,
+            optimization_runtime_ms=runtime_ms
+        )
+        
+        return ScheduleResult(
+            schedule_id=schedule_id,
+            generated_at=now.isoformat(),
+            valid_from=f"{date}T05:00:00+05:30",
+            valid_until=f"{date}T23:00:00+05:30",
+            depot=depot,
+            trainsets=trainsets,
+            fleet_summary=fleet_summary,
+            optimization_metrics=opt_metrics,
+            alerts=alerts
+        )
+    
+    def _generate_service_trainset(
+        self,
+        trainset_id: str,
+        index: int,
+        num_service: int
+    ) -> tuple:
+        """Generate schedule for a service trainset.
+        
+        Returns:
+            Tuple of (ScheduleTrainset, alerts, daily_km)
+        """
+        ts_data = self.status_map.get(trainset_id, {})
+        cumulative_km = ts_data.get('total_mileage_km', 0)
+        
+        # Generate service blocks
+        blocks_data = self.service_block_generator.generate_service_blocks(index, num_service)
+        service_blocks = [
+            ServiceBlock(
+                block_id=b['block_id'],
+                departure_time=b['departure_time'],
+                origin=b['origin'],
+                destination=b['destination'],
+                trip_count=b['trip_count'],
+                estimated_km=b['estimated_km']
+            )
+            for b in blocks_data
+        ]
+        
+        daily_km = sum(b.estimated_km for b in service_blocks)
+        
+        # Calculate readiness score
+        readiness = self._calculate_readiness(trainset_id)
+        
+        # Generate alerts
+        alerts = self._check_alerts(trainset_id)
+        alert_messages = [a.message for a in alerts]
+        
+        trainset = ScheduleTrainset(
+            trainset_id=trainset_id,
+            status=TrainStatus.REVENUE_SERVICE,
+            readiness_score=readiness,
+            daily_km_allocation=daily_km,
+            cumulative_km=cumulative_km,
+            assigned_duty=f"DUTY-{chr(65 + index // 10)}{(index % 10) + 1}",
+            priority_rank=index + 1,
+            service_blocks=service_blocks,
+            stabling_bay=random.choice(DEPOT_BAYS),
+            alerts=alert_messages
+        )
+        
+        return trainset, alerts, daily_km
+    
+    def _generate_standby_trainset(self, trainset_id: str) -> tuple:
+        """Generate schedule for a standby trainset.
+        
+        Returns:
+            Tuple of (ScheduleTrainset, alerts)
+        """
+        ts_data = self.status_map.get(trainset_id, {})
+        cumulative_km = ts_data.get('total_mileage_km', 0)
+        readiness = self._calculate_readiness(trainset_id)
+        
+        alerts = self._check_alerts(trainset_id)
+        alert_messages = [a.message for a in alerts]
+        
+        trainset = ScheduleTrainset(
+            trainset_id=trainset_id,
+            status=TrainStatus.STANDBY,
+            readiness_score=readiness,
+            daily_km_allocation=0,
+            cumulative_km=cumulative_km,
+            stabling_bay=random.choice(DEPOT_BAYS),
+            standby_reason=random.choice(STANDBY_REASONS),
+            alerts=alert_messages
+        )
+        
+        return trainset, alerts
+    
+    def _generate_maintenance_trainset(self, trainset_id: str) -> tuple:
+        """Generate schedule for a maintenance trainset.
+        
+        Returns:
+            Tuple of (ScheduleTrainset, alerts)
+        """
+        ts_data = self.status_map.get(trainset_id, {})
+        cumulative_km = ts_data.get('total_mileage_km', 0)
+        readiness = self._calculate_readiness(trainset_id)
+        
+        # Estimate completion time (4-12 hours from now)
+        completion = datetime.now() + timedelta(hours=random.randint(4, 12))
+        
+        alerts = self._check_alerts(trainset_id)
+        alert_messages = [a.message for a in alerts]
+        
+        trainset = ScheduleTrainset(
+            trainset_id=trainset_id,
+            status=TrainStatus.MAINTENANCE,
+            readiness_score=readiness,
+            daily_km_allocation=0,
+            cumulative_km=cumulative_km,
+            maintenance_type=MaintenanceType.SCHEDULED_INSPECTION,
+            ibl_bay=random.choice(IBL_BAYS),
+            estimated_completion=completion.isoformat(),
+            alerts=alert_messages
+        )
+        
+        return trainset, alerts
+    
+    def _calculate_readiness(self, trainset_id: str) -> float:
+        """Calculate readiness score for a trainset."""
+        score = 1.0
+        
+        # Check certificates
+        certs = self.cert_map.get(trainset_id, [])
+        for cert in certs:
+            status = normalize_certificate_status(cert.get('status', 'Valid'))
+            if status == 'Expired':
+                score -= 0.3
+            elif status == 'Expiring-Soon':
+                score -= 0.1
+            elif status == 'Suspended':
+                score -= 0.2
+        
+        # Check component health
+        components = self.health_map.get(trainset_id, [])
+        for comp in components:
+            status = normalize_component_status(comp.get('status', 'Good'))
+            if status == 'Critical':
+                score -= 0.15
+            elif status == 'Warning':
+                score -= 0.05
+        
+        return max(0.0, min(1.0, round(score, 2)))
+    
+    def _check_alerts(self, trainset_id: str) -> List[ScheduleAlert]:
+        """Check for alerts on a trainset."""
+        alerts = []
+        
+        # Check certificates
+        certs = self.cert_map.get(trainset_id, [])
+        for cert in certs:
+            status = normalize_certificate_status(cert.get('status', 'Valid'))
+            dept = cert.get('department', 'Unknown')
+            
+            if status == 'Expired':
+                alerts.append(ScheduleAlert(
+                    trainset_id=trainset_id,
+                    severity=AlertSeverity.HIGH,
+                    alert_type="CERTIFICATE_EXPIRED",
+                    message=f"{dept} certificate expired"
+                ))
+            elif status == 'Expiring-Soon':
+                alerts.append(ScheduleAlert(
+                    trainset_id=trainset_id,
+                    severity=AlertSeverity.MEDIUM,
+                    alert_type="CERTIFICATE_EXPIRING",
+                    message=f"{dept} certificate expiring soon"
+                ))
+        
+        # Check component health
+        components = self.health_map.get(trainset_id, [])
+        for comp in components:
+            status = normalize_component_status(comp.get('status', 'Good'))
+            comp_name = comp.get('component', 'Unknown')
+            wear = comp.get('wear_level', 0)
+            
+            if status == 'Critical':
+                alerts.append(ScheduleAlert(
+                    trainset_id=trainset_id,
+                    severity=AlertSeverity.HIGH,
+                    alert_type="COMPONENT_CRITICAL",
+                    message=f"{comp_name} in critical condition (wear: {wear}%)"
+                ))
+            elif status == 'Warning' and wear > 80:
+                alerts.append(ScheduleAlert(
+                    trainset_id=trainset_id,
+                    severity=AlertSeverity.MEDIUM,
+                    alert_type="COMPONENT_WARNING",
+                    message=f"{comp_name} requires attention (wear: {wear}%)"
+                ))
+        
+        return alerts
+
+
+def generate_schedule_from_result(
+    data: Dict,
+    optimization_result: OptimizationResult,
+    method: str = "ga",
+    runtime_ms: int = 0,
+    config: Optional[OptimizationConfig] = None,
+    date: Optional[str] = None,
+    depot: str = "Muttom_Depot"
+) -> ScheduleResult:
+    """Convenience function to generate schedule from optimization result.
+    
+    Args:
+        data: Input data dictionary
+        optimization_result: Result from optimizer
+        method: Optimization method used
+        runtime_ms: Runtime in milliseconds
+        config: Optimization configuration
+        date: Schedule date
+        depot: Depot name
+        
+    Returns:
+        Complete ScheduleResult
+    """
+    generator = ScheduleGenerator(data, config)
+    return generator.generate_schedule(
+        optimization_result,
+        method=method,
+        runtime_ms=runtime_ms,
+        date=date,
+        depot=depot
+    )