moved to more generalized station input

api/greedyoptim_api.py

@@ -482,6 +482,203 @@ async def list_methods():
     }
 
 
+# ============================================================================
+# Station & Route Information Endpoints
+# ============================================================================
+
+@app.get("/stations")
+async def get_stations():
+    """Get all metro stations with their details.
+    
+    Returns the complete list of stations from the configured route,
+    including distance information, terminal status, and depot locations.
+    """
+    try:
+        from greedyOptim.station_loader import get_station_loader
+        
+        loader = get_station_loader()
+        return {
+            "success": True,
+            "route": loader.to_dict(),
+            "summary": {
+                "total_stations": loader.station_count,
+                "total_distance_km": loader.total_distance_km,
+                "terminals": loader.terminals
+            }
+        }
+    except Exception as e:
+        logger.error(f"Failed to get station data: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to load station data: {str(e)}")
+
+
+@app.get("/stations/{station_identifier}")
+async def get_station_details(station_identifier: str):
+    """Get details for a specific station by name or code.
+    
+    Args:
+        station_identifier: Station name (e.g., 'Aluva') or code (e.g., 'ALV')
+    """
+    try:
+        from greedyOptim.station_loader import get_station_loader
+        
+        loader = get_station_loader()
+        
+        # Try by name first, then by code
+        station = loader.get_station_by_name(station_identifier)
+        if not station:
+            station = loader.get_station_by_code(station_identifier)
+        
+        if not station:
+            raise HTTPException(
+                status_code=404, 
+                detail=f"Station not found: {station_identifier}"
+            )
+        
+        return {
+            "success": True,
+            "station": {
+                "sr_no": station.sr_no,
+                "code": station.code,
+                "name": station.name,
+                "distance_from_prev_km": station.distance_from_prev_km,
+                "cumulative_distance_km": station.cumulative_distance_km,
+                "is_terminal": station.is_terminal,
+                "has_depot": station.has_depot,
+                "platform_count": station.platform_count,
+                "depot_name": station.depot_name
+            }
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get station details: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/route/journey")
+async def calculate_journey(
+    origin: str, 
+    destination: str, 
+    departure_time: str = "07:00"
+):
+    """Calculate journey details between two stations.
+    
+    Args:
+        origin: Origin station name or code
+        destination: Destination station name or code  
+        departure_time: Departure time in HH:MM format (default: 07:00)
+    
+    Returns:
+        Journey details including intermediate stations with arrival times
+    """
+    try:
+        from greedyOptim.station_loader import get_station_loader
+        
+        loader = get_station_loader()
+        
+        # Validate stations exist
+        origin_station = loader.get_station_by_name(origin) or loader.get_station_by_code(origin)
+        dest_station = loader.get_station_by_name(destination) or loader.get_station_by_code(destination)
+        
+        if not origin_station:
+            raise HTTPException(status_code=404, detail=f"Origin station not found: {origin}")
+        if not dest_station:
+            raise HTTPException(status_code=404, detail=f"Destination station not found: {destination}")
+        
+        # Get journey details
+        station_sequence = loader.get_station_sequence_for_trip(
+            origin_station.name, 
+            dest_station.name,
+            include_times=True,
+            departure_time=departure_time
+        )
+        
+        distance = loader.get_distance_between(origin_station.name, dest_station.name)
+        journey_time = loader.calculate_journey_time(origin_station.name, dest_station.name)
+        
+        return {
+            "success": True,
+            "journey": {
+                "origin": origin_station.name,
+                "destination": dest_station.name,
+                "distance_km": round(distance, 3),
+                "journey_time_minutes": round(journey_time, 1),
+                "departure_time": departure_time,
+                "num_stops": len(station_sequence) - 1,
+                "stations": station_sequence
+            }
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to calculate journey: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/route/round-trip")
+async def get_round_trip_info():
+    """Get round trip information for the full route.
+    
+    Returns round trip time and distance between terminals.
+    """
+    try:
+        from greedyOptim.station_loader import get_station_loader
+        
+        loader = get_station_loader()
+        
+        round_trip_time = loader.calculate_round_trip_time()
+        terminals = loader.terminals
+        one_way_distance = loader.total_distance_km
+        
+        return {
+            "success": True,
+            "round_trip": {
+                "terminals": terminals,
+                "one_way_distance_km": round(one_way_distance, 3),
+                "round_trip_distance_km": round(one_way_distance * 2, 3),
+                "round_trip_time_minutes": round(round_trip_time, 1),
+                "round_trip_time_hours": round(round_trip_time / 60, 2)
+            },
+            "operational_params": loader.route_info.operational_params
+        }
+    except Exception as e:
+        logger.error(f"Failed to get round trip info: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/service-blocks")
+async def get_service_blocks():
+    """Get all available service blocks for the day.
+    
+    Returns pre-defined service blocks that can be assigned to trainsets.
+    """
+    try:
+        from greedyOptim.service_blocks import ServiceBlockGenerator
+        
+        generator = ServiceBlockGenerator()
+        blocks = generator.get_all_service_blocks()
+        
+        # Group by period
+        by_period = {}
+        for block in blocks:
+            period = block['period']
+            if period not in by_period:
+                by_period[period] = []
+            by_period[period].append(block)
+        
+        return {
+            "success": True,
+            "total_blocks": len(blocks),
+            "route_length_km": generator.route_length_km,
+            "terminals": generator.terminals,
+            "blocks_by_period": by_period,
+            "all_blocks": blocks
+        }
+    except Exception as e:
+        logger.error(f"Failed to get service blocks: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @app.post("/optimize", response_model=ScheduleOptimizationResponse)
 async def optimize_schedule(request: ScheduleOptimizationRequest):
     """

greedyOptim/__init__.py

@@ -38,6 +38,11 @@ from .error_handling import (
     DataValidationError, ConstraintViolationError, ConfigurationError
 )
 from .schedule_generator import ScheduleGenerator, generate_schedule_from_result
+from .station_loader import (
+    StationDataLoader, get_station_loader, get_route_distance, get_terminals,
+    Station, RouteInfo
+)
+from .service_blocks import ServiceBlockGenerator
 
 # Optional OR-Tools integration
 try:
@@ -89,7 +94,14 @@ __all__ = [
     'ConstraintViolationError',
     'ConfigurationError',
     'ScheduleGenerator',
-    'generate_schedule_from_result'
+    'generate_schedule_from_result',
+    'StationDataLoader',
+    'get_station_loader',
+    'get_route_distance',
+    'get_terminals',
+    'Station',
+    'RouteInfo',
+    'ServiceBlockGenerator'
 ]
 
 # Add OR-Tools to exports if available

greedyOptim/data/kochi_metro_stations.json

@@ -0,0 +1,267 @@
+{
+  "line_info": {
+    "name": "Kochi Metro Blue Line",
+    "operator": "Kochi Metro Rail Ltd (KMRL)",
+    "gauge": "Standard Gauge (1435 mm)",
+    "traction": "750 V DC Third Rail",
+    "max_speed_kmh": 80,
+    "average_speed_kmh": 35
+  },
+  "stations": [
+    {
+      "sr_no": 1,
+      "code": "ALV",
+      "name": "Aluva",
+      "distance_from_prev_km": 0.0,
+      "cumulative_distance_km": 0.0,
+      "is_terminal": true,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 2,
+      "code": "PUL",
+      "name": "Pulinchodu",
+      "distance_from_prev_km": 1.729,
+      "cumulative_distance_km": 1.729,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 3,
+      "code": "CMP",
+      "name": "Companypady",
+      "distance_from_prev_km": 0.969,
+      "cumulative_distance_km": 2.698,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 4,
+      "code": "AMB",
+      "name": "Ambattukavu",
+      "distance_from_prev_km": 0.984,
+      "cumulative_distance_km": 3.682,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 5,
+      "code": "MUT",
+      "name": "Muttom",
+      "distance_from_prev_km": 0.937,
+      "cumulative_distance_km": 4.619,
+      "is_terminal": false,
+      "has_depot": true,
+      "platform_count": 2,
+      "interchange": null,
+      "depot_name": "Muttom Depot"
+    },
+    {
+      "sr_no": 6,
+      "code": "KLM",
+      "name": "Kalamassery",
+      "distance_from_prev_km": 2.052,
+      "cumulative_distance_km": 6.671,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 7,
+      "code": "CUU",
+      "name": "Cochin University",
+      "distance_from_prev_km": 1.379,
+      "cumulative_distance_km": 8.050,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 8,
+      "code": "PAT",
+      "name": "Pathadipalam",
+      "distance_from_prev_km": 1.247,
+      "cumulative_distance_km": 9.297,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 9,
+      "code": "EDP",
+      "name": "Edapally",
+      "distance_from_prev_km": 1.393,
+      "cumulative_distance_km": 10.690,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 10,
+      "code": "CPK",
+      "name": "Changampuzha Park",
+      "distance_from_prev_km": 1.300,
+      "cumulative_distance_km": 11.990,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 11,
+      "code": "PLV",
+      "name": "Palarivattom",
+      "distance_from_prev_km": 1.008,
+      "cumulative_distance_km": 12.998,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 12,
+      "code": "JLN",
+      "name": "J.L.N. Stadium",
+      "distance_from_prev_km": 1.121,
+      "cumulative_distance_km": 14.119,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 13,
+      "code": "KLR",
+      "name": "Kaloor",
+      "distance_from_prev_km": 1.033,
+      "cumulative_distance_km": 15.152,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 14,
+      "code": "TWH",
+      "name": "Town Hall",
+      "distance_from_prev_km": 0.473,
+      "cumulative_distance_km": 15.625,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 15,
+      "code": "MGR",
+      "name": "M.G. Road",
+      "distance_from_prev_km": 1.203,
+      "cumulative_distance_km": 16.828,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 16,
+      "code": "MHC",
+      "name": "Maharaja's College",
+      "distance_from_prev_km": 1.173,
+      "cumulative_distance_km": 18.001,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 17,
+      "code": "EKS",
+      "name": "Ernakulam South",
+      "distance_from_prev_km": 0.856,
+      "cumulative_distance_km": 18.857,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 18,
+      "code": "KDV",
+      "name": "Kadavanthra",
+      "distance_from_prev_km": 1.185,
+      "cumulative_distance_km": 20.042,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 19,
+      "code": "ELM",
+      "name": "Elamkulam",
+      "distance_from_prev_km": 1.155,
+      "cumulative_distance_km": 21.197,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 20,
+      "code": "VYT",
+      "name": "Vyttila",
+      "distance_from_prev_km": 1.439,
+      "cumulative_distance_km": 22.636,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 21,
+      "code": "TKD",
+      "name": "Thaikoodam",
+      "distance_from_prev_km": 1.024,
+      "cumulative_distance_km": 23.660,
+      "is_terminal": false,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    },
+    {
+      "sr_no": 22,
+      "code": "PTH",
+      "name": "Pettah",
+      "distance_from_prev_km": 1.183,
+      "cumulative_distance_km": 24.843,
+      "is_terminal": true,
+      "has_depot": false,
+      "platform_count": 2,
+      "interchange": null
+    }
+  ],
+  "operational_params": {
+    "dwell_time_seconds": 30,
+    "terminal_turnaround_seconds": 180,
+    "min_headway_peak_minutes": 5,
+    "min_headway_offpeak_minutes": 10,
+    "operational_start": "05:00",
+    "operational_end": "23:00",
+    "peak_hours": [
+      {"start": "07:00", "end": "10:00", "type": "morning"},
+      {"start": "17:00", "end": "21:00", "type": "evening"}
+    ]
+  }
+}

greedyOptim/service_blocks.py

@@ -1,39 +1,191 @@
 """
 Service Block Generator
 Generates realistic service blocks with departure times for train schedules.
+Uses station data from JSON configuration for flexible route support.
 """
-from typing import List, Dict, Tuple
+from typing import List, Dict, Tuple, Optional
 from datetime import time, datetime, timedelta
+import logging
+
+# Import station loader for route configuration
+try:
+    from .station_loader import get_station_loader, StationDataLoader
+    STATION_LOADER_AVAILABLE = True
+except ImportError:
+    STATION_LOADER_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
 
 
 class ServiceBlockGenerator:
-    """Generates service blocks for trains based on operational requirements."""
+    """Generates service blocks for trains based on operational requirements.
     
-    # Kochi Metro operational parameters
-    OPERATIONAL_START = time(5, 0)  # 5:00 AM
-    OPERATIONAL_END = time(23, 0)  # 11:00 PM
-    
-    # Service patterns
-    PEAK_HOURS = [(7, 9), (18, 21)]  # Morning and evening peaks (7-9 AM, 6-9 PM)
-    PEAK_HEADWAY_MINUTES = 6.0  # 6 minutes between trains during peak (target 5-7)
-    OFFPEAK_HEADWAY_MINUTES = 15.0  # 15 minutes during off-peak
+    Loads route parameters from station configuration JSON, allowing
+    easy customization for different metro lines.
+    """
     
-    # Route parameters
-    ROUTE_LENGTH_KM = 25.612
-    AVG_SPEED_KMH = 35.0
-    TERMINALS = ['Aluva', 'Pettah']
+    # Fallback defaults (used if station config not available)
+    DEFAULT_ROUTE_LENGTH_KM = 24.843  # Aluva to Pettah
+    DEFAULT_AVG_SPEED_KMH = 35.0
+    DEFAULT_TERMINALS = ['Aluva', 'Pettah']
+    DEFAULT_OPERATIONAL_START = time(5, 0)
+    DEFAULT_OPERATIONAL_END = time(23, 0)
+    DEFAULT_PEAK_HEADWAY_MINUTES = 6.0
+    DEFAULT_OFFPEAK_HEADWAY_MINUTES = 15.0
+    DEFAULT_DWELL_TIME_SECONDS = 30
+    DEFAULT_TURNAROUND_SECONDS = 180
     
-    def __init__(self):
-        """Initialize service block generator."""
-        self.round_trip_time_hours = (self.ROUTE_LENGTH_KM * 2) / self.AVG_SPEED_KMH
-        self.round_trip_time_minutes = self.round_trip_time_hours * 60
+    def __init__(self, station_config_path: Optional[str] = None):
+        """Initialize service block generator.
+        
+        Args:
+            station_config_path: Optional path to station JSON config.
+                                If None, uses default configuration.
+        """
+        self._station_loader: Optional[StationDataLoader] = None
         self._all_blocks_cache = None
+        self._stations_cache = None
+        
+        # Load station configuration
+        self._load_station_config(station_config_path)
+        
+        # Calculate derived values
+        self.round_trip_time_hours = (self.route_length_km * 2) / self.avg_speed_kmh
+        self.round_trip_time_minutes = self.round_trip_time_hours * 60
+    
+    def _load_station_config(self, config_path: Optional[str] = None):
+        """Load station configuration from JSON."""
+        if STATION_LOADER_AVAILABLE:
+            try:
+                self._station_loader = get_station_loader(config_path)
+                route_info = self._station_loader.route_info
+                op_params = route_info.operational_params
+                
+                # Route parameters from config
+                self.route_length_km = self._station_loader.total_distance_km
+                self.terminals = self._station_loader.terminals
+                self.avg_speed_kmh = self._station_loader.load()['line_info'].get(
+                    'average_speed_kmh', self.DEFAULT_AVG_SPEED_KMH
+                )
+                
+                # Operational parameters
+                self.dwell_time_seconds = op_params.get(
+                    'dwell_time_seconds', self.DEFAULT_DWELL_TIME_SECONDS
+                )
+                self.turnaround_seconds = op_params.get(
+                    'terminal_turnaround_seconds', self.DEFAULT_TURNAROUND_SECONDS
+                )
+                self.peak_headway_minutes = op_params.get(
+                    'min_headway_peak_minutes', self.DEFAULT_PEAK_HEADWAY_MINUTES
+                )
+                self.offpeak_headway_minutes = op_params.get(
+                    'min_headway_offpeak_minutes', self.DEFAULT_OFFPEAK_HEADWAY_MINUTES
+                )
+                
+                # Parse operational hours
+                op_start = op_params.get('operational_start', '05:00')
+                op_end = op_params.get('operational_end', '23:00')
+                self.operational_start = datetime.strptime(op_start, '%H:%M').time()
+                self.operational_end = datetime.strptime(op_end, '%H:%M').time()
+                
+                # Peak hours configuration
+                self.peak_hours = []
+                for peak in op_params.get('peak_hours', []):
+                    start = int(peak['start'].split(':')[0])
+                    end = int(peak['end'].split(':')[0])
+                    self.peak_hours.append((start, end))
+                
+                if not self.peak_hours:
+                    self.peak_hours = [(7, 10), (17, 21)]  # Default peaks
+                
+                logger.info(f"Loaded station config: {len(self._station_loader.stations)} stations, "
+                           f"{self.route_length_km:.3f} km route")
+                return
+                
+            except Exception as e:
+                logger.warning(f"Failed to load station config: {e}. Using defaults.")
+        
+        # Use defaults if loading failed
+        self._use_defaults()
+    
+    def _use_defaults(self):
+        """Set default values when config loading fails."""
+        self.route_length_km = self.DEFAULT_ROUTE_LENGTH_KM
+        self.terminals = self.DEFAULT_TERMINALS
+        self.avg_speed_kmh = self.DEFAULT_AVG_SPEED_KMH
+        self.dwell_time_seconds = self.DEFAULT_DWELL_TIME_SECONDS
+        self.turnaround_seconds = self.DEFAULT_TURNAROUND_SECONDS
+        self.peak_headway_minutes = self.DEFAULT_PEAK_HEADWAY_MINUTES
+        self.offpeak_headway_minutes = self.DEFAULT_OFFPEAK_HEADWAY_MINUTES
+        self.operational_start = self.DEFAULT_OPERATIONAL_START
+        self.operational_end = self.DEFAULT_OPERATIONAL_END
+        self.peak_hours = [(7, 10), (17, 21)]
+    
+    @property
+    def stations(self) -> List[Dict]:
+        """Get list of all stations with their details."""
+        if self._stations_cache is not None:
+            return self._stations_cache
+        
+        if self._station_loader:
+            self._stations_cache = [
+                {
+                    'sr_no': s.sr_no,
+                    'code': s.code,
+                    'name': s.name,
+                    'distance_from_prev_km': s.distance_from_prev_km,
+                    'cumulative_distance_km': s.cumulative_distance_km,
+                    'is_terminal': s.is_terminal,
+                    'has_depot': s.has_depot
+                }
+                for s in self._station_loader.stations
+            ]
+        else:
+            # Minimal fallback
+            self._stations_cache = [
+                {'sr_no': 1, 'code': 'ALV', 'name': 'Aluva', 'cumulative_distance_km': 0, 'is_terminal': True},
+                {'sr_no': 22, 'code': 'PTH', 'name': 'Pettah', 'cumulative_distance_km': self.route_length_km, 'is_terminal': True}
+            ]
+        
+        return self._stations_cache
+    
+    def get_station_sequence(self, origin: str, destination: str, departure_time: str = "07:00") -> List[Dict]:
+        """Get detailed station sequence for a trip with arrival times.
+        
+        Args:
+            origin: Origin station name
+            destination: Destination station name  
+            departure_time: Departure time (HH:MM format)
+            
+        Returns:
+            List of dicts with station info and calculated times
+        """
+        if self._station_loader:
+            return self._station_loader.get_station_sequence_for_trip(
+                origin, destination, 
+                include_times=True, 
+                departure_time=departure_time
+            )
+        
+        # Fallback for no station loader
+        return [
+            {'name': origin, 'departure_time': departure_time, 'arrival_time': None},
+            {'name': destination, 'arrival_time': self._estimate_arrival(departure_time), 'departure_time': None}
+        ]
+    
+    def _estimate_arrival(self, departure_time: str) -> str:
+        """Estimate arrival time at destination (fallback)."""
+        dep = datetime.strptime(departure_time, '%H:%M')
+        travel_minutes = (self.route_length_km / self.avg_speed_kmh) * 60
+        arr = dep + timedelta(minutes=travel_minutes)
+        return arr.strftime('%H:%M')
     
     def get_all_service_blocks(self) -> List[Dict]:
         """Get all available service blocks for the day.
         
         Pre-generates all possible service blocks that need to be assigned to trainsets.
         These represent the "slots" that the optimizer will fill.
+        Includes intermediate station information for each block.
         
         Returns:
             List of all service block dictionaries with block_id, departure_time, etc.
@@ -44,77 +196,64 @@ class ServiceBlockGenerator:
         all_blocks = []
         block_counter = 0
         
-        # Morning peak blocks (7:00 - 10:00)
-        # Need departures every 6 minutes = 10 per hour = 30 blocks
-        for hour in [7, 8, 9]:
-            for minute in range(0, 60, 6):
-                block_counter += 1
-                origin = self.TERMINALS[block_counter % 2]
-                destination = self.TERMINALS[(block_counter + 1) % 2]
-                all_blocks.append({
-                    'block_id': f'BLK-{block_counter:03d}',
-                    'departure_time': f'{hour:02d}:{minute:02d}',
-                    'origin': origin,
-                    'destination': destination,
-                    'trip_count': 3,  # ~3 hours of peak service
-                    'estimated_km': int(3 * self.ROUTE_LENGTH_KM * 2),
-                    'period': 'morning_peak',
-                    'is_peak': True
-                })
-        
-        # Midday off-peak blocks (10:00 - 17:00)
-        # Need departures every 15 minutes = 4 per hour = 28 blocks
-        for hour in range(10, 17):
-            for minute in range(0, 60, 15):
-                block_counter += 1
-                origin = self.TERMINALS[block_counter % 2]
-                destination = self.TERMINALS[(block_counter + 1) % 2]
-                all_blocks.append({
-                    'block_id': f'BLK-{block_counter:03d}',
-                    'departure_time': f'{hour:02d}:{minute:02d}',
-                    'origin': origin,
-                    'destination': destination,
-                    'trip_count': 2,
-                    'estimated_km': int(2 * self.ROUTE_LENGTH_KM * 2),
-                    'period': 'midday',
-                    'is_peak': False
-                })
-        
-        # Evening peak blocks (17:00 - 21:00)
-        # Need departures every 6 minutes = 10 per hour = 40 blocks
-        for hour in range(17, 21):
-            for minute in range(0, 60, 6):
-                block_counter += 1
-                origin = self.TERMINALS[block_counter % 2]
-                destination = self.TERMINALS[(block_counter + 1) % 2]
-                all_blocks.append({
-                    'block_id': f'BLK-{block_counter:03d}',
-                    'departure_time': f'{hour:02d}:{minute:02d}',
-                    'origin': origin,
-                    'destination': destination,
-                    'trip_count': 3,
-                    'estimated_km': int(3 * self.ROUTE_LENGTH_KM * 2),
-                    'period': 'evening_peak',
-                    'is_peak': True
-                })
+        # Generate blocks based on peak hours configuration
+        current_hour = self.operational_start.hour
+        end_hour = self.operational_end.hour
         
-        # Late evening blocks (21:00 - 23:00)
-        # Need departures every 15 minutes = 4 per hour = 8 blocks
-        for hour in range(21, 23):
-            for minute in range(0, 60, 15):
+        while current_hour < end_hour:
+            # Check if current hour is in peak
+            is_peak = any(start <= current_hour < end for start, end in self.peak_hours)
+            headway = self.peak_headway_minutes if is_peak else self.offpeak_headway_minutes
+            
+            # Determine period name
+            if current_hour < 10:
+                period = 'morning_peak' if is_peak else 'early_morning'
+            elif current_hour < 17:
+                period = 'midday'
+            elif current_hour < 21:
+                period = 'evening_peak' if is_peak else 'evening'
+            else:
+                period = 'late_evening'
+            
+            # Generate blocks for this hour
+            for minute in range(0, 60, int(headway)):
                 block_counter += 1
-                origin = self.TERMINALS[block_counter % 2]
-                destination = self.TERMINALS[(block_counter + 1) % 2]
-                all_blocks.append({
+                origin = self.terminals[block_counter % 2]
+                destination = self.terminals[(block_counter + 1) % 2]
+                
+                # Calculate trips based on period
+                if is_peak:
+                    trip_count = 3  # More trips during peak
+                elif current_hour >= 21:
+                    trip_count = 1  # Fewer trips late evening
+                else:
+                    trip_count = 2  # Normal off-peak
+                
+                departure_time = f'{current_hour:02d}:{minute:02d}'
+                
+                block = {
                     'block_id': f'BLK-{block_counter:03d}',
-                    'departure_time': f'{hour:02d}:{minute:02d}',
+                    'departure_time': departure_time,
                     'origin': origin,
                     'destination': destination,
-                    'trip_count': 1,
-                    'estimated_km': int(1 * self.ROUTE_LENGTH_KM * 2),
-                    'period': 'late_evening',
-                    'is_peak': False
-                })
+                    'trip_count': trip_count,
+                    'estimated_km': int(trip_count * self.route_length_km * 2),
+                    'period': period,
+                    'is_peak': is_peak
+                }
+                
+                # Add station sequence if loader available
+                if self._station_loader:
+                    block['station_count'] = len(self._station_loader.stations)
+                    block['intermediate_stops'] = len(self._station_loader.stations) - 2
+                    # Add journey details for first trip
+                    block['journey_time_minutes'] = round(
+                        self._station_loader.calculate_journey_time(origin, destination), 1
+                    )
+                
+                all_blocks.append(block)
+            
+            current_hour += 1
         
         self._all_blocks_cache = all_blocks
         return all_blocks
@@ -142,13 +281,13 @@ class ServiceBlockGenerator:
             num_service_trains: Total number of trains in service
             
         Returns:
-            List of service block dictionaries
+            List of service block dictionaries with station details
         """
         blocks = []
         
         # Calculate departure interval based on number of trains
         # Distribute trains evenly throughout peak hours
-        peak_interval = max(5, int(self.PEAK_HEADWAY_MINUTES))
+        peak_interval = max(5, int(self.peak_headway_minutes))
         
         # Stagger departures so trains are evenly spaced
         offset_minutes = (train_index * peak_interval) % 60
@@ -156,57 +295,107 @@ class ServiceBlockGenerator:
         # Morning peak block (7-10 AM, 3 hours)
         morning_start_hour = 7 + (train_index * peak_interval) // 60
         if morning_start_hour < 10:  # Only if within morning peak
-            blocks.append({
+            origin = self.terminals[0] if train_index % 2 == 0 else self.terminals[1]
+            destination = self.terminals[1] if train_index % 2 == 0 else self.terminals[0]
+            departure_time = f'{morning_start_hour:02d}:{offset_minutes:02d}'
+            
+            block = {
                 'block_id': f'BLK-M-{train_index+1:03d}',
-                'departure_time': f'{morning_start_hour:02d}:{offset_minutes:02d}',
-                'origin': self.TERMINALS[0] if train_index % 2 == 0 else self.TERMINALS[1],
-                'destination': self.TERMINALS[1] if train_index % 2 == 0 else self.TERMINALS[0],
+                'departure_time': departure_time,
+                'origin': origin,
+                'destination': destination,
                 'trip_count': self._calculate_trips(3.0),  # 3 hours
                 'estimated_km': self._calculate_km(3.0)
-            })
+            }
+            
+            # Add station sequence
+            if self._station_loader:
+                block['stations'] = self.get_station_sequence(origin, destination, departure_time)
+                block['journey_time_minutes'] = round(
+                    self._station_loader.calculate_journey_time(origin, destination), 1
+                )
+            
+            blocks.append(block)
         
         # Midday block (11-16, 5 hours)
         midday_start_hour = 11 + (train_index * 15) // 60  # 15 min intervals
         midday_minute = (train_index * 15) % 60
         if midday_start_hour < 16:
-            blocks.append({
+            origin = self.terminals[1] if train_index % 2 == 0 else self.terminals[0]
+            destination = self.terminals[0] if train_index % 2 == 0 else self.terminals[1]
+            departure_time = f'{midday_start_hour:02d}:{midday_minute:02d}'
+            
+            block = {
                 'block_id': f'BLK-D-{train_index+1:03d}',
-                'departure_time': f'{midday_start_hour:02d}:{midday_minute:02d}',
-                'origin': self.TERMINALS[1] if train_index % 2 == 0 else self.TERMINALS[0],
-                'destination': self.TERMINALS[0] if train_index % 2 == 0 else self.TERMINALS[1],
+                'departure_time': departure_time,
+                'origin': origin,
+                'destination': destination,
                 'trip_count': self._calculate_trips(5.0, peak=False),
                 'estimated_km': self._calculate_km(5.0, peak=False)
-            })
+            }
+            
+            if self._station_loader:
+                block['stations'] = self.get_station_sequence(origin, destination, departure_time)
+                block['journey_time_minutes'] = round(
+                    self._station_loader.calculate_journey_time(origin, destination), 1
+                )
+            
+            blocks.append(block)
         
         # Evening peak block (17-20, 3 hours)
         evening_start_hour = 17 + (train_index * peak_interval) // 60
         evening_minute = (train_index * peak_interval) % 60
         if evening_start_hour < 20:
-            blocks.append({
+            origin = self.terminals[0] if train_index % 2 == 0 else self.terminals[1]
+            destination = self.terminals[1] if train_index % 2 == 0 else self.terminals[0]
+            departure_time = f'{evening_start_hour:02d}:{evening_minute:02d}'
+            
+            block = {
                 'block_id': f'BLK-E-{train_index+1:03d}',
-                'departure_time': f'{evening_start_hour:02d}:{evening_minute:02d}',
-                'origin': self.TERMINALS[0] if train_index % 2 == 0 else self.TERMINALS[1],
-                'destination': self.TERMINALS[1] if train_index % 2 == 0 else self.TERMINALS[0],
+                'departure_time': departure_time,
+                'origin': origin,
+                'destination': destination,
                 'trip_count': self._calculate_trips(3.0),
                 'estimated_km': self._calculate_km(3.0)
-            })
+            }
+            
+            if self._station_loader:
+                block['stations'] = self.get_station_sequence(origin, destination, departure_time)
+                block['journey_time_minutes'] = round(
+                    self._station_loader.calculate_journey_time(origin, destination), 1
+                )
+            
+            blocks.append(block)
         
         # Late evening block (20-22, 2 hours) - lower frequency
         if train_index % 2 == 0:  # Only half the fleet for late evening
-            blocks.append({
+            origin = self.terminals[1]
+            destination = self.terminals[0]
+            departure_time = f'20:{(train_index * 20) % 60:02d}'
+            
+            block = {
                 'block_id': f'BLK-L-{train_index+1:03d}',
-                'departure_time': f'20:{(train_index * 20) % 60:02d}',
-                'origin': self.TERMINALS[1],
-                'destination': self.TERMINALS[0],
+                'departure_time': departure_time,
+                'origin': origin,
+                'destination': destination,
                 'trip_count': self._calculate_trips(2.0, peak=False),
                 'estimated_km': self._calculate_km(2.0, peak=False)
-            })
+            }
+            
+            if self._station_loader:
+                block['stations'] = self.get_station_sequence(origin, destination, departure_time)
+                block['journey_time_minutes'] = round(
+                    self._station_loader.calculate_journey_time(origin, destination), 1
+                )
+            
+            blocks.append(block)
         
         return blocks
     
     def _calculate_trips(self, duration_hours: float, peak: bool = True) -> int:
         """Calculate number of round trips in a time block."""
-        trips_per_hour = 60 / (self.PEAK_HEADWAY_MINUTES if peak else self.OFFPEAK_HEADWAY_MINUTES)
+        headway = self.peak_headway_minutes if peak else self.offpeak_headway_minutes
+        trips_per_hour = 60 / headway
         trips_per_hour = trips_per_hour / 2  # One-way trips, so divide by 2 for round trips
         total_trips = int(duration_hours * trips_per_hour)
         return max(1, total_trips)
@@ -214,7 +403,7 @@ class ServiceBlockGenerator:
     def _calculate_km(self, duration_hours: float, peak: bool = True) -> int:
         """Calculate estimated kilometers for a time block."""
         trips = self._calculate_trips(duration_hours, peak)
-        km = trips * self.ROUTE_LENGTH_KM * 2  # Round trips
+        km = trips * self.route_length_km * 2  # Round trips
         return int(km)
     
     def generate_all_service_blocks(self, num_service_trains: int) -> Dict[int, List[Dict]]:

greedyOptim/station_loader.py

@@ -0,0 +1,375 @@
+"""
+Station Data Loader
+Loads and manages station/route information from JSON configuration.
+Enables flexible route configuration for different metro lines.
+"""
+import json
+import os
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass
+from functools import lru_cache
+
+
+@dataclass
+class Station:
+    """Represents a metro station."""
+    sr_no: int
+    code: str
+    name: str
+    distance_from_prev_km: float
+    cumulative_distance_km: float
+    is_terminal: bool
+    has_depot: bool
+    platform_count: int
+    interchange: Optional[str] = None
+    depot_name: Optional[str] = None
+
+
+@dataclass
+class RouteInfo:
+    """Complete route information."""
+    name: str
+    operator: str
+    stations: List[Station]
+    total_distance_km: float
+    terminal_stations: List[str]
+    depot_stations: List[str]
+    operational_params: Dict
+
+
+class StationDataLoader:
+    """Loads and manages station data from JSON configuration."""
+    
+    # Default path to station data
+    DEFAULT_DATA_PATH = os.path.join(
+        os.path.dirname(__file__), 
+        'data', 
+        'kochi_metro_stations.json'
+    )
+    
+    def __init__(self, config_path: Optional[str] = None):
+        """Initialize station data loader.
+        
+        Args:
+            config_path: Path to station JSON file. If None, uses default.
+        """
+        self.config_path = config_path or self.DEFAULT_DATA_PATH
+        self._data: Optional[Dict] = None
+        self._stations: Optional[List[Station]] = None
+        self._route_info: Optional[RouteInfo] = None
+        
+    def load(self) -> Dict:
+        """Load station data from JSON file."""
+        if self._data is not None:
+            return self._data
+            
+        if not os.path.exists(self.config_path):
+            raise FileNotFoundError(
+                f"Station data file not found: {self.config_path}\n"
+                f"Please ensure the station configuration exists."
+            )
+        
+        with open(self.config_path, 'r') as f:
+            self._data = json.load(f)
+        
+        return self._data
+    
+    @property
+    def stations(self) -> List[Station]:
+        """Get list of Station objects."""
+        if self._stations is not None:
+            return self._stations
+        
+        data = self.load()
+        self._stations = []
+        
+        for s in data['stations']:
+            station = Station(
+                sr_no=s['sr_no'],
+                code=s['code'],
+                name=s['name'],
+                distance_from_prev_km=s['distance_from_prev_km'],
+                cumulative_distance_km=s['cumulative_distance_km'],
+                is_terminal=s['is_terminal'],
+                has_depot=s['has_depot'],
+                platform_count=s['platform_count'],
+                interchange=s.get('interchange'),
+                depot_name=s.get('depot_name')
+            )
+            self._stations.append(station)
+        
+        return self._stations
+    
+    @property
+    def route_info(self) -> RouteInfo:
+        """Get complete route information."""
+        if self._route_info is not None:
+            return self._route_info
+        
+        data = self.load()
+        stations = self.stations
+        
+        self._route_info = RouteInfo(
+            name=data['line_info']['name'],
+            operator=data['line_info']['operator'],
+            stations=stations,
+            total_distance_km=stations[-1].cumulative_distance_km if stations else 0,
+            terminal_stations=[s.name for s in stations if s.is_terminal],
+            depot_stations=[s.name for s in stations if s.has_depot],
+            operational_params=data.get('operational_params', {})
+        )
+        
+        return self._route_info
+    
+    @property
+    def total_distance_km(self) -> float:
+        """Get total route distance in km."""
+        return self.route_info.total_distance_km
+    
+    @property
+    def terminals(self) -> List[str]:
+        """Get terminal station names."""
+        return self.route_info.terminal_stations
+    
+    @property
+    def station_count(self) -> int:
+        """Get number of stations."""
+        return len(self.stations)
+    
+    def get_station_by_name(self, name: str) -> Optional[Station]:
+        """Get station by name (case-insensitive)."""
+        name_lower = name.lower()
+        for station in self.stations:
+            if station.name.lower() == name_lower:
+                return station
+        return None
+    
+    def get_station_by_code(self, code: str) -> Optional[Station]:
+        """Get station by code."""
+        code_upper = code.upper()
+        for station in self.stations:
+            if station.code.upper() == code_upper:
+                return station
+        return None
+    
+    def get_distance_between(self, station1: str, station2: str) -> float:
+        """Get distance between two stations (by name or code).
+        
+        Args:
+            station1: Name or code of first station
+            station2: Name or code of second station
+            
+        Returns:
+            Distance in km (absolute value)
+        """
+        s1 = self.get_station_by_name(station1) or self.get_station_by_code(station1)
+        s2 = self.get_station_by_name(station2) or self.get_station_by_code(station2)
+        
+        if not s1 or not s2:
+            raise ValueError(f"Station not found: {station1 if not s1 else station2}")
+        
+        return abs(s2.cumulative_distance_km - s1.cumulative_distance_km)
+    
+    def get_intermediate_stations(self, origin: str, destination: str) -> List[Station]:
+        """Get all intermediate stations between origin and destination.
+        
+        Args:
+            origin: Origin station name or code
+            destination: Destination station name or code
+            
+        Returns:
+            List of stations between origin and destination (inclusive)
+        """
+        s1 = self.get_station_by_name(origin) or self.get_station_by_code(origin)
+        s2 = self.get_station_by_name(destination) or self.get_station_by_code(destination)
+        
+        if not s1 or not s2:
+            raise ValueError(f"Station not found: {origin if not s1 else destination}")
+        
+        # Get indices
+        idx1 = s1.sr_no - 1  # sr_no is 1-based
+        idx2 = s2.sr_no - 1
+        
+        # Ensure correct order
+        start_idx, end_idx = min(idx1, idx2), max(idx1, idx2)
+        
+        return self.stations[start_idx:end_idx + 1]
+    
+    def calculate_journey_time(
+        self, 
+        origin: str, 
+        destination: str, 
+        avg_speed_kmh: Optional[float] = None
+    ) -> float:
+        """Calculate journey time between two stations.
+        
+        Args:
+            origin: Origin station name or code
+            destination: Destination station name or code
+            avg_speed_kmh: Average speed (uses config default if None)
+            
+        Returns:
+            Journey time in minutes (including dwell times)
+        """
+        data = self.load()
+        
+        if avg_speed_kmh is None:
+            avg_speed_kmh = data['line_info'].get('average_speed_kmh', 35)
+        
+        dwell_time_sec = data['operational_params'].get('dwell_time_seconds', 30)
+        
+        distance = self.get_distance_between(origin, destination)
+        intermediate = self.get_intermediate_stations(origin, destination)
+        
+        # Travel time
+        travel_time_hours = distance / avg_speed_kmh
+        travel_time_minutes = travel_time_hours * 60
+        
+        # Add dwell time at each intermediate station (except destination)
+        num_stops = len(intermediate) - 1  # Exclude destination
+        total_dwell_minutes = (num_stops * dwell_time_sec) / 60
+        
+        return travel_time_minutes + total_dwell_minutes
+    
+    def calculate_round_trip_time(self, avg_speed_kmh: Optional[float] = None) -> float:
+        """Calculate round trip time between terminals.
+        
+        Returns:
+            Round trip time in minutes (including turnaround)
+        """
+        data = self.load()
+        terminals = self.terminals
+        
+        if len(terminals) < 2:
+            raise ValueError("Need at least 2 terminal stations for round trip")
+        
+        turnaround_sec = data['operational_params'].get('terminal_turnaround_seconds', 180)
+        
+        # One-way journey time
+        one_way_time = self.calculate_journey_time(terminals[0], terminals[-1], avg_speed_kmh)
+        
+        # Round trip = 2 * one_way + 2 * turnaround
+        return (2 * one_way_time) + (2 * turnaround_sec / 60)
+    
+    def get_station_sequence_for_trip(
+        self, 
+        origin: str, 
+        destination: str, 
+        include_times: bool = True,
+        departure_time: str = "07:00"
+    ) -> List[Dict]:
+        """Get detailed station sequence for a trip.
+        
+        Args:
+            origin: Origin station name
+            destination: Destination station name
+            include_times: Whether to calculate arrival times
+            departure_time: Departure time from origin (HH:MM format)
+            
+        Returns:
+            List of dicts with station info and arrival times
+        """
+        data = self.load()
+        avg_speed = data['line_info'].get('average_speed_kmh', 35)
+        dwell_time_sec = data['operational_params'].get('dwell_time_seconds', 30)
+        
+        stations = self.get_intermediate_stations(origin, destination)
+        
+        # Parse departure time
+        from datetime import datetime, timedelta
+        current_time = datetime.strptime(departure_time, "%H:%M")
+        
+        sequence = []
+        prev_cumulative = stations[0].cumulative_distance_km
+        
+        for i, station in enumerate(stations):
+            entry = {
+                'sr_no': station.sr_no,
+                'code': station.code,
+                'name': station.name,
+                'distance_from_origin_km': round(station.cumulative_distance_km - stations[0].cumulative_distance_km, 3),
+                'is_terminal': station.is_terminal
+            }
+            
+            if include_times:
+                if i == 0:
+                    # Origin station - departure time
+                    entry['arrival_time'] = None
+                    entry['departure_time'] = current_time.strftime("%H:%M")
+                else:
+                    # Calculate travel time from previous station
+                    segment_distance = station.cumulative_distance_km - prev_cumulative
+                    travel_time_min = (segment_distance / avg_speed) * 60
+                    current_time += timedelta(minutes=travel_time_min)
+                    
+                    entry['arrival_time'] = current_time.strftime("%H:%M")
+                    
+                    if i < len(stations) - 1:
+                        # Not destination - add dwell time
+                        current_time += timedelta(seconds=dwell_time_sec)
+                        entry['departure_time'] = current_time.strftime("%H:%M")
+                    else:
+                        # Destination - no departure
+                        entry['departure_time'] = None
+                
+                prev_cumulative = station.cumulative_distance_km
+            
+            sequence.append(entry)
+        
+        return sequence
+    
+    def to_dict(self) -> Dict:
+        """Export route info as dictionary."""
+        return {
+            'line_name': self.route_info.name,
+            'operator': self.route_info.operator,
+            'total_distance_km': self.total_distance_km,
+            'station_count': self.station_count,
+            'terminals': self.terminals,
+            'stations': [
+                {
+                    'sr_no': s.sr_no,
+                    'code': s.code,
+                    'name': s.name,
+                    'distance_from_prev_km': s.distance_from_prev_km,
+                    'cumulative_distance_km': s.cumulative_distance_km,
+                    'is_terminal': s.is_terminal,
+                    'has_depot': s.has_depot
+                }
+                for s in self.stations
+            ],
+            'operational_params': self.route_info.operational_params
+        }
+
+
+# Global cached instance for performance
+_default_loader: Optional[StationDataLoader] = None
+
+
+def get_station_loader(config_path: Optional[str] = None) -> StationDataLoader:
+    """Get station data loader (cached for default path).
+    
+    Args:
+        config_path: Custom config path, or None for default
+        
+    Returns:
+        StationDataLoader instance
+    """
+    global _default_loader
+    
+    if config_path is None:
+        if _default_loader is None:
+            _default_loader = StationDataLoader()
+        return _default_loader
+    
+    return StationDataLoader(config_path)
+
+
+def get_route_distance() -> float:
+    """Get total route distance (convenience function)."""
+    return get_station_loader().total_distance_km
+
+
+def get_terminals() -> List[str]:
+    """Get terminal station names (convenience function)."""
+    return get_station_loader().terminals