Delete question_runner.py

question_runner.py

@@ -1,226 +0,0 @@
-# question_runner.py
-
-import tempfile
-import re
-from router_client import query_model
-from doc_utils import get_questions_from_doc
-from config import SYNTAX_DOC_URL, MORPHOLOGY_DOC_URL, SEMANTICS_DOC_URL
-
-
-def detect_language(passage):
-    """
-    Detect whether the passage is in Latin or Greek based on character analysis.
-    
-    Returns:
-        str: 'latin', 'greek', or 'unknown'
-    """
-    # Remove whitespace, punctuation, and numbers for analysis
-    import string
-    punctuation_and_whitespace = set(string.punctuation + string.whitespace + string.digits)
-    cleaned = ''.join(char for char in passage if char not in punctuation_and_whitespace)
-    
-    # Greek alphabet ranges (Unicode)
-    greek_chars = re.findall(r'[\u0370-\u03FF\u1F00-\u1FFF]', cleaned)
-    
-    # Latin alphabet - look for standard Latin letters
-    # Greek text might have some Latin, so we check for Greek-specific patterns
-    latin_chars = re.findall(r'[a-zA-Z]', cleaned)
-    
-    if not cleaned:
-        return 'unknown'
-    
-    # If we find Greek characters, it's Greek
-    if greek_chars and len(greek_chars) > len(cleaned) * 0.3:  # At least 30% Greek chars
-        return 'greek'
-    
-    # Otherwise assume Latin if it has Latin characters
-    if latin_chars and len(latin_chars) > len(cleaned) * 0.3:
-        return 'latin'
-    
-    return 'unknown'
-
-
-def get_language_specific_instructions(language, doc_type):
-    """
-    Generate language-specific instructions to prevent AI hallucinations
-    and incorrect application of grammatical rules.
-    
-    Args:
-        language: 'latin' or 'greek'
-        doc_type: 'syntax', 'morphology', or 'semantics'
-    
-    Returns:
-        str: Language-specific instruction text
-    """
-    if language == 'latin':
-        if doc_type.lower() == 'morphology':
-            return """You are a Latin morphology expert. When analyzing Latin:
-- Focus ONLY on Latin grammatical categories: tense, mood, voice, person, number, case, gender
-- Use traditional Latin grammatical terminology
-- Do NOT apply Greek-specific concepts like the dual number (which does not exist in Latin)
-- Do NOT apply Greek-specific mood distinctions
-- Remember Latin has 6 cases (nominative, genitive, dative, accusative, ablative, vocative)
-- Remember Latin verb system: 6 tenses, 3 moods (indicative, subjunctive, imperative), 3 voices"""
-        elif doc_type.lower() == 'syntax':
-            return """You are a Latin syntax expert. When analyzing Latin:
-- Apply ONLY Latin syntactic rules and conventions
-- Focus on Latin clause structure, agreement patterns, and word order principles
-- Do NOT assume Greek syntactic conventions (e.g., Greek subjunctive/optative patterns may differ)
-- Remember Latin typically uses SVO/SOV word order with flexible positioning
-- Apply Roman conventions for subordination and clause relationships
-- Do NOT apply Modern Greek or Koine Greek-specific syntax patterns"""
-        else:  # semantics
-            return """You are a Latin semantics expert. When analyzing Latin meaning:
-- Focus on etymological and semantic fields relevant to Latin
-- Use Roman cultural context to interpret meaning
-- Do NOT apply Greek philosophical or semantic frameworks that may not apply to Latin texts
-- Consider the historical period of the text (Classical, Silver Age, etc.)
-- Remember Latin word meanings evolved differently from their Greek cognates"""
-    
-    elif language == 'greek':
-        if doc_type.lower() == 'morphology':
-            return """You are an Ancient Greek morphology expert. When analyzing Ancient Greek:
-- Focus ONLY on Ancient Greek grammatical categories: tense, mood, voice, person, number, case, gender, dual
-- Use Attic/Ionic Greek conventions as appropriate to the text
-- Remember Greek HAS the dual number (in addition to singular and plural)
-- Remember Greek has 3 moods: indicative, subjunctive, optative
-- Remember Greek has 5 cases (nominative, genitive, dative, accusative, vocative)
-- Do NOT apply Latin-specific grammatical categories (Latin lacks dual, has different mood system)"""
-        elif doc_type.lower() == 'syntax':
-            return """You are an Ancient Greek syntax expert. When analyzing Ancient Greek:
-- Apply ONLY Ancient Greek syntactic rules and conventions
-- Focus on Greek clause structure, participle usage, and optative/subjunctive patterns
-- Do NOT assume Latin syntactic conventions (Latin lacks Greek optative, uses subjunctive differently)
-- Remember Greek favors parataxis and uses participles extensively
-- Apply Greek conventions for indirect discourse and optative in conditional sentences
-- Do NOT apply Latin syntax patterns"""
-        else:  # semantics
-            return """You are an Ancient Greek semantics expert. When analyzing Greek meaning:
-- Focus on etymological and semantic fields relevant to Ancient Greek
-- Use Hellenic cultural and philosophical context to interpret meaning
-- Do NOT apply Roman cultural frameworks that may not apply to Greek texts
-- Consider whether the text is Attic, Ionic, or another Greek dialect
-- Remember Greek philosophical terminology has specific meanings distinct from Latin usage"""
-    
-    else:  # unknown language
-        return """You are a classical language expert analyzing a passage of unknown classical language.
-- First identify whether the text is in Latin or Greek
-- Then apply only the grammatical and syntactic rules appropriate to that language
-- Be careful not to mix grammatical conventions between Latin and Greek
-- If unable to determine, ask for clarification"""
-
-
-def create_language_aware_prompt(passage, question, language):
-    """
-    Create a prompt that is aware of the language and specific doc type.
-    
-    Args:
-        passage: The text to analyze
-        question: The question to answer
-        language: 'latin', 'greek', or 'unknown'
-    
-    Returns:
-        str: The complete prompt
-    """
-    language_context = {
-        'latin': 'Latin',
-        'greek': 'Ancient Greek',
-        'unknown': 'Latin or Greek'
-    }[language]
-    
-    prompt = f"""You are a classical language expert specializing in {language_context}.
-
-LANGUAGE IDENTIFIED: {language.upper()}
-
-Given the following {language_context} passage:
-
-{passage}
-
-Answer the following question concisely and directly:
-
-{question}
-
-IMPORTANT GUIDELINES:
-- Only apply grammatical and syntactic rules specific to {language_context}
-- Do not confuse or mix conventions from Latin and Greek
-- If the question asks about a grammatical feature that doesn't exist in {language_context}, note that explicitly
-- Be precise about which language's conventions you are applying
-- Provide ONLY your direct answer without explanation of your reasoning process
-- Do NOT repeat the question or reiterate the principles you're using
-- Keep your answer brief and focused
-
-Answer:"""
-    
-    return prompt
-
-
-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 'Syntax', 'Morphology', or 'Semantics'.", None, None
-
-    try:
-        # Detect the language of the passage
-        language = detect_language(passage)
-        
-        if doc_type.lower() == "syntax":
-            doc_url = SYNTAX_DOC_URL
-        elif doc_type.lower() == "morphology":
-            doc_url = MORPHOLOGY_DOC_URL
-        else:  # semantics
-            doc_url = SEMANTICS_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):
-            # Get language-specific instructions
-            language_instructions = get_language_specific_instructions(language, doc_type)
-            
-            # Create language-aware prompt
-            base_prompt = create_language_aware_prompt(passage, question, language)
-            
-            # Combine with language-specific instructions
-            prompt = f"""{language_instructions}
-
----
-
-{base_prompt}"""
-
-            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.>
-Language Detected: {language.upper()}
-===
-"""
-            else:
-                answer = raw_response.split("Answer:")[-1].strip()
-                formatted_block = f"""Question: {question.strip()}
-Answer:
-{answer}
-Language Detected: {language.upper()}
-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
-