Update app.py

app.py

@@ -151,35 +151,67 @@ class URLProcessor:
             
 class FileProcessor:
     """Class to handle file processing"""
-    
+
     def __init__(self, max_file_size: int = 2 * 1024 * 1024 * 1024):  # 2GB default
         self.max_file_size = max_file_size
         self.supported_text_extensions = {'.txt', '.md', '.csv', '.json', '.xml'}
+        self.processed_zip_count = 0
+        self.max_zip_files = 5
+
+    def is_text_file(self, file_path: str) -> bool:
+        """Check if the file is a text file based on its extension."""
+        return any(file_path.lower().endswith(ext) for ext in self.supported_text_extensions)
 
-    def process_file(self, file) -> List[Dict]:
-        """Process uploaded file with enhanced error handling"""
-        if not file:
+    def process_files(self, files: Union[List[gr.File], List[str]]) -> List[Dict]:
+        """Process multiple uploaded files and return a single JSON extraction"""
+        if not files:
             return []
 
-        dataset = []
+        combined_data = []
+        self.processed_zip_count = 0
+        
         try:
-            file_size = os.path.getsize(file.name)
-            if file_size > self.max_file_size:
-                logger.warning(f"File size ({file_size} bytes) exceeds maximum allowed size")
-                return [{"error": f"File size ({file_size} bytes) exceeds maximum allowed size of {self.max_file_size} bytes."}]
+            for file in files:
+                # Check if the file is a Gradio File object or a string path
+                file_path = file.name if isinstance(file, gr.File) else file
+                
+                # Log the file path being processed
+                logger.info(f"Processing file: {file_path}")
+                
+                # Skip if it's a directory
+                if os.path.isdir(file_path):
+                    logger.warning(f"Skipping directory: {file_path}")
+                    continue
+                    
+                # Skip if file doesn't exist
+                if not os.path.exists(file_path):
+                    logger.warning(f"File does not exist: {file_path}")
+                    continue
+                
+                # Check file size
+                file_size = os.path.getsize(file_path)
+                if file_size > self.max_file_size:
+                    logger.warning(f"File size ({file_size} bytes) exceeds maximum allowed size")
+                    continue  # Skip this file
 
-            with tempfile.TemporaryDirectory() as temp_dir:
-                if zipfile.is_zipfile(file.name):
-                    dataset.extend(self._process_zip_file(file.name, temp_dir))
+                # Process based on file type
+                if zipfile.is_zipfile(file_path):
+                    if self.processed_zip_count >= self.max_zip_files:
+                        logger.warning(f"Maximum number of ZIP files ({self.max_zip_files}) reached, skipping {file_path}")
+                        continue
+                    self.processed_zip_count += 1
+                    zip_results = self._process_zip_file(file_path)
+                    combined_data.extend(zip_results)
+                elif self.is_text_file(file_path):
+                    file_results = self._process_single_file(file_path)
+                    combined_data.extend(file_results)
                 else:
-                    dataset.extend(self._process_single_file(file))
+                    logger.warning(f"Unsupported file type: {file_path}")
 
         except Exception as e:
-            logger.error(f"Error processing file: {str(e)}")
-            return []
-
-        return dataset
-
+            logger.error(f"Error processing files: {str(e)}")
+        
+        return combined_data
     def _process_zip_file(self, zip_path: str, temp_dir: str) -> List[Dict]:
         """Process ZIP file contents"""
         results = []