Update route_optimizer/green_route_optimizer.py

route_optimizer/green_route_optimizer.py

@@ -1,68 +1,56 @@
 # route_optimizer/green_route_optimizer.py
 
-import math
 from geopy.geocoders import Nominatim
+import math
 
 class GreenRouteOptimizer:
     """
-    A route optimizer for green transport modes: rail, road, and ship.
-    Calculates approximate distance and CO2 emissions.
+    GreenRouteOptimizer calculates optimized routes for rail, road, and ship.
+    Accepts place names (with optional country/short code) and returns distance and emission estimates.
     """
 
-    # Emission factors in kg CO2 per km
-    EMISSION_FACTORS = {
-        "rail": 0.041,
-        "road": 0.21,
-        "ship": 0.015
-    }
-
-    def __init__(self):
-        # Initialize geocoder
-        self.geolocator = Nominatim(user_agent="green_route_optimizer")
+    def __init__(self, user_agent="green_route_app"):
+        self.geolocator = Nominatim(user_agent=user_agent)
+        # Emission factors in kg CO2 per km (example values)
+        self.emission_factors = {
+            "road": 0.21,  # road transport
+            "rail": 0.041, # rail transport
+            "ship": 0.014  # shipping
+        }
 
     def geocode(self, place_name):
-        """
-        Convert a place name into coordinates (latitude, longitude).
-        Accepts place name, city+country, or city+state+country.
-        """
+        """Returns (latitude, longitude) tuple for a given place name."""
         location = self.geolocator.geocode(place_name)
         if location is None:
             raise ValueError(f"Could not geocode place: '{place_name}'")
         return (location.latitude, location.longitude)
 
-    def optimize(self, start_coords, end_coords, mode):
-        """
-        Returns a mock optimized route result using Euclidean distance approximation.
-        """
-        distance_km = math.dist(start_coords, end_coords)
-        return {
+    def optimize(self, start_coords, end_coords, mode="road"):
+        """Calculates Euclidean distance and estimated emissions."""
+        if mode not in self.emission_factors:
+            raise ValueError(f"Invalid mode '{mode}'. Choose from {list(self.emission_factors.keys())}.")
+        
+        distance_km = math.dist(start_coords, end_coords) * 111  # approx km per degree
+        optimized_route = {
             "start": start_coords,
             "end": end_coords,
             "mode": mode,
             "optimized_distance_km": round(distance_km, 2),
-            "estimated_emission_kg": round(distance_km * self.EMISSION_FACTORS[mode], 3)
+            "estimated_emission_kg": round(distance_km * self.emission_factors[mode], 3)
         }
+        return optimized_route
 
-    def recommend_green_routes(self, start_place, end_place, modes=None):
+    def recommend_green_routes(self, start_place, end_place):
         """
-        Returns optimized routes for green transport modes.
-
-        start_place, end_place: place names (city, city+state, or city+country)
-        modes: optional list of modes (rail, road, ship). Defaults to all.
+        Returns optimized routes for all transport modes.
+        start_place and end_place can be:
+        - "City"
+        - "City, Country"
+        - "City, CountryCode" (short form)
         """
         start_coords = self.geocode(start_place)
         end_coords = self.geocode(end_place)
-
-        if modes is None:
-            modes = ["rail", "road", "ship"]
-
-        routes = []
-        for mode in modes:
-            if mode not in self.EMISSION_FACTORS:
-                continue
-            route = self.optimize(start_coords, end_coords, mode)
-            routes.append(route)
-
-        # Sort routes by lowest emission first
-        routes.sort(key=lambda x: x["estimated_emission_kg"])
-        return routes
+        results = {}
+        for mode in self.emission_factors:
+            results[mode] = self.optimize(start_coords, end_coords, mode)
+        return results