Update app.py

app.py

@@ -162,41 +162,63 @@ def normalize(d, target=1.0):
     return {key: value * factor for key, value in d.items()}
 
 # --- Visualization Functions with Error Handling ---
+
 def safe_plot(func, *args, **kwargs):
+    """Executes a plotting function and returns the image, handling errors."""
+    buf = None # Initialize buffer
     try:
-        plt.clf()
+        # Ensure a clean figure state
+        fig = plt.figure() # Create a new figure explicitly
         func(*args, **kwargs)
         buf = BytesIO()
-        plt.savefig(buf, format='png', bbox_inches='tight') # Add bbox_inches for better fit
+        # Try saving with bbox_inches, but catch potential apply_aspect error
+        try:
+            plt.savefig(buf, format='png', bbox_inches='tight')
+        except AttributeError as ae:
+            if "apply_aspect" in str(ae):
+                print(f"Warning: bbox_inches='tight' failed ({ae}), saving without it.")
+                buf.seek(0) # Reset buffer as it might be partially written
+                buf = BytesIO() # Get a fresh buffer
+                plt.savefig(buf, format='png') # Save without bbox_inches
+            else:
+                raise # Re-raise if it's a different AttributeError
         buf.seek(0)
         img = Image.open(buf)
-        plt.close() # Use plt.close() instead of clf for better memory management after save
+        plt.close(fig) # Explicitly close the specific figure
         return img
     except Exception as e:
         print(f"Plotting error in safe_plot: {e}")
-        traceback.print_exc() # Print traceback for debugging
-        return None # Return None on error
+        if buf:
+            buf.close() # Ensure buffer is closed on error if it was created
+        traceback.print_exc()
+        # Try to return a placeholder or None
+        plt.close('all') # Aggressive close on error
+        return None
+
+
 
 def fDistancePlot(text2Party):
+    """Generates the frequency distribution plot."""
     def plot_func():
         tokens = word_tokenize(text2Party)
         if not tokens:
-             plt.text(0.5, 0.5, "No data to plot", ha='center', va='center')
-             return
+            plt.text(0.5, 0.5, "No data to plot", ha='center', va='center', transform=plt.gca().transAxes) # Use Axes coordinates
+            return
         fdist = FreqDist(tokens)
         fdist.plot(15, title='Frequency Distribution')
-        plt.xticks(rotation=45, ha='right') # Rotate x-axis labels if needed
+        plt.xticks(rotation=45, ha='right')
         plt.tight_layout()
     return safe_plot(plot_func)
 
+
 def DispersionPlot(textParty):
+    """Generates the word dispersion plot."""
     try:
         word_tokens_party = word_tokenize(textParty)
         if not word_tokens_party:
-             return None
+            return None
         moby = Text(word_tokens_party)
         fdistance = FreqDist(word_tokens_party)
-        # Get top 5 words, handle potential IndexError if less than 5 unique words
         common_words = fdistance.most_common(6)
         if len(common_words) < 5:
             word_Lst = [word for word, _ in common_words]
@@ -204,31 +226,44 @@ def DispersionPlot(textParty):
             word_Lst = [common_words[x][0] for x in range(5)]
 
         if not word_Lst:
-             return None
+            return None
 
-        plt.figure(figsize=(10, 5)) # Adjust figure size
-        plt.title('Dispersion Plot')
-        moby.dispersion_plot(word_Lst)
-        plt.tight_layout()
+        fig, ax = plt.subplots(figsize=(10, 5)) # Explicitly create figure and axes
+        ax.set_title('Dispersion Plot')
+        moby.dispersion_plot(word_Lst, ax=ax) # Pass the axes object
+        fig.tight_layout() # Use fig.tight_layout()
         buf = BytesIO()
-        plt.savefig(buf, format='png', bbox_inches='tight')
+        # Handle potential apply_aspect error for dispersion plot too
+        try:
+            fig.savefig(buf, format='png', bbox_inches='tight')
+        except AttributeError as ae:
+            if "apply_aspect" in str(ae):
+                 print(f"Warning: bbox_inches='tight' failed for Dispersion Plot ({ae}), saving without it.")
+                 buf.seek(0)
+                 buf = BytesIO()
+                 fig.savefig(buf, format='png')
+            else:
+                 raise
         buf.seek(0)
         img = Image.open(buf)
-        plt.close() # Close the figure
+        plt.close(fig) # Close the specific figure
         return img
     except Exception as e:
         print(f"Dispersion plot error: {e}")
         traceback.print_exc()
+        plt.close('all') # Aggressive close on error
         return None
 
+
 def word_cloud_generator(parsed_text_name, text_Party):
+    """Generates the word cloud image."""
+    buf = None # Initialize buffer
     try:
-        # Handle case where parsed_text_name might not have .name
         filename_lower = ""
         if hasattr(parsed_text_name, 'name') and parsed_text_name.name:
             filename_lower = parsed_text_name.name.lower()
         elif isinstance(parsed_text_name, str):
-             filename_lower = parsed_text_name.lower()
+            filename_lower = parsed_text_name.lower()
 
         mask_path = None
         if 'bjp' in filename_lower:
@@ -238,35 +273,51 @@ def word_cloud_generator(parsed_text_name, text_Party):
         elif 'aap' in filename_lower:
             mask_path = 'aapMain2.jpg'
 
-        # Generate word cloud
         if text_Party.strip() == "":
-             raise ValueError("Text for word cloud is empty")
+            raise ValueError("Text for word cloud is empty")
 
+        # Generate word cloud object
         if mask_path and os.path.exists(mask_path):
             orgImg = Image.open(mask_path)
-            # Ensure mask is in the right format (e.g., uint8)
             if orgImg.mode != 'RGB':
                 orgImg = orgImg.convert('RGB')
             mask = np.array(orgImg)
-            wordcloud = WordCloud(max_words=3000, mask=mask, background_color='white').generate(text_Party) # Added background color
+            wordcloud = WordCloud(max_words=3000, mask=mask, background_color='white', mode='RGBA').generate(text_Party)
         else:
-            wordcloud = WordCloud(max_words=2000, background_color='white').generate(text_Party)
+            wordcloud = WordCloud(max_words=2000, background_color='white', mode='RGBA').generate(text_Party)
+
+        # --- Key Fix: Explicitly manage figure and axes for word cloud ---
+        fig, ax = plt.subplots(figsize=(8, 6)) # Create new figure and axes
+        ax.imshow(wordcloud, interpolation='bilinear')
+        ax.axis("off")
+        fig.tight_layout(pad=0) # Remove padding
 
-        plt.figure(figsize=(8, 6)) # Set figure size
-        plt.imshow(wordcloud, interpolation='bilinear') # Use bilinear interpolation
-        plt.axis("off")
-        plt.tight_layout()
         buf = BytesIO()
-        plt.savefig(buf, format='png', bbox_inches='tight')
+        # Handle potential apply_aspect error for word cloud too
+        try:
+             fig.savefig(buf, format='png', bbox_inches='tight', dpi=300, facecolor='white') # Added dpi and facecolor
+        except AttributeError as ae:
+            if "apply_aspect" in str(ae):
+                 print(f"Warning: bbox_inches='tight' failed for Word Cloud ({ae}), saving without it.")
+                 buf.seek(0)
+                 buf = BytesIO()
+                 fig.savefig(buf, format='png', dpi=300, facecolor='white')
+            else:
+                 raise
         buf.seek(0)
         img = Image.open(buf)
-        plt.close() # Close the figure
+        plt.close(fig) # Close the specific figure
         return img
+
     except Exception as e:
         print(f"Word cloud error: {e}")
+        if buf:
+            buf.close() # Ensure buffer is closed on error
         traceback.print_exc()
+        plt.close('all') # Aggressive close on error
         return None # Return None on error
 
+
 # Initial design for concordance based search
 def get_all_phases_containing_tar_wrd(target_word, tar_passage, left_margin=10, right_margin=10, numLins=4):
     """