iteration 2

app.py

@@ -9,6 +9,8 @@ from datasets import get_dataset_infos
 from transformers import AutoConfig
 from huggingface_hub import whoami
 from typing import Optional, List, Tuple, Union
+# import threading  # DISABLED - was part of hanging database test functions
+# import time       # DISABLED - was part of hanging database test functions
 
 """
  Still TODO:
@@ -17,6 +19,16 @@ from typing import Optional, List, Tuple, Union
  - validate max model params
 """
 
+SUPPORTED_MODELS = [
+    "Qwen/Qwen3-4B-Instruct-2507",
+    "Qwen/Qwen3-30B-A3B-Instruct-2507",
+    "meta-llama/Llama-3.2-1B-Instruct",
+    "meta-llama/Llama-3.2-3B-Instruct",
+    "baidu/ERNIE-4.5-21B-A3B-Thinking",
+    "LLM360/K2-Think",
+    "openai/gpt-oss-20b",
+]
+
 
 def verify_pro_status(token: Optional[Union[gr.OAuthToken, str]]) -> bool:
     """Verifies if the user is a Hugging Face PRO user or part of an enterprise org."""
@@ -127,8 +139,34 @@ def validate_request(request: GenerationRequest, oauth_token: Optional[Union[gr.
     try:
         output_dataset_info = get_dataset_infos(request.output_dataset_name, token=request.output_dataset_token)
         raise Exception(f"Output dataset {request.output_dataset_name} already exists. Please choose a different name.")
-    except Exception as e:
+    except Exception:
         pass  # dataset does not exist, which is expected
+    
+    # check the output dataset name doesn't already exist in the database
+    try:
+        url = os.getenv("SUPABASE_URL")
+        key = os.getenv("SUPABASE_KEY")
+        
+        if url and key:
+            supabase = create_client(
+                url,
+                key,
+                options=ClientOptions(
+                    postgrest_client_timeout=10,
+                    storage_client_timeout=10,
+                    schema="public",
+                )
+            )
+            
+            existing_request = supabase.table("gen-requests").select("id").eq("output_dataset_name", request.output_dataset_name).execute()
+            if existing_request.data:
+                raise Exception(f"Output dataset {request.output_dataset_name} is already being generated or has been requested. Please choose a different name.")
+    except Exception as e:
+        # If it's our custom exception about dataset already existing, re-raise it
+        if "already being generated" in str(e):
+            raise e
+        # Otherwise, ignore database connection errors and continue
+        pass
 
     # check the models exists
     try:
@@ -205,6 +243,44 @@ def add_request_to_db(request: GenerationRequest):
         raise Exception("Failed to add request to database")
 
 
+
+
+def get_generation_stats_safe():
+    """Safely fetch generation request statistics with proper error handling"""
+    try:
+        url = os.getenv("SUPABASE_URL")
+        key = os.getenv("SUPABASE_KEY")
+        
+        if not url or not key:
+            raise Exception("Missing SUPABASE_URL or SUPABASE_KEY environment variables")
+        
+        supabase = create_client(
+            url,
+            key,
+            options=ClientOptions(
+                postgrest_client_timeout=10,
+                storage_client_timeout=10,
+                schema="public",
+            )
+        )
+        
+        # Fetch data excluding sensitive token fields
+        response = supabase.table("gen-requests").select(
+            "id, created_at, status, input_dataset_name, input_dataset_config, "
+            "input_dataset_split, output_dataset_name, prompt_column, "
+            "model_name_or_path, model_revision, max_tokens, temperature, "
+            "top_k, top_p, username, num_output_examples, private"
+        ).order("created_at", desc=True).limit(50).execute()
+        
+        return {"status": "success", "data": response.data}
+        
+    except Exception as e:
+        return {"status": "error", "message": str(e), "data": []}
+
+
+# Old commented code removed - replaced with DatabaseManager and get_generation_stats_safe()
+
+
 def main():
     with gr.Blocks(title="Synthetic Data Generation") as demo:
         gr.HTML("<h3 style='text-align:center'>Generate synthetic data with AI models. Free to use! Sign in for PRO benefits (10k samples vs 100). <a href='http://huggingface.co/subscribe/pro?source=synthetic-data-universe' target='_blank'>Upgrade to PRO</a></h3>", elem_id="sub_title")
@@ -230,7 +306,7 @@ def main():
                     Welcome to the Synthetic Data Generation service! This tool allows you to generate synthetic data using large language models. Generation is FREE for Hugging Face PRO users and uses idle GPUs on the HF science cluster.\n
                     Outputs from this service will be PUBLIC and available on the Hugging Face Hub under the organization [synthetic-data-universe](https://huggingface.co/synthetic-data-universe).\n
                     """)
-            with gr.Accordion("How it works", open=False):
+            with gr.Accordion("More Information", open=False):
                 with gr.Row():
                     gr.Markdown("""
                     **How it works:**
@@ -255,20 +331,9 @@ def main():
                         with gr.Column():
                             with gr.Row():
                                 model_name_or_path = gr.Dropdown(
-                                    choices=[
-                                        "microsoft/Phi-3.5-mini-instruct",
-                                        "Qwen/Qwen2.5-7B-Instruct", 
-                                        "meta-llama/Llama-3.2-8B-Instruct",
-                                        "mistralai/Mistral-7B-Instruct-v0.3",
-                                        "google/gemma-2-9b-it",
-                                        "microsoft/DialoGPT-medium",
-                                        "HuggingFaceH4/zephyr-7b-beta",
-                                        "teknium/OpenHermes-2.5-Mistral-7B",
-                                        "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",
-                                        "01-ai/Yi-34B-Chat"
-                                    ],
+                                    choices=SUPPORTED_MODELS,
                                     label="Select Model",
-                                    value="microsoft/Phi-3.5-mini-instruct",
+                                    value="Qwen/Qwen3-4B-Instruct-2507",
                                     info="Choose from popular instruction-tuned models under 40B parameters"
                                 )
                             # model_token = gr.Textbox(label="Model Token (Optional)", type="password", placeholder="Your HF token with read/write access to the model...")
@@ -317,9 +382,102 @@ def main():
                     submit_btn = gr.Button("Submit Generation Request", variant="primary")
                     output_status = gr.Textbox(label="Status", interactive=False)
                 
-                with gr.TabItem("Coming Soon"):
-                    gr.Markdown("## New features coming soon!")
-                    gr.Markdown("This tab will contain additional functionality in future updates.")
+                with gr.TabItem("Statistics Dashboard"):
+                    gr.Markdown("## Generation Requests Statistics")
+                    gr.Markdown("📊 View recent synthetic data generation requests and their status.")
+                    
+                    with gr.Row():
+                        refresh_stats_btn = gr.Button("🔄 Refresh Statistics", size="sm", variant="secondary")
+                        clear_stats_btn = gr.Button("🗑️ Clear Display", size="sm")
+                    
+                    stats_status = gr.Markdown("Click 'Refresh Statistics' to load recent generation requests.", visible=True)
+                    
+                    stats_dataframe = gr.Dataframe(
+                        headers=["ID", "Created", "Status", "Input Dataset", "Output Dataset", "Model", "Samples", "User"],
+                        datatype=["str", "str", "str", "str", "str", "str", "number", "str"],
+                        interactive=False,
+                        wrap=True,
+                        value=[],
+                        label="Recent Generation Requests (Last 50)",
+                        visible=False
+                    )
+                    
+                    def load_statistics():
+                        """Load and format statistics data"""
+                        try:
+                            # Use the new safe database function
+                            result = get_generation_stats_safe()
+                            
+                            if result["status"] == "error":
+                                return (
+                                    f"❌ **Error loading statistics**: {result['message']}",
+                                    gr.update(visible=False),
+                                    gr.update(visible=True)
+                                )
+                            
+                            data = result["data"]
+                            if not data:
+                                return (
+                                    "📝 **No data found**: The database appears to be empty or the table doesn't exist yet.",
+                                    gr.update(visible=False),
+                                    gr.update(visible=True)
+                                )
+                            
+                            # Format data for display
+                            formatted_data = []
+                            for item in data:
+                                # Format timestamp
+                                created_at = item.get('created_at', 'Unknown')
+                                if created_at and created_at != 'Unknown':
+                                    try:
+                                        from datetime import datetime
+                                        dt = datetime.fromisoformat(created_at.replace('Z', '+00:00'))
+                                        created_at = dt.strftime('%Y-%m-%d %H:%M')
+                                    except:
+                                        pass
+                                
+                                formatted_data.append([
+                                    str(item.get('id', ''))[:8] + "..." if len(str(item.get('id', ''))) > 8 else str(item.get('id', '')),
+                                    created_at,
+                                    item.get('status', 'Unknown'),
+                                    (item.get('input_dataset_name', '')[:30] + "...") if len(item.get('input_dataset_name', '')) > 30 else item.get('input_dataset_name', ''),
+                                    (item.get('output_dataset_name', '')[:30] + "...") if len(item.get('output_dataset_name', '')) > 30 else item.get('output_dataset_name', ''),
+                                    (item.get('model_name_or_path', '')[:25] + "...") if len(item.get('model_name_or_path', '')) > 25 else item.get('model_name_or_path', ''),
+                                    item.get('num_output_examples', 0),
+                                    item.get('username', 'Anonymous')
+                                ])
+                            
+                            return (
+                                f"✅ **Statistics loaded successfully**: Found {len(formatted_data)} recent requests.",
+                                gr.update(value=formatted_data, visible=True),
+                                gr.update(visible=True)
+                            )
+                            
+                        except Exception as e:
+                            return (
+                                f"❌ **Unexpected error**: {str(e)}",
+                                gr.update(visible=False),
+                                gr.update(visible=True)
+                            )
+                    
+                    def clear_statistics():
+                        """Clear the statistics display"""
+                        return (
+                            "Click 'Refresh Statistics' to load recent generation requests.",
+                            gr.update(value=[], visible=False),
+                            gr.update(visible=True)
+                        )
+                    
+                    # Connect buttons to functions
+                    refresh_stats_btn.click(
+                        load_statistics,
+                        outputs=[stats_status, stats_dataframe, stats_status]
+                    )
+                    
+                    clear_stats_btn.click(
+                        clear_statistics,
+                        outputs=[stats_status, stats_dataframe, stats_status]
+                    )
 
             def submit_request(input_dataset_name, input_split, input_dataset_config, output_dataset_name, prompt_col, model_name, model_rev, sys_prompt,
                                 max_tok, temp, top_k_val, top_p_val, email_addr, num_output_samples, oauth_token=None):