Upd efficiency API with doc

README.md

@@ -97,6 +97,7 @@ The application is structured into modular components:
 - `GET /download/{filename}`: Download cleaned CSV
 - `GET /events`: Get processing status
 - `GET /predictions/latest`: Get latest driver behavior and fuel efficiency predictions
+- `GET /efficiency/{filename}`: Get fuel efficiency prediction for specific processed file
 
 ### MongoDB Operations
 - `GET /mongo/status`: Check MongoDB connection
@@ -163,10 +164,21 @@ The application is structured into modular components:
 }
 ```
 
+### Efficiency Retrieval Response (`GET /efficiency/{filename}`)
+```json
+{
+  "filename": "001_2024-12-01_processed.csv",
+  "efficiency_score": 85.2,
+  "timestamp": "2024-12-01T14:30:22",
+  "status": "success"
+}
+```
+
 ### Firebase Storage
 - Structured data storage with automatic versioning
 - **`skyledge/raw/`**: Original OBD data files
 - **`skyledge/processed/`**: Cleaned and processed data
+- **`skyledge/processed/efficiency.json`**: Fuel efficiency predictions for each processed file
 - **`skyledge/labeled/`**: Human-labeled data for RLHF training
 - **`skyledge/labeled/trained.txt`**: Tracks processed datasets to avoid retraining
 

app.py

@@ -26,7 +26,7 @@ from data.drive_saver import DriveSaver, get_drive_service, upload_to_folder
 
 # Database
 from data.mongo_saver import MongoSaver, save_csv_to_mongo, save_dataframe_to_mongo, MONGODB_AVAILABLE
-from data.firebase_saver import FirebaseSaver, save_csv_increment, save_dataframe_increment
+from data.firebase_saver import FirebaseSaver, save_csv_increment, save_dataframe_increment, save_efficiency_data, get_efficiency_by_filename
 
 # UL Model
 from utils.dbehavior_labeler import ULLabeler
@@ -547,6 +547,21 @@ def _process_and_save(df, norm_ts):
             # Save to Firebase Storage (incremented NNN_YYYY-MM-DD_processed.csv at fixed path)
             if gs_url:
                 logger.info(f"✅ Saved to Firebase Storage: {gs_url}")
+                
+                # Extract filename from gs_url for efficiency data storage
+                try:
+                    filename = gs_url.split('/')[-1]  # Get filename from gs://bucket/path/filename.csv
+                    if FUEL_EFFICIENCY and len(FUEL_EFFICIENCY) > 0:
+                        efficiency_score = FUEL_EFFICIENCY[0]  # Get the first (and only) efficiency score
+                        success = save_efficiency_data(filename, efficiency_score)
+                        if success:
+                            logger.info(f"✅ Efficiency data saved for {filename}: {efficiency_score}%")
+                        else:
+                            logger.warning(f"⚠️ Failed to save efficiency data for {filename}")
+                    else:
+                        logger.warning("⚠️ No fuel efficiency data available to save")
+                except Exception as e:
+                    logger.error(f"❌ Error saving efficiency data: {e}")
             else:
                 logger.warning("⚠️ Firebase Storage upload returned empty URL")
         else:
@@ -640,6 +655,39 @@ def get_latest_predictions():
         "fuel_efficiency_count": len(FUEL_EFFICIENCY)
     }
 
+@app.get("/efficiency/{filename}")
+def get_efficiency_by_filename(filename: str):
+    """
+    Get fuel efficiency prediction for a specific processed file from Firebase.
+    
+    Args:
+        filename: The processed filename (e.g., "001_2024-12-01_processed.csv")
+        
+    Returns:
+        dict: Efficiency data or error message
+    """
+    try:
+        if not firebase_saver.is_available():
+            raise HTTPException(status_code=503, detail="Firebase Storage not available")
+        
+        efficiency_data = get_efficiency_by_filename(filename)
+        
+        if efficiency_data is None:
+            raise HTTPException(status_code=404, detail=f"Efficiency data not found for {filename}")
+        
+        return {
+            "filename": filename,
+            "efficiency_score": efficiency_data["efficiency_score"],
+            "timestamp": efficiency_data["timestamp"],
+            "status": "success"
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"❌ Error retrieving efficiency data for {filename}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to retrieve efficiency data: {str(e)}")
+
 
 # ────── Delete event from dashboard ──────────────
 @app.delete("/events/remove/{timestamp}")

data/firebase_saver.py

@@ -294,6 +294,90 @@ class FirebaseSaver:
         except Exception as e:
             logger.error(f"❌ Firebase DF upload failed: {e}")
             return ""
+    
+    def save_efficiency_data(self, filename: str, efficiency_score: float) -> bool:
+        """
+        Save efficiency data to efficiency.json file in Firebase.
+        
+        Args:
+            filename: The processed filename (e.g., "001_2024-12-01_processed.csv")
+            efficiency_score: The fuel efficiency score (0-100)
+            
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        try:
+            # Load existing efficiency data
+            efficiency_data = self.load_efficiency_data()
+            
+            # Add new entry
+            efficiency_data[filename] = {
+                "efficiency_score": efficiency_score,
+                "timestamp": datetime.now().isoformat(),
+                "filename": filename
+            }
+            
+            # Convert to JSON
+            json_data = json.dumps(efficiency_data, indent=2)
+            
+            # Upload to Firebase
+            dest_path = f"{FIXED_PREFIX}/efficiency.json"
+            self.client.upload_from_bytes(
+                json_data.encode("utf-8"), 
+                dest_path, 
+                "application/json"
+            )
+            
+            logger.info(f"✅ Efficiency data saved for {filename}: {efficiency_score}%")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to save efficiency data: {e}")
+            return False
+    
+    def load_efficiency_data(self) -> dict:
+        """
+        Load efficiency data from efficiency.json file in Firebase.
+        
+        Returns:
+            dict: Efficiency data or empty dict if file doesn't exist
+        """
+        try:
+            dest_path = f"{FIXED_PREFIX}/efficiency.json"
+            
+            # Try to download the file
+            blob = self.bucket.blob(dest_path)
+            if not blob.exists():
+                logger.info("📄 efficiency.json not found, returning empty data")
+                return {}
+            
+            # Download and parse JSON
+            json_data = blob.download_as_text()
+            efficiency_data = json.loads(json_data)
+            
+            logger.info(f"✅ Loaded efficiency data: {len(efficiency_data)} entries")
+            return efficiency_data
+            
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to load efficiency data: {e}")
+            return {}
+    
+    def get_efficiency_by_filename(self, filename: str) -> Optional[dict]:
+        """
+        Get efficiency data for a specific filename.
+        
+        Args:
+            filename: The processed filename
+            
+        Returns:
+            dict: Efficiency data or None if not found
+        """
+        try:
+            efficiency_data = self.load_efficiency_data()
+            return efficiency_data.get(filename)
+        except Exception as e:
+            logger.error(f"❌ Failed to get efficiency data for {filename}: {e}")
+            return None
 
 
 # ---------- Convenience free functions ----------
@@ -312,4 +396,31 @@ def save_dataframe_increment(df: pd.DataFrame, date_str: Optional[str] = None) -
     Returns gs:// URL or "".
     """
     saver = FirebaseSaver()
-    return saver.upload_dataframe_with_increment(df, date_str=date_str)
+    return saver.upload_dataframe_with_increment(df, date_str=date_str)
+
+def save_efficiency_data(filename: str, efficiency_score: float) -> bool:
+    """
+    Save efficiency data to Firebase efficiency.json file.
+    
+    Args:
+        filename: The processed filename
+        efficiency_score: The fuel efficiency score (0-100)
+        
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    saver = FirebaseSaver()
+    return saver.save_efficiency_data(filename, efficiency_score)
+
+def get_efficiency_by_filename(filename: str) -> Optional[dict]:
+    """
+    Get efficiency data for a specific filename from Firebase.
+    
+    Args:
+        filename: The processed filename
+        
+    Returns:
+        dict: Efficiency data or None if not found
+    """
+    saver = FirebaseSaver()
+    return saver.get_efficiency_by_filename(filename)