attempt direct install grc model on script load

app.py

@@ -3,11 +3,11 @@ import spacy
 from spacy import displacy
 import base64
 import traceback
+import subprocess
 import sys
 import os
-import subprocess
-import importlib
-from typing import Dict, Optional, Tuple, List
+from pathlib import Path
+from typing import Dict, Optional
 
 # ============================================================================
 # CONFIGURATION
@@ -77,44 +77,31 @@ UI_TEXT = {
     }
 }
 
+MODELS: Dict[str, Optional[spacy.Language]] = {}
+
 # ============================================================================
-# MODEL MANAGEMENT
+# GRECY MODEL INSTALLATION
 # ============================================================================
 
-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}")
+def install_grecy_once(model_name: str) -> bool:
+    """
+    Install grecy model only if not already installed.
+    Uses a marker file to track installation.
+    """
+    marker_file = Path(f".{model_name}_installed")
+    
+    if marker_file.exists():
+        print(f"✓ {model_name} already installed (marker found)")
         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."""
+    
+    print(f"Installing grecy model: {model_name} (this will take several minutes)...")
     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}")
+        # Run the grecy install command
         result = subprocess.run(
             [sys.executable, "-m", "grecy", "install", model_name],
             capture_output=True,
             text=True,
-            timeout=600  # 10 minute timeout for large models
+            timeout=900  # 15 minute timeout
         )
         
         print(result.stdout)
@@ -122,395 +109,195 @@ def install_grecy_model(model_name: str) -> bool:
             print(f"stderr: {result.stderr}")
         
         if result.returncode == 0:
-            print(f"✓ Successfully installed grecy model {model_name}")
+            # Create marker file
+            marker_file.touch()
+            print(f"✓ Successfully installed {model_name}")
             return True
         else:
-            print(f"✗ Failed to install {model_name}, return code: {result.returncode}")
+            print(f"✗ Installation failed with return code {result.returncode}")
             return False
             
     except subprocess.TimeoutExpired:
-        print(f"✗ Installation of {model_name} timed out")
+        print(f"✗ Installation timed out")
         return False
     except Exception as e:
-        print(f"✗ Error installing {model_name}: {e}")
+        print(f"✗ Installation error: {e}")
         traceback.print_exc()
         return False
 
-def load_grecy_model_directly(model_name: str) -> Optional[spacy.Language]:
-    """
-    Load grecy model by finding it in site-packages.
-    grecy models install differently than standard spaCy models.
-    """
+# ============================================================================
+# MODEL LOADING
+# ============================================================================
+
+def load_spacy_model(model_name: str) -> Optional[spacy.Language]:
+    """Load or install a standard spaCy model."""
     try:
-        import site
-        import glob
-        
-        # Find the model in site-packages
-        site_packages = site.getsitepackages()
-        
-        for sp in site_packages:
-            # Look for the model directory
-            model_pattern = os.path.join(sp, model_name.replace('_', '-') + '*')
-            matches = glob.glob(model_pattern)
-            
-            if matches:
-                model_path = matches[0]
-                print(f"Found grecy model at: {model_path}")
-                
-                # Try to load from the path
-                nlp = spacy.load(model_path)
-                print(f"✓ Successfully loaded grecy model from {model_path}")
-                return nlp
-        
-        # If not found in site-packages, try standard load
-        print(f"Model not found in site-packages, trying standard load...")
         nlp = spacy.load(model_name)
         return nlp
-        
-    except Exception as e:
-        print(f"✗ Failed to load grecy model directly: {e}")
-        traceback.print_exc()
-        return None
-
-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):
+    except OSError:
+        print(f"Installing {model_name}...")
         try:
-            print(f"Attempt {attempt + 1}/{max_retries}: Loading model '{model_name}' for language '{lang_code}'")
-            
-            # For grecy models, use special loading method
-            if model_type == "grecy":
-                nlp = load_grecy_model_directly(model_name)
-                if nlp is not None:
-                    print(f"✓ Successfully loaded {model_name}")
-                    return nlp
-                raise OSError(f"Could not load grecy model {model_name}")
-            else:
-                # Standard spaCy model loading
-                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
-        
+            subprocess.check_call([sys.executable, "-m", "spacy", "download", model_name])
+            return spacy.load(model_name)
         except Exception as e:
-            print(f"✗ Unexpected error loading {model_name}: {e}")
-            traceback.print_exc()
+            print(f"✗ Failed to install {model_name}: {e}")
             return None
+
+def load_grecy_model(model_name: str) -> Optional[spacy.Language]:
+    """Load a grecy model, installing if necessary."""
+    # First, ensure it's installed
+    install_grecy_once(model_name)
     
-    return None
+    # Try to load it
+    try:
+        nlp = spacy.load(model_name)
+        print(f"✓ Loaded {model_name}")
+        return nlp
+    except Exception as e:
+        print(f"✗ Failed to load {model_name}: {e}")
+        print(f"   Try: python -m grecy install {model_name}")
+        traceback.print_exc()
+        return None
 
 def initialize_models():
-    """Initialize all models at startup."""
+    """Load all models at startup."""
     print("\n" + "="*70)
     print("INITIALIZING MODELS")
-    print("="*70)
+    print("="*70 + "\n")
     
     for lang_code, (lang_name, model_name, model_type) in MODEL_INFO.items():
-        print(f"\n--- Loading {lang_name} ({model_name}) ---")
+        print(f"Loading {lang_name} ({model_name})...")
+        
+        if model_type == "grecy":
+            nlp = load_grecy_model(model_name)
+        else:
+            nlp = load_spacy_model(model_name)
         
-        nlp = load_model_with_retry(lang_code, model_name, model_type)
+        MODELS[lang_code] = nlp
         
-        if nlp is not None:
-            MODELS[lang_code] = nlp
-            print(f"✓ {lang_name} model ready")
+        if nlp:
+            print(f"✓ {lang_name} ready\n")
         else:
-            MODELS[lang_code] = None
-            print(f"✗ {lang_name} model FAILED - analysis will be unavailable")
+            print(f"✗ {lang_name} FAILED\n")
     
-    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")
+    loaded = sum(1 for m in MODELS.values() if m is not None)
+    print(f"Loaded {loaded}/{len(MODELS)} models successfully")
+    print("="*70 + "\n")
 
 # ============================================================================
-# TEXT ANALYSIS
+# ANALYSIS
 # ============================================================================
 
 def get_analysis(ui_lang: str, model_lang: str, text: str):
-    """
-    Perform morpho-syntactic analysis on the input text.
-    
-    Returns tuple of outputs for Gradio.
-    """
-    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"]
+    """Analyze text and return results."""
+    ui_config = UI_TEXT.get(ui_lang.lower(), UI_TEXT["en"])
+    error_prefix = ui_config["error_message"]
     
     try:
-        # Validate input
-        if not text or not text.strip():
-            return (
-                [],
-                [],
-                "<p style='color: orange;'>No text provided for analysis.</p>",
-                gr.Button(value=current_ui_config["button_text"], interactive=True)
-            )
-        
-        # Extract language code from selection like 'GRC (grc_proiel_trf)'
-        lang_code = model_lang.split(" ")[0].lower()
+        if not text.strip():
+            return ([], [], "<p style='color: orange;'>No text provided.</p>",
+                   gr.Button(value=ui_config["button_text"], interactive=True))
         
-        # Check if model is available
-        if lang_code not in MODELS:
-            raise ValueError(f"Unknown language code: '{lang_code}'")
+        lang_code = model_lang.split()[0].lower()
         
-        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."
-            )
+        if lang_code not in MODELS or MODELS[lang_code] is None:
+            raise ValueError(f"Model for {lang_code} is not available. Please check logs.")
         
-        # 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,
+                "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
-            ])
+            dataframe_output.append([token.text, lemma_str, pos_str, tag_str, morph_str, dep_str])
         
-        # Generate dependency visualization if available
-        html_out_content = ""
+        # Generate visualization
+        html_out = ""
         if doc.has_annotation("DEP"):
             try:
-                options = {
-                    "compact": True,
-                    "bg": "#ffffff",
-                    "color": "#000000",
-                    "font": "Source Sans Pro"
-                }
+                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>"
+                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>'
+            except Exception as e:
+                html_out = f"<p style='color: orange;'>Visualization error: {e}</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>
-            """
+            html_out = "<p style='color: orange;'>Dependency parsing not available for this model.</p>"
         
-        # Return tuple of outputs
-        return (
-            dataframe_output,
-            json_output,
-            html_out_content,
-            gr.Button(value=current_ui_config["button_text"], interactive=True)
-        )
+        return (dataframe_output, json_output, html_out,
+               gr.Button(value=ui_config["button_text"], interactive=True))
         
     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>
-        """
-        
-        return (
-            [[f"{error_prefix}{error_details}"]],
-            {"error": error_details},
-            error_html,
-            gr.Button(value=current_ui_config["button_text"], interactive=True)
-        )
+        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,
+               gr.Button(value=ui_config["button_text"], interactive=True))
 
 # ============================================================================
-# UI UPDATE
+# UI
 # ============================================================================
 
 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"])
-    
+    """Update UI language."""
+    ui_config = UI_TEXT.get(ui_lang.lower(), UI_TEXT["en"])
     return [
         gr.Markdown(value=ui_config["title"]),
         gr.Markdown(value=ui_config["subtitle"]),
         gr.Radio(label=ui_config["ui_lang_label"]),
         gr.Radio(label=ui_config["model_lang_label"]),
-        gr.Textbox(
-            label=ui_config["input_label"],
-            placeholder=ui_config["input_placeholder"]
-        ),
+        gr.Textbox(label=ui_config["input_label"], placeholder=ui_config["input_placeholder"]),
         gr.Button(value=ui_config["button_text"]),
         gr.Tab(label=ui_config["tab_graphic"]),
         gr.Tab(label=ui_config["tab_table"]),
         gr.Tab(label=ui_config["tab_json"]),
         gr.HTML(label=ui_config["html_label"]),
-        gr.DataFrame(
-            label=ui_config["table_label"],
-            headers=ui_config["table_headers"],
-            interactive=False
-        ),
+        gr.DataFrame(label=ui_config["table_label"], headers=ui_config["table_headers"], interactive=False),
         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()
-    ]
+    """Create Gradio interface."""
+    config = UI_TEXT["en"]
+    model_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]
-            )
+            ui_lang_radio = gr.Radio(["DE", "EN", "ES"], label=config["ui_lang_label"], value="EN")
+            model_lang_radio = gr.Radio(model_choices, label=config["model_lang_label"], value=model_choices[0])
         
-        markdown_title = gr.Markdown(default_config["title"])
-        markdown_subtitle = gr.Markdown(default_config["subtitle"])
+        markdown_title = gr.Markdown(config["title"])
+        markdown_subtitle = gr.Markdown(config["subtitle"])
+        text_input = gr.Textbox(label=config["input_label"], placeholder=config["input_placeholder"], lines=5)
+        analyze_button = gr.Button(config["button_text"], variant="primary")
         
-        # 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")
+        with gr.Tabs():
+            with gr.Tab(config["tab_graphic"]) as tab_graphic:
+                html_out = gr.HTML(label=config["html_label"])
+            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"])
         
-        # 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"])
+        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")
         
-        # Event handlers - FIXED: Use list outputs instead of dict
-        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"
-        )
-        
-        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
-            ]
-        )
-    
+        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])
     return demo
 
 # ============================================================================
@@ -520,16 +307,8 @@ def create_interface():
 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
-    )
+    demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)