Update app.py

app.py

@@ -85,40 +85,64 @@ except ImportError:
     WN_AVAILABLE = False
     print("CRITICAL WARNING: `wn` library not found.")
 
+# --- Pattern.en Import (ENGLISH) ---
 # --- Pattern.en Import (ENGLISH) ---
 PATTERN_EN_AVAILABLE = False
+
+# Define constants locally as fallbacks (Pattern standard values) to prevent import errors
+# Tenses
+INFINITIVE = "inf"
+PRESENT = "pres"
+PAST = "pst"
+FUTURE = "fut"
+PARTICIPLE = "part"
+# Person/Number
+FIRST = 1
+SECOND = 2
+THIRD = 3
+SINGULAR = "sg"
+PLURAL = "pl"
+# POS
+NOUN = "NN"
+VERB = "VB"
+ADJECTIVE = "JJ"
+
 try:
-    # Try importing from the standard pattern library
     import pattern.en
+    # Import functions safely
     from pattern.en import (
-        pluralize, singularize, conjugate, tenses, lemma, lexeme,
-        attributive, predicative,
-        article, MALE, FEMALE, NEUTRAL, PLURAL,
-        INFINITIVE, PRESENT, PAST, PARTICIPLE,
-        FIRST, SECOND, THIRD, SINGULAR, PLURAL as PL,
-        INDICATIVE, IMPERATIVE, SUBJUNCTIVE,
+        pluralize, singularize, 
+        conjugate, lemma, lexeme, tenses,
         comparative, superlative,
-        NOUN, VERB, ADJECTIVE,
+        predicative, attributive,
+        article,
         parse, split
     )
+    
+    # Try to import constants, but don't fail if they are missing (we use fallbacks)
+    try:
+        from pattern.en import (
+            INFINITIVE, PRESENT, PAST, PARTICIPLE,
+            FIRST, SECOND, THIRD, SINGULAR, PLURAL,
+            NOUN, VERB, ADJECTIVE
+        )
+    except ImportError:
+        print("Using local fallback constants for Pattern.en")
+
     PATTERN_EN_AVAILABLE = True
     print("✓ Successfully imported pattern.en")
+
 except ImportError:
-    print("Using PatternLite fallback...")
+    print("Using PatternLite fallback logic...")
     try:
-        # Sometimes PatternLite structure is slightly different, but usually compatible
+        # Attempt simple import for PatternLite structure
         import pattern.en
-        from pattern.en import (
-            pluralize, singularize, conjugate, tenses, lemma, lexeme,
-            attributive, predicative,
-            article, MALE, FEMALE, NEUTRAL, PLURAL,
-            INFINITIVE, PRESENT, PAST, PARTICIPLE,
-            FIRST, SECOND, THIRD, SINGULAR, PLURAL as PL,
-            INDICATIVE, IMPERATIVE, SUBJUNCTIVE,
-            comparative, superlative,
-            NOUN, VERB, ADJECTIVE,
-            parse, split
-        )
+        from pattern.en import pluralize, singularize, conjugate, lemma, lexeme
+        
+        # Manually map functions if they are missing in Lite but available under different names
+        if not 'comparative' in dir(pattern.en):
+            from pattern.en import comparative, superlative
+            
         PATTERN_EN_AVAILABLE = True
         print("✓ Successfully imported pattern.en (via PatternLite)")
     except ImportError as e:
@@ -136,20 +160,45 @@ except ImportError:
     HANTA_AVAILABLE = False
     print("CRITICAL WARNING: `HanTa` library not found.")
 
-# --- NLTK Import ---
+# --- NLTK & TextBlob Import ---
 try:
     import nltk
     from nltk.corpus import wordnet as nltk_wn
     from nltk.stem import WordNetLemmatizer
+    
+    # --- CRITICAL: Download required NLTK data ---
+    # These are the specific packages causing your "LookupError" and "MissingCorpusError"
+    print("Downloading NLTK data...")
+    _nltk_packages = [
+        'wordnet', 
+        'omw-1.4', 
+        'averaged_perceptron_tagger', 
+        'averaged_perceptron_tagger_eng', # Specific for newer NLTK
+        'punkt', 
+        'punkt_tab' # Specific for newer TextBlob/NLTK
+    ]
+    for pkg in _nltk_packages:
+        try:
+            nltk.download(pkg, quiet=True)
+        except Exception as e:
+            print(f"Warning: Failed to download NLTK package '{pkg}': {e}")
+
     NLTK_AVAILABLE = True
-    print("✓ Successfully imported nltk")
-    # One-time downloads
-    nltk.download('wordnet', quiet=True, raise_on_error=True)
-    nltk.download('averaged_perceptron_tagger', quiet=True, raise_on_error=True)
-    nltk.download('punkt', quiet=True, raise_on_error=True) # For TextBlob
+    print("✓ Successfully imported nltk and downloaded data")
+except ImportError:
+    NLTK_AVAILABLE = False
+    print("WARNING: `nltk` library not found.")
 except Exception as e:
     NLTK_AVAILABLE = False
-    print(f"WARNING: `nltk` or its data failed to load: {e}")
+    print(f"WARNING: `nltk` data download failed: {e}")
+
+try:
+    from textblob import TextBlob
+    TEXTBLOB_AVAILABLE = True
+    print("✓ Successfully imported textblob")
+except ImportError:
+    TEXTBLOB_AVAILABLE = False
+    print("WARNING: `textblob` library not found.")
 
 # --- Stanza Import ---
 try:
@@ -160,14 +209,6 @@ except ImportError:
     STANZA_AVAILABLE = False
     print("WARNING: `stanza` library not found.")
 
-# --- TextBlob Import ---
-try:
-    from textblob import TextBlob
-    TEXTBLOB_AVAILABLE = True
-    print("✓ Successfully imported textblob")
-except ImportError:
-    TEXTBLOB_AVAILABLE = False
-    print("WARNING: `textblob` library not found.")
 
 # --- German-specific imports are not needed ---
 IWNLP_AVAILABLE = False
@@ -220,7 +261,10 @@ def _conjugate_to_person_number_en(verb_lemma: str, person: str, number: str) ->
         return None
     try:
         p_num = int(person)
+        # Use the constants defined in the import block
         n_num = SINGULAR if number == 'sg' else PLURAL
+        
+        # Explicitly name arguments for safety across Pattern versions
         return conjugate(verb_lemma, tense=PRESENT, person=p_num, number=n_num)
     except Exception:
         return None
@@ -748,80 +792,122 @@ def pattern_is_good_analysis(analysis, analysis_type):
 
 def pattern_analyze_as_noun_en(word: str, hint_lemma: str = None) -> Dict[str, Any]:
     """Comprehensive noun inflection analysis for English."""
-    log(f"  Analyzing as noun (hint_lemma={hint_lemma})")
+    log(f"   Analyzing as noun (hint_lemma={hint_lemma})")
     if not PATTERN_EN_AVAILABLE: return {'error': 'pattern.en not available'}
     
-    singular_form = singularize(word)
-    base = singular_form
-    plural_form = pluralize(base)
-    
+    # 1. Determine Singular/Plural base
+    # If the word is already plural, singularize it to get the lemma
+    try:
+        singular_form = singularize(word)
+        plural_form = pluralize(singular_form)
+    except Exception as e:
+        return {'error': f'Inflection failed: {e}'}
+
+    # 2. Get Indefinite Article (a/an)
+    try:
+        art = article(singular_form)
+        art_str = f"{art} {singular_form}"
+    except Exception:
+        art_str = f"a/an {singular_form}"
+
     analysis = {
-        "base_form": base,
-        "singular": base,
+        "base_form": singular_form,
+        "singular": singular_form,
         "plural": plural_form,
+        "article": art_str,
         "declension": {
-            "Singular": {"form": base},
+            "Singular": {"form": singular_form},
             "Plural": {"form": plural_form}
         },
-        "gender": "Neuter" # English nouns don't have grammatical gender
+        "gender": "N/A" # English nouns strictly do not have grammatical gender
     }
     return analysis
 
 def pattern_analyze_as_verb_en(word: str, hint_lemma: str = None) -> Dict[str, Any]:
     """Comprehensive verb conjugation analysis for English."""
-    log(f"  Analyzing as verb (hint_lemma={hint_lemma})")
+    log(f"   Analyzing as verb (hint_lemma={hint_lemma})")
     if not PATTERN_EN_AVAILABLE: return {'error': 'pattern.en not available'}
 
-    verb_lemma = lemma(word)
-    if not verb_lemma:
+    # 1. Get Lemma
+    try:
+        verb_lemma = lemma(word)
+    except:
         verb_lemma = word
         
     analysis = {"infinitive": verb_lemma}
+
+    # 2. Get Lexeme (List of all forms)
     try:
-        analysis["lexeme"] = lexeme(verb_lemma)
+        # lexeme returns: [infinitive, 3sg, present_participle, past, past_participle]
+        # e.g., be => ['be', 'is', 'being', 'was', 'been']
+        forms = lexeme(verb_lemma)
+        analysis["lexeme"] = forms
     except Exception as e:
-        log(f"  Failed to get lexeme: {e}")
+        log(f"   Failed to get lexeme: {e}")
+        analysis["lexeme"] = []
 
+    # 3. Conjugation Table
     analysis["conjugation"] = {}
     try:
+        # Present Tense
         analysis["conjugation"]["Present"] = {
-            "I": conjugate(verb_lemma, PRESENT, 1, SINGULAR),
-            "you": conjugate(verb_lemma, PRESENT, 2, SINGULAR),
-            "he/she/it": conjugate(verb_lemma, PRESENT, 3, SINGULAR),
-            "we": conjugate(verb_lemma, PRESENT, 1, PLURAL),
-            "you (pl)": conjugate(verb_lemma, PRESENT, 2, PLURAL),
-            "they": conjugate(verb_lemma, PRESENT, 3, PLURAL),
+            "I (1sg)":       conjugate(verb_lemma, tense=PRESENT, person=1, number=SINGULAR),
+            "you (2sg)":     conjugate(verb_lemma, tense=PRESENT, person=2, number=SINGULAR),
+            "he/she (3sg)":  conjugate(verb_lemma, tense=PRESENT, person=3, number=SINGULAR),
+            "we (1pl)":      conjugate(verb_lemma, tense=PRESENT, person=1, number=PLURAL),
+            "you (2pl)":     conjugate(verb_lemma, tense=PRESENT, person=2, number=PLURAL),
+            "they (3pl)":    conjugate(verb_lemma, tense=PRESENT, person=3, number=PLURAL),
         }
+        
+        # Past Tense (Pattern usually handles simple past variations)
         analysis["conjugation"]["Past"] = {
-            "I": conjugate(verb_lemma, PAST, 1, SINGULAR),
-            "he/she/it": conjugate(verb_lemma, PAST, 3, SINGULAR),
+            "I (1sg)":       conjugate(verb_lemma, tense=PAST, person=1, number=SINGULAR),
+            "he/she (3sg)":  conjugate(verb_lemma, tense=PAST, person=3, number=SINGULAR),
+            "General":       conjugate(verb_lemma, tense=PAST) # For regular verbs where all are same
         }
+
+        # Participles
         analysis["participles"] = {
-            "Present Participle": conjugate(verb_lemma, PARTICIPLE, tense=PRESENT),
-            "Past Participle": conjugate(verb_lemma, PARTICIPLE, tense=PAST)
+            "Present Participle (gerund)": conjugate(verb_lemma, tense=PRESENT, aspect="progressive"), # or aspect=PROGRESSIVE
+            "Past Participle": conjugate(verb_lemma, tense=PAST, aspect="perfective") # or use PARTICIPLE constant
         }
     except Exception as e:
-        log(f"  Failed to conjugate: {e}")
+        log(f"   Failed to conjugate: {e}")
         
     return analysis
     
 def pattern_analyze_as_adjective_en(word: str, hint_lemma: str = None) -> Dict[str, Any]:
     """Comprehensive adjective inflection analysis for English."""
-    log(f"  Analyzing as adjective (hint_lemma={hint_lemma})")
+    log(f"   Analyzing as adjective (hint_lemma={hint_lemma})")
     if not PATTERN_EN_AVAILABLE: return {'error': 'pattern.en not available'}
     
-    base = predicative(word)
+    try:
+        # If the word is comparative/superlative, try to get the base (predicative)
+        # Note: Pattern doesn't have a strong 'un-grade' function, so we rely on lemma if available
+        # or assumes input is the base.
+        base = word 
+    except Exception:
+        base = word
+
     analysis = {}
     analysis["predicative"] = base
+    
     try:
-        analysis["comparative"] = comparative(base)
-        analysis["superlative"] = superlative(base)
+        comp = comparative(base)
+        sup = superlative(base)
+        
+        analysis["comparative"] = comp
+        analysis["superlative"] = sup
+        
+        analysis["grading"] = {
+            "Positive": base,
+            "Comparative": comp,
+            "Superlative": sup
+        }
     except Exception as e:
-        log(f"  Failed to get comparison: {e}")
+        log(f"   Failed to get comparison: {e}")
+        analysis["grading"] = {"error": "Could not grade adjective"}
         
-    analysis["attributive"] = {
-        "Base": {"form": base, "example": f"a {base} [noun]"}
-    }
     return analysis
 
 # --- Public API (Adapted) ---
@@ -1635,15 +1721,29 @@ def nltk_get_lemmatizer() -> Optional[WordNetLemmatizer]:
     """ Thread-safe function to get the NLTK Lemmatizer. """
     global NLTK_LEMMATIZER
     if not NLTK_AVAILABLE:
-        raise ImportError("NLTK library is not installed.")
+        return None # Don't raise error, just return None to trigger graceful fallback
+    
     if NLTK_LEMMATIZER:
         return NLTK_LEMMATIZER
+        
     with NLTK_LEMMATIZER_LOCK:
         if NLTK_LEMMATIZER:
             return NLTK_LEMMATIZER
-        NLTK_LEMMATIZER = WordNetLemmatizer()
-        print("✓ NLTK Lemmatizer initialized.")
-        return NLTK_LEMMATIZER
+        try:
+            # Ensure data is present one last time before init
+            try:
+                nltk.data.find('corpora/wordnet.zip')
+            except LookupError:
+                nltk.download('wordnet', quiet=True)
+                
+            NLTK_LEMMATIZER = WordNetLemmatizer()
+            # Warm up
+            _ = NLTK_LEMMATIZER.lemmatize("cats") 
+            print("✓ NLTK Lemmatizer initialized.")
+            return NLTK_LEMMATIZER
+        except Exception as e:
+             print(f"✗ NLTK Init Failed: {e}")
+             return None
 
 def _nltk_get_wordnet_pos(treebank_tag):
     """Converts NLTK's Treebank POS tag to a WordNet tag."""
@@ -1654,7 +1754,7 @@ def _nltk_get_wordnet_pos(treebank_tag):
     return None
 
 def _analyze_word_with_nltk(word: str, top_n: int) -> Dict[str, Any]:
-    """ (FALLBACK ENGINE 3) Analyzes with NLTK. Must match JSON. """
+    """ (FALLBACK ENGINE 3) Analyzes with NLTK. """
     if not NLTK_AVAILABLE: return {}
     print(f"\n[Word Encyclopedia] Running NLTK fallback for: \"{word}\"")
     final_result = {"input_word": word, "analysis": {}}
@@ -1664,7 +1764,14 @@ def _analyze_word_with_nltk(word: str, top_n: int) -> Dict[str, Any]:
         if not lemmatizer: return {}
         
         # NLTK's POS tagger needs a list
-        tag = nltk.pos_tag([word])[0][1]
+        # This specific call was crashing because 'averaged_perceptron_tagger_eng' was missing
+        try:
+            tag = nltk.pos_tag([word])[0][1]
+        except LookupError:
+            # Last ditch attempt to download if it was missing
+            nltk.download('averaged_perceptron_tagger_eng', quiet=True)
+            tag = nltk.pos_tag([word])[0][1]
+
         wn_pos = _nltk_get_wordnet_pos(tag)
         
         if not wn_pos: 
@@ -1672,13 +1779,17 @@ def _analyze_word_with_nltk(word: str, top_n: int) -> Dict[str, Any]:
             return {}
         
         lemma = lemmatizer.lemmatize(word, wn_pos)
-        pos_map = {nltk_wn.NOUN: "noun", nltk_wn.VERB: "verb", nltk_wn.ADJ: "adjective", nltk_wn.ADV: "adverb"}
-        pos_key = pos_map[wn_pos]
         
+        # Map NLTK WN constants to strings
+        pos_map_rev = {nltk_wn.NOUN: "noun", nltk_wn.VERB: "verb", nltk_wn.ADJ: "adjective", nltk_wn.ADV: "adverb"}
+        pos_key = pos_map_rev.get(wn_pos)
+        if not pos_key: return {}
+
         log(f"--- Analyzing NLTK path: lemma='{lemma}', pos='{pos_key}' ---")
         
         pattern_block = {}
         if PATTERN_EN_AVAILABLE:
+            # Use the fixed pattern functions from previous step
             if pos_key == "noun": pattern_block = pattern_analyze_as_noun_en(lemma)
             elif pos_key == "verb": pattern_block = pattern_analyze_as_verb_en(lemma)
             elif pos_key == "adjective": pattern_block = pattern_analyze_as_adjective_en(lemma)
@@ -1709,18 +1820,17 @@ def _analyze_word_with_nltk(word: str, top_n: int) -> Dict[str, Any]:
         return final_result
     except Exception as e:
         log(f"NLTK Engine FAILED: {e}")
-        traceback.print_exc()
+        # traceback.print_exc() # Optional: Uncomment for deep debugging
         return {}
 
 # --- FALLBACK 4: TEXTBLOB ---
 def _analyze_word_with_textblob(word: str, top_n: int) -> Dict[str, Any]:
-    """ (FALLBACK ENGINE 4) Analyzes with TextBlob. Must match JSON. """
+    """ (FALLBACK ENGINE 4) Analyzes with TextBlob. """
     if not TEXTBLOB_AVAILABLE: return {}
     print(f"\n[Word Encyclopedia] Running TextBlob fallback for: \"{word}\"")
     final_result = {"input_word": word, "analysis": {}}
     
     def get_wordnet_pos_tb(treebank_tag):
-        """ Maps Treebank to TextBlob's lemmatizer tags (n, v, a, r) """
         if treebank_tag.startswith('J'): return 'a'
         if treebank_tag.startswith('V'): return 'v'
         if treebank_tag.startswith('N'): return 'n'
@@ -1728,19 +1838,33 @@ def _analyze_word_with_textblob(word: str, top_n: int) -> Dict[str, Any]:
         return None
         
     try:
-        blob = TextBlob(word)
-        if not blob.tags: return {}
+        try:
+            blob = TextBlob(word)
+            # This access triggers the tokenizer
+            tags = blob.tags 
+        except (LookupError, Exception) as e:
+            if "punkt" in str(e):
+                 print("Attempting to download missing TextBlob/NLTK data...")
+                 import nltk
+                 nltk.download('punkt_tab', quiet=True)
+                 nltk.download('punkt', quiet=True)
+                 blob = TextBlob(word)
+                 tags = blob.tags
+            else:
+                raise e
+
+        if not tags: return {}
         
-        # Process each tag TextBlob finds
         processed_lemmas_pos: Set[Tuple[str, str]] = set()
 
-        for tb_word, tag in blob.tags:
+        for tb_word, tag in tags:
             tb_pos = get_wordnet_pos_tb(tag)
             if not tb_pos: continue
             
             lemma = tb_word.lemmatize(tb_pos)
             pos_map = {'n': "noun", 'v': "verb", 'a': "adjective", 'r': "adverb"}
-            pos_key = pos_map[tb_pos]
+            pos_key = pos_map.get(tb_pos)
+            if not pos_key: continue
 
             if (lemma, pos_key) in processed_lemmas_pos: continue
             processed_lemmas_pos.add((lemma, pos_key))
@@ -1777,7 +1901,6 @@ def _analyze_word_with_textblob(word: str, top_n: int) -> Dict[str, Any]:
         return final_result
     except Exception as e:
         log(f"TextBlob Engine FAILED: {e}")
-        traceback.print_exc()
         return {}