Error: Error processing document with GOT-OCR (ZeroGPU): Numpy is not available

.gitignore

@@ -79,8 +79,8 @@ requirement.txt
 test_gemini_parser.py
 
 # Ignore documents folder
-# /documents/
-# /documents/*
+/documents/
+/documents/*
 
 # Ignore tessdata folder
 /tessdata/

requirements.txt

@@ -24,7 +24,4 @@ transformers==4.37.2  # Pin to a specific version that works with safetensors 0.
 tiktoken==0.6.0
 verovio==4.3.1
 accelerate==0.28.0
-safetensors==0.4.3  # Updated to meet minimum version required by accelerate
-
-# ZeroGPU support for HuggingFace Spaces
-spaces>=0.19.1
+safetensors==0.4.3  # Updated to meet minimum version required by accelerate

setup.sh

@@ -34,11 +34,6 @@ echo "Installing GOT-OCR dependencies..."
 pip install -q -U torch==2.0.1 torchvision==0.15.2 transformers==4.37.2 tiktoken==0.6.0 verovio==4.3.1 accelerate==0.28.0 safetensors==0.4.3
 echo "GOT-OCR dependencies installed successfully"
 
-# Install ZeroGPU support
-echo "Installing ZeroGPU support..."
-pip install -q -U spaces>=0.19.1
-echo "ZeroGPU support installed successfully"
-
 # Install the project in development mode
 echo "Installing project in development mode..."
 pip install -e .

src/parsers/got_ocr_parser.py

@@ -34,19 +34,9 @@ try:
             "Consider downgrading to version <4.48.0"
         )
     
-    # Import spaces for ZeroGPU support
-    try:
-        import spaces
-        ZEROGPU_AVAILABLE = True
-        logger.info("ZeroGPU support is available")
-    except ImportError:
-        ZEROGPU_AVAILABLE = False
-        logger.info("ZeroGPU not available, will use standard GPU if available")
-    
     GOT_AVAILABLE = True and NUMPY_AVAILABLE
 except ImportError:
     GOT_AVAILABLE = False
-    ZEROGPU_AVAILABLE = False
     NUMPY_AVAILABLE = False
     logger.warning("GOT-OCR dependencies not installed. The parser will not be available.")
 
@@ -75,6 +65,10 @@ class GotOcrParser(DocumentParser):
             }
         ]
     
+    @classmethod
+    def get_description(cls) -> str:
+        return "GOT-OCR 2.0 parser for converting images to text (requires CUDA)"
+    
     @classmethod
     def _load_model(cls):
         """Load the GOT-OCR model and tokenizer if not already loaded."""
@@ -162,21 +156,6 @@ class GotOcrParser(DocumentParser):
         # Determine OCR type based on method
         ocr_type = "format" if ocr_method == "format" else "ocr"
         
-        # Use ZeroGPU if available, otherwise use regular processing
-        if ZEROGPU_AVAILABLE:
-            try:
-                return self._parse_with_zerogpu(file_path, ocr_type, **kwargs)
-            except RuntimeError as e:
-                if "numpy" in str(e).lower():
-                    logger.warning("NumPy issues in ZeroGPU environment, falling back to regular processing")
-                    return self._parse_regular(file_path, ocr_type, **kwargs)
-                else:
-                    raise
-        else:
-            return self._parse_regular(file_path, ocr_type, **kwargs)
-    
-    def _parse_regular(self, file_path: Path, ocr_type: str, **kwargs) -> str:
-        """Regular parsing without ZeroGPU."""
         try:
             # Load the model
             self._load_model()
@@ -189,7 +168,8 @@ class GotOcrParser(DocumentParser):
                 ocr_type=ocr_type
             )
             
-            return self._format_result(result, **kwargs)
+            # Return the result directly as markdown
+            return result
                 
         except torch.cuda.OutOfMemoryError:
             self.release_model()  # Release memory
@@ -213,69 +193,6 @@ class GotOcrParser(DocumentParser):
         except Exception as e:
             logger.error(f"Error processing document with GOT-OCR: {str(e)}")
             raise RuntimeError(f"Error processing document with GOT-OCR: {str(e)}")
-    
-    def _parse_with_zerogpu(self, file_path: Path, ocr_type: str, **kwargs) -> str:
-        """Parse using ZeroGPU for dynamic GPU allocation."""
-        try:
-            # Define the GPU-dependent function
-            @spaces.GPU
-            def process_with_gpu():
-                # Ensure NumPy is available
-                try:
-                    import numpy
-                except ImportError:
-                    # Try to install numpy if not available
-                    import subprocess
-                    import sys
-                    logger.warning("NumPy not found in ZeroGPU environment, attempting to install...")
-                    subprocess.check_call([sys.executable, "-m", "pip", "install", "numpy>=1.24.0"])
-                    import numpy
-                    logger.info(f"NumPy {numpy.__version__} installed successfully in ZeroGPU environment")
-                
-                # Load the model
-                self._load_model()
-                
-                # Use the model's chat method
-                logger.info(f"Processing image with GOT-OCR using ZeroGPU: {file_path}")
-                return self._model.chat(
-                    self._tokenizer, 
-                    str(file_path), 
-                    ocr_type=ocr_type
-                )
-            
-            # Call the GPU-decorated function
-            result = process_with_gpu()
-            
-            # Format and return the result
-            return self._format_result(result, **kwargs)
-            
-        except ImportError as e:
-            if "numpy" in str(e).lower():
-                logger.error(f"NumPy import error in ZeroGPU environment: {str(e)}")
-                raise RuntimeError(
-                    "NumPy is not available in the ZeroGPU environment. "
-                    "This is a known issue with some HuggingFace Spaces. "
-                    "Please try using a different parser or contact support."
-                )
-            else:
-                logger.error(f"Import error in ZeroGPU environment: {str(e)}")
-                raise RuntimeError(f"Error processing document with GOT-OCR (ZeroGPU): {str(e)}")
-        except Exception as e:
-            logger.error(f"Error processing document with GOT-OCR (ZeroGPU): {str(e)}")
-            raise RuntimeError(f"Error processing document with GOT-OCR (ZeroGPU): {str(e)}")
-    
-    def _format_result(self, result: str, **kwargs) -> str:
-        """Format the OCR result based on the requested format."""
-        output_format = kwargs.get("output_format", "markdown").lower()
-        if output_format == "json":
-            return json.dumps({"content": result}, ensure_ascii=False, indent=2)
-        elif output_format == "text":
-            # Simple markdown to text conversion
-            return result.replace("#", "").replace("*", "").replace("_", "")
-        elif output_format == "document_tags":
-            return f"<doc>\n{result}\n</doc>"
-        else:
-            return result
 
 # Register the parser with the registry if GOT is available
 if GOT_AVAILABLE: