Update app.py

app.py

@@ -21,6 +21,7 @@ MODEL_INFO: Dict[str, Tuple[str, str, str]] = {
     "es": ("Spanish", "es_core_news_md", "spacy"),
     "grc-proiel-trf": ("Ancient Greek (PROIEL TRF)", "grc_proiel_trf", "grecy"),
     "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"),
@@ -40,10 +41,11 @@ UI_TEXT = {
         "tab_graphic": "Grafische Darstellung",
         "tab_table": "Tabelle",
         "tab_json": "JSON",
+        "tab_ner": "Entitäten", # <-- ADDED
         "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", # <-- ADDED
         "error_message": "Fehler: "
     },
     "en": {
@@ -58,10 +60,11 @@ UI_TEXT = {
         "tab_graphic": "Graphic View",
         "tab_table": "Table",
         "tab_json": "JSON",
+        "tab_ner": "Entities", # <-- ADDED
         "html_label": "Dependency Parsing",
         "table_label": "Morphological Analysis",
-        "table_headers": ["Word", "Lemma", "POS", "Tag", "Morphology", "Dependency"],
         "json_label": "JSON Output",
+        "ner_label": "Named Entities", # <-- ADDED
         "error_message": "Error: "
     },
     "es": {
@@ -76,15 +79,15 @@ UI_TEXT = {
         "tab_graphic": "Vista Gráfica",
         "tab_table": "Tabla",
         "tab_json": "JSON",
+        "tab_ner": "Entidades", # <-- ADDED
         "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", # <-- ADDED
         "error_message": "Error: "
     }
 }
 
-# This global dict holds the *loaded* models
 MODELS: Dict[str, Optional[spacy.Language]] = {}
 
 # ============================================================================
@@ -92,9 +95,7 @@ MODELS: Dict[str, Optional[spacy.Language]] = {}
 # ============================================================================
 
 def install_spacy_transformers_once():
-    """
-    Installs spacy-transformers, required for all _trf models.
-    """
+    """ Installs spacy-transformers, required for all _trf models. """
     marker_file = Path(".spacy_transformers_installed")
     if marker_file.exists():
         print("✓ spacy-transformers already installed (marker found)")
@@ -113,10 +114,7 @@ def install_spacy_transformers_once():
         return False
 
 def install_grecy_model_from_github(model_name: str) -> bool:
-    """
-    Installs a greCy model from your specific GitHub Release.
-    Uses --no-deps to prevent dependency conflicts.
-    """
+    """ Installs a greCy model from your specific GitHub Release. """
     marker_file = Path(f".{model_name}_installed")
     if marker_file.exists():
         print(f"✓ {model_name} already installed (marker found)")
@@ -124,16 +122,15 @@ def install_grecy_model_from_github(model_name: str) -> bool:
 
     print(f"Installing grecy model: {model_name}...")
 
-    # --- *** THIS IS THE CRITICAL FILENAME FIX *** ---
-    # The wheel filename's "distribution" part uses underscores,
-    # not hyphens, to be PEP 427 compliant.
     if model_name == "grc_proiel_trf":
         wheel_filename = "grc_proiel_trf-3.7.5-py3-none-any.whl"
-    else:
-        # All other models use the 0.0.0 version and underscore in name
-        # e.g., grc_perseus_trf-0.0.0-py3-none-any.whl
+    # --- UPDATED: Added grc_ner_trf to this list ---
+    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"
-    # --- *** END FIX *** ---
+    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"]
@@ -150,11 +147,6 @@ def install_grecy_model_from_github(model_name: str) -> bool:
         print(f"✗ Installation subprocess FAILED with code {e.returncode}")
         print("STDOUT:", e.stdout)
         print("STDERR:", e.stderr)
-        print("\n\n!! --- NOTE --- !!")
-        print(f"If the error is 'Invalid wheel filename', it means the files on your GitHub Release are named incorrectly.")
-        print(f"You must delete the release and re-run the fixed 'create_grecy_release.sh' script.")
-        print(f"The correct filename should be: '{wheel_filename}'.")
-        print("!! --- END NOTE --- !!\n\n")
         return False
     except Exception as e:
         print(f"✗ Installation exception: {e}")
@@ -162,7 +154,7 @@ def install_grecy_model_from_github(model_name: str) -> bool:
         return False
 
 # ============================================================================
-# MODEL LOADING (NOW WITH LAZY LOADING)
+# MODEL LOADING (LAZY LOADING)
 # ============================================================================
 
 def load_spacy_model(model_name: str) -> Optional[spacy.Language]:
@@ -179,10 +171,7 @@ def load_spacy_model(model_name: str) -> Optional[spacy.Language]:
             return None
 
 def load_grecy_model(model_name: str) -> Optional[spacy.Language]:
-    """
-    Load a grecy model.
-    First, installs it from our GitHub. Then, loads it.
-    """
+    """ Load a grecy model, installing from GitHub if needed. """
     if not install_grecy_model_from_github(model_name):
         print(f"✗ Cannot load {model_name} because installation failed.")
         return None
@@ -190,7 +179,7 @@ def load_grecy_model(model_name: str) -> Optional[spacy.Language]:
         print("Refreshing importlib to find new package...")
         importlib.invalidate_caches()
         try: importlib.reload(site)
-        except Exception: pass # Fails in some envs, but that's ok
+        except Exception: pass
 
         print(f"Trying: spacy.load('{model_name}')")
         nlp = spacy.load(model_name)
@@ -203,16 +192,11 @@ def load_grecy_model(model_name: str) -> Optional[spacy.Language]:
         return None
 
 def initialize_models():
-    """
-    Load all *non-grecy* models at startup for speed.
-    Grecy models will be lazy-loaded on first use.
-    Also ensures spacy-transformers is installed.
-    """
+    """ Pre-load standard models and ensure _trf dependencies are ready. """
     print("\n" + "="*70)
     print("INITIALIZING MODELS")
     print("="*70 + "\n")
     
-    # First, ensure dependencies are met
     install_spacy_transformers_once()
     
     loaded_count = 0
@@ -223,22 +207,21 @@ def initialize_models():
             spacy_model_count += 1
             print(f"Loading {lang_name} ({model_name})...")
             nlp = load_spacy_model(model_name)
-            MODELS[lang_code] = nlp # Store the loaded model
+            MODELS[lang_code] = nlp
             if nlp:
                 print(f"✓ {lang_name} ready\n")
                 loaded_count += 1
             else:
                 print(f"✗ {lang_name} FAILED\n")
         else:
-            # It's a grecy model, just mark as not loaded yet
             print(f"✓ {lang_name} ({model_name}) will be loaded on first use.\n")
-            MODELS[lang_code] = None # Mark as available but not loaded
+            MODELS[lang_code] = None
     
     print(f"Pre-loaded {loaded_count}/{spacy_model_count} standard models.")
     print("="*70 + "\n")
 
 # ============================================================================
-# ANALYSIS (WITH LAZY LOADING)
+# ANALYSIS (WITH NER)
 # ============================================================================
 
 def get_analysis(ui_lang: str, model_lang_key: str, text: str):
@@ -248,36 +231,29 @@ def get_analysis(ui_lang: str, model_lang_key: str, text: str):
     
     try:
         if not text.strip():
-            return ([], [], "<p style='color: orange;'>No text provided.</p>",
+            # Return empty values for all outputs
+            return ([], [], "<p style='color: orange;'>No text provided.</p>", "",
                     gr.Button(value=ui_config["button_text"], interactive=True))
         
-        # --- LAZY LOADING LOGIC ---
         nlp = MODELS.get(model_lang_key)
         
         if nlp is None:
-            # Model hasn't been loaded yet
             print(f"First use of {model_lang_key}. Loading model...")
-            
             if model_lang_key not in MODEL_INFO:
                  raise ValueError(f"Unknown model key: {model_lang_key}")
-            
             _, model_name, model_type = MODEL_INFO[model_lang_key]
             
             if model_type == "grecy":
                 nlp = load_grecy_model(model_name)
             else:
-                # This case should be pre-loaded, but as a fallback
                 nlp = load_spacy_model(model_name)
             
             if nlp is None:
-                # Failed to load
-                MODELS.pop(model_lang_key, None) # Remove from cache to try again next time
+                MODELS.pop(model_lang_key, None)
                 raise ValueError(f"Model for {model_lang_key} ({model_name}) FAILED to load. Check logs.")
             else:
-                # Store in cache
                 MODELS[model_lang_key] = nlp
                 print(f"✓ {model_lang_key} is now loaded and cached.")
-        # --- END LAZY LOADING ---
         
         doc = nlp(text)
         
@@ -296,32 +272,48 @@ def get_analysis(ui_lang: str, model_lang_key: str, text: 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_out = ""
-        if doc.has_annotation("DEP"):
+        # --- DEPENDENCY PARSE VISUALIZATION ---
+        html_dep_out = ""
+        if "parser" in nlp.pipe_names:
             try:
                 options = {"compact": True, "bg": "#ffffff", "color": "#000000", "font": "Source Sans Pro"}
                 html_svg = displacy.render(doc, style="dep", jupyter=False, options=options)
                 svg_b64 = base64.b64encode(html_svg.encode("utf-8")).decode("utf-8")
-                html_out = f'<div style="background-color: #ffffff; overflow-x: auto; border: 1px solid #e6e9ef; border-radius: 0.25rem; padding: 1rem; line-height: 2.5;"><img src="data:image/svg+xml;base64,{svg_b64}" /></div>'
+                html_dep_out = f'<div style="overflow-x: auto; border: 1px solid #e6e9ef; border-radius: 0.25rem; padding: 1rem; line-height: 2.5;"><img src="data:image/svg+xml;base64,{svg_b64}" /></div>'
             except Exception as e:
-                html_out = f"<p style='color: orange;'>Visualization error: {e}</p>"
+                html_dep_out = f"<p style='color: orange;'>Visualization error (DEP): {e}</p>"
         else:
-            html_out = "<p style='color: orange;'>Dependency parsing not available for this model.</p>"
+            html_dep_out = "<p style='color: orange;'>Dependency parsing ('parser') not available for this model.</p>"
         
-        return (dataframe_output, json_output, html_out,
+        # --- NAMED ENTITY VISUALIZATION (NEW) ---
+        html_ner_out = ""
+        if "ner" in nlp.pipe_names:
+            if doc.ents:
+                try:
+                    # Let displacy use its default colors
+                    html_ner_out = displacy.render(doc, style="ent", jupyter=False)
+                    html_ner_out = f'<div style="overflow-x: auto; border: 1px solid #e6e9ef; border-radius: 0.25rem; padding: 1rem; line-height: 2.5;">{html_ner_out}</div>'
+                except Exception as e:
+                    html_ner_out = f"<p style='color: orange;'>Visualization error (NER): {e}</p>"
+            else:
+                html_ner_out = "<p>No named entities found in this text.</p>"
+        else:
+            html_ner_out = "<p style='color: orange;'>Named Entity Recognition ('ner') not available for this model.</p>"
+        
+        return (dataframe_output, json_output, html_dep_out, html_ner_out,
                 gr.Button(value=ui_config["button_text"], interactive=True))
         
     except Exception as e:
         traceback.print_exc()
         error_html = f"<div style='color: red; border: 1px solid red; padding: 10px; border-radius: 5px; background-color: #fff5f5;'><strong>{error_prefix}</strong> {str(e)}</div>"
-        return ([[f"{error_prefix}{str(e)}"]], {"error": str(e)}, error_html,
+        # Return error for all 4 outputs
+        return ([[f"{error_prefix}{str(e)}"]], {"error": str(e)}, error_html, error_html,
                 gr.Button(value=ui_config["button_text"], interactive=True))
 
 # ============================================================================
-# UI
+# UI (UPDATED FOR NER)
 # ============================================================================
 
 def update_ui(ui_lang: str):
@@ -337,26 +329,25 @@ def update_ui(ui_lang: str):
         gr.Tab(label=ui_config["tab_graphic"]),
         gr.Tab(label=ui_config["tab_table"]),
         gr.Tab(label=ui_config["tab_json"]),
+        gr.Tab(label=ui_config["tab_ner"]), # <-- ADDED
         gr.HTML(label=ui_config["html_label"]),
         gr.DataFrame(label=ui_config["table_label"], headers=ui_config["table_headers"], interactive=False),
-        gr.JSON(label=ui_config["json_label"])
+        gr.JSON(label=ui_config["json_label"]),
+        gr.HTML(label=ui_config["ner_label"]) # <-- ADDED
     ]
 
 def create_interface():
     """Create Gradio interface."""
     config = UI_TEXT["en"]
-    
-    # Use the keys from MODEL_INFO as the choices
     model_choices = list(MODEL_INFO.keys())
     
     with gr.Blocks(title="Multilingual Morpho-Syntactic Analyzer") as demo:
         with gr.Row():
             ui_lang_radio = gr.Radio(["DE", "EN", "ES"], label=config["ui_lang_label"], value="EN")
-            # Update the radio to pass the key, but display the friendly name
             model_lang_radio = gr.Radio(
-                choices=[(MODEL_INFO[k][0], k) for k in model_choices], # (Label, Value)
+                choices=[(MODEL_INFO[k][0], k) for k in model_choices],
                 label=config["model_lang_label"],
-                value=model_choices[0] # Default to the first key
+                value=model_choices[0]
             )
         
         markdown_title = gr.Markdown(config["title"])
@@ -366,19 +357,28 @@ def create_interface():
         
         with gr.Tabs():
             with gr.Tab(config["tab_graphic"]) as tab_graphic:
-                html_out = gr.HTML(label=config["html_label"])
+                html_dep_out = gr.HTML(label=config["html_label"])
+            # --- ADDED NEW TAB ---
+            with gr.Tab(config["tab_ner"]) as tab_ner:
+                html_ner_out = gr.HTML(label=config["ner_label"])
+            # --- END ADDITION ---
             with gr.Tab(config["tab_table"]) as tab_table:
                 df_out = gr.DataFrame(label=config["table_label"], headers=config["table_headers"], interactive=False)
             with gr.Tab(config["tab_json"]) as tab_json:
                 json_out = gr.JSON(label=config["json_label"])
         
-        analyze_button.click(fn=get_analysis, inputs=[ui_lang_radio, model_lang_radio, text_input],
-                              outputs=[df_out, json_out, html_out, analyze_button], api_name="get_morphology")
+        # --- UPDATED OUTPUTS ---
+        analyze_button.click(fn=get_analysis, 
+                             inputs=[ui_lang_radio, model_lang_radio, text_input],
+                             outputs=[df_out, json_out, html_dep_out, html_ner_out, analyze_button], 
+                             api_name="get_morphology")
         
-        ui_lang_radio.change(fn=update_ui, inputs=ui_lang_radio,
-                               outputs=[markdown_title, markdown_subtitle, ui_lang_radio, model_lang_radio,
-                                        text_input, analyze_button, tab_graphic, tab_table, tab_json,
-                                        html_out, df_out, json_out])
+        # --- UPDATED OUTPUTS ---
+        ui_lang_radio.change(fn=update_ui, 
+                             inputs=ui_lang_radio,
+                             outputs=[markdown_title, markdown_subtitle, ui_lang_radio, model_lang_radio,
+                                      text_input, analyze_button, tab_graphic, tab_table, tab_json, tab_ner,
+                                      html_dep_out, df_out, json_out, html_ner_out])
     return demo
 
 # ============================================================================