fixed main

main.py

@@ -1,49 +1,35 @@
 # main.py
-
-import subprocess
-import sys
-import webbrowser
-import time
 import gradio as gr
+from gradio.themes import Soft
 import spaces
+
 from question_runner import run_tool
 from config import MODEL_PRIORITY, SYNTAX_DOC_URL, MORPHOLOGY_DOC_URL
 from doc_utils import get_questions_from_doc
 
-# Auto-install required packages if missing
-def install_missing_packages():
-    from importlib.metadata import distributions
-    required = {"gradio", "requests"}
-    installed = {dist.metadata['Name'].lower() for dist in distributions()}
-    missing = required - installed
-
-    if missing:
-        print(f"Installing missing packages: {missing}")
-        subprocess.check_call([sys.executable, "-m", "pip", "install", *missing])
-
-install_missing_packages()
+# --- ZERO-GPU ENTRYPOINT (must be top-level and referenced by Gradio) ---
+@spaces.GPU
+def run_query(passage: str, doc_type: str):
+    # Delegate to your existing business logic
+    return run_tool(passage, doc_type)
 
 # Estimate runtime based on # of questions
 def estimate_runtime(passage, doc_type):
-    if not passage.strip() or not doc_type:
+    if not passage or not doc_type:
         return ""
     doc_url = SYNTAX_DOC_URL if doc_type.lower() == "syntax" else MORPHOLOGY_DOC_URL
     questions = get_questions_from_doc(doc_url)
-    if not questions or questions[0].startswith("Error"):
+    if not questions or (isinstance(questions, list) and questions and str(questions[0]).startswith("Error")):
         return "Unable to load questions."
     est_seconds = round(len(questions) * 2.5, 1)
     return f"Estimated generation time: ~{est_seconds} seconds"
 
-def launch_app():
-    with gr.Blocks(theme="soft") as demo:
+def build_app():
+    with gr.Blocks(theme=Soft()) as demo:
         gr.Markdown("""
         ## **Classical Language Query Assistant**
         Submit a Latin or Greek passage and select the question type.
         Answers are generated using a rotating chain of hosted AI models via OpenRouter.
-
-        - Models are attempted in descending priority, starting from the most accurate.
-        - The model that answers each question is recorded in the response.
-        - Model quota or errors may trigger automatic fallback to the next-best option.
         """)
 
         with gr.Row():
@@ -52,8 +38,7 @@ def launch_app():
 
         top_model = MODEL_PRIORITY[0]
         full_model_list = "\n".join(f"- `{m}`" for m in MODEL_PRIORITY)
-        demo_model_info = gr.Markdown(
-            f"""
+        gr.Markdown(f"""
 **Currently prioritized model:** `{top_model}`  
 **Model fallback chain (if needed):**  
 {full_model_list}
@@ -65,26 +50,20 @@ def launch_app():
 
         estimated_time_box = gr.Textbox(label="Estimated Time", interactive=False)
 
-        # Trigger time estimate dynamically
         passage_input.change(fn=estimate_runtime, inputs=[passage_input, question_type], outputs=estimated_time_box)
         question_type.change(fn=estimate_runtime, inputs=[passage_input, question_type], outputs=estimated_time_box)
 
         submit_button = gr.Button("Generate Answers")
 
+        # IMPORTANT: point Gradio at the decorated function
         submit_button.click(
-            fn=run_tool,
+            fn=run_query,
             inputs=[passage_input, question_type],
-            outputs=[output_text, output_file, estimated_time_box]
+            outputs=[output_text, output_file, estimated_time_box],
         )
-
-        # Launch app and open browser
-        _, _, share_url = demo.launch(share=True, prevent_thread_lock=True)
-        if share_url:
-            webbrowser.open(share_url)
-
-        # Keep app running
-        while True:
-            time.sleep(1)
+    return demo
 
 if __name__ == "__main__":
-    launch_app()
+    # On Spaces: no share=True, no webbrowser.open, no infinite loop
+    app = build_app()
+    app.launch()