Upload 7 files

README.md

@@ -1,13 +1,23 @@
----
-title: AIClassicsQueryTool
-emoji: 🐠
-colorFrom: purple
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Classical Language Query Assistant
+
+This app uses modern AI models to answer grammatical and syntactic questions about Latin and Greek passages. It's designed for use in research and pedagogy, especially in classical language instruction.
+
+## Features
+- Supports Syntax and Morphology question sets
+- Pulls questions live from shared Google Docs
+- Uses Claude 3, GPT-3.5, and other fallback models via OpenRouter
+- Automatically attributes which model answered each question
+
+## How to Run
+1. Clone or download this repo  
+2. Install dependencies and launch the app:
+
+   ```bash
+   pip install -r requirements.txt
+   python main.py
+   ```
+
+The app will open automatically in your browser with a public Gradio link.
+
+## Configuration
+API keys, model priorities, and document URLs can be adjusted in `config.py`.

config.py

@@ -0,0 +1,20 @@
+# config.py
+
+# === API SETTINGS ===
+OPENROUTER_API_KEY = "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"
+OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions"
+
+# === GOOGLE DOCS INPUT ===
+SYNTAX_DOC_URL = "https://docs.google.com/document/d/1Fx81TMaGh_s6vuOqG-6y9WVpVULriO6NrKovcrxqzmA/export?format=txt"
+MORPHOLOGY_DOC_URL = "https://docs.google.com/document/d/1pk3CBDM2Vov2tGsfwxIlJp4h2QpPOEYuaqMpBSdBShw/export?format=txt"
+
+# === MODEL PRIORITY ===
+# Ordered from best to weakest. Will try top → bottom until one succeeds.
+MODEL_PRIORITY = [
+    "anthropic/claude-3-haiku",
+    "openai/gpt-3.5-turbo",
+    "nousresearch/nous-hermes-2-mistral",
+    "meta-llama/llama-3-8b-instruct",
+    "mistralai/mistral-7b-instruct",
+    "gryphe/mythomax-l2-13b"
+]

doc_utils.py

@@ -0,0 +1,13 @@
+# doc_utils.py
+
+import requests
+
+def get_questions_from_doc(url):
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+        text = response.text
+        questions = [line.strip() for line in text.splitlines() if line.strip().endswith('?')]
+        return questions
+    except Exception as e:
+        return [f"Error loading questions: {e}"]

main.py

@@ -0,0 +1,89 @@
+# main.py
+
+import subprocess
+import sys
+import webbrowser
+import time
+import gradio as gr
+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()
+
+# Estimate runtime based on # of questions
+def estimate_runtime(passage, doc_type):
+    if not passage.strip() 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"):
+        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:
+        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():
+            passage_input = gr.Textbox(label="Latin or Greek Passage", lines=4)
+            question_type = gr.Radio(["Syntax", "Morphology"], label="Question Type")
+
+        top_model = MODEL_PRIORITY[0]
+        full_model_list = "\n".join(f"- `{m}`" for m in MODEL_PRIORITY)
+        demo_model_info = gr.Markdown(
+            f"""
+**Currently prioritized model:** `{top_model}`  
+**Model fallback chain (if needed):**  
+{full_model_list}
+""")
+
+        with gr.Row():
+            output_text = gr.Textbox(label="Generated Answers", lines=25, interactive=False)
+            output_file = gr.File(label="Download Answers (.txt)", interactive=False)
+
+        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")
+
+        submit_button.click(
+            fn=run_tool,
+            inputs=[passage_input, question_type],
+            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)
+
+if __name__ == "__main__":
+    launch_app()

question_runner.py

@@ -0,0 +1,65 @@
+# question_runner.py
+
+import tempfile
+from router_client import query_model
+from doc_utils import get_questions_from_doc
+from config import SYNTAX_DOC_URL, MORPHOLOGY_DOC_URL
+
+def run_tool(passage, doc_type):
+    if not passage.strip():
+        return "Please enter a passage to analyze.", None, None
+    if not doc_type:
+        return "Please select either 'Syntax' or 'Morphology'.", None, None
+
+    try:
+        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"):
+            return questions[0], None, None
+
+        est_seconds = round(len(questions) * 2.5, 1)
+        estimated_time_message = f"Estimated generation time: ~{est_seconds} seconds"
+
+        responses = []
+        for idx, question in enumerate(questions):
+            prompt = f"""You are a classical language expert.
+
+Given the following Latin or Greek passage:
+
+{passage}
+
+Answer the following question:
+
+{question}
+
+Answer:"""
+
+            raw_response, model_used = query_model(prompt)
+
+            if not raw_response or not model_used:
+                formatted_block = f"""Question: {question.strip()}
+Answer:
+<No answer – all models failed or quota exceeded.>
+===
+"""
+            else:
+                answer = raw_response.split("Answer:")[-1].strip()
+                formatted_block = f"""Question: {question.strip()}
+Answer:
+{answer}
+Model used: {model_used}
+==="""  # Separator for logic tree parsing
+
+            responses.append(formatted_block)
+
+        result = "\n\n".join(responses)
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".txt", mode="w", encoding="utf-8") as f:
+            f.write(result)
+            file_path = f.name
+
+        return result, file_path, estimated_time_message
+
+    except Exception as e:
+        return f"An error occurred: {str(e)}", None, None

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=4.0.0
+requests>=2.31.0

router_client.py

@@ -0,0 +1,35 @@
+# router_client.py
+
+import requests
+from config import OPENROUTER_API_KEY, OPENROUTER_API_URL, MODEL_PRIORITY
+
+def query_model(prompt):
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "Content-Type": "application/json"
+    }
+
+    for model in MODEL_PRIORITY:
+        try:
+            print(f"Trying model: {model}")
+            payload = {
+                "model": model,
+                "messages": [
+                    {"role": "system", "content": "You are a classical language expert. Answer clearly and precisely."},
+                    {"role": "user", "content": prompt}
+                ],
+                "temperature": 0.7,
+                "max_tokens": 1000
+            }
+
+            response = requests.post(OPENROUTER_API_URL, headers=headers, json=payload, timeout=60)
+            response.raise_for_status()
+
+            content = response.json()["choices"][0]["message"]["content"]
+            return content.strip(), model
+
+        except requests.exceptions.RequestException as e:
+            print(f"Model {model} failed: {e}")
+            continue
+
+    return "All models failed or quota exceeded.", None