Update app.py

app.py

@@ -1,7 +1,7 @@
 import os
 import logging
 import requests
-from geopy.geocoders import Nominatim  # Valid import
+from geopy.geocoders import Nominatim
 from stable_baselines3 import PPO
 from stable_baselines3.common.vec_env import DummyVecEnv
 import gymnasium as gym
@@ -17,9 +17,9 @@ HOSTED_API_URL = os.getenv("HOSTED_API_URL")  # FastAPI backend URL
 WEATHER_API_KEY = os.getenv("WEATHER_API_KEY")  # OpenWeatherMap API key
 
 # Logging setup
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")  # Valid logging format
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 
-# Validate Environment Variables
+# Validation Environment Variables
 if not HOSTED_API_URL:
     logging.error("HOSTED_API_URL environment variable is not set.")
     raise ValueError("HOSTED_API_URL must be set.")
@@ -28,9 +28,9 @@ if not WEATHER_API_KEY:
     raise ValueError("WEATHER_API_KEY must be set.")
 
 # OpenStreetMap Setup
-geolocator = Nominatim(user_agent="traffic_management_system")  # Valid usage of Nominatim
+geolocator = Nominatim(user_agent="traffic_management_system")
 
-# Analyze Traffic using FastAPI API URL
+# Post Image to FastAPI API URL
 def analyze_traffic(image_path):
     """
     Sends the traffic image to the FastAPI backend for analysis.
@@ -69,17 +69,14 @@ class TrafficSimEnv(gym.Env):
         super(TrafficSimEnv, self).__init__()
         self.congestion_level = congestion_level
 
-        # Define observation space: [congestion_level, signal_duration]
         self.observation_space = spaces.Box(
             low=np.array([0, 0], dtype=np.float32),
             high=np.array([10, 60], dtype=np.float32),
             dtype=np.float32
         )
 
-        # Define action space: [increase, decrease, maintain]
         self.action_space = spaces.Discrete(3)
-
-        # Initial state
+        
         self.state = np.array([congestion_level, 30], dtype=np.float32)
         self.done = False
 
@@ -97,26 +94,23 @@ class TrafficSimEnv(gym.Env):
         congestion, signal_duration = self.state
 
         # Apply action
-        if action == 0:  # Decrease signal duration
+        if action == 0: 
             signal_duration = max(10, signal_duration - 5)
-        elif action == 1:  # Maintain signal duration
+        elif action == 1: 
             signal_duration = signal_duration
-        elif action == 2:  # Increase signal duration
+        elif action == 2: 
             signal_duration = min(60, signal_duration + 5)
 
-        # Update congestion (simple simulation logic for this example)
         if signal_duration > 30:
             congestion += 1
         else:
             congestion -= 1
 
-        # Set rewards (example logic)
         if 20 <= signal_duration <= 40:
             reward = 0
         else:
             reward = -abs(signal_duration - 30)
 
-        # Check if done
         self.done = congestion <= 0 or congestion >= 10
 
         self.state = np.array([congestion, signal_duration], dtype=np.float32)
@@ -132,24 +126,22 @@ class TrafficSimEnv(gym.Env):
 
 def optimize_signal_rl(congestion_level):
     try:
-        # Map congestion levels (string to numeric)
+        # Map congestion levels (string to numeric) converter
         congestion_map = {"Low": 2, "Medium": 5, "High": 8}
         congestion_level = congestion_map.get(congestion_level, 5) if isinstance(congestion_level, str) else congestion_level
 
         # Create environment
         env = DummyVecEnv([lambda: TrafficSimEnv(congestion_level)])
-
-        # Initialize PPO model
         model = PPO("MlpPolicy", env, verbose=0)
 
         # Train the model
         model.learn(total_timesteps=1000)
 
-        # Reset the environment and get the initial observation
+        # Reset environment and get the initial observation
         obs = env.reset()
-        logging.info(f"Initial observation: {obs}")
+        logging.info(f"Initial Observation: {obs}")
 
-        # Ensure `obs` is valid
+        # Ensure `obs` is valid (It was a very bugged area I faced)
         if not isinstance(obs, np.ndarray) or obs.ndim != 2:
             raise ValueError(f"Invalid observation after reset: {obs} (type: {type(obs)}, ndim: {obs.ndim if isinstance(obs, np.ndarray) else 'N/A'})")
 
@@ -164,21 +156,21 @@ def optimize_signal_rl(congestion_level):
             # Check and log the observation
             logging.debug(f"Step {step_count}: Obs: {obs}, Rewards: {rewards}, Done: {dones}, Infos: {infos}")
 
-            # Validate `obs` after each step
+            # Validate `obs` after each step (To make sure it doesnt go 0 and create an error)
             if not isinstance(obs, np.ndarray):
                 raise ValueError(f"Observation is not an array after step {step_count}: {obs}")
-            if obs.ndim == 0:  # Handle 0-dimensional observation
-                obs = np.array([obs])  # Convert to at least 1D
+            if obs.ndim == 0: 
+                obs = np.array([obs])  # Convert at least 1D
                 logging.warning(f"Converted 0D obs to array: {obs}")
-            elif obs.ndim == 1:  # Ensure it's 2D for consistency
+            elif obs.ndim == 1:  # Makesure its 2D for consistency
                 obs = obs.reshape(1, -1)
 
-            # Stop if the environment signals it's done
+            # Stop if the env signals is done
             if dones[0]:
                 break
 
-        # Extract the optimal signal duration from the last valid observation
-        obs = obs.flatten()  # Ensure it's a 1D array for indexing
+        # Get the optimal signal duration from the last valid observation
+        obs = obs.flatten()  # Confirm its a 1D array for indexing
         if len(obs) < 2:
             raise ValueError(f"Observation does not contain enough elements: {obs}")
         optimal_duration = int(obs[1])
@@ -199,7 +191,7 @@ def process_traffic_image(image):
     Orchestrates the traffic analysis workflow.
     """
 
-    # Save the uploaded image temporarily
+    # Save the uploaded image temp
     image_path = "temp_traffic_image.jpg"
     image.save(image_path)
 
@@ -214,7 +206,7 @@ def process_traffic_image(image):
         logging.error(f"Error in backend request: {e}")
         return "Error in backend request.", None
     finally:
-        os.remove(image_path)  # Clean up the temporary image
+        os.remove(image_path)  # Clean up the temp
 
     # Process backend response
     if response.status_code == 200: