refactor the app to use firestore

.gitignore

@@ -38,4 +38,5 @@ ENV/
 .streamlit/
 
 # Logs
-*.log 
+*.log 
+pocketpal-ai-6e230-6fe017a6fd65.json

main.py

@@ -7,7 +7,7 @@ from src.components.visualizations import (
     render_performance_plots,
     render_leaderboard_table,
 )
-from src.services.api import fetch_leaderboard_data
+from src.services.firebase import fetch_leaderboard_data
 
 # Configure the page
 st.set_page_config(

requirements.txt

@@ -4,4 +4,5 @@ python-dotenv>=1.0.0
 pandas>=2.1.3
 plotly>=5.18.0
 httpx>=0.25.1
-pydantic-settings>=2.0.3 
+pydantic-settings>=2.0.3 
+firebase-admin

src/app.py

@@ -7,7 +7,7 @@ async def fetch_and_filter_data(
     benchmark_label: Optional[str] = None
 ) -> pd.DataFrame:
     """Fetch and filter data based on parameters"""
-    from .services.api import fetch_leaderboard_data
+    from .services.firebase import fetch_leaderboard_data
     
     return await fetch_leaderboard_data(
         model_name=model_name,

src/core/config.py

@@ -2,8 +2,7 @@ from pydantic_settings import BaseSettings
 from functools import lru_cache
 
 class Settings(BaseSettings):
-    API_URL: str = "https://a-ghorbani-ai-phone-benchmark-api.hf.space"
-    HF_TOKEN: str
+    FIRESTORE_COLLECTION: str = "benchmarks"
     
     class Config:
         case_sensitive = True

src/services/api.py

@@ -1,38 +0,0 @@
-import httpx
-import pandas as pd
-from typing import Optional, Dict
-import streamlit as st
-from src.core.config import settings
-
-async def fetch_leaderboard_data(
-    model_name: Optional[str] = None,
-    benchmark_label: Optional[str] = None
-) -> pd.DataFrame:
-    """Fetch and process leaderboard data"""
-    params = {}
-    if model_name and model_name != "All":
-        params["model_name"] = model_name
-    if benchmark_label and benchmark_label != "All":
-        params["benchmark_label"] = benchmark_label
-
-    headers = {
-        "Authorization": f"Bearer {settings.HF_TOKEN}",
-        "Accept": "application/json"
-    }
-
-    try:
-        async with httpx.AsyncClient() as client:
-            response = await client.get(
-                f"{settings.API_URL}/api/v1/leaderboard",
-                params=params,
-                headers=headers,
-                follow_redirects=True
-            )
-            response.raise_for_status()
-            data = response.json()
-            return pd.DataFrame(data)
-    except Exception as e:
-        st.error(f"Error fetching data: {str(e)}")
-        if hasattr(e, 'response'):
-            st.error(f"Response: {e.response.text}")
-        return pd.DataFrame() 

src/services/firebase.py

@@ -0,0 +1,111 @@
+import firebase_admin
+from firebase_admin import credentials, firestore
+from typing import List, Dict, Optional
+import pandas as pd
+import streamlit as st
+
+def initialize_firebase():
+    """Initialize Firebase with credentials"""
+    try:
+        firebase_admin.get_app()
+    except ValueError:
+        cred = credentials.Certificate('pocketpal-ai-6e230-6fe017a6fd65.json')
+        firebase_admin.initialize_app(cred)
+    return firestore.client()
+
+db = initialize_firebase()
+
+def normalize_device_id(device_info: dict) -> str:
+    """Normalize device identifier for aggregation"""
+    emulator = "/Emulator" if device_info["isEmulator"] else ""
+    if device_info["systemName"].lower() == "ios":
+        return f"iOS/{device_info['model']}{emulator}"
+    
+    memory_tier = f"{device_info['totalMemory'] // (1024**3)}GB"
+    return f"{device_info['brand']}/{device_info['model']}/{memory_tier}{emulator}"
+
+def format_params_in_b(params: int) -> float:
+    """Format number of parameters in billions"""
+    b_value = params / 1e9
+    if b_value >= 10:
+        return round(b_value, 1)
+    elif b_value >= 1:
+        return round(b_value, 2)
+    else:
+        return round(b_value, 3)
+
+def format_leaderboard_data(submissions: List[dict]) -> pd.DataFrame:
+    """Format submissions for leaderboard display"""
+    formatted_data = []
+    
+    for sub in submissions:
+        try:
+            benchmark_result = sub.get('benchmarkResult', {})
+            device_info = sub.get('deviceInfo', {})
+            
+            if not benchmark_result or not device_info:
+                continue
+                
+            formatted_data.append({
+                "Device": f"{device_info.get('model', 'Unknown')} [Emulator]" if device_info.get('isEmulator') else device_info.get('model', 'Unknown'),
+                "Platform": device_info.get('systemName', 'Unknown'),
+                "Benchmark": f"{benchmark_result.get('config', {}).get('label', 'Unknown')} (pp: {benchmark_result.get('config', {}).get('pp', 'N/A')}, tg: {benchmark_result.get('config', {}).get('tg', 'N/A')})",
+                "Model": benchmark_result.get('modelName', 'Unknown'),
+                "Model Size": format_params_in_b(benchmark_result.get('modelNParams', 0)),
+                "Prompt Processing": round(benchmark_result.get('ppAvg', 0), 2),
+                "Token Generation": round(benchmark_result.get('tgAvg', 0), 2),
+                "Memory Usage (%)": benchmark_result.get('peakMemoryUsage', {}).get('percentage'),
+                "Memory Usage (GB)": round(benchmark_result.get('peakMemoryUsage', {}).get('used', 0) / (1024**3), 2) if benchmark_result.get('peakMemoryUsage', {}).get('used') else None,
+                "Total Memory (GB)": round(device_info.get('totalMemory', 0) / (1024**3), 2),
+                "CPU Cores": device_info.get('cpuDetails', {}).get('cores', 'Unknown'),
+                "Normalized Device ID": normalize_device_id(device_info),
+                "Timestamp": benchmark_result.get('timestamp', 'Unknown'),
+                "Model ID": benchmark_result.get('modelId', 'Unknown'),
+                "OID": benchmark_result.get('oid'),
+            })
+        except Exception as e:
+            st.warning(f"Error processing submission: {str(e)}")
+            continue
+            
+    return pd.DataFrame(formatted_data)
+
+async def fetch_leaderboard_data(
+    model_name: Optional[str] = None,
+    benchmark_label: Optional[str] = None
+) -> pd.DataFrame:
+    """Fetch and process leaderboard data from Firestore"""
+    try:
+        # Navigate to the correct collection path: benchmarks/v1/submissions
+        submissions_ref = db.collection('benchmarks').document('v1').collection('submissions')
+        
+        # Get all documents
+        docs = submissions_ref.stream()
+        all_docs = list(docs)
+        
+        if len(all_docs) == 0:
+            return pd.DataFrame()
+            
+        # Process documents and filter in memory
+        submissions = []
+        
+        for doc in all_docs:
+            data = doc.to_dict()
+            
+            if not data or 'benchmarkResult' not in data:
+                continue
+                
+            benchmark_result = data['benchmarkResult']
+            
+            # Apply filters
+            if model_name and model_name != "All" and benchmark_result.get('modelName') != model_name:
+                continue
+            if benchmark_label and benchmark_label != "All" and benchmark_result.get('config', {}).get('label') != benchmark_label:
+                continue
+                
+            submissions.append(data)
+        
+        return format_leaderboard_data(submissions)
+    
+    except Exception as e:
+        st.error(f"Error fetching data from Firestore: {str(e)}")
+        return pd.DataFrame()