Update app.py

app.py

@@ -1,357 +1,513 @@
 import gradio as gr
 import spacy
-# Removed: import spacy_transformers
-import os
-import subprocess # Keep for spacy download fallback
-import sys
 from spacy import displacy
 import base64
 import traceback
-import shlex # Import shlex for safer command splitting
-
-# --- 1. UI Translations ---
-# (Keep UI text dictionary as before, but only DE, EN, ES needed now)
-UI_TEXT = {
-    "de": {
-        "title": "# NLP-Analysator (mit spaCy)",
-        "subtitle": "Geben Sie einen Text ein, um die morphologischen Details für jedes Wort zu erhalten.\n**Um dies als API zu verwenden, klicken Sie auf den \"View API\"-Link unten.**",
-        "ui_lang_label": "UI Sprache",
-        "model_lang_label": "Textsprache (Modell)",
-        "input_label": "Eingabetext",
-        "input_placeholder": "Die schnellen braunen Füchse...",
-        "button_text": "Analysieren",
-        "button_processing_text": "Verarbeite...",
-        "tab_graphic": "Syntaktische Analyse (Grafik)",
-        "tab_table": "Visuelle Tabelle (Tokens)",
-        "tab_json": "Roh-JSON (für API)",
-        "html_label": "Abhängigkeits-Parse",
-        "table_label": "Analyse-Ergebnisse (Tabelle)",
-        "table_headers": ["Wort", "Lemma", "POS", "Tag (detailliert)", "Morphologie", "Abhängigkeit"],
-        "json_label": "Analyse-Ergebnisse (JSON)",
-        "error_message": "Fehler bei der Textverarbeitung: "
-    },
-    "en": {
-        "title": "# NLP Analyzer (with spaCy)",
-        "subtitle": "Enter any text to get the morphological details for each word.\n**To use this as an API, click the \"View API\" link at the bottom.**",
-        "ui_lang_label": "UI Language",
-        "model_lang_label": "Text Language (Model)",
-        "input_label": "Input Text",
-        "input_placeholder": "The quick brown foxes...",
-        "button_text": "Analyze",
-        "button_processing_text": "Processing...",
-        "tab_graphic": "Syntactic Analysis (Graphic)",
-        "tab_table": "Visual Table (Tokens)",
-        "tab_json": "Raw JSON (for API)",
-        "html_label": "Dependency Parse",
-        "table_label": "Analysis Results (Table)",
-        "table_headers": ["Word", "Lemma", "POS", "Tag (detailed)", "Morphology", "Dependency"],
-        "json_label": "Analysis Results (JSON)",
-        "error_message": "Error processing text: "
-    },
-    "es": {
-        "title": "# Analizador NLP (con spaCy)",
-        "subtitle": "Ingrese cualquier texto para obtener los detalles morfológicos de cada palabra.\n**Para usar esto como API, haga clic en el enlace \"View API\" en la parte inferior.**",
-        "ui_lang_label": "Idioma de UI",
-        "model_lang_label": "Idioma del Texto (Modelo)",
-        "input_label": "Texto de entrada",
-        "input_placeholder": "Los rápidos zorros marrones...",
-        "button_text": "Analizar",
-        "button_processing_text": "Procesando...",
-        "tab_graphic": "Análisis Sintáctico (Gráfico)",
-        "tab_table": "Tabla Visual (Tokens)",
-        "tab_json": "JSON Crudo (para API)",
-        "html_label": "Análisis de Dependencia",
-        "table_label": "Resultados del Análisis (Tabla)",
-        "table_headers": ["Palabra", "Lema", "POS", "Tag (detallado)", "Morfología", "Dependencia"],
-        "json_label": "Resultados del Análisis (JSON)",
-        "error_message": "Error al procesar el texto: "
-    }
-}
+import sys
+import os
+import subprocess
+import importlib
+from typing import Dict, Optional, Tuple, List
 
+# ============================================================================
+# CONFIGURATION
+# ============================================================================
 
-# --- 2. Model Loading Info ---
-# Define model types: 'spacy' (standard download), 'grecy' (uses grecy install)
 MODEL_INFO = {
-    # lang_code: (model_type, model_name_to_load, install_arg [optional])
-    "de": ("spacy", "de_core_news_md", "de_core_news_md"),
-    "en": ("spacy", "en_core_web_md", "en_core_web_md"),
-    "es": ("spacy", "es_core_news_md", "es_core_news_md"),
-    "grc": ("grecy", "grc_proiel_trf", "grc_proiel_trf"), # Use grecy install model_name
-    # Removed HE, AR, LA
+    "de": ("German", "de_core_news_md", "spacy"),
+    "en": ("English", "en_core_web_md", "spacy"),
+    "es": ("Spanish", "es_core_news_md", "spacy"),
+    "grc": ("Ancient Greek", "grc_proiel_trf", "grecy")
 }
 
-def load_model(lang_code, model_info):
-    """
-    Loads a spaCy model based on its type, handling installation/download failures.
-    """
-    model_type, model_name_to_load, install_arg = model_info
-    nlp = None
-
-    try:
-        # First, try loading directly
-        nlp = spacy.load(model_name_to_load)
-        print(f"Model '{model_name_to_load}' loaded successfully for '{lang_code}'.")
+UI_TEXT = {
+    "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",
+        "html_label": "Abhängigkeitsparsing",
+        "table_label": "Morphologische Analyse",
+        "table_headers": ["Wort", "Lemma", "POS", "Tag", "Morphologie", "Abhängigkeit"],
+        "json_label": "JSON-Ausgabe",
+        "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",
+        "html_label": "Dependency Parsing",
+        "table_label": "Morphological Analysis",
+        "table_headers": ["Word", "Lemma", "POS", "Tag", "Morphology", "Dependency"],
+        "json_label": "JSON Output",
+        "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",
+        "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",
+        "error_message": "Error: "
+    }
+}
 
-    except OSError:
-        # If loading fails, attempt installation based on model_type
-        print(f"Model '{model_name_to_load}' not found or failed initial load. Attempting installation...")
-        install_success = False # Flag specifically for install types
-        try:
-            if model_type == "spacy" and install_arg:
-                print(f"Running: spacy download {install_arg}")
-                subprocess.check_call([sys.executable, "-m", "spacy", "download", install_arg])
-                install_success = True
-                print(f"spaCy download for '{install_arg}' completed.")
+# ============================================================================
+# MODEL MANAGEMENT
+# ============================================================================
+
+MODELS: Dict[str, Optional[spacy.Language]] = {}
+
+def install_spacy_model(model_name: str) -> bool:
+    """Install a standard spaCy model."""
+    try:
+        print(f"Installing spaCy model: {model_name}")
+        subprocess.check_call(
+            [sys.executable, "-m", "spacy", "download", model_name],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        print(f"✓ Successfully installed {model_name}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"✗ Failed to install {model_name}: {e}")
+        return False
+
+def install_grecy_model(model_name: str) -> bool:
+    """Install a grecy model for Ancient Greek."""
+    try:
+        # First ensure grecy package is installed
+        print(f"Ensuring grecy package is installed...")
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", "-U", "grecy"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        
+        print(f"Installing grecy model: {model_name}")
+        result = subprocess.run(
+            [sys.executable, "-m", "grecy", "install", model_name],
+            capture_output=True,
+            text=True,
+            timeout=600  # 10 minute timeout for large models
+        )
+        
+        print(result.stdout)
+        if result.stderr:
+            print(f"stderr: {result.stderr}")
+        
+        if result.returncode == 0:
+            print(f"✓ Successfully installed grecy model {model_name}")
+            # Invalidate import caches to help Python find the new model
+            importlib.invalidate_caches()
+            return True
+        else:
+            print(f"✗ Failed to install {model_name}, return code: {result.returncode}")
+            return False
             
-            # --- THIS BLOCK IS THE FIX ---
-            elif model_type == "grecy" and install_arg:
-                 # Grecy needs to run its own command, using the *current* Python executable
-                 print(f"Running: {sys.executable} -m grecy install {install_arg}")
-                 # Use sys.executable to ensure it installs into the correct environment
-                 subprocess.check_call([sys.executable, "-m", "grecy", "install", install_arg])
-                 install_success = True
-                 print(f"Grecy install for '{install_arg}' completed.")
-            # --- END OF FIX ---
+    except subprocess.TimeoutExpired:
+        print(f"✗ Installation of {model_name} timed out")
+        return False
+    except Exception as e:
+        print(f"✗ Error installing {model_name}: {e}")
+        traceback.print_exc()
+        return False
+
+def load_model_with_retry(lang_code: str, model_name: str, model_type: str, max_retries: int = 2) -> Optional[spacy.Language]:
+    """
+    Load a spaCy model with installation retry logic.
+    
+    Args:
+        lang_code: Language code (e.g., 'de', 'en', 'grc')
+        model_name: Name of the model to load
+        model_type: Type of model ('spacy' or 'grecy')
+        max_retries: Maximum number of installation attempts
+    
+    Returns:
+        Loaded spaCy model or None if loading fails
+    """
+    for attempt in range(max_retries):
+        try:
+            print(f"Attempt {attempt + 1}/{max_retries}: Loading model '{model_name}' for language '{lang_code}'")
             
-            else:
-                 print(f"--- WARNING: No installation method defined for model type '{model_type}' or missing install_arg for '{model_name_to_load}'. ---")
-
-            # --- Installation Attempt Finished ---
-
-            # Try loading again *only* if an installation was attempted
-            if install_success:
-                print(f"Attempting to load '{model_name_to_load}' again after installation...")
-                nlp = spacy.load(model_name_to_load)
-                print(f"Model '{model_name_to_load}' loaded successfully after installation for '{lang_code}'.")
-            else:
-                 # If no install method was triggered or defined
-                 raise OSError(f"Model '{model_name_to_load}' not found and no valid installation method triggered.")
-
-
-        # --- Error Handling during Installation/Secondary Load ---
-        except subprocess.CalledProcessError as e:
-            print(f"--- ERROR: Installation command failed for '{model_name_to_load}'. Error: {e} ---")
-            raise OSError(f"[E050] Can't find model '{model_name_to_load}' after installation attempt failed.") from e
-        except OSError as e: # Catch failure during the second spacy.load()
-            print(f"--- ERROR: Failed to load model '{model_name_to_load}' even after installation attempt. Error: {e} ---")
-            raise
-        except Exception as e: # Catch other unexpected errors during install/load
-            print(f"--- ERROR: An unexpected error occurred during installation/load for '{model_name_to_load}': {e} ---")
-            traceback.print_exc()
-            raise
-
-    # --- Catch Errors During Initial Load ---
-    except Exception as e: # Catch any other unexpected loading errors during initial spacy.load
-         print(f"--- ERROR: An unexpected error occurred trying to initially load model '{model_name_to_load}' for language '{lang_code}': {e} ---")
-         traceback.print_exc()
-         raise # Re-raise error
-
-    # Final check
-    if nlp is None:
-         raise RuntimeError(f"Model object for '{model_name_to_load}' is None after loading attempts.")
-
-    return nlp
-
-
-# Load all models at startup and store them in a dictionary
-print("Loading all models...")
-MODELS = {}
-loading_errors = False
-
-# Ensure spacy itself is loaded before trying to load models
-try:
-    import spacy
-    print(f"Using spaCy version: {spacy.__version__}")
-except ImportError as e:
-    print(f"--- FATAL ERROR: Failed to import spaCy. Check requirements.txt. Error: {e} ---")
-    sys.exit(1) # Exit if core dependencies are missing
-
-for lang_code, model_info_tuple in MODEL_INFO.items():
-    try:
-        MODELS[lang_code] = load_model(lang_code, model_info_tuple)
-    except Exception as e:
-        print(f"--- MODEL LOAD FAILED for language '{lang_code}'. Error: {e} ---")
-        # Don't print "FATAL" here, allow others to load
-        loading_errors = True
-        MODELS[lang_code] = None # Explicitly mark as failed
-
-if not loading_errors:
-    print("All specified models loaded successfully.")
-else:
-    print("--- WARNING: One or more models failed to load. The app will run but analysis for failed languages will not work. Check logs above. ---")
-
-
-# --- 3. The Core Processing Function (with Error Handling) ---
-def get_analysis(ui_lang, model_lang, text, analyze_button_state):
-    """
-    Processes text in the selected language and returns FOUR formats:
-    1. A list of lists for the visual DataFrame (or error message).
-    2. A list of dicts for the JSON API (or error message).
-    3. An HTML string for the dependency parse visualization (or error message).
-    4. An updated, re-enabled analyze button.
-    """
-    current_ui_lang_code = ui_lang.lower()
-    current_ui_config = UI_TEXT.get(current_ui_lang_code, UI_TEXT["en"])
-    error_prefix = current_ui_config["error_message"]
-    yield {analyze_button: gr.Button(interactive=False, value=current_ui_config["button_processing_text"])}
-    try:
-        if not text:
-            yield {
-                df_out: [], json_out: [], html_out: "",
-                analyze_button: gr.Button(interactive=True, value=current_ui_config["button_text"])
-            }
-            return
-        # Extract lang code like 'GRC' from 'GRC (grc_proiel_trf)'
-        lang_code = model_lang.split(" ")[0].lower()
-
-        if lang_code not in MODELS or MODELS[lang_code] is None:
-             raise ValueError(f"Model for language code '{lang_code}' failed to load during startup or is unavailable. Cannot process text.")
-
-        nlp = MODELS[lang_code]
-        doc = nlp(text)
-        dataframe_output = []
-        json_output = []
-
-        # Extract data, accessing attributes directly and providing fallbacks
-        for token in doc:
-            # Use getattr to safely access attributes with a default value ('') if missing
-            morph_str = str(getattr(token, 'morph', ''))
-            dep_str = getattr(token, 'dep_', '') if doc.has_annotation("DEP") else "" # Keep DEP check here
-            tag_str = getattr(token, 'tag_', '')
-            pos_str = getattr(token, 'pos_', '')
-            # Lemma check remains the same
-            lemma_str = token.lemma_ if getattr(token, 'lemma', 0) != 0 else token.text
-
-            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 # is_stop should generally be safe
-            })
-            dataframe_output.append([
-                token.text,
-                lemma_str,
-                pos_str,
-                tag_str,
-                morph_str,
-                dep_str
-  _B_])
-
-        options = {"compact": True, "bg": "#ffffff", "color": "#000000", "font": "Source Sans Pro"}
-
-        # Use displacy only if the model supports parsing (has DEP annotation)
-        html_out_content = ""
-        if doc.has_annotation("DEP"):
-             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_content = 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>
-             """
-        else:
-             # Provide more context if dependency info is missing
-             model_name_used = MODEL_INFO.get(lang_code, ("unknown", "", ""))[1] # Get model name/path
-             html_out_content = f"<p style='color: orange;'>Dependency parse visualization not available for the selected model ('{model_name_used}'). Ensure the loaded pipeline includes a parser component.</p>"
-
-
-        yield {
-            df_out: dataframe_output, json_out: json_output, html_out: html_out_content,
-            analyze_button: gr.Button(interactive=True, value=current_ui_config["button_text"])
-        }
-    except Exception as e:
-        print(f"--- ERROR during get_analysis ---")
-        traceback.print_exc()
-        error_details = str(e)
-        error_html = f"<div style='color: red; border: 1px solid red; padding: 10px; border-radius: 5px;'>{error_prefix}{error_details}</div>"
-        yield {
-            df_out: [[f"{error_prefix}{error_details}"]],
-            json_out: {"error": error_details},
-            html_out: error_html,
-            analyze_button: gr.Button(interactive=True, value=current_ui_config["button_text"])
-        }
-
-
-# --- 4. UI Update Function ---
-# (No changes needed here)
-def update_ui(ui_lang):
-    """Updates all UI components when the language is changed."""
-    lang_code = ui_lang.lower()
-    ui_config = UI_TEXT[lang_code]
-    return {
-        markdown_title: gr.Markdown(value=ui_config["title"]),
-        markdown_subtitle: gr.Markdown(value=ui_config["subtitle"]),
-        ui_lang_radio: gr.Radio(label=ui_config["ui_lang_label"]),
-        model_lang_radio: gr.Radio(label=ui_config["model_lang_label"]),
-        text_input: gr.Textbox(
-            label=ui_config["input_label"],
-            placeholder=ui_config["input_placeholder"]
-        ),
-        analyze_button: gr.Button(value=ui_config["button_text"]),
-button_text"]),
-        tab_graphic: gr.Tab(label=ui_config["tab_graphic"]),
-        tab_table: gr.Tab(label=ui_config["tab_table"]),
-        tab_json: gr.Tab(label=ui_config["tab_json"]),
-        html_out: gr.HTML(label=ui_config["html_label"]),
-        df_out: gr.DataFrame(
-            label=ui_config["table_label"],
-            headers=ui_config["table_headers"],
-            interactive=False
-        ),
-        json_out: gr.JSON(label=ui_config["json_label"])
-    }
-
-
-# --- 5. Gradio Interface ---
-with gr.Blocks() as demo:
-    default_config = UI_TEXT["de"]
-    with gr.Row():
-        ui_lang_radio = gr.Radio(
-            ["DE", "EN", "ES"], label=default_config["ui_lang_label"], value="DE"
-        )
-        # Dynamically generate choices from updated MODEL_INFO keys
-        model_lang_choices = [f"{k.upper()} ({v[1]})" for k, v in MODEL_INFO.items()]
-        model_lang_radio = gr.Radio(
-            model_lang_choices,
-            label=default_config["model_lang_label"], value=model_lang_choices[0] # Default to first model
-        )
-    markdown_title = gr.Markdown(default_config["title"])
-    markdown_subtitle = gr.Markdown(default_config["subtitle"])
-    text_input = gr.Textbox(
-        label=default_config["input_label"], placeholder=default_config["input_placeholder"], lines=5
-    )
-    analyze_button = gr.Button(default_config["button_text"], variant="primary")
-    with gr.Tabs() as tabs:
-        with gr.Tab(default_config["tab_graphic"]) as tab_graphic:
-            html_out = gr.HTML(label=default_config["html_label"])
-        with gr.Tab(default_config["tab_table"]) as tab_table:
-            df_out = gr.DataFrame(
-                label=default_config["table_label"], headers=default_config["table_headers"], interactive=False
-            )
-        with gr.Tab(default_config["tab_json"]) as tab_json:
-            json_out = gr.JSON(label=default_config["json_label"])
-    analyze_button_state = gr.State(value=True)
-
-    # --- 6. Event Listeners ---
-    # (No changes needed here)
-    analyze_button.click(
-        fn=get_analysis,
-        inputs=[ui_lang_radio, model_lang_radio, text_input, analyze_button_state],
-        outputs=[df_out, json_out, html_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
-        ]
-    )
-
-# Launch the app
-demo.launch()
+            # Try to load the model
+            nlp = spacy.load(model_name)
+            print(f"✓ Successfully loaded {model_name}")
+            return nlp
+            
+        except OSError as e:
+            print(f"✗ Model '{model_name}' not found: {e}")
+            
+            if attempt < max_retries - 1:
+                # Try to install the model
+                print(f"Attempting to install {model_name}...")
+                
+                if model_type == "spacy":
+                    success = install_spacy_model(model_name)
+                elif model_type == "grecy":
+                    success = install_grecy_model(model_name)
+                else:
+                    print(f"Unknown model type: {model_type}")
+                    return None
+                
+                if not success:
+                    print(f"Installation failed for {model_name}")
+                    if attempt == max_retries - 2:
+                        return None
+                else:
+                    # Give the system a moment to register the new model
+                    import time
+                    time.sleep(2)
+                    # Refresh Python's module cache
+                    importlib.invalidate_caches()
+            else:
+                print(f"✗ All attempts to load {model_name} failed")
+                return None
+        
+        except Exception as e:
+            print(f"✗ Unexpected error loading {model_name}: {e}")
+            traceback.print_exc()
+            return None
+    
+    return None
+
+def initialize_models():
+    """Initialize all models at startup."""
+    print("\n" + "="*70)
+    print("INITIALIZING MODELS")
+    print("="*70)
+    
+    for lang_code, (lang_name, model_name, model_type) in MODEL_INFO.items():
+        print(f"\n--- Loading {lang_name} ({model_name}) ---")
+        
+        nlp = load_model_with_retry(lang_code, model_name, model_type)
+        
+        if nlp is not None:
+            MODELS[lang_code] = nlp
+            print(f"✓ {lang_name} model ready")
+        else:
+            MODELS[lang_code] = None
+            print(f"✗ {lang_name} model FAILED - analysis will be unavailable")
+    
+    print("\n" + "="*70)
+    print("MODEL INITIALIZATION COMPLETE")
+    print("="*70)
+    
+    # Print summary
+    loaded = sum(1 for model in MODELS.values() if model is not None)
+    total = len(MODELS)
+    print(f"\nLoaded {loaded}/{total} models successfully")
+    
+    if loaded < total:
+        print("\n⚠ WARNING: Some models failed to load")
+        for lang_code, model in MODELS.items():
+            if model is None:
+                lang_name = MODEL_INFO[lang_code][0]
+                print(f"  - {lang_name} ({lang_code}): UNAVAILABLE")
+    
+    print("\n")
+
+# ============================================================================
+# TEXT ANALYSIS
+# ============================================================================
+
+def get_analysis(ui_lang: str, model_lang: str, text: str, analyze_button: gr.Button):
+    """
+    Perform morpho-syntactic analysis on the input text.
+    
+    Yields progressive updates to the UI components.
+    """
+    current_ui_lang_code = ui_lang.lower()
+    current_ui_config = UI_TEXT.get(current_ui_lang_code, UI_TEXT["en"])
+    error_prefix = current_ui_config["error_message"]
+    
+    # Disable button during processing
+    yield {
+        analyze_button: gr.Button(interactive=False, value=current_ui_config["button_processing_text"])
+    }
+    
+    try:
+        # Validate input
+        if not text or not text.strip():
+            yield {
+                "df_out": [],
+                "json_out": [],
+                "html_out": "<p style='color: orange;'>No text provided for analysis.</p>",
+                "analyze_button": gr.Button(interactive=True, value=current_ui_config["button_text"])
+            }
+            return
+        
+        # Extract language code from selection like 'GRC (grc_proiel_trf)'
+        lang_code = model_lang.split(" ")[0].lower()
+        
+        # Check if model is available
+        if lang_code not in MODELS:
+            raise ValueError(f"Unknown language code: '{lang_code}'")
+        
+        if MODELS[lang_code] is None:
+            lang_name = MODEL_INFO[lang_code][0]
+            model_name = MODEL_INFO[lang_code][1]
+            raise ValueError(
+                f"Model for {lang_name} ('{model_name}') failed to load during startup. "
+                f"Please check the logs or try restarting the Space."
+            )
+        
+        # Get the model and process text
+        nlp = MODELS[lang_code]
+        doc = nlp(text)
+        
+        # Prepare outputs
+        dataframe_output = []
+        json_output = []
+        
+        # Extract linguistic information for each token
+        for token in doc:
+            # Safely extract attributes
+            morph_str = str(token.morph) if hasattr(token, 'morph') else ''
+            dep_str = token.dep_ if doc.has_annotation("DEP") else ''
+            tag_str = token.tag_ if hasattr(token, 'tag_') else ''
+            pos_str = token.pos_ if hasattr(token, 'pos_') else ''
+            lemma_str = token.lemma_ if token.lemma != 0 else token.text
+            
+            # Add to JSON output
+            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
+            })
+            
+            # Add to dataframe output
+            dataframe_output.append([
+                token.text,
+                lemma_str,
+                pos_str,
+                tag_str,
+                morph_str,
+                dep_str
+            ])
+        
+        # Generate dependency visualization if available
+        html_out_content = ""
+        if doc.has_annotation("DEP"):
+            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_content = 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}" alt="Dependency Parse" />
+                </div>
+                """
+            except Exception as viz_error:
+                print(f"Warning: Could not generate visualization: {viz_error}")
+                html_out_content = f"<p style='color: orange;'>Dependency visualization could not be generated: {viz_error}</p>"
+        else:
+            model_name = MODEL_INFO[lang_code][1]
+            html_out_content = f"""
+            <p style='color: orange;'>
+                Dependency parse visualization is not available for the selected model ('{model_name}'). 
+                The model may not include a parser component.
+            </p>
+            """
+        
+        # Yield final results
+        yield {
+            "df_out": dataframe_output,
+            "json_out": json_output,
+            "html_out": html_out_content,
+            "analyze_button": gr.Button(interactive=True, value=current_ui_config["button_text"])
+        }
+        
+    except Exception as e:
+        print(f"--- ERROR during get_analysis ---")
+        traceback.print_exc()
+        
+        error_details = str(e)
+        error_html = f"""
+        <div style='color: red; border: 1px solid red; padding: 10px; border-radius: 5px; 
+                    background-color: #fff5f5;'>
+            <strong>{error_prefix}</strong> {error_details}
+        </div>
+        """
+        
+        yield {
+            "df_out": [[f"{error_prefix}{error_details}"]],
+            "json_out": {"error": error_details},
+            "html_out": error_html,
+            "analyze_button": gr.Button(interactive=True, value=current_ui_config["button_text"])
+        }
+
+# ============================================================================
+# UI UPDATE
+# ============================================================================
+
+def update_ui(ui_lang: str):
+    """Update all UI components when the interface language is changed."""
+    lang_code = ui_lang.lower()
+    ui_config = UI_TEXT.get(lang_code, UI_TEXT["en"])
+    
+    return {
+        "markdown_title": gr.Markdown(value=ui_config["title"]),
+        "markdown_subtitle": gr.Markdown(value=ui_config["subtitle"]),
+        "ui_lang_radio": gr.Radio(label=ui_config["ui_lang_label"]),
+        "model_lang_radio": gr.Radio(label=ui_config["model_lang_label"]),
+        "text_input": gr.Textbox(
+            label=ui_config["input_label"],
+            placeholder=ui_config["input_placeholder"]
+        ),
+        "analyze_button": gr.Button(value=ui_config["button_text"]),
+        "tab_graphic": gr.Tab(label=ui_config["tab_graphic"]),
+        "tab_table": gr.Tab(label=ui_config["tab_table"]),
+        "tab_json": gr.Tab(label=ui_config["tab_json"]),
+        "html_out": gr.HTML(label=ui_config["html_label"]),
+        "df_out": gr.DataFrame(
+            label=ui_config["table_label"],
+            headers=ui_config["table_headers"],
+            interactive=False
+        ),
+        "json_out": gr.JSON(label=ui_config["json_label"])
+    }
+
+# ============================================================================
+# GRADIO INTERFACE
+# ============================================================================
+
+def create_interface():
+    """Create and configure the Gradio interface."""
+    default_config = UI_TEXT["en"]
+    
+    # Generate model choices dynamically
+    model_lang_choices = [
+        f"{k.upper()} ({v[1]})" 
+        for k, v in MODEL_INFO.items()
+    ]
+    
+    with gr.Blocks(title="Multilingual Morpho-Syntactic Analyzer") as demo:
+        # Header
+        with gr.Row():
+            ui_lang_radio = gr.Radio(
+                ["DE", "EN", "ES"],
+                label=default_config["ui_lang_label"],
+                value="EN"
+            )
+            model_lang_radio = gr.Radio(
+                model_lang_choices,
+                label=default_config["model_lang_label"],
+                value=model_lang_choices[0]
+            )
+        
+        markdown_title = gr.Markdown(default_config["title"])
+        markdown_subtitle = gr.Markdown(default_config["subtitle"])
+        
+        # Input section
+        text_input = gr.Textbox(
+            label=default_config["input_label"],
+            placeholder=default_config["input_placeholder"],
+            lines=5
+        )
+        analyze_button = gr.Button(default_config["button_text"], variant="primary")
+        
+        # Output tabs
+        with gr.Tabs() as tabs:
+            with gr.Tab(default_config["tab_graphic"]) as tab_graphic:
+                html_out = gr.HTML(label=default_config["html_label"])
+            
+            with gr.Tab(default_config["tab_table"]) as tab_table:
+                df_out = gr.DataFrame(
+                    label=default_config["table_label"],
+                    headers=default_config["table_headers"],
+                    interactive=False
+                )
+            
+            with gr.Tab(default_config["tab_json"]) as tab_json:
+                json_out = gr.JSON(label=default_config["json_label"])
+        
+        # Event handlers
+        analyze_button.click(
+            fn=get_analysis,
+            inputs=[ui_lang_radio, model_lang_radio, text_input, analyze_button],
+            outputs={
+                "df_out": df_out,
+                "json_out": json_out,
+                "html_out": html_out,
+                "analyze_button": analyze_button
+            },
+            api_name="get_morphology"
+        )
+        
+        ui_lang_radio.change(
+            fn=update_ui,
+            inputs=ui_lang_radio,
+            outputs={
+                "markdown_title": markdown_title,
+                "markdown_subtitle": markdown_subtitle,
+                "ui_lang_radio": ui_lang_radio,
+                "model_lang_radio": model_lang_radio,
+                "text_input": text_input,
+                "analyze_button": analyze_button,
+                "tab_graphic": tab_graphic,
+                "tab_table": tab_table,
+                "tab_json": tab_json,
+                "html_out": html_out,
+                "df_out": df_out,
+                "json_out": json_out
+            }
+        )
+    
+    return demo
+
+# ============================================================================
+# MAIN
+# ============================================================================
+
+if __name__ == "__main__":
+    print("\n" + "="*70)
+    print("MULTILINGUAL MORPHO-SYNTACTIC ANALYZER")
+    print("Starting application...")
+    print("="*70 + "\n")
+    
+    # Initialize all models
+    initialize_models()
+    
+    # Create and launch the interface
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )