Rename src/streamlit_app.py to src/main.py

src/main.py

@@ -0,0 +1,202 @@
+import streamlit as st
+import pandas as pd
+import sqlite3
+import hashlib
+from datetime import datetime
+from localization_eval import evaluate_submission
+
+# --- CONFIGURATION & SETUP ---
+st.set_page_config(
+    page_title="AI Benchmark Arena",
+    page_icon="🏆",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+DB_NAME = "./benchmark.db"
+
+
+def init_db():
+    conn = sqlite3.connect(DB_NAME)
+    c = conn.cursor()
+    # User Table
+    c.execute('''CREATE TABLE IF NOT EXISTS users 
+                 (username TEXT PRIMARY KEY, password TEXT)''')
+    # Submissions Table
+    c.execute('''CREATE TABLE IF NOT EXISTS submissions 
+                 (id INTEGER PRIMARY KEY AUTOINCREMENT, 
+                  username TEXT, score REAL, timestamp DATETIME)''')
+    conn.commit()
+    conn.close()
+
+def make_hashes(password):
+    return hashlib.sha256(str.encode(password)).hexdigest()
+
+def check_hashes(password, hashed_text):
+    if make_hashes(password) == hashed_text:
+        return hashed_text
+    return False
+
+def add_user(username, password):
+    conn = sqlite3.connect(DB_NAME)
+    c = conn.cursor()
+    try:
+        c.execute('INSERT INTO users(username, password) VALUES (?,?)', 
+                  (username, make_hashes(password)))
+        conn.commit()
+        return True
+    except sqlite3.IntegrityError:
+        return False
+    finally:
+        conn.close()
+
+def login_user(username, password):
+    conn = sqlite3.connect(DB_NAME)
+    c = conn.cursor()
+    c.execute('SELECT * FROM users WHERE username =? AND password = ?', 
+              (username, make_hashes(password)))
+    data = c.fetchall()
+    conn.close()
+    return data
+
+def save_submission(username, score):
+    conn = sqlite3.connect(DB_NAME)
+    c = conn.cursor()
+    c.execute('INSERT INTO submissions(username, score, timestamp) VALUES (?,?,?)', 
+              (username, score, datetime.now()))
+    conn.commit()
+    conn.close()
+
+def get_leaderboard_data():
+    conn = sqlite3.connect(DB_NAME)
+    # Get the BEST score for each user
+    query = """
+    SELECT username, MAX(score) as best_accuracy, MAX(timestamp) as last_submission
+    FROM submissions 
+    GROUP BY username 
+    ORDER BY best_accuracy DESC
+    """
+    df = pd.read_sql_query(query, conn)
+    conn.close()
+    return df
+
+# --- User Interface ---
+
+def ui_login_signup():
+    st.title("Welcome to Benchmark Arena 🏆")
+    
+    tab1, tab2 = st.tabs(["Login", "Sign Up"])
+
+    with tab1:
+        st.subheader("Sign In")
+        username = st.text_input("Username", key="login_user")
+        password = st.text_input("Password", type='password', key="login_pass")
+        
+        if st.button("Login"):
+            if login_user(username, password):
+                st.session_state['logged_in'] = True
+                st.session_state['username'] = username
+                st.rerun()
+            else:
+                st.error("Username or Password incorrect")
+
+    with tab2:
+        st.subheader("Create New Account")
+        new_user = st.text_input("Username", key="new_user")
+        new_pass = st.text_input("Password", type='password', key="new_pass")
+        
+        if st.button("Sign Up"):
+            if add_user(new_user, new_pass):
+                st.success("Account created! Please navigate to Login.")
+            else:
+                st.warning("Username already exists.")
+
+def main_app():
+    # Sidebar Navigation
+    st.sidebar.title(f"Hi, {st.session_state['username']}!")
+    menu = ["Submit Model", "Leaderboard"]
+    choice = st.sidebar.radio("Navigation", menu)
+    
+    st.sidebar.markdown("---")
+    if st.sidebar.button("Logout"):
+        st.session_state['logged_in'] = False
+        st.session_state['username'] = None
+        st.rerun()
+
+    # --- PAGE: SUBMIT MODEL ---
+    if choice == "Submit Model":
+        st.header("🚀 Submit your Predictions")
+        
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            # st.info("Upload your CSV file. It must contain `id` and `prediction` columns.")
+            uploaded_file = st.file_uploader("Choose a CSV file", type="json")
+            
+            
+            if uploaded_file is not None:
+                save_path = f"./{uploaded_file.name}"  
+
+                # Write the file to the current directory
+                with open(save_path, "wb") as f:
+                    f.write(uploaded_file.getbuffer())
+
+                if st.button("Evaluate"):
+                    with st.spinner('Calculating score against Ground Truth...'):
+                        score = evaluate_submission("./biv_query.json", save_path)
+                        st.success(f"Score : {score}")
+                        if score is not None:
+                            save_submission(st.session_state['username'], score)
+                            st.balloons()
+                            st.success("Submission Successful!")
+                            
+                            # Display Metrics
+                            st.metric(label="Your Model Accuracy Score", value=f"{score}%")
+        
+        with col2:
+            st.markdown("### Sample Format")
+            st.dataframe(pd.DataFrame({'id': [1, 2], 'prediction': [100, 205]}), hide_index=True)
+
+    # --- PAGE: LEADERBOARD ---
+    elif choice == "Leaderboard":
+        
+        st.header("🏆 Leaderboard")
+        st.write("Rankings based on the highest accuracy score achieved.")
+        
+        df_leaderboard = get_leaderboard_data()
+        
+        if not df_leaderboard.empty:
+            # styling the leaderboard
+            st.dataframe(
+                df_leaderboard,
+                column_config={
+                    "username": "Participant",
+                    "best_accuracy": st.column_config.ProgressColumn(
+                        "Accuracy Score",
+                        format="%.2f%%",
+                        min_value=0,
+                        max_value=100,
+                    ),
+                    "last_submission": st.column_config.DatetimeColumn(
+                        "Last Active",
+                        format="D MMM YYYY, h:mm a",
+                    ),
+                },
+                use_container_width=True,
+                hide_index=True,
+            )
+        else:
+            st.info("No submissions yet. Be the first!")
+
+if __name__ == '__main__':
+    init_db()
+    
+    # Session State Initialization
+    if 'logged_in' not in st.session_state:
+        st.session_state['logged_in'] = False
+        st.session_state['username'] = None
+
+    if not st.session_state['logged_in']:
+        ui_login_signup()
+    else:
+        main_app()

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))