continues to remove cache parameter

app.py

@@ -49,6 +49,37 @@ warnings.filterwarnings("ignore", message="Setting `pad_token_id` to `eos_token_
 warnings.filterwarnings("ignore", message="The attention mask is not set and cannot be inferred")
 warnings.filterwarnings("ignore", message="The `seen_tokens` attribute is deprecated")
 
+def global_cache_clear():
+    """Global cache clearing function to prevent DynamicCache issues"""
+    try:
+        # Clear torch cache
+        import torch
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        
+        # Clear transformers cache
+        try:
+            from transformers.cache_utils import clear_cache
+            clear_cache()
+        except:
+            pass
+        
+        # Clear any DynamicCache instances
+        try:
+            from transformers.cache_utils import DynamicCache
+            if hasattr(DynamicCache, 'clear_all'):
+                DynamicCache.clear_all()
+        except:
+            pass
+        
+        # Force garbage collection
+        import gc
+        gc.collect()
+        
+    except Exception as e:
+        print(f"Global cache clear warning: {str(e)}")
+        pass
+
 class ModelCacheManager:
     """
     Manages model cache to prevent DynamicCache errors
@@ -58,7 +89,10 @@ class ModelCacheManager:
         self._clear_all_caches()
     
     def _clear_all_caches(self):
-        """Clear all possible caches"""
+        """Clear all possible caches including DynamicCache"""
+        # Use global cache clearing first
+        global_cache_clear()
+        
         # Clear model cache
         if hasattr(self.model, 'clear_cache'):
             try:
@@ -72,6 +106,23 @@ class ModelCacheManager:
             except:
                 pass
         
+        # Clear any generation cache
+        try:
+            if hasattr(self.model, 'generation_config'):
+                if hasattr(self.model.generation_config, 'clear_cache'):
+                    self.model.generation_config.clear_cache()
+        except:
+            pass
+        
+        # Clear any cache attributes that might cause DynamicCache issues
+        cache_attrs = ['cache', '_cache', 'past_key_values', 'use_cache', '_past_key_values']
+        for attr in cache_attrs:
+            if hasattr(self.model, attr):
+                try:
+                    delattr(self.model, attr)
+                except:
+                    pass
+        
         # Clear transformers cache based on version
         try:
             if USE_LEGACY_CACHE:
@@ -94,6 +145,15 @@ class ModelCacheManager:
                         GenerationConfig.clear_cache()
                 except:
                     pass
+                
+                # Try to clear DynamicCache specifically
+                try:
+                    from transformers.cache_utils import DynamicCache
+                    # Clear any global DynamicCache instances
+                    if hasattr(DynamicCache, 'clear_all'):
+                        DynamicCache.clear_all()
+                except:
+                    pass
         except:
             pass
         
@@ -104,6 +164,13 @@ class ModelCacheManager:
                 torch.cuda.empty_cache()
         except:
             pass
+        
+        # Force garbage collection
+        try:
+            import gc
+            gc.collect()
+        except:
+            pass
     
     def safe_call(self, method_name, *args, **kwargs):
         """Safely call model methods with cache management"""
@@ -167,6 +234,58 @@ class ModelCacheManager:
         except Exception as e:
             # Fallback to direct call
             return self.direct_call(method_name, *args, **kwargs)
+    
+    def dynamic_cache_safe_call(self, method_name, *args, **kwargs):
+        """Specialized method to handle DynamicCache errors"""
+        try:
+            # First, try to completely disable cache mechanisms
+            original_attrs = {}
+            
+            # Store and remove cache-related attributes
+            cache_attrs = ['cache', '_cache', 'past_key_values', 'use_cache', '_past_key_values']
+            for attr in cache_attrs:
+                if hasattr(self.model, attr):
+                    original_attrs[attr] = getattr(self.model, attr)
+                    try:
+                        delattr(self.model, attr)
+                    except:
+                        pass
+            
+            # Clear all caches
+            self._clear_all_caches()
+            
+            # Create minimal kwargs
+            minimal_kwargs = {}
+            essential_params = ['ocr_type', 'render', 'save_render_file', 'ocr_box', 'ocr_color']
+            for key, value in kwargs.items():
+                if key in essential_params and 'cache' not in key.lower():
+                    minimal_kwargs[key] = value
+            
+            # Make the call
+            method = getattr(self.model, method_name)
+            result = method(*args, **minimal_kwargs)
+            
+            # Restore original attributes
+            for attr, value in original_attrs.items():
+                try:
+                    setattr(self.model, attr, value)
+                except:
+                    pass
+            
+            return result
+            
+        except AttributeError as e:
+            if "get_max_length" in str(e) and "DynamicCache" in str(e):
+                # If DynamicCache error still occurs, try with no parameters
+                try:
+                    method = getattr(self.model, method_name)
+                    return method(*args)
+                except Exception as final_error:
+                    raise Exception(f"DynamicCache safe call failed: {str(final_error)}")
+            else:
+                raise e
+        except Exception as e:
+            raise e
 
 def initialize_model_safely():
     """
@@ -264,49 +383,109 @@ def direct_model_call(model, method_name, *args, **kwargs):
 
 def safe_model_call_with_dynamic_cache_fix(model, method_name, *args, **kwargs):
     """
-    Safe model call that handles DynamicCache errors specifically
+    Comprehensive safe model call that handles DynamicCache errors with multiple fallback strategies
     """
+    # Strategy 1: Try with complete cache clearing and minimal parameters
     try:
-        return direct_model_call(model, method_name, *args, **kwargs)
-    except AttributeError as e:
-        if "get_max_length" in str(e) and "DynamicCache" in str(e):
-            # This is the specific DynamicCache error we need to handle
-            print("DynamicCache error detected, applying workaround...")
+        # Clear all possible caches first
+        try:
+            if hasattr(model, 'clear_cache'):
+                model.clear_cache()
+            if hasattr(model, '_clear_cache'):
+                model._clear_cache()
             
-            # Try to clear any existing cache
+            # Clear transformers cache
             try:
-                if hasattr(model, 'clear_cache'):
-                    model.clear_cache()
-                # Also try to clear transformers cache
                 import torch
                 if torch.cuda.is_available():
                     torch.cuda.empty_cache()
             except:
                 pass
             
-            # Try the call again with minimal parameters
+            # Clear any generation cache
+            try:
+                if hasattr(model, 'generation_config'):
+                    if hasattr(model.generation_config, 'clear_cache'):
+                        model.generation_config.clear_cache()
+            except:
+                pass
+        except:
+            pass
+        
+        # Create minimal kwargs with only essential parameters
+        minimal_kwargs = {}
+        essential_params = ['ocr_type', 'render', 'save_render_file', 'ocr_box', 'ocr_color']
+        for key, value in kwargs.items():
+            if key in essential_params and 'cache' not in key.lower():
+                minimal_kwargs[key] = value
+        
+        method = getattr(model, method_name)
+        return method(*args, **minimal_kwargs)
+        
+    except AttributeError as e:
+        if "get_max_length" in str(e) and "DynamicCache" in str(e):
+            print("DynamicCache error detected, applying comprehensive workaround...")
+            
+            # Strategy 2: Try with model cache manager
             try:
-                # Create minimal kwargs with only essential parameters
-                minimal_kwargs = {}
-                essential_params = ['ocr_type', 'render', 'save_render_file', 'ocr_box', 'ocr_color']
-                for key, value in kwargs.items():
-                    if key in essential_params and 'cache' not in key.lower():
-                        minimal_kwargs[key] = value
+                return cache_manager.direct_call(method_name, *args, **kwargs)
+            except Exception as cache_error:
+                print(f"Cache manager failed: {str(cache_error)}")
                 
-                method = getattr(model, method_name)
-                return method(*args, **minimal_kwargs)
-            except Exception as retry_error:
-                # If still failing, try with even more minimal approach
+                # Strategy 3: Try with legacy cache handling
                 try:
-                    # Try with only the most basic parameters
-                    basic_kwargs = {}
-                    if 'ocr_type' in kwargs:
-                        basic_kwargs['ocr_type'] = kwargs['ocr_type']
+                    return cache_manager.legacy_call(method_name, *args, **kwargs)
+                except Exception as legacy_error:
+                    print(f"Legacy cache handling failed: {str(legacy_error)}")
                     
-                    method = getattr(model, method_name)
-                    return method(*args, **basic_kwargs)
-                except Exception as final_error:
-                    raise Exception(f"DynamicCache workaround failed: {str(final_error)}")
+                    # Strategy 4: Try with completely stripped parameters
+                    try:
+                        # Remove ALL parameters except the most basic ones
+                        stripped_kwargs = {}
+                        if 'ocr_type' in kwargs:
+                            stripped_kwargs['ocr_type'] = kwargs['ocr_type']
+                        
+                        method = getattr(model, method_name)
+                        return method(*args, **stripped_kwargs)
+                    except Exception as stripped_error:
+                        print(f"Stripped parameters failed: {str(stripped_error)}")
+                        
+                        # Strategy 5: Try with monkey patching to bypass cache
+                        try:
+                            # Temporarily disable cache-related attributes
+                            original_attrs = {}
+                            
+                            # Store original attributes that might cause issues
+                            for attr_name in ['cache', '_cache', 'past_key_values', 'use_cache']:
+                                if hasattr(model, attr_name):
+                                    original_attrs[attr_name] = getattr(model, attr_name)
+                                    try:
+                                        delattr(model, attr_name)
+                                    except:
+                                        pass
+                            
+                            # Try the call
+                            method = getattr(model, method_name)
+                            result = method(*args, **stripped_kwargs)
+                            
+                            # Restore original attributes
+                            for attr_name, value in original_attrs.items():
+                                try:
+                                    setattr(model, attr_name, value)
+                                except:
+                                    pass
+                            
+                            return result
+                            
+                        except Exception as monkey_error:
+                            print(f"Monkey patching failed: {str(monkey_error)}")
+                            
+                            # Strategy 6: Final fallback - try with no parameters at all
+                            try:
+                                method = getattr(model, method_name)
+                                return method(*args)
+                            except Exception as final_error:
+                                raise Exception(f"All DynamicCache workarounds failed. Last error: {str(final_error)}")
         else:
             # Re-raise if it's not the DynamicCache error
             raise e
@@ -319,6 +498,9 @@ def process_image(image, task, ocr_type=None, ocr_box=None, ocr_color=None):
     """
     Process image with OCR using ZeroGPU-compatible approach
     """
+    # Clear global cache at the start to prevent DynamicCache issues
+    global_cache_clear()
+    
     if image is None:
         return "Error: No image provided", None, None
     
@@ -345,22 +527,22 @@ def process_image(image, task, ocr_type=None, ocr_box=None, ocr_color=None):
         else:
             return "Error: Unsupported image format", None, None
 
-        # Use safe model calls with DynamicCache error handling
+        # Use specialized DynamicCache-safe model calls
         try:
             if task == "Plain Text OCR":
-                res = safe_model_call_with_dynamic_cache_fix(model, 'chat', tokenizer, image_path, ocr_type='ocr')
+                res = cache_manager.dynamic_cache_safe_call('chat', tokenizer, image_path, ocr_type='ocr')
                 return res, None, unique_id
             else:
                 if task == "Format Text OCR":
-                    res = safe_model_call_with_dynamic_cache_fix(model, 'chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                    res = cache_manager.dynamic_cache_safe_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
                 elif task == "Fine-grained OCR (Box)":
-                    res = safe_model_call_with_dynamic_cache_fix(model, 'chat', tokenizer, image_path, ocr_type=ocr_type, ocr_box=ocr_box, render=True, save_render_file=result_path)
+                    res = cache_manager.dynamic_cache_safe_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_box=ocr_box, render=True, save_render_file=result_path)
                 elif task == "Fine-grained OCR (Color)":
-                    res = safe_model_call_with_dynamic_cache_fix(model, 'chat', tokenizer, image_path, ocr_type=ocr_type, ocr_color=ocr_color, render=True, save_render_file=result_path)
+                    res = cache_manager.dynamic_cache_safe_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_color=ocr_color, render=True, save_render_file=result_path)
                 elif task == "Multi-crop OCR":
-                    res = safe_model_call_with_dynamic_cache_fix(model, 'chat_crop', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                    res = cache_manager.dynamic_cache_safe_call('chat_crop', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
                 elif task == "Render Formatted OCR":
-                    res = safe_model_call_with_dynamic_cache_fix(model, 'chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                    res = cache_manager.dynamic_cache_safe_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
                 
                 if os.path.exists(result_path):
                     with open(result_path, 'r') as f:
@@ -369,22 +551,22 @@ def process_image(image, task, ocr_type=None, ocr_box=None, ocr_color=None):
                 else:
                     return res, None, unique_id
         except Exception as e:
-            # If safe call fails, try with cache manager as fallback
+            # If dynamic cache safe call fails, try with comprehensive workaround
             try:
                 if task == "Plain Text OCR":
-                    res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type='ocr')
+                    res = safe_model_call_with_dynamic_cache_fix(model, 'chat', tokenizer, image_path, ocr_type='ocr')
                     return res, None, unique_id
                 else:
                     if task == "Format Text OCR":
-                        res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                        res = safe_model_call_with_dynamic_cache_fix(model, 'chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
                     elif task == "Fine-grained OCR (Box)":
-                        res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_box=ocr_box, render=True, save_render_file=result_path)
+                        res = safe_model_call_with_dynamic_cache_fix(model, 'chat', tokenizer, image_path, ocr_type=ocr_type, ocr_box=ocr_box, render=True, save_render_file=result_path)
                     elif task == "Fine-grained OCR (Color)":
-                        res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_color=ocr_color, render=True, save_render_file=result_path)
+                        res = safe_model_call_with_dynamic_cache_fix(model, 'chat', tokenizer, image_path, ocr_type=ocr_type, ocr_color=ocr_color, render=True, save_render_file=result_path)
                     elif task == "Multi-crop OCR":
-                        res = cache_manager.safe_call('chat_crop', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                        res = safe_model_call_with_dynamic_cache_fix(model, 'chat_crop', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
                     elif task == "Render Formatted OCR":
-                        res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                        res = safe_model_call_with_dynamic_cache_fix(model, 'chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
                     
                     if os.path.exists(result_path):
                         with open(result_path, 'r') as f:
@@ -393,7 +575,31 @@ def process_image(image, task, ocr_type=None, ocr_box=None, ocr_color=None):
                     else:
                         return res, None, unique_id
             except Exception as fallback_error:
-                return f"Error: {str(fallback_error)}", None, None
+                # Final fallback to basic cache manager
+                try:
+                    if task == "Plain Text OCR":
+                        res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type='ocr')
+                        return res, None, unique_id
+                    else:
+                        if task == "Format Text OCR":
+                            res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                        elif task == "Fine-grained OCR (Box)":
+                            res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_box=ocr_box, render=True, save_render_file=result_path)
+                        elif task == "Fine-grained OCR (Color)":
+                            res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_color=ocr_color, render=True, save_render_file=result_path)
+                        elif task == "Multi-crop OCR":
+                            res = cache_manager.safe_call('chat_crop', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                        elif task == "Render Formatted OCR":
+                            res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                        
+                        if os.path.exists(result_path):
+                            with open(result_path, 'r') as f:
+                                html_content = f.read()
+                            return res, html_content, unique_id
+                        else:
+                            return res, None, unique_id
+                except Exception as final_error:
+                    return f"Error: {str(final_error)}", None, None
                 
     except Exception as e:
         return f"Error: {str(e)}", None, None