vibe coded

README.md

@@ -9,4 +9,31 @@ app_file: app.py
 pinned: false
 ---
 
+# VLA Foundry Database Viewer
+
+Interactive visualization tool for exploring the VLA Foundry database from the [TRI-ML/vla_foundry_database](https://huggingface.co/datasets/TRI-ML/vla_foundry_database) dataset.
+
+## Features
+
+- 📊 **Interactive Table Viewer**: Browse all tables in the database
+- 🔍 **Search**: Search across all columns in the selected table
+- 🎯 **Filter**: Filter by specific columns (show non-null values)
+- 🔄 **Sort**: Sort by any column in ascending or descending order
+- 📈 **Table Info**: View table statistics (row count, column count, column names)
+
+## Usage
+
+1. Select a table from the dropdown menu
+2. Use the search box to find specific entries
+3. Filter by column to focus on specific data
+4. Sort by any column to organize the data
+5. Click "Clear Filters" to reset all filters
+
+## Local Development
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,190 @@
+import gradio as gr
+import sqlite3
+import pandas as pd
+from huggingface_hub import hf_hub_download
+import os
+
+# Download the database from HF dataset
+def download_database():
+    """Download vla_foundry.db from the HF dataset"""
+    try:
+        db_path = hf_hub_download(
+            repo_id="TRI-ML/vla_foundry_database",
+            filename="vla_foundry.db",
+            repo_type="dataset"
+        )
+        return db_path
+    except Exception as e:
+        print(f"Error downloading database: {e}")
+        return None
+
+# Load data from database
+def load_database_tables(db_path):
+    """Load all tables from the database"""
+    if not db_path or not os.path.exists(db_path):
+        return {}, []
+
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+
+    # Get all table names
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+    tables = [row[0] for row in cursor.fetchall()]
+
+    # Load each table into a DataFrame
+    table_data = {}
+    for table in tables:
+        try:
+            df = pd.read_sql_query(f"SELECT * FROM {table}", conn)
+            table_data[table] = df
+        except Exception as e:
+            print(f"Error loading table {table}: {e}")
+
+    conn.close()
+    return table_data, tables
+
+# Initialize database
+db_path = download_database()
+table_data, table_names = load_database_tables(db_path)
+
+# Function to get table data with filters
+def get_filtered_data(table_name, search_query="", column_filter="All", sort_column="", sort_order="Ascending"):
+    """Get filtered and sorted data from selected table"""
+    if table_name not in table_data:
+        return pd.DataFrame()
+
+    df = table_data[table_name].copy()
+
+    # Apply search filter
+    if search_query.strip():
+        # Search across all columns
+        mask = df.astype(str).apply(lambda x: x.str.contains(search_query, case=False, na=False)).any(axis=1)
+        df = df[mask]
+
+    # Apply column-specific filter
+    if column_filter != "All" and column_filter in df.columns:
+        # Show only rows where the selected column has non-null values
+        df = df[df[column_filter].notna()]
+
+    # Apply sorting
+    if sort_column and sort_column in df.columns:
+        ascending = (sort_order == "Ascending")
+        df = df.sort_values(by=sort_column, ascending=ascending)
+
+    return df
+
+def update_column_choices(table_name):
+    """Update column choices based on selected table"""
+    if table_name not in table_data:
+        return gr.update(choices=["All"]), gr.update(choices=[])
+
+    columns = ["All"] + list(table_data[table_name].columns)
+    return gr.update(choices=columns, value="All"), gr.update(choices=list(table_data[table_name].columns), value="")
+
+def get_table_info(table_name):
+    """Get information about the selected table"""
+    if table_name not in table_data:
+        return "No table selected"
+
+    df = table_data[table_name]
+    info = f"**Table: {table_name}**\n\n"
+    info += f"- Total rows: {len(df)}\n"
+    info += f"- Total columns: {len(df.columns)}\n"
+    info += f"- Columns: {', '.join(df.columns)}\n"
+
+    return info
+
+# Create Gradio interface
+with gr.Blocks(title="VLA Foundry Database Viewer") as demo:
+    gr.Markdown("# 🤖 VLA Foundry Database Viewer")
+    gr.Markdown("Explore the VLA Foundry database with searchable, filterable, and sortable tables.")
+
+    if not table_data:
+        gr.Markdown("⚠️ **Error**: Could not load database. Please check if the database file exists in the dataset.")
+    else:
+        with gr.Row():
+            with gr.Column(scale=1):
+                table_selector = gr.Dropdown(
+                    choices=table_names,
+                    label="Select Table",
+                    value=table_names[0] if table_names else None
+                )
+                table_info = gr.Markdown(
+                    value=get_table_info(table_names[0]) if table_names else ""
+                )
+
+                gr.Markdown("### Filters")
+                search_box = gr.Textbox(
+                    label="Search (across all columns)",
+                    placeholder="Enter search term...",
+                    value=""
+                )
+                column_filter = gr.Dropdown(
+                    choices=["All"],
+                    label="Filter by Column (show non-null)",
+                    value="All"
+                )
+
+                gr.Markdown("### Sorting")
+                sort_column = gr.Dropdown(
+                    choices=[],
+                    label="Sort by Column",
+                    value=""
+                )
+                sort_order = gr.Radio(
+                    choices=["Ascending", "Descending"],
+                    label="Sort Order",
+                    value="Ascending"
+                )
+
+                clear_btn = gr.Button("Clear Filters")
+
+            with gr.Column(scale=3):
+                data_table = gr.Dataframe(
+                    value=table_data[table_names[0]] if table_names else pd.DataFrame(),
+                    label="Table Data",
+                    interactive=False,
+                    wrap=True,
+                    height=600
+                )
+
+        # Event handlers
+        def update_table(table_name, search, col_filter, sort_col, sort_ord):
+            filtered_df = get_filtered_data(table_name, search, col_filter, sort_col, sort_ord)
+            info = get_table_info(table_name)
+            return filtered_df, info
+
+        # Update columns when table changes
+        table_selector.change(
+            fn=update_column_choices,
+            inputs=[table_selector],
+            outputs=[column_filter, sort_column]
+        ).then(
+            fn=update_table,
+            inputs=[table_selector, search_box, column_filter, sort_column, sort_order],
+            outputs=[data_table, table_info]
+        )
+
+        # Update table when filters/sorting change
+        for component in [search_box, column_filter, sort_column, sort_order]:
+            component.change(
+                fn=update_table,
+                inputs=[table_selector, search_box, column_filter, sort_column, sort_order],
+                outputs=[data_table, table_info]
+            )
+
+        # Clear filters
+        def clear_filters():
+            return "", "All", "", "Ascending"
+
+        clear_btn.click(
+            fn=clear_filters,
+            outputs=[search_box, column_filter, sort_column, sort_order]
+        ).then(
+            fn=update_table,
+            inputs=[table_selector, search_box, column_filter, sort_column, sort_order],
+            outputs=[data_table, table_info]
+        )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio==6.1.0
+pandas
+huggingface_hub