continues to remove cache parameter

app.py

@@ -248,113 +248,25 @@ def image_to_base64(image):
     image.save(buffered, format="PNG")
     return base64.b64encode(buffered.getvalue()).decode()
 
-def safe_model_chat(model, tokenizer, image_path, **kwargs):
+def direct_model_call(model, method_name, *args, **kwargs):
     """
-    Safe wrapper for model.chat to handle DynamicCache and other compatibility issues
-    Optimized for ZeroGPU environments
+    Direct model call without any cache-related parameters
     """
-    try:
-        # First attempt: normal call
-        return model.chat(tokenizer, image_path, **kwargs)
-    except AttributeError as e:
-        if "get_max_length" in str(e):
-            # Try to fix the cache issue by clearing it
-            try:
-                # Clear any existing cache
-                if hasattr(model, 'clear_cache'):
-                    model.clear_cache()
-                elif hasattr(model, '_clear_cache'):
-                    model._clear_cache()
-                
-                # Try to clear cache from transformers
-                try:
-                    from transformers import GenerationConfig
-                    if hasattr(GenerationConfig, 'clear_cache'):
-                        GenerationConfig.clear_cache()
-                except:
-                    pass
-                
-                # Retry the call
-                return model.chat(tokenizer, image_path, **kwargs)
-            except:
-                # If still failing, try with different parameters
-                try:
-                    # Remove any cache-related parameters
-                    kwargs_copy = kwargs.copy()
-                    for key in list(kwargs_copy.keys()):
-                        if 'cache' in key.lower():
-                            del kwargs_copy[key]
-                    return model.chat(tokenizer, image_path, **kwargs_copy)
-                except:
-                    raise Exception("Model compatibility issue: DynamicCache error. Please try again.")
-        else:
-            raise e
-    except Exception as e:
-        # Handle other potential issues
-        if "attention_mask" in str(e).lower():
-            # Try to handle attention mask issues
-            try:
-                return model.chat(tokenizer, image_path, **kwargs)
-            except:
-                raise Exception(f"Attention mask error: {str(e)}")
-        else:
-            raise e
-
-def safe_model_chat_crop(model, tokenizer, image_path, **kwargs):
-    """
-    Safe wrapper for model.chat_crop to handle DynamicCache and other compatibility issues
-    Optimized for ZeroGPU environments
-    """
-    try:
-        # First attempt: normal call
-        return model.chat_crop(tokenizer, image_path, **kwargs)
-    except AttributeError as e:
-        if "get_max_length" in str(e):
-            # Try to fix the cache issue by clearing it
-            try:
-                # Clear any existing cache
-                if hasattr(model, 'clear_cache'):
-                    model.clear_cache()
-                elif hasattr(model, '_clear_cache'):
-                    model._clear_cache()
-                
-                # Try to clear cache from transformers
-                try:
-                    from transformers import GenerationConfig
-                    if hasattr(GenerationConfig, 'clear_cache'):
-                        GenerationConfig.clear_cache()
-                except:
-                    pass
-                
-                # Retry the call
-                return model.chat_crop(tokenizer, image_path, **kwargs)
-            except:
-                # If still failing, try with different parameters
-                try:
-                    # Remove any cache-related parameters
-                    kwargs_copy = kwargs.copy()
-                    for key in list(kwargs_copy.keys()):
-                        if 'cache' in key.lower():
-                            del kwargs_copy[key]
-                    return model.chat_crop(tokenizer, image_path, **kwargs_copy)
-                except:
-                    raise Exception("Model compatibility issue: DynamicCache error. Please try again.")
-        else:
-            raise e
-    except Exception as e:
-        # Handle other potential issues
-        if "attention_mask" in str(e).lower():
-            # Try to handle attention mask issues
-            try:
-                return model.chat_crop(tokenizer, image_path, **kwargs)
-            except:
-                raise Exception(f"Attention mask error: {str(e)}")
-        else:
-            raise e
-
+    # Create a clean kwargs dict without any cache-related parameters
+    clean_kwargs = {}
+    for key, value in kwargs.items():
+        if 'cache' not in key.lower():
+            clean_kwargs[key] = value
+    
+    # Get the method and call it directly
+    method = getattr(model, method_name)
+    return method(*args, **clean_kwargs)
 
 @spaces.GPU()
 def process_image(image, task, ocr_type=None, ocr_box=None, ocr_color=None):
+    """
+    Process image with OCR using ZeroGPU-compatible approach
+    """
     if image is None:
         return "Error: No image provided", None, None
     
@@ -381,61 +293,22 @@ def process_image(image, task, ocr_type=None, ocr_box=None, ocr_color=None):
         else:
             return "Error: Unsupported image format", None, None
 
-        # Wrap model calls in try-except to handle DynamicCache errors
+        # Use direct model calls without any cache management
         try:
             if task == "Plain Text OCR":
-                # Use cache manager for safer calls
-                try:
-                    res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type='ocr')
-                except:
-                    try:
-                        # Fallback to direct call
-                        res = cache_manager.direct_call('chat', tokenizer, image_path, ocr_type='ocr')
-                    except:
-                        # Final fallback to legacy call
-                        res = cache_manager.legacy_call('chat', tokenizer, image_path, ocr_type='ocr')
+                res = direct_model_call(model, 'chat', tokenizer, image_path, ocr_type='ocr')
                 return res, None, unique_id
             else:
                 if task == "Format Text OCR":
-                    try:
-                        res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
-                    except:
-                        try:
-                            res = cache_manager.direct_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
-                        except:
-                            res = cache_manager.legacy_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                    res = direct_model_call(model, 'chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
                 elif task == "Fine-grained OCR (Box)":
-                    try:
-                        res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_box=ocr_box, render=True, save_render_file=result_path)
-                    except:
-                        try:
-                            res = cache_manager.direct_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_box=ocr_box, render=True, save_render_file=result_path)
-                        except:
-                            res = cache_manager.legacy_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_box=ocr_box, render=True, save_render_file=result_path)
+                    res = direct_model_call(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)":
-                    try:
-                        res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_color=ocr_color, render=True, save_render_file=result_path)
-                    except:
-                        try:
-                            res = cache_manager.direct_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_color=ocr_color, render=True, save_render_file=result_path)
-                        except:
-                            res = cache_manager.legacy_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_color=ocr_color, render=True, save_render_file=result_path)
+                    res = direct_model_call(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":
-                    try:
-                        res = cache_manager.safe_call('chat_crop', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
-                    except:
-                        try:
-                            res = cache_manager.direct_call('chat_crop', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
-                        except:
-                            res = cache_manager.legacy_call('chat_crop', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                    res = direct_model_call(model, 'chat_crop', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
                 elif task == "Render Formatted OCR":
-                    try:
-                        res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
-                    except:
-                        try:
-                            res = cache_manager.direct_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
-                        except:
-                            res = cache_manager.legacy_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                    res = direct_model_call(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:
@@ -443,19 +316,39 @@ def process_image(image, task, ocr_type=None, ocr_box=None, ocr_color=None):
                     return res, html_content, unique_id
                 else:
                     return res, None, unique_id
-        except AttributeError as e:
-            if "get_max_length" in str(e):
-                # Handle DynamicCache compatibility issue
-                return "Error: Model compatibility issue detected. Please try again or contact support.", None, None
-            else:
-                raise e
+        except Exception as e:
+            # If direct call fails, try with cache manager as fallback
+            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 fallback_error:
+                return f"Error: {str(fallback_error)}", None, None
                 
     except Exception as e:
         return f"Error: {str(e)}", None, None
     finally:
         if os.path.exists(image_path):
             os.remove(image_path)
-            
+
 def update_image_input(task):
     if task == "Fine-grained OCR (Color)":
         return gr.update(visible=False), gr.update(visible=True), gr.update(visible=True)