structrue change for schedule

api/greedyoptim_api.py

@@ -174,14 +174,40 @@ class ScheduleOptimizationResponse(BaseModel):
 
 
 # New models for full schedule response
+class StationStopResponse(BaseModel):
+    """A single station stop within a trip"""
+    station_code: str
+    station_name: str
+    arrival_time: Optional[str] = None
+    departure_time: Optional[str] = None
+    distance_from_origin_km: float
+    platform: Optional[int] = None
+
+
+class TripResponse(BaseModel):
+    """A single trip from origin to destination with all stops"""
+    trip_id: str
+    trip_number: int
+    direction: str  # "UP" or "DOWN"
+    origin: str
+    destination: str
+    departure_time: str
+    arrival_time: str
+    stops: List[StationStopResponse] = []
+
+
 class ServiceBlockResponse(BaseModel):
-    """Service block with timing details"""
+    """Service block with timing details and trips"""
     block_id: str
     departure_time: str
     origin: str
     destination: str
     trip_count: int
     estimated_km: float
+    journey_time_minutes: Optional[float] = None
+    period: Optional[str] = None
+    is_peak: bool = False
+    trips: Optional[List[TripResponse]] = None
 
 
 class TrainsetScheduleResponse(BaseModel):
@@ -330,17 +356,47 @@ def convert_schedule_result_to_response(schedule_result) -> FullScheduleResponse
     for ts in schedule_result.trainsets:
         service_blocks_resp = None
         if ts.service_blocks:
-            service_blocks_resp = [
-                ServiceBlockResponse(
+            service_blocks_resp = []
+            for sb in ts.service_blocks:
+                # Convert trips with station stops
+                trips_resp = None
+                if sb.trips:
+                    trips_resp = []
+                    for trip in sb.trips:
+                        stops_resp = [
+                            StationStopResponse(
+                                station_code=stop.station_code,
+                                station_name=stop.station_name,
+                                arrival_time=stop.arrival_time,
+                                departure_time=stop.departure_time,
+                                distance_from_origin_km=stop.distance_from_origin_km,
+                                platform=stop.platform
+                            )
+                            for stop in trip.stops
+                        ]
+                        trips_resp.append(TripResponse(
+                            trip_id=trip.trip_id,
+                            trip_number=trip.trip_number,
+                            direction=trip.direction,
+                            origin=trip.origin,
+                            destination=trip.destination,
+                            departure_time=trip.departure_time,
+                            arrival_time=trip.arrival_time,
+                            stops=stops_resp
+                        ))
+                
+                service_blocks_resp.append(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
-            ]
+                    estimated_km=sb.estimated_km,
+                    journey_time_minutes=sb.journey_time_minutes,
+                    period=sb.period,
+                    is_peak=sb.is_peak,
+                    trips=trips_resp
+                ))
         
         trainsets.append(TrainsetScheduleResponse(
             trainset_id=ts.trainset_id,

greedyOptim/__init__.py

@@ -19,7 +19,8 @@ Usage:
 from .models import (
     OptimizationResult, OptimizationConfig, TrainsetConstraints,
     ScheduleResult, ScheduleTrainset, ServiceBlock, FleetSummary,
-    OptimizationMetrics, ScheduleAlert, TrainStatus, MaintenanceType, AlertSeverity
+    OptimizationMetrics, ScheduleAlert, TrainStatus, MaintenanceType, AlertSeverity,
+    StationStop, Trip
 )
 from .evaluator import TrainsetSchedulingEvaluator
 from .genetic_algorithm import GeneticAlgorithmOptimizer

greedyOptim/data/kochi_metro_stations.json

@@ -264,4 +264,4 @@
       {"start": "17:00", "end": "21:00", "type": "evening"}
     ]
   }
-}
+}

greedyOptim/models.py

@@ -29,6 +29,56 @@ class AlertSeverity(str, Enum):
     CRITICAL = "CRITICAL"
 
 
+@dataclass
+class StationStop:
+    """A single station stop within a trip."""
+    station_code: str
+    station_name: str
+    arrival_time: Optional[str]  # HH:MM format, None for origin
+    departure_time: Optional[str]  # HH:MM format, None for destination
+    distance_from_origin_km: float
+    platform: Optional[int] = None
+    
+    def to_dict(self) -> Dict:
+        result = {
+            'station_code': self.station_code,
+            'station_name': self.station_name,
+            'distance_from_origin_km': self.distance_from_origin_km
+        }
+        if self.arrival_time:
+            result['arrival_time'] = self.arrival_time
+        if self.departure_time:
+            result['departure_time'] = self.departure_time
+        if self.platform:
+            result['platform'] = self.platform
+        return result
+
+
+@dataclass
+class Trip:
+    """A single trip from origin to destination with all stops."""
+    trip_id: str
+    trip_number: int  # 1, 2, 3... within the block
+    direction: str  # "UP" (towards Pettah) or "DOWN" (towards Aluva)
+    origin: str
+    destination: str
+    departure_time: str
+    arrival_time: str
+    stops: List[StationStop] = field(default_factory=list)
+    
+    def to_dict(self) -> Dict:
+        return {
+            'trip_id': self.trip_id,
+            'trip_number': self.trip_number,
+            'direction': self.direction,
+            'origin': self.origin,
+            'destination': self.destination,
+            'departure_time': self.departure_time,
+            'arrival_time': self.arrival_time,
+            'stops': [s.to_dict() for s in self.stops]
+        }
+
+
 @dataclass
 class ServiceBlock:
     """A service block represents a continuous operating period for a train."""
@@ -38,9 +88,14 @@ class ServiceBlock:
     destination: str
     trip_count: int
     estimated_km: int
+    # Enhanced fields
+    journey_time_minutes: Optional[float] = None
+    trips: List[Trip] = field(default_factory=list)  # Detailed trip breakdown
+    period: Optional[str] = None  # morning_peak, midday, evening_peak, late_evening
+    is_peak: bool = False
     
     def to_dict(self) -> Dict:
-        return {
+        result = {
             'block_id': self.block_id,
             'departure_time': self.departure_time,
             'origin': self.origin,
@@ -48,6 +103,14 @@ class ServiceBlock:
             'trip_count': self.trip_count,
             'estimated_km': self.estimated_km
         }
+        if self.journey_time_minutes:
+            result['journey_time_minutes'] = self.journey_time_minutes
+        if self.period:
+            result['period'] = self.period
+        result['is_peak'] = self.is_peak
+        if self.trips:
+            result['trips'] = [t.to_dict() for t in self.trips]
+        return result
 
 
 @dataclass

greedyOptim/schedule_generator.py

@@ -9,9 +9,11 @@ from typing import Dict, List, Optional
 from .models import (
     OptimizationResult, OptimizationConfig,
     ScheduleResult, ScheduleTrainset, ServiceBlock, FleetSummary,
-    OptimizationMetrics, ScheduleAlert, TrainStatus, MaintenanceType, AlertSeverity
+    OptimizationMetrics, ScheduleAlert, TrainStatus, MaintenanceType, AlertSeverity,
+    StationStop, Trip
 )
 from .service_blocks import ServiceBlockGenerator
+from .station_loader import get_station_loader, StationDataLoader
 from .evaluator import normalize_certificate_status, normalize_component_status
 
 
@@ -37,6 +39,12 @@ class ScheduleGenerator:
         self.config = config or OptimizationConfig()
         self.service_block_generator = ServiceBlockGenerator()
         
+        # Initialize station loader for detailed trip generation
+        try:
+            self.station_loader = get_station_loader()
+        except Exception:
+            self.station_loader = None
+        
         # Build lookups
         self._build_lookups()
     
@@ -178,6 +186,97 @@ class ScheduleGenerator:
             alerts=alerts
         )
     
+    def _generate_trips_for_block(
+        self,
+        block_data: Dict,
+        block_id: str
+    ) -> List[Trip]:
+        """Generate detailed trips with station stops for a service block.
+        
+        Args:
+            block_data: Block data dictionary
+            block_id: Block ID
+            
+        Returns:
+            List of Trip objects with station stops
+        """
+        if not self.station_loader:
+            return []
+        
+        trips = []
+        origin = block_data['origin']
+        destination = block_data['destination']
+        trip_count = block_data.get('trip_count', 1)
+        
+        # Parse initial departure time
+        dep_time_str = block_data['departure_time']
+        current_time = datetime.strptime(dep_time_str, '%H:%M')
+        
+        # Get terminals for direction determination
+        terminals = self.station_loader.terminals
+        
+        for trip_num in range(1, trip_count + 1):
+            # Determine direction
+            if origin == terminals[0]:  # Aluva
+                direction = "DOWN"  # Towards Pettah
+            else:
+                direction = "UP"  # Towards Aluva
+            
+            # Get station sequence with times
+            try:
+                station_sequence = self.station_loader.get_station_sequence_for_trip(
+                    origin, destination,
+                    include_times=True,
+                    departure_time=current_time.strftime('%H:%M')
+                )
+            except Exception:
+                station_sequence = []
+            
+            # Convert to StationStop objects
+            stops = []
+            for station in station_sequence:
+                stop = StationStop(
+                    station_code=station.get('code', ''),
+                    station_name=station['name'],
+                    arrival_time=station.get('arrival_time'),
+                    departure_time=station.get('departure_time'),
+                    distance_from_origin_km=station.get('distance_from_origin_km', 0),
+                    platform=random.choice([1, 2])  # Random platform assignment
+                )
+                stops.append(stop)
+            
+            # Calculate arrival time at destination
+            if stops:
+                arrival_time = stops[-1].arrival_time or current_time.strftime('%H:%M')
+            else:
+                # Fallback calculation
+                journey_minutes = block_data.get('journey_time_minutes', 53)
+                arrival = current_time + timedelta(minutes=journey_minutes)
+                arrival_time = arrival.strftime('%H:%M')
+            
+            trip = Trip(
+                trip_id=f"{block_id}-T{trip_num:02d}",
+                trip_number=trip_num,
+                direction=direction,
+                origin=origin,
+                destination=destination,
+                departure_time=current_time.strftime('%H:%M'),
+                arrival_time=arrival_time,
+                stops=stops
+            )
+            trips.append(trip)
+            
+            # Calculate next trip start time (arrival + turnaround)
+            journey_minutes = block_data.get('journey_time_minutes', 53)
+            turnaround_minutes = 3  # Turnaround at terminal
+            total_minutes = journey_minutes + turnaround_minutes
+            current_time = current_time + timedelta(minutes=total_minutes)
+            
+            # Swap origin and destination for return trip
+            origin, destination = destination, origin
+        
+        return trips
+    
     def _generate_service_trainset(
         self,
         trainset_id: str,
@@ -214,17 +313,26 @@ class ScheduleGenerator:
             # Fall back to legacy index-based block generation
             blocks_data = self.service_block_generator.generate_service_blocks(index, num_service)
         
-        service_blocks = [
-            ServiceBlock(
-                block_id=b['block_id'],
+        service_blocks = []
+        for b in blocks_data:
+            block_id = b['block_id']
+            
+            # Generate detailed trips with station stops
+            trips = self._generate_trips_for_block(b, block_id)
+            
+            service_block = ServiceBlock(
+                block_id=block_id,
                 departure_time=b['departure_time'],
                 origin=b['origin'],
                 destination=b['destination'],
                 trip_count=b['trip_count'],
-                estimated_km=b['estimated_km']
+                estimated_km=b['estimated_km'],
+                journey_time_minutes=b.get('journey_time_minutes'),
+                period=b.get('period'),
+                is_peak=b.get('is_peak', False),
+                trips=trips
             )
-            for b in blocks_data
-        ]
+            service_blocks.append(service_block)
         
         daily_km = sum(b.estimated_km for b in service_blocks)