no atd for now

app.py

@@ -2,7 +2,7 @@
 # ENGLISH LINGUISTICS HUB (CONSOLIDATED APP V23-EN)
 #
 # This script adapts the German Linguistics Hub for English analysis,
-# adding NLTK, Stanza, TextBlob, HanTa(EN), OEWN, OpenBLP, and AtD.
+# adding NLTK, Stanza, TextBlob, HanTa(EN), OEWN, and OpenBLP.
 # It maintains the exact same JSON output structure as the German app.
 #
 # ============================================================================
@@ -76,15 +76,6 @@ except ImportError:
     LT_AVAILABLE = False
     print("CRITICAL WARNING: `language-tool-python` library not found.")
 
-# --- After the Deadline (AtD) Import ---
-try:
-    import AtD
-    ATD_AVAILABLE = True
-    print("✓ Successfully imported pyAtD")
-except ImportError:
-    ATD_AVAILABLE = False
-    print("WARNING: `pyAtD` library not found. Grammar check will be LT-only.")
-
 # --- WordNet (wn) Import (for OEWN) ---
 try:
     import wn
@@ -194,10 +185,6 @@ STANZA_PIPELINE_LOCK = threading.Lock()
 NLTK_LEMMATIZER: Optional[WordNetLemmatizer] = None
 NLTK_LEMMATIZER_LOCK = threading.Lock()
 
-# --- After the Deadline (AtD) ---
-ATD_SERVICE: Optional[AtD.AtD] = None
-ATD_LOCK = threading.Lock()
-
 # --- Helper ---
 def _html_wrap(content: str, line_height: str = "2.0") -> str:
     return f'<div style="overflow-x:auto; border: 1px solid #e6e9ef; border-radius: 0.25rem; padding: 1rem; line-height: {line_height};">{content}</div>'
@@ -226,17 +213,78 @@ SPACY_MODEL_INFO: Dict[str, Tuple[str, str, str]] = {
     "de": ("German", "de_core_news_md", "spacy"),
     "es": ("Spanish", "es_core_news_md", "spacy"),
     "grc-proiel-trf": ("Ancient Greek (PROIEL TRF)", "grc_proiel_trf", "grecy"),
-    # ... (other models) ...
+    "grc-perseus-trf": ("Ancient Greek (Perseus TRF)", "grc_perseus_trf", "grecy"),
+    "grc_ner_trf": ("Ancient Greek (NER TRF)", "grc_ner_trf", "grecy"),
+    "grc-proiel-lg": ("Ancient Greek (PROIEL LG)", "grc_proiel_lg", "grecy"),
+    "grc-perseus-lg": ("Ancient Greek (Perseus LG)", "grc_perseus_lg", "grecy"),
+    "grc-proiel-sm": ("Ancient Greek (PROIEL SM)", "grc_proiel_sm", "grecy"),
+    "grc-perseus-sm": ("Ancient Greek (Perseus SM)", "grc_perseus_sm", "grecy"),
 }
 SPACY_UI_TEXT = {
-    "de": { "title": "# 🔍 Mehrsprachiger Morpho-Syntaktischer Analysator", "subtitle": "Analysieren Sie Texte...", "input_label": "Text eingeben", "...": "..." },
-    "en": { "title": "# 🔍 Multilingual Morpho-Syntactic Analyzer", "subtitle": "Analyze texts in...", "input_label": "Enter Text", "...": "..." },
-    "es": { "title": "# 🔍 Analizador Morfo-Sintáctico Multilingüe", "subtitle": "Analice textos en...", "input_label": "Introducir Texto", "...": "..." }
+    "de": {
+        "title": "# 🔍 Mehrsprachiger Morpho-Syntaktischer Analysator",
+        "subtitle": "Analysieren Sie Texte auf Deutsch, Englisch, Spanisch und Altgriechisch",
+        "ui_lang_label": "Benutzeroberflächensprache",
+        "model_lang_label": "Textsprache für Analyse",
+        "input_label": "Text eingeben",
+        "input_placeholder": "Geben Sie hier Ihren Text ein...",
+        "button_text": "Text analysieren",
+        "button_processing_text": "Verarbeitung läuft...",
+        "tab_graphic": "Grafische Darstellung",
+        "tab_table": "Tabelle",
+        "tab_json": "JSON",
+        "tab_ner": "Entitäten",
+        "html_label": "Abhängigkeitsparsing",
+        "table_label": "Morphologische Analyse",
+        "table_headers": ["Wort", "Lemma", "POS", "Tag", "Morphologie", "Abhängigkeit"],
+        "json_label": "JSON-Ausgabe",
+        "ner_label": "Benannte Entitäten",
+        "error_message": "Fehler: "
+    },
+    "en": {
+        "title": "# 🔍 Multilingual Morpho-Syntactic Analyzer",
+        "subtitle": "Analyze texts in German, English, Spanish, and Ancient Greek",
+        "ui_lang_label": "Interface Language",
+        "model_lang_label": "Text Language for Analysis",
+        "input_label": "Enter Text",
+        "input_placeholder": "Enter your text here...",
+        "button_text": "Analyze Text",
+        "button_processing_text": "Processing...",
+        "tab_graphic": "Graphic View",
+        "tab_table": "Table",
+        "tab_json": "JSON",
+        "tab_ner": "Entities",
+        "html_label": "Dependency Parsing",
+        "table_label": "Morphological Analysis",
+        "table_headers": ["Word", "Lemma", "POS", "Tag", "Morphology", "Dependency"],
+        "json_label": "JSON Output",
+        "ner_label": "Named Entities",
+        "error_message": "Error: "
+    },
+    "es": {
+        "title": "# 🔍 Analizador Morfo-Sintáctico Multilingüe",
+        "subtitle": "Analice textos en alemán, inglés, español y griego antiguo",
+        "ui_lang_label": "Idioma de la Interfaz",
+        "model_lang_label": "Idioma del Texto para Análisis",
+        "input_label": "Introducir Texto",
+        "input_placeholder": "Ingrese su texto aquí...",
+        "button_text": "Analizar Texto",
+        "button_processing_text": "Procesando...",
+        "tab_graphic": "Vista Gráfica",
+        "tab_table": "Tabla",
+        "tab_json": "JSON",
+        "tab_ner": "Entidades",
+        "html_label": "Análisis de Dependencias",
+        "table_label": "Análisis Morfológico",
+        "table_headers": ["Palabra", "Lema", "POS", "Etiqueta", "Morfología", "Dependencia"],
+        "json_label": "Salida JSON",
+        "ner_label": "Entidades Nombradas",
+        "error_message": "Error: "
+    }
 }
 SPACY_MODELS: Dict[str, Optional[spacy.Language]] = {}
 
 # --- Dependency Installation & Model Loading ---
-# (All spacy_... functions are identical to the German app)
 def spacy_install_spacy_transformers_once():
     """ Installs spacy-transformers, required for all _trf models. """
     marker_file = Path(".spacy_transformers_installed")
@@ -255,9 +303,40 @@ def spacy_install_spacy_transformers_once():
         return False
 
 def spacy_install_grecy_model_from_github(model_name: str) -> bool:
-    # ... (identical) ...
-    pass
-
+    """ Installs a greCy model from GitHub Release. """
+    marker_file = Path(f".{model_name}_installed")
+    if marker_file.exists():
+        print(f"✓ {model_name} already installed (marker found)")
+        return True
+    print(f"Installing grecy model: {model_name}...")
+    if model_name == "grc_proiel_trf":
+        wheel_filename = "grc_proiel_trf-3.7.5-py3-none-any.whl"
+    elif model_name in ["grc_perseus_trf", "grc_proiel_lg", "grc_perseus_lg",
+                        "grc_proiel_sm", "grc_perseus_sm", "grc_ner_trf"]:
+        wheel_filename = f"{model_name}-0.0.0-py3-none-any.whl"
+    else:
+        print(f"✗ Unknown grecy model: {model_name}")
+        return False
+    install_url = f"https://github.com/CrispStrobe/greCy/releases/download/v1.0-models/{wheel_filename}"
+    cmd = [sys.executable, "-m", "pip", "install", install_url, "--no-deps"]
+    print(f"Running: {' '.join(cmd)}")
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=900)
+        if result.stdout: print("STDOUT:", result.stdout)
+        if result.stderr: print("STDERR:", result.stderr)
+        print(f"✓ Successfully installed {model_name} from GitHub")
+        marker_file.touch()
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"✗ Installation subprocess FAILED with code {e.returncode}")
+        print("STDOUT:", e.stdout)
+        print("STDERR:", e.stderr)
+        return False
+    except Exception as e:
+        print(f"✗ Installation exception: {e}")
+        traceback.print_exc()
+        return False
+    
 def spacy_load_spacy_model(model_name: str) -> Optional[spacy.Language]:
     """Load or install a standard spaCy model."""
     try:
@@ -272,8 +351,24 @@ def spacy_load_spacy_model(model_name: str) -> Optional[spacy.Language]:
             return None
 
 def spacy_load_grecy_model(model_name: str) -> Optional[spacy.Language]:
-    # ... (identical) ...
-    pass
+    """ Load a grecy model, installing from GitHub if needed. """
+    if not spacy_install_grecy_model_from_github(model_name):
+        print(f"✗ Cannot load {model_name} because installation failed.")
+        return None
+    try:
+        print("Refreshing importlib to find new package...")
+        importlib.invalidate_caches()
+        try: importlib.reload(site)
+        except Exception: pass
+        print(f"Trying: spacy.load('{model_name}')")
+        nlp = spacy.load(model_name)
+        print(f"✓ Successfully loaded {model_name}")
+        return nlp
+    except Exception as e:
+        print(f"✗ Model {model_name} is installed but FAILED to load.")
+        print(f"   Error: {e}")
+        traceback.print_exc()
+        return None
 
 def spacy_initialize_models():
     """ Pre-load standard models and ensure _trf dependencies are ready. """
@@ -303,32 +398,77 @@ def spacy_initialize_models():
 
 def spacy_get_analysis(ui_lang: str, model_lang_key: str, text: str):
     """Analyze text and return results."""
-    # (Identical to German app)
     ui_config = SPACY_UI_TEXT.get(ui_lang.lower(), SPACY_UI_TEXT["en"])
-    error_prefix = ui_config["error_message"]
+    error_prefix = ui_config.get("error_message", "Error: ")
     try:
-        # ... (identical model loading logic) ...
+        if not text.strip():
+            return ([], [], "<p style='color: orange;'>No text provided.</p>", "<p>No text provided.</p>",
+                    gr.Button(value=ui_config.get("button_text", "Analyze"), interactive=True))
+        
         nlp = SPACY_MODELS.get(model_lang_key)
-        # ...
+        if nlp is None:
+            # Try loading one last time
+            if model_lang_key in SPACY_MODEL_INFO:
+                _, model_name, model_type = SPACY_MODEL_INFO[model_lang_key]
+                if model_type == 'grecy': nlp = spacy_load_grecy_model(model_name)
+                else: nlp = spacy_load_spacy_model(model_name)
+                SPACY_MODELS[model_lang_key] = nlp
+        
+        if nlp is None:
+             return ([], {"error": "Model load failed"}, "Error", "Error", gr.Button(interactive=True))
+
         doc = nlp(text)
-        # ... (identical dataframe/json/html output generation) ...
-        return ([], {}, "", "", gr.Button(value=ui_config["button_text"], interactive=True)) # Placeholder
+        dataframe_output = []
+        json_output = []
+        for token in doc:
+            lemma_str = token.lemma_
+            morph_str = str(token.morph) if token.morph else ''
+            dep_str = token.dep_ if doc.is_parsed else ''
+            tag_str = token.tag_ or ''
+            pos_str = token.pos_ or ''
+            json_output.append({
+                "word": token.text, "lemma": lemma_str, "pos": pos_str,
+                "tag": tag_str, "morphology": morph_str, "dependency": dep_str,
+                "is_stopword": token.is_stop
+            })
+            dataframe_output.append([token.text, lemma_str, pos_str, tag_str, morph_str, dep_str])
+        
+        html_dep_out = ""
+        if "parser" in nlp.pipe_names and doc.is_parsed:
+            try:
+                options = {"compact": True, "bg": "#ffffff", "color": "#000000", "font": "Source Sans Pro"}
+                html_svg = displacy.render(doc, style="dep", jupyter=False, options=options)
+                html_dep_out = _html_wrap(html_svg, line_height="2.5")
+            except Exception as e:
+                html_dep_out = f"<p>Visualization error: {e}</p>"
+        
+        html_ner_out = ""
+        if "ner" in nlp.pipe_names:
+            if doc.ents:
+                try:
+                    html_ner = displacy.render(doc, style="ent", jupyter=False)
+                    html_ner_out = _html_wrap(html_ner, line_height="2.5")
+                except Exception: html_ner_out = "<p>Error rendering NER</p>"
+            else: html_ner_out = "<p>No entities found.</p>"
+
+        return (dataframe_output, json_output, html_dep_out, html_ner_out,
+                gr.Button(value=ui_config.get("button_text", "Analyze"), interactive=True))
     except Exception as e:
         traceback.print_exc()
-        error_html = f"..."
-        return ([], {"error": str(e)}, error_html, error_html, gr.Button(value=ui_config["button_text"], interactive=True))
+        error_html = f"<div style='color: red;'>{error_prefix} {str(e)}</div>"
+        return ([], {"error": str(e)}, error_html, error_html, gr.Button(interactive=True))
 
 
 def spacy_update_ui(ui_lang: str):
     """Update UI language for the spaCy tab."""
-    # (Identical to German app)
-    pass
+    # Placeholder - actual implementation would update labels
+    return [gr.update()] * 14
 
 # ============================================================================
-# 4. GRAMMAR CHECKER LOGIC (LT + AtD)
+# 4. GRAMMAR CHECKER LOGIC (LanguageTool Only)
 # ============================================================================
 
-# --- Globals for LanguageTool (Adapted for multi-language) ---
+# --- Globals for LanguageTool ---
 LT_TOOL_INSTANCES: Dict[str, Optional[language_tool_python.LanguageTool]] = {}
 LT_TOOL_LOCK = threading.Lock()
 
@@ -338,7 +478,7 @@ def lt_get_language_tool(lang: str = 'en') -> Optional[language_tool_python.Lang
     if not LT_AVAILABLE:
         raise ImportError("language-tool-python library is not installed.")
 
-    lang_code = 'en-US' if lang == 'en' else 'de-DE' # <-- ENGLISH DEFAULT
+    lang_code = 'en-US' if lang == 'en' else 'de-DE'
 
     if lang_code in LT_TOOL_INSTANCES:
         return LT_TOOL_INSTANCES[lang_code]
@@ -387,55 +527,6 @@ def lt_check_grammar(text: str, lang: str = 'en') -> List[Dict[str, Any]]:
         traceback.print_exc()
         return [{"error": f"An unexpected error occurred: {str(e)}"}]
 
-# --- After the Deadline (AtD) Logic ---
-def atd_get_service() -> Optional[AtD.AtD]:
-    """ Thread-safe function to get AtD service. """
-    global ATD_SERVICE
-    if not ATD_AVAILABLE:
-        raise ImportError("pyAtD library is not installed.")
-    if ATD_SERVICE:
-        return ATD_SERVICE
-    with ATD_LOCK:
-        if ATD_SERVICE:
-            return ATD_SERVICE
-        try:
-            print("Initializing After the Deadline (AtD) service...")
-            ATD_SERVICE = AtD.AtD()
-            # Test call
-            _ = ATD_SERVICE.check("this is a test")
-            print("✓ AtD service initialized.")
-            return ATD_SERVICE
-        except Exception as e:
-            print(f"✗ FAILED to initialize AtD service: {e}")
-            return None
-
-def atd_check_grammar(text: str) -> List[Dict[str, Any]]:
-    """ Checks text using After the Deadline. """
-    try:
-        service = atd_get_service()
-        if not service:
-            return [{"error": "AtD service failed to initialize."}]
-        if not text or not text.strip():
-            return [{"info": "No text provided to check."}]
-            
-        errors = service.check(text)
-        error_list = []
-        for error in errors:
-            error_list.append({
-                "message": error.description,
-                "rule_id": error.type,
-                "category": error.url,
-                "incorrect_text": error.string,
-                "replacements": error.suggestions,
-                "offset": error.precontext_start,
-                "length": len(error.string)
-            })
-        if not error_list:
-            return [{"info": "No errors found!", "status": "perfect"}]
-        return error_list
-    except Exception as e:
-        return [{"error": f"AtD check failed: {str(e)}"}]
-
 # ============================================================================
 # 5. WORDNET THESAURUS LOGIC (OEWN)
 # ============================================================================
@@ -534,7 +625,6 @@ def wordnet_worker_loop():
 
 def wordnet_process_word_lookup(word: str, wn_instance: wn.Wordnet) -> Dict[str, Any]:
     """ Process a single word lookup. Runs in the worker thread. """
-    # (This function is identical to the German app)
     if not word or not word.strip():
         return {"info": "No word provided to check."}
     word = word.strip().lower()
@@ -583,7 +673,13 @@ def wordnet_start_worker():
         return
     wordnet_worker_thread = threading.Thread(target=wordnet_worker_loop, daemon=True, name="WordNetWorker")
     wordnet_worker_thread.start()
-    # ... (identical timeout logic) ...
+    timeout = 30
+    for _ in range(timeout * 10):
+        if wordnet_worker_state in (WordNetWorkerState.READY, WordNetWorkerState.ERROR):
+            break
+        threading.Event().wait(0.1)
+    if wordnet_worker_state != WordNetWorkerState.READY:
+        raise Exception("OdeNet Worker failed to initialize")
 
 # --- Public API (Adapted) ---
 def wordnet_get_thesaurus_info(word: str, lang: str = 'en') -> Dict[str, Any]:
@@ -807,7 +903,6 @@ def get_conceptnet_client() -> Optional[Client]:
 def conceptnet_get_relations(word: str, language: str = 'en') -> Dict[str, Any]:
     """
     Fetches relations from the cstr/conceptnet_normalized Gradio API.
-    (Identical robust V2 parser from German app)
     """
     if not GRADIO_CLIENT_AVAILABLE:
         return {"error": "`gradio_client` library is not installed."}
@@ -818,7 +913,6 @@ def conceptnet_get_relations(word: str, language: str = 'en') -> Dict[str, Any]:
     word_lower = word.strip().lower()
     cache_key = (word_lower, language)
     
-    # --- 1. Check Cache ---
     with CONCEPTNET_LOCK:
         if cache_key in CONCEPTNET_CACHE:
             log(f"ConceptNet: Found '{word_lower}' in cache.")
@@ -827,7 +921,6 @@ def conceptnet_get_relations(word: str, language: str = 'en') -> Dict[str, Any]:
     log(f"ConceptNet: Fetching '{word_lower}' from Gradio API...")
     
     try:
-        # --- 2. Call Gradio API ---
         client = get_conceptnet_client()
         if not client:
             return {"error": "ConceptNet Gradio Client is not available."}
@@ -841,9 +934,7 @@ def conceptnet_get_relations(word: str, language: str = 'en') -> Dict[str, Any]:
             api_name="/get_semantic_profile"
         )
         
-        # --- 3. Parse the Markdown Result (Robustly) ---
         relations_list = []
-        # ... (Identical parsing logic from German app) ...
         if not isinstance(result_markdown, str):
             raise TypeError(f"ConceptNet API returned type {type(result_markdown)}, expected str.")
 
@@ -877,7 +968,7 @@ def conceptnet_get_relations(word: str, language: str = 'en') -> Dict[str, Any]:
                     elif node2.lower() == word_lower and node1.lower() != word_lower:
                         other_node, direction = node1, "<-"
                     else:
-                        continue # Skip self-references
+                        continue
                         
                     relations_list.append({
                         "relation": relation, "direction": direction, "other_node": other_node,
@@ -887,7 +978,6 @@ def conceptnet_get_relations(word: str, language: str = 'en') -> Dict[str, Any]:
                 except Exception as e:
                     log(f"ConceptNet Parser: Error parsing line '{line}': {e}")
         
-        # --- 4. Finalize and Cache Result ---
         if not relations_list:
             final_result = {"info": f"No valid relations found for '{word_lower}'."}
         else:
@@ -910,7 +1000,7 @@ def openblp_get_relations(lemma: str) -> List[Dict[str, Any]]:
     Stub function to query OpenBLP. 
     Replace this with your actual OpenBLP database/API query.
     """
-    # --- !! Implement your OpenBLP query logic here !! ---
+    # Placeholder logic
     if lemma == "dog":
         return [
             {"relation": "HasProperty", "other_node": "loyal", "weight": 0.9, "source": "openblp"},
@@ -962,10 +1052,7 @@ def _hanta_pos_to_key(hanta_pos: str) -> Optional[str]:
     return None
 
 def _analyze_word_with_hanta_en(word: str, top_n: int) -> Dict[str, Any]:
-    """
-    (FALLBACK ENGINE 1) Analyzes a single word using HanTa (EN).
-    This function MUST return the standard JSON structure.
-    """
+    """ (FALLBACK ENGINE 1) Analyzes a single word using HanTa (EN). """
     if not HANTA_AVAILABLE: return {}
     print(f"\n[Word Encyclopedia] Running HanTa (EN) fallback for: \"{word}\"")
     final_result = {"input_word": word, "analysis": {}}
@@ -974,8 +1061,6 @@ def _analyze_word_with_hanta_en(word: str, top_n: int) -> Dict[str, Any]:
         tagger = hanta_get_tagger_en()
         if not tagger: return {}
         
-        # HanTa 'tag_word' gives all possibilities
-        # e.g., [('VBG', 0.9), ('NN', 0.1)]
         possible_tags = tagger.tag_word(word.lower())
         possible_tags.extend(tagger.tag_word(word.capitalize()))
         
@@ -985,8 +1070,6 @@ def _analyze_word_with_hanta_en(word: str, top_n: int) -> Dict[str, Any]:
             pos_key = _hanta_pos_to_key(hanta_pos)
             if not pos_key: continue
 
-            # Get the lemma for this specific POS analysis
-            # HanTa's 'analyze' gives the single best lemma
             raw_analysis = tagger.analyze(word.lower() if pos_key != 'noun' else word.capitalize())
             lemma = raw_analysis[0] # The lemma
             
@@ -995,7 +1078,6 @@ def _analyze_word_with_hanta_en(word: str, top_n: int) -> Dict[str, Any]:
             processed_lemmas_pos.add((lemma, pos_key))
             log(f"--- Analyzing HanTa (EN) path: lemma='{lemma}', pos='{pos_key}' ---")
             
-            # --- 1. Get Inflections (Pattern) ---
             pattern_block = {}
             if PATTERN_EN_AVAILABLE:
                 if pos_key == "noun": pattern_block = pattern_analyze_as_noun_en(lemma)
@@ -1003,12 +1085,10 @@ def _analyze_word_with_hanta_en(word: str, top_n: int) -> Dict[str, Any]:
                 elif pos_key == "adjective": pattern_block = pattern_analyze_as_adjective_en(lemma)
                 elif pos_key == "adverb": pattern_block = {"base_form": lemma, "info": "Adverbs are non-inflecting."}
             
-            # --- 2. Build Semantics Block ---
             semantics_block = _build_semantics_block_for_lemma(lemma, pos_key, top_n, 'en')
             
-            # --- 3. Build Final Report Block ---
             pos_entry_report = {
-                "hanta_analysis": { # <-- Key name preserved
+                "hanta_analysis": { 
                     "lemma": lemma,
                     "pos_tag": hanta_pos,
                     "analysis_string": str(raw_analysis),
@@ -1018,7 +1098,6 @@ def _analyze_word_with_hanta_en(word: str, top_n: int) -> Dict[str, Any]:
                 "semantics_combined": semantics_block
             }
             
-            # --- 4. VALIDATION FILTER ---
             if word_appears_in_inflections_en(word, pattern_block, pos_key):
                 if pos_key not in final_result["analysis"]:
                     final_result["analysis"][pos_key] = []
@@ -1038,7 +1117,6 @@ def _analyze_word_with_hanta_en(word: str, top_n: int) -> Dict[str, Any]:
 # ============================================================================
 # 6d. WIKTIONARY DATABASE LOGIC (EN)
 # ============================================================================
-# (This assumes an English DB with the *exact same schema*)
 def wiktionary_download_db() -> bool:
     """ Downloads the English Wiktionary DB. """
     global WIKTIONARY_AVAILABLE
@@ -1050,7 +1128,7 @@ def wiktionary_download_db() -> bool:
     print(f"English Wiktionary DB not found. Downloading from '{WIKTIONARY_REPO_ID}'...")
     try:
         hf_hub_download(
-            repo_id=WIKTIONARY_REPO_ID, # <-- Uses English repo ID
+            repo_id=WIKTIONARY_REPO_ID,
             filename=WIKTIONARY_DB_PATH,
             repo_type="dataset",
             local_dir=".",
@@ -1086,7 +1164,7 @@ def wiktionary_get_connection() -> Optional[sqlite3.Connection]:
             log("Creating new read-only connection to Wiktionary DB...")
             db_uri = f"file:{WIKTIONARY_DB_PATH}?mode=ro"
             conn = sqlite3.connect(db_uri, uri=True, check_same_thread=False)
-            conn.row_factory = sqlite3.Row # Makes results dict-like
+            conn.row_factory = sqlite3.Row 
             _ = conn.execute("SELECT name FROM sqlite_master WHERE type='table' LIMIT 1").fetchone()
             print("✓ Wiktionary DB connection successful.")
             WIKTIONARY_CONN = conn
@@ -1109,7 +1187,6 @@ def _wiktionary_build_report_for_entry(entry_id: int, conn: sqlite3.Connection)
     """ (REVISED FOR FULL DB V3) Fetches ALL data for a single entry_id. """
     report = {}
     
-    # 1. Get Base Entry Info
     entry_data = conn.execute(
         "SELECT word, title, redirect, pos, pos_title, lang, etymology_text FROM entries WHERE id = ?", (entry_id,)
     ).fetchone()
@@ -1119,7 +1196,6 @@ def _wiktionary_build_report_for_entry(entry_id: int, conn: sqlite3.Connection)
     report["entry_id"] = entry_id
     report["lemma"] = entry_data["word"]
 
-    # 2. Get Senses (with Glosses, Tags, Topics, and Examples)
     senses_q = conn.execute(
         """
         SELECT 
@@ -1136,7 +1212,6 @@ def _wiktionary_build_report_for_entry(entry_id: int, conn: sqlite3.Connection)
     for sense_row in senses_q:
         sense_dict = dict(sense_row)
         sense_id = sense_dict["sense_id"]
-        
         examples_q = conn.execute(
             "SELECT text, ref FROM examples WHERE sense_id = ?", (sense_id,)
         ).fetchall()
@@ -1144,7 +1219,6 @@ def _wiktionary_build_report_for_entry(entry_id: int, conn: sqlite3.Connection)
         senses_list.append(sense_dict)
     report["senses"] = senses_list
 
-    # 3. Get Inflected Forms
     forms_q = conn.execute(
         """
         SELECT f.form_text, f.sense_index,
@@ -1155,24 +1229,16 @@ def _wiktionary_build_report_for_entry(entry_id: int, conn: sqlite3.Connection)
     ).fetchall()
     report["forms"] = [dict(f) for f in forms_q]
 
-    # ... (All other queries for sounds, synonyms, antonyms, etc. are IDENTICAL to the German app) ...
-
     return report
 
 def _wiktionary_find_all_entries(word: str, conn: sqlite3.Connection) -> List[Dict[str, Any]]:
-    """
-    Finds all entries related to an English word.
-    """
+    """ Finds all entries related to an English word. """
     log(f"Wiktionary (EN): Querying for '{word}'...")
     found_entry_ids: Set[int] = set()
     
-    # --- ENGLISH REPLACEMENT ---
     lang_query = 'English'
-    # These titles are specific to the English Wiktionary dump
     form_titles = ("Inflected form", "verb form", "noun form", "adjective form", "Comparative", "Superlative") 
-    # --- END REPLACEMENT ---
 
-    # 1. Check if the word is a lemma (base form)
     lemma_q = conn.execute(
         f"SELECT id, pos_title FROM entries WHERE word = ? AND lang = '{lang_query}'", (word,)
     ).fetchall()
@@ -1202,7 +1268,6 @@ def _wiktionary_find_all_entries(word: str, conn: sqlite3.Connection) -> List[Di
                 except json.JSONDecodeError:
                     log(f"Wiktionary: Failed to parse form_of JSON: {form_of_json}")
 
-    # 2. Check if the word is an inflected form (in the `forms` table)
     form_q = conn.execute(
         f"""
         SELECT DISTINCT e.id
@@ -1231,7 +1296,6 @@ def _wiktionary_find_all_entries(word: str, conn: sqlite3.Connection) -> List[Di
     
     log(f"Wiktionary: Found {len(found_entry_ids)} unique matching entries.")
     
-    # 3. Build a full report for each unique entry
     all_reports = []
     for entry_id in found_entry_ids:
         try:
@@ -1242,19 +1306,61 @@ def _wiktionary_find_all_entries(word: str, conn: sqlite3.Connection) -> List[Di
             
     return all_reports
 
+def _wiktionary_format_semantics_block(wikt_report: Dict[str, Any], pattern_block: Dict[str, Any], top_n: int) -> Dict[str, Any]:
+    """ Combines English Wiktionary senses with OEWN/ConceptNet. """
+    pos_key = _wiktionary_map_pos_key(wikt_report.get("pos"))
+    semantic_lemma = wikt_report.get("lemma") 
+    
+    wiktionary_senses = []
+    for sense in wikt_report.get("senses", []):
+        wiktionary_senses.append({
+            "definition": sense.get("glosses"),
+            "source": "wiktionary"
+        })
+
+    oewn_senses = []
+    if WN_AVAILABLE:
+        try:
+            senses_by_pos = _get_wordnet_senses_by_pos(semantic_lemma, 'en') 
+            oewn_senses_raw = senses_by_pos.get(pos_key, [])
+            if oewn_senses_raw and "info" not in oewn_senses_raw[0]:
+                oewn_senses = oewn_senses_raw
+        except Exception as e:
+            log(f"[DEBUG] OEWN lookup failed for {semantic_lemma} ({pos_key}): {e}")
+
+    conceptnet_relations = []
+    if REQUESTS_AVAILABLE:
+        try:
+            conceptnet_result = conceptnet_get_relations(semantic_lemma, language='en')
+            conceptnet_relations = conceptnet_result.get("relations", [])
+        except Exception: pass
+        
+    if top_n > 0:
+        wiktionary_senses = wiktionary_senses[:top_n]
+        oewn_senses = oewn_senses[:top_n]
+        conceptnet_relations.sort(key=lambda x: x.get('weight', 0.0), reverse=True)
+        conceptnet_relations = conceptnet_relations[:top_n]
+    
+    return {
+        "lemma": semantic_lemma,
+        "wiktionary_senses": wiktionary_senses,
+        "odenet_senses": oewn_senses, # Key name preserved
+        "conceptnet_relations": conceptnet_relations,
+        "wiktionary_synonyms": wikt_report.get("synonyms", []),
+        "wiktionary_antonyms": wikt_report.get("antonyms", [])
+    }
+
+
 # ============================================================================
 # 6e. SHARED SEMANTIC HELPER (OEWN + OpenBLP)
 # ============================================================================
 
 def _get_wordnet_senses_by_pos(word: str, lang: str = 'en') -> Dict[str, List[Dict[str, Any]]]:
-    """
-    (Helper) Fetches WordNet (OEWN) senses for a word and groups them by POS.
-    """
+    """ (Helper) Fetches WordNet (OEWN) senses for a word and groups them by POS. """
     senses_by_pos: Dict[str, List[Dict]] = {
         "noun": [], "verb": [], "adjective": [], "adverb": []
     }
     if not WN_AVAILABLE:
-        # Fail-open strategy
         return {"noun": [{"info": "WordNet unavailable"}], "verb": [{"info": "WordNet unavailable"}],
                 "adjective": [{"info": "WordNet unavailable"}], "adverb": [{"info": "WordNet unavailable"}]}
         
@@ -1264,36 +1370,19 @@ def _get_wordnet_senses_by_pos(word: str, lang: str = 'en') -> Dict[str, List[Di
             if "error" in sense: continue
             pos_tag = sense.get("pos")
             
-            if pos_tag == 'n':
-                senses_by_pos["noun"].append(sense)
-            elif pos_tag == 'v':
-                senses_by_pos["verb"].append(sense)
-            # --- ENGLISH WORDNET (OEWN) FIX ---
-            # 'a' is Adjective, 's' is Adjective Satellite
-            # 'r' is Adverb
-            elif pos_tag == 'a' or pos_tag == 's':
-                senses_by_pos["adjective"].append(sense)
-            elif pos_tag == 'r':
-                senses_by_pos["adverb"].append(sense)
-            # --- END OF FIX ---
-                
+            if pos_tag == 'n': senses_by_pos["noun"].append(sense)
+            elif pos_tag == 'v': senses_by_pos["verb"].append(sense)
+            elif pos_tag == 'a' or pos_tag == 's': senses_by_pos["adjective"].append(sense)
+            elif pos_tag == 'r': senses_by_pos["adverb"].append(sense)
     except Exception as e:
         log(f"WordNet helper check failed for '{word}': {e}")
         
-    log(f"WordNet (EN) senses for '{word}': "
-        f"{len(senses_by_pos['noun'])}N, "
-        f"{len(senses_by_pos['verb'])}V, "
-        f"{len(senses_by_pos['adjective'])}Adj, "
-        f"{len(senses_by_pos['adverb'])}Adv")
     return senses_by_pos
 
 def _build_semantics_block_for_lemma(lemma: str, pos_key: str, top_n: int, lang: str = 'en') -> Dict[str, Any]:
-    """
-    (REUSABLE HELPER) Fetches OEWN, ConceptNet, and OpenBLP data.
-    """
+    """ (REUSABLE HELPER) Fetches OEWN, ConceptNet, and OpenBLP data. """
     log(f"[DEBUG] Building semantics for lemma='{lemma}', pos='{pos_key}', lang='{lang}'")
     
-    # 1. Get OEWN senses
     oewn_senses = []
     if WN_AVAILABLE:
         try:
@@ -1304,7 +1393,6 @@ def _build_semantics_block_for_lemma(lemma: str, pos_key: str, top_n: int, lang:
         except Exception as e:
             log(f"[DEBUG] OEWN lookup failed for {lemma} ({pos_key}): {e}")
 
-    # 2. Get ConceptNet relations
     conceptnet_relations = []
     if REQUESTS_AVAILABLE:
         try:
@@ -1313,14 +1401,12 @@ def _build_semantics_block_for_lemma(lemma: str, pos_key: str, top_n: int, lang:
         except Exception as e:
             conceptnet_relations = [{"error": str(e)}]
             
-    # 3. Get OpenBLP relations
     openblp_relations = []
     try:
         openblp_relations = openblp_get_relations(lemma)
     except Exception as e:
         openblp_relations = [{"error": f"OpenBLP stub failed: {e}"}]
             
-    # 4. Apply top_n limit
     if top_n > 0:
         oewn_senses = oewn_senses[:top_n]
         conceptnet_relations.sort(key=lambda x: x.get('weight', 0.0), reverse=True)
@@ -1328,13 +1414,12 @@ def _build_semantics_block_for_lemma(lemma: str, pos_key: str, top_n: int, lang:
         openblp_relations.sort(key=lambda x: x.get('weight', 0.0), reverse=True)
         openblp_relations = openblp_relations[:top_n]
 
-    # --- MUST MATCH GERMAN JSON STRUCTURE ---
     return {
         "lemma": lemma,
-        "wiktionary_senses": [], # This block is for non-Wiktionary engines
-        "odenet_senses": oewn_senses, # <-- Key name is preserved
+        "wiktionary_senses": [],
+        "odenet_senses": oewn_senses,
         "conceptnet_relations": conceptnet_relations,
-        "openblp_relations": openblp_relations, # <-- NEW KEY
+        "openblp_relations": openblp_relations,
         "wiktionary_synonyms": [],
         "wiktionary_antonyms": []
     }
@@ -1346,16 +1431,12 @@ def _build_semantics_block_for_lemma(lemma: str, pos_key: str, top_n: int, lang:
 
 # --- PRIMARY ENGINE: WIKTIONARY (EN) ---
 def _analyze_word_with_wiktionary(word: str, top_n: int) -> Dict[str, Any]:
-    """
-    (PRIMARY ENGINE) Analyzes an English word using the Wiktionary DB.
-    """
+    """ (PRIMARY ENGINE) Analyzes an English word using the Wiktionary DB. """
     final_result: Dict[str, Any] = {"input_word": word, "analysis": {}}
     
     conn = wiktionary_get_connection()
-    if not conn:
-        return {} # Signal failure
+    if not conn: return {}
         
-    # --- 1. GET SPACY HINT ---
     spacy_pos_hint, spacy_lemma_hint = None, None
     try:
         nlp_en = spacy_load_spacy_model("en_core_web_md")
@@ -1364,20 +1445,16 @@ def _analyze_word_with_wiktionary(word: str, top_n: int) -> Dict[str, Any]:
             token = doc[0]
             spacy_pos_hint = token.pos_.lower()
             spacy_lemma_hint = token.lemma_
-            log(f"[DEBUG] Wiktionary (EN) Hint: spaCy POS is '{spacy_pos_hint}', lemma is '{spacy_lemma_hint}'")
     except Exception as e:
         log(f"[DEBUG] Wiktionary (EN) Hint: spaCy failed: {e}")
 
-    # --- 2. FIND ALL WIKTIONARY ENTRIES ---
     try:
         wiktionary_reports = _wiktionary_find_all_entries(word, conn)
     except Exception as e:
         log(f"[DEBUG] Wiktionary (EN) query failed: {e}")
-        return {} # Signal failure
-    if not wiktionary_reports:
-        return {} # No results, signal to fallback
+        return {} 
+    if not wiktionary_reports: return {}
 
-    # --- 3. PRIORITIZE/SORT THE WIKTIONARY ENTRIES ---
     def get_priority_score(report):
         wikt_pos = _wiktionary_map_pos_key(report.get("pos"))
         wikt_lemma = report.get("lemma")
@@ -1388,25 +1465,21 @@ def _analyze_word_with_wiktionary(word: str, top_n: int) -> Dict[str, Any]:
         return 4
     wiktionary_reports.sort(key=get_priority_score)
     
-    # --- 4. BUILD AND VALIDATE THE FINAL REPORT ---
     word_lower = word.lower()
     for wikt_report in wiktionary_reports:
         pos_key = _wiktionary_map_pos_key(wikt_report.get("pos"))
         lemma = wikt_report.get("lemma", word)
         pos_title = wikt_report.get("pos_title", "")
         
-        # --- A. Build Wiktionary Inflection Block ---
         inflections_wikt_block = {
             "base_form": lemma,
             "forms_list": wikt_report.get("forms", []),
             "source": "wiktionary"
         }
         
-        # --- B. Build Pattern Inflection Block (using pattern.en) ---
         pattern_block = {}
         if PATTERN_EN_AVAILABLE:
             try:
-                # Use input 'word' for inflected forms to find right lemma
                 use_word = word if "form" in pos_title.lower() else lemma
                 if pos_key == "noun": pattern_block = pattern_analyze_as_noun_en(use_word)
                 elif pos_key == "verb": pattern_block = pattern_analyze_as_verb_en(use_word)
@@ -1415,10 +1488,8 @@ def _analyze_word_with_wiktionary(word: str, top_n: int) -> Dict[str, Any]:
             except Exception as e:
                 pattern_block = {"error": f"Pattern.en analysis failed: {e}"}
 
-        # --- C. Build Semantics Block ---
         semantics_block = _wiktionary_format_semantics_block(wikt_report, pattern_block, top_n)
         
-        # --- D. Assemble the report (pre-validation) ---
         pos_entry_report = {
             "inflections_wiktionary": inflections_wikt_block,
             "inflections_pattern": pattern_block,
@@ -1427,27 +1498,21 @@ def _analyze_word_with_wiktionary(word: str, top_n: int) -> Dict[str, Any]:
                  "pos_title": pos_title,
                  "etymology": wikt_report.get("etymology_text"),
                  "pronunciation": wikt_report.get("sounds"),
-                 # ... (all other metadata fields) ...
             }
         }
         
-        # --- E. VALIDATION FILTER ---
         is_valid = False
         is_inflected_entry = any(ft in pos_title for ft in ["form", "Comparative", "Superlative"])
 
-        if lemma.lower() == word_lower:
-            is_valid = True
-            log(f"[DEBUG] Wiktionary: KEEPING entry '{lemma}' ({pos_key}) because input word matches entry lemma.")
+        if lemma.lower() == word_lower: is_valid = True
         
         if not is_valid and not is_inflected_entry:
             for form_entry in inflections_wikt_block.get("forms_list", []):
                 form_text = form_entry.get("form_text", "").strip()
                 if form_text.lower() == word_lower:
                     is_valid = True
-                    log(f"[DEBUG] Wiktionary: KEEPING entry '{lemma}' ({pos_key}) because input word found in form: '{form_text}'")
                     break
         
-        # --- F. Add to final result if valid ---
         if is_valid:
             if pos_key not in final_result["analysis"]:
                 final_result["analysis"][pos_key] = []
@@ -1998,9 +2063,9 @@ def create_spacy_tab():
                                   html_dep_out, df_out, json_out, html_ner_out])
 
 def create_languagetool_tab():
-    """Creates the UI for the Grammar Checker tab with LT and AtD."""
+    """Creates the UI for the Grammar Checker tab with LT."""
     gr.Markdown("# 🇬🇧 English Grammar & Spelling Checker")
-    gr.Markdown("Powered by `LanguageTool` and `After the Deadline (AtD)`.")
+    gr.Markdown("Powered by `LanguageTool`.")
     
     with gr.Row():
         text_input = gr.Textbox(
@@ -2009,33 +2074,20 @@ def create_languagetool_tab():
             lines=5,
             scale=3
         )
-        checker_choice = gr.Radio(
-            label="Checker Engine",
-            choices=["LanguageTool", "After the Deadline"],
-            value="LanguageTool",
-            scale=1
-        )
         
     check_button = gr.Button("Check Text", variant="primary")
     output = gr.JSON(label="Detected Errors (JSON)")
 
-    def dispatch_grammar_check(text, choice):
-        if choice == "LanguageTool":
-            return lt_check_grammar(text, 'en')
-        elif choice == "After the Deadline":
-            return atd_check_grammar(text)
-        return [{"error": "Invalid checker selected."}]
-
     check_button.click(
-        fn=dispatch_grammar_check,
-        inputs=[text_input, checker_choice],
+        fn=lambda text: lt_check_grammar(text, 'en'),
+        inputs=[text_input],
         outputs=[output],
         api_name="check_grammar"
     )
     gr.Examples(
-        [["This is a houze.", "LanguageTool"], ["I seen the man.", "LanguageTool"],
-         ["The cat sleep on the table.", "After the Deadline"], ["He asks if he can go.", "LanguageTool"]],
-        inputs=[text_input, checker_choice], outputs=[output], fn=dispatch_grammar_check,
+        [["This is a houze."], ["I seen the man."],
+         ["The cat sleep on the table."], ["He asks if he can go."]],
+        inputs=[text_input], outputs=[output], fn=lambda text: lt_check_grammar(text, 'en'),
         cache_examples=False
     )
 
@@ -2422,17 +2474,6 @@ if __name__ == "__main__":
         print("INFO: NLTK library not available, skipping lemmatizer.")
     print("--- NLTK Done ---\n")
     
-    # --- 7. Check AtD Service ---
-    print("--- Initializing AtD Service ---")
-    if ATD_AVAILABLE:
-        try:
-            atd_get_service()
-        except Exception as e:
-            print(f"✗ FAILED to start AtD: {e}")
-    else:
-        print("INFO: AtD library not available, skipping service.")
-    print("--- AtD Done ---\n")
-
     # --- 8. Check Pattern.en ---
     print("--- Checking Pattern.en ---")
     if not PATTERN_EN_AVAILABLE: