Update app.py

app.py

@@ -150,6 +150,24 @@ except ImportError:
     print("Install with: pip install HanTa")
     print("="*70)
 
+# --- DWDSmor Import ---
+DWDSMOR_AVAILABLE = False
+DwdsmorLemmatizerClass = object # Dummy definition
+try:
+    import dwdsmor
+    import dwdsmor.spacy # Test this import
+    DWDSMOR_AVAILABLE = True
+    print("✓ Successfully imported dwdsmor")
+except ImportError as e:
+    DWDSMOR_AVAILABLE = False
+    print("="*70)
+    print(f"WARNING: `dwdsmor` or a dependency failed to import: {e}")
+    print("The DWDSmor engine will not be available.")
+    print("On macOS, run: brew install sfst")
+    print("On Debian/Ubuntu, run: apt-get install sfst")
+    print("Then, run: pip install dwdsmor")
+    print("="*70)
+
 # ============================================================================
 # 2. SHARED GLOBALS & CONFIG
 # ============================================================================
@@ -174,6 +192,10 @@ CONCEPTNET_LOCK = threading.Lock()
 HANTA_TAGGER_INSTANCE: Optional[HanoverTagger] = None
 HANTA_TAGGER_LOCK = threading.Lock()
 
+# --- DWDSmor Cache & Lock ---
+DWDSMOR_LEMMATIZER: Optional[Any] = None
+DWDSMOR_LEMMATIZER_LOCK = threading.Lock()
+
 # --- Helper ---
 def _html_wrap(content: str, line_height: str = "2.0") -> str:
     """Wraps displaCy HTML in a consistent, scrollable div."""
@@ -1624,11 +1646,7 @@ def _build_semantics(lemma: str, odenet_senses: List[Dict], top_n: int) -> Dict[
     }
 
 # ============================================================================
-# 6d. WIKTIONARY DATABASE LOGIC (NEW PRIMARY ENGINE)
-# ============================================================================
-
-# ============================================================================
-# 6d. WIKTIONARY DATABASE LOGIC (NEW PRIMARY ENGINE)
+# 6d. WIKTIONARY DATABASE LOGIC (PRIMARY ENGINE)
 # ============================================================================
 
 def wiktionary_download_db() -> bool:
@@ -1913,7 +1931,7 @@ def _wiktionary_format_semantics_block(
 
 def _analyze_word_with_wiktionary(word: str, top_n: int) -> Dict[str, Any]:
     """
-    (NEW PRIMARY ENGINE) Analyzes a word using the Wiktionary DB.
+    (PRIMARY ENGINE) Analyzes a word using the Wiktionary DB.
     Returns {} on failure to signal dispatcher to fall back.
     """
     final_result: Dict[str, Any] = {
@@ -2033,7 +2051,7 @@ def _analyze_word_with_wiktionary(word: str, top_n: int) -> Dict[str, Any]:
             }
         }
         
-        # --- E. *** YOUR NEW VALIDATION FILTER (Corrected) *** ---
+        # --- E. VALIDATION FILTER ---
         is_valid = False
         is_inflected_entry = "Konjugierte Form" in pos_title or "Deklinierte Form" in pos_title
 
@@ -2069,6 +2087,199 @@ def _analyze_word_with_wiktionary(word: str, top_n: int) -> Dict[str, Any]:
     final_result["info"] = f"Analysis from Wiktionary (Primary Engine). Found {len(wiktionary_reports)} matching entries, kept {sum(len(v) for v in final_result.get('analysis', {}).values())}."
     return final_result
 
+# ============================================================================
+# 6e. SHARED SEMANTIC HELPER 
+# ============================================================================
+
+def _build_semantics_block_for_lemma(lemma: str, pos_key: str, top_n: int) -> Dict[str, Any]:
+    """
+    (REUSABLE HELPER)
+    Fetches OdeNet and ConceptNet data for a given lemma and POS.
+    """
+    log(f"[DEBUG] Building semantics for lemma='{lemma}', pos='{pos_key}'")
+    
+    # 1. Get OdeNet senses for this lemma + POS
+    odenet_senses = []
+    if WN_AVAILABLE:
+        try:
+            senses_by_pos = _get_odenet_senses_by_pos(lemma)
+            odenet_senses_raw = senses_by_pos.get(pos_key, [])
+            
+            # Filter out placeholder
+            if odenet_senses_raw and "info" not in odenet_senses_raw[0]:
+                odenet_senses = odenet_senses_raw
+        except Exception as e:
+            log(f"[DEBUG] OdeNet lookup failed for {lemma} ({pos_key}): {e}")
+
+    # 2. Get ConceptNet relations for this lemma
+    conceptnet_relations = []
+    if REQUESTS_AVAILABLE:
+        try:
+            conceptnet_result = conceptnet_get_relations(lemma, language='de')
+            conceptnet_relations = conceptnet_result.get("relations", [])
+        except Exception as e:
+            conceptnet_relations = [{"error": str(e)}]
+            
+    # 3. Apply top_n limit
+    if top_n > 0:
+        odenet_senses = odenet_senses[:top_n]
+        conceptnet_relations.sort(key=lambda x: x.get('weight', 0.0), reverse=True)
+        conceptnet_relations = conceptnet_relations[:top_n]
+
+    return {
+        "lemma": lemma,
+        "wiktionary_senses": [], # This block is for non-Wiktionary engines
+        "odenet_senses": odenet_senses,
+        "conceptnet_relations": conceptnet_relations,
+        "wiktionary_synonyms": [],
+        "wiktionary_antonyms": []
+    }
+
+# ============================================================================
+# 6f. DWDSMOR ENGINE (NEW FALLBACK 1)
+# ============================================================================
+
+def dwdsmor_get_lemmatizer() -> Optional[Any]: # Return type is 'sfst.Transducer'
+    """
+    Thread-safe function to get a single instance of the DWDSmor analyzer.
+    It will automatically download/cache the 'open' automata from Hugging Face Hub.
+    """
+    global DWDSMOR_LEMMATIZER
+    if not DWDSMOR_AVAILABLE:
+        raise ImportError("dwdsmor library is not installed.")
+
+    if DWDSMOR_LEMMATIZER:
+        return DWDSMOR_LEMMATIZER
+
+    with DWDSMOR_LEMMATIZER_LOCK:
+        if DWDSMOR_LEMMATIZER:
+            return DWDSMOR_LEMMATIZER
+        
+        try:
+            print("Initializing DWDSmor lemmatizer (loading automata)...")
+            
+            # --- THIS IS THE FIX ---
+            # Use the correct API from dwdsmor's own tools (analysis.py)
+            # This will find and download the HF repo automatically
+            from dwdsmor import automaton
+            automata = automaton.automata() 
+            analyzer = automata.analyzer("lemma") # Use the 'lemma' automaton
+            # --- END OF FIX ---
+
+            # Force the traversal to actually run by converting to a list.
+            print("[DEBUG] DWDSmor: Running warm-up call...")
+            _ = list(analyzer.analyze("Test", join_tags=True)) 
+
+            print("✓ DWDSmor lemmatizer initialized successfully.")
+            DWDSMOR_LEMMATIZER = analyzer
+            return DWDSMOR_LEMMATIZER
+        except Exception as e:
+            print(f"✗ CRITICAL: Failed to initialize DWDSmor: {e}")
+            traceback.print_exc()
+            return None
+
+def _dwdsmor_map_pos_key(dwdsmor_pos: str) -> str:
+    """Maps DWDSmor POS tags to our internal keys."""
+    if dwdsmor_pos == "V": return "verb"
+    if dwdsmor_pos == "NN": return "noun"
+    if dwdsmor_pos == "NPROP": return "noun" # Proper Noun
+    if dwdsmor_pos == "ADJ": return "adjective"
+    if dwdsmor_pos == "ADV": return "adverb"
+    return dwdsmor_pos.lower() # Fallback for others
+
+def _analyze_word_with_dwdsmor(word: str, top_n: int) -> Dict[str, Any]:
+    """
+    (FALLBACK ENGINE 1) Analyzes a single word using DWDSmor + Pattern + Semantics.
+    Returns {} on failure.
+    """
+    if not DWDSMOR_AVAILABLE:
+        return {} # Signal failure
+        
+    print(f"\n[Word Encyclopedia] Running V21 (DWDSmor) engine for: \"{word}\"")
+    final_result: Dict[str, Any] = {
+        "input_word": word,
+        "analysis": {}
+    }
+    
+    try:
+        analyzer = dwdsmor_get_lemmatizer()
+        if not analyzer:
+            raise Exception("DWDSmor lemmatizer failed to initialize.")
+
+        analyses = list(analyzer.analyze(word, join_tags=True))
+        
+        if not analyses:
+            return {} # No results
+        
+        log(f"[DEBUG] DWDSmor: Found {len(analyses)} potential analyses.")
+        
+        processed_lemmas_pos: Set[Tuple[str, str]] = set()
+
+        for analysis in analyses:
+            
+            # --- THIS IS THE FIX ---
+            # The 'Traversal' object from analyzer.analyze() uses:
+            # .analysis -> for the lemma string (e.g., "Haus")
+            # .pos -> for the POS tag (e.g., "NN")
+            # .spec -> for the full analysis string
+            if not analysis.analysis or not analysis.pos:
+                continue
+
+            lemma = analysis.analysis  # Use .analysis, not .lemma
+            pos_key = _dwdsmor_map_pos_key(analysis.pos)
+            # --- END OF FIX ---
+            
+            if (lemma, pos_key) in processed_lemmas_pos:
+                continue
+            processed_lemmas_pos.add((lemma, pos_key))
+
+            log(f"--- Analyzing DWDSmor path: lemma='{lemma}', pos='{pos_key}' ---")
+
+            # --- 1. Get Inflections (Pattern) ---
+            pattern_block = {}
+            if PATTERN_DE_AVAILABLE:
+                try:
+                    if pos_key == "noun":
+                        pattern_block = pattern_analyze_as_noun(lemma)
+                    elif pos_key == "verb":
+                        pattern_block = pattern_analyze_as_verb(lemma)
+                    elif pos_key == "adjective":
+                        pattern_block = pattern_analyze_as_adjective(lemma)
+                    elif pos_key == "adverb":
+                        pattern_block = {"base_form": lemma, "info": "Adverbs are non-inflecting."}
+                except Exception as e:
+                    pattern_block = {"error": f"Pattern.de analysis for {pos_key}('{lemma}') failed: {e}"}
+
+            # --- 2. Build Semantics Block ---
+            semantics_block = _build_semantics_block_for_lemma(lemma, pos_key, top_n)
+
+            # --- 3. Build Final Report Block ---
+            pos_entry_report = {
+                "dwdsmor_analysis": {
+                    "lemma": lemma,
+                    "pos": analysis.pos,
+                    "analysis_string": analysis.spec, # .spec is the full string
+                    "source": "dwdsmor"
+                },
+                "inflections_pattern": pattern_block,
+                "semantics_combined": semantics_block
+            }
+            
+            if pos_key not in final_result["analysis"]:
+                final_result["analysis"][pos_key] = []
+            final_result["analysis"][pos_key].append(pos_entry_report)
+
+        if not final_result["analysis"]:
+            return {} # No valid paths found
+            
+        final_result["info"] = "Analysis performed by DWDSmor-led engine."
+        return final_result
+
+    except Exception as e:
+        print(f"[Word Encyclopedia] DWDSmor Engine FAILED: {e}")
+        traceback.print_exc()
+        return {} # Signal failure
+    
 # ============================================================================
 # 7. CONSOLIDATED ANALYZER LOGIC
 # ============================================================================
@@ -2079,7 +2290,7 @@ def comprehensive_german_analysis(text: str, top_n_value: Optional[float] = 0) -
     """
     (CONTEXTUAL) Combines NLP tools for a deep analysis of German text.
     
-    ** V19 UPDATE: ** Reads the new list-based, multi-engine output 
+    Reads the list-based, multi-engine output 
     from `analyze_word_encyclopedia` and combines all senses for ranking.
     """
     
@@ -2256,7 +2467,6 @@ def comprehensive_german_analysis(text: str, top_n_value: Optional[float] = 0) -
                     if key.endswith("_senses") and nlp_de:
                         ranked_senses = []
                         for sense in semantic_analysis[key]:
-                            # ... (your existing re-ranking code) ...
                             if "error" in sense: continue
                             definition = sense.get("definition", "")
                             relevance = 0.0
@@ -2278,7 +2488,6 @@ def comprehensive_german_analysis(text: str, top_n_value: Optional[float] = 0) -
                 # ConceptNet Relations
                 if "conceptnet_relations" in semantic_analysis and nlp_de:
                     ranked_relations = []
-                    # ... (your existing re-ranking code) ...
                     for rel in semantic_analysis["conceptnet_relations"]:
                         if "error" in rel: continue
                         text_to_score = rel.get('surface') or rel.get('other_node', '')
@@ -2400,7 +2609,7 @@ def _analyze_word_with_hanta(word: str, top_n_value: int) -> Dict[str, Any]:
                         inflection_report = {"error": f"pattern.de failed: {e}", "traceback": traceback.format_exc()}
 
                 # --- 3d. Build Final Report Block ---
-                final_result["analysis"][pos_group] = {
+                final_result["analysis"][pos_group] = [{
                     "hanta_analysis": {
                         "detected_tags": sorted(list(specific_tags)),
                         "lemma": lemma,
@@ -2408,9 +2617,9 @@ def _analyze_word_with_hanta(word: str, top_n_value: int) -> Dict[str, Any]:
                              hanta_tagger.analyze(word.capitalize() if pos_group == 'noun' else word.lower(), taglevel=3)
                         ]
                     },
-                    "inflections": inflection_report,
-                    "semantics": _build_semantics(lemma, pos_odenet_senses, top_n)
-                }
+                    "inflections_pattern": inflection_report,
+                    "semantics_combined": _build_semantics_block_for_lemma(lemma, pos_group, top_n),
+                }]
 
             if not final_result["analysis"]:
                 return {
@@ -2430,7 +2639,6 @@ def _analyze_word_with_hanta(word: str, top_n_value: int) -> Dict[str, Any]:
     if IWNLP_AVAILABLE:
         try:
             log("--- Dispatcher: HanTa not found or failed. Attempting IWNLP Fallback Engine ---")
-            # We call your existing V16 function, which we just made robust in Step 2.
             result = _analyze_word_with_iwnlp(word, top_n_value)
             result["info"] = result.get("info", "") + " (Analysis performed by IWNLP-based fallback engine)"
             return result
@@ -2739,20 +2947,15 @@ def _analyze_word_with_iwnlp(word: str, top_n_value: int) -> Dict[str, Any]:
 
     # --- 5. BUILD FINAL REPORT ---
     for pos_key, analysis_data in valid_analyses.items():
+        lemma = analysis_data["lemma"]
         pos_report = {
             "inflections_pattern": analysis_data["inflections"],
-            "semantics_combined": _build_semantics(
-                analysis_data["lemma"],
-                analysis_data["odenet_senses"],
-                top_n
-            )
+            "semantics_combined": _build_semantics_block_for_lemma(lemma, pos_key, top_n)
         }
-        # Add spaCy analysis if it was included
         if "spacy_analysis" in analysis_data:
              pos_report["spacy_analysis"] = analysis_data["spacy_analysis"]
         
-        # Wrap it in a list
-        final_result["analysis"][pos_key] = [pos_report] # <--- THE CHANGE
+        final_result["analysis"][pos_key] = [pos_report] # Wrap in list
 
     if not final_result["analysis"]:
        return {} # No results
@@ -2761,14 +2964,16 @@ def _analyze_word_with_iwnlp(word: str, top_n_value: int) -> Dict[str, Any]:
     return final_result
 
 
-# --- 7b. NEW: Word Encyclopedia (Non-Contextual) Analyzer ---
+# --- 7b. Word Encyclopedia (Non-Contextual) Analyzer ---
 
-# --- THIS IS THE NEW PUBLIC DISPATCHER FUNCTION ---
+# --- PUBLIC DISPATCHER FUNCTION ---
 # --- THIS IS THE NEW PUBLIC DISPATCHER FUNCTION ---
 def analyze_word_encyclopedia(word: str, top_n_value: Optional[float] = 0, engine_choice: str = "wiktionary") -> Dict[str, Any]:
     """
-    (PUBLIC DISPATCHER V21) Analyzes a single word using the selected engine
+    (PUBLIC DISPATCHER V22) Analyzes a single word using the selected engine
     as a starting point, then automatically falls back if no results are found.
+    
+    Chain: Wiktionary -> DWDSmor -> HanTa -> IWNLP
     """
     if not word or not word.strip():
         return {"info": "Please enter a word."}
@@ -2781,37 +2986,41 @@ def analyze_word_encyclopedia(word: str, top_n_value: Optional[float] = 0, engin
     log(f"\n[Word Encyclopedia] User selected engine: '{engine_choice}' for word: '{word}'")
 
     try:
-        # --- 1. Try Wiktionary (if selected) ---
+        # --- 1. Try Wiktionary ---
         if engine_choice == "wiktionary":
-            log(f"[DEBUG] V21 Dispatcher: Trying Wiktionary (Primary) for '{word}'...")
+            log(f"[DEBUG] V22 Dispatcher: Trying Wiktionary (Primary) for '{word}'...")
             result = _analyze_word_with_wiktionary(word, top_n)
             if result and result.get("analysis"):
                 return result # Success
             info_log.append("Wiktionary found no results.")
-            log(f"[DEBUG] V21 Dispatcher: Wiktionary found no results for '{word}'. Falling back to HanTa...")
-
-        # --- 2. Try HanTa (if selected or as fallback) ---
-        # This block runs if:
-        #   a) User selected "hanta" OR
-        #   b) User selected "wiktionary" and it found nothing
-        if engine_choice == "hanta" or (engine_choice == "wiktionary" and not result.get("analysis")):
-            log(f"[DEBUG] V21 Dispatcher: Trying HanTa (Fallback 1) for '{word}'...")
+            log(f"[DEBUG] V22 Dispatcher: Wiktionary found no results. Falling back to DWDSmor...")
+        
+        # --- 2. Try DWDSmor (NEW) ---
+        if engine_choice == "dwdsmor" or (engine_choice == "wiktionary" and not result.get("analysis")):
+            log(f"[DEBUG] V22 Dispatcher: Trying DWDSmor (Fallback 1) for '{word}'...")
+            result = _analyze_word_with_dwdsmor(word, top_n)
+            if result and result.get("analysis"):
+                result["info"] = f"Analysis from DWDSmor (Fallback 1). {(' '.join(info_log))}"
+                return result # Success
+            info_log.append("DWDSmor found no results.")
+            log(f"[DEBUG] V22 Dispatcher: DWDSmor found no results. Falling back to HanTa...")
+
+        # --- 3. Try HanTa ---
+        if engine_choice == "hanta" or (not result.get("analysis")):
+            log(f"[DEBUG] V22 Dispatcher: Trying HanTa (Fallback 2) for '{word}'...")
             result = _analyze_word_with_hanta(word, top_n)
             if result and result.get("analysis"):
-                result["info"] = f"Analysis from HanTa (Fallback 1). {(' '.join(info_log))}"
+                result["info"] = f"Analysis from HanTa (Fallback 2). {(' '.join(info_log))}"
                 return result # Success
             info_log.append("HanTa found no results.")
-            log(f"[DEBUG] V21 Dispatcher: HanTa found no results for '{word}'. Falling back to IWNLP...")
+            log(f"[DEBUG] V22 Dispatcher: HanTa found no results. Falling back to IWNLP...")
 
-        # --- 3. Try IWNLP (if selected or as fallback) ---
-        # This block runs if:
-        #   a) User selected "iwnlp" OR
-        #   b) The previous engines were tried and all failed (result['analysis'] is still empty)
+        # --- 4. Try IWNLP ---
         if engine_choice == "iwnlp" or (not result.get("analysis")):
-            log(f"[DEBUG] V21 Dispatcher: Trying IWNLP (Fallback 2) for '{word}'...")
+            log(f"[DEBUG] V22 Dispatcher: Trying IWNLP (Fallback 3) for '{word}'...")
             result = _analyze_word_with_iwnlp(word, top_n)
             if result and result.get("analysis"):
-                result["info"] = f"Analysis from IWNLP (Fallback 2). {(' '.join(info_log))}"
+                result["info"] = f"Analysis from IWNLP (Fallback 3). {(' '.join(info_log))}"
                 return result # Success
             info_log.append("IWNLP found no results.")
             
@@ -2825,7 +3034,7 @@ def analyze_word_encyclopedia(word: str, top_n_value: Optional[float] = 0, engin
         }
 
     # --- No engines found anything ---
-    log(f"[DEBUG] V21 Dispatcher: All engines failed to find results for '{word}'.")
+    log(f"[DEBUG] V22 Dispatcher: All engines failed to find results for '{word}'.")
     return {
         "input_word": word,
         "info": f"No analysis found. All engines failed. ({' '.join(info_log)})"
@@ -3023,7 +3232,7 @@ def create_combined_tab():
     )
 
 def create_word_encyclopedia_tab():
-    """--- NEW: Creates the UI for the NON-CONTEXTUAL Word Analyzer tab ---"""
+    """--- UI for the NON-CONTEXTUAL Word Analyzer tab ---"""
     gr.Markdown("# 📖 Word Encyclopedia (Non-Contextual)")
     gr.Markdown("This tool analyzes a **single word** for *all possible* grammatical and semantic forms. It finds ambiguities (e.g., 'Lauf' as noun and verb) and groups all data by Part-of-Speech.")
     
@@ -3042,39 +3251,37 @@ def create_word_encyclopedia_tab():
                 interactive=True
             )
             
-            # --- THIS IS THE NEW UI ELEMENT ---
+            # --- ADD DWDSMOR TO THE RADIO BUTTONS ---
             engine_radio = gr.Radio(
-                label="Select Analysis Engine",
+                label="Select Analysis Engine (will auto-fallback)",
                 choices=[
                     ("Wiktionary (Default)", "wiktionary"),
-                    ("HanTa (Fallback 1)", "hanta"),
-                    ("IWNLP (Fallback 2)", "iwnlp")
+                    ("DWDSmor (New)", "dwdsmor"), 
+                    ("HanTa (Fallback 2)", "hanta"),
+                    ("IWNLP (Fallback 3)", "iwnlp")
                 ],
                 value="wiktionary",
                 interactive=True
             )
-            # --- END OF NEW UI ELEMENT ---
+            # --- END OF CHANGE ---
 
         analyze_button = gr.Button("Analyze Word", variant="primary")
     
     output = gr.JSON(label="Word Encyclopedia Analysis (JSON)")
     
-    # --- UPDATE THE CLICK FUNCTION ---
     analyze_button.click(
         fn=analyze_word_encyclopedia,
-        # Add 'engine_radio' to the inputs
         inputs=[word_input, top_n_number, engine_radio], 
         outputs=[output],
         api_name="analyze_word"
     )
     
-    # Update the examples to include the radio button
     gr.Examples(
         [["Lauf", 3, "wiktionary"], 
          ["See", 0, "wiktionary"], 
          ["schnell", 3, "wiktionary"],
          ["heute", 0, "wiktionary"],
-         ["heute", 0, "hanta"]], # Example to show a different engine
+         ["gebildet", 0, "dwdsmor"]], # Example to show the new engine
         inputs=[word_input, top_n_number, engine_radio],
         outputs=[output], 
         fn=analyze_word_encyclopedia
@@ -3105,6 +3312,61 @@ def create_wiktionary_tab():
         inputs=[word_input], outputs=[output], fn=lambda word: _analyze_word_with_wiktionary(word, 0)
     )
 
+def create_dwdsmor_tab():
+    """Creates the UI for the standalone DWDSmor lookup tab."""
+    gr.Markdown("# 🏛️ DWDSmor Morphology (Raw Engine)")
+    gr.Markdown("Directly query the `dwdsmor` FST-based engine. This is a high-precision morphological analyzer.")
+    
+    def dwdsmor_raw_analysis(word):
+        """Wrapper to get raw DWDSmor analysis as JSON."""
+        if not DWDSMOR_AVAILABLE:
+            return {"error": "DWDSmor library not installed."}
+        try:
+            analyzer = dwdsmor_get_lemmatizer()
+            if not analyzer:
+                return {"error": "DWDSmor lemmatizer failed to initialize."}
+            
+            # --- THIS IS THE FIX ---
+            # The analyzer.analyze() returns a Traversal object, which is iterable
+            analyses = list(analyzer.analyze(word, join_tags=True))
+            # --- END OF FIX ---
+            
+            if not analyses:
+                return {"info": f"No analysis found for '{word}'."}
+            
+            # Convert Traversal objects to plain dicts for JSON output
+            results = []
+            for analysis in analyses:
+                results.append({
+                    "lemma": analysis.analysis, # In this object, .analysis is the lemma
+                    "pos": analysis.pos,
+                    "analysis_string": analysis.spec, # .spec is the full string
+                    "tags": analysis.tags
+                })
+            return {"input_word": word, "analyses": results}
+        except Exception as e:
+            return {"error": str(e), "traceback": traceback.format_exc()}
+
+    with gr.Column():
+        word_input = gr.Textbox(
+            label="Single German Word",
+            placeholder="e.g., gebildet, schnell, Häuser"
+        )
+        analyze_button = gr.Button("Analyze Word with DWDSmor", variant="primary")
+    
+    output = gr.JSON(label="DWDSmor Raw Analysis (JSON)")
+    
+    analyze_button.click(
+        fn=dwdsmor_raw_analysis,
+        inputs=[word_input],
+        outputs=[output],
+        api_name="dwdsmor_lookup"
+    )
+    gr.Examples(
+        [["gebildet"], ["schnell"], ["Häuser"], ["gehe"]],
+        inputs=[word_input], outputs=[output], fn=dwdsmor_raw_analysis
+    )
+
 def create_hanta_tab():
     """Creates the UI for the standalone HanTa Engine tab."""
     gr.Markdown("# 🤖 HanTa Lookup (Raw Engine)")
@@ -3185,6 +3447,9 @@ def create_consolidated_interface():
 
             with gr.Tab("🔬 Engine: IWNLP-spaCy (DE)"):
                 create_iwnlp_tab()
+
+            with gr.Tab("🏛️ Engine: DWDSmor (DE)"):
+                create_dwdsmor_tab()
                 
             # --- Standalone Component Tabs ---
             with gr.Tab("📚 Component: Inflections (DE)"):
@@ -3237,6 +3502,18 @@ if __name__ == "__main__":
         print(f"✗ FAILED to initialize Wiktionary: {e}")
     print("--- Wiktionary Done ---\n")
 
+    # --- Initialize DWDSmor ---
+    print("--- Initializing DWDSmor Lemmatizer ---")
+    if DWDSMOR_AVAILABLE:
+        try:
+            dwdsmor_get_lemmatizer() # Call the function to load the model
+        except Exception as e:
+            print(f"✗ FAILED to start DWDSmor: {e}")
+            print("  'Word Encyclopedia' DWDSmor engine will fail.")
+    else:
+        print("INFO: DWDSmor library not available, skipping lemmatizer.")
+    print("--- DWDSmor Done ---\n")
+
     # --- 4. Initialize HanTa Tagger ---
     print("--- Initializing HanTa Tagger ---")
     if HANTA_AVAILABLE: