Update app.py

app.py

@@ -99,110 +99,107 @@ def convert_file(file):
     """Process uploaded file and convert it to text"""
     if file is None:
         logging.warning("No file provided")
-        return "No file uploaded. Please select a file first.", None, None
+        return "No file uploaded. Please select a file first.", None, "No file uploaded"
     
     try:
         # Log file info
         logging.info(f"File type: {type(file)}")
-        logging.info(f"File attributes: {dir(file) if hasattr(file, '__dir__') else 'No dir method'}")
         
-        # Wczesna obsługa obiektu NamedString
-        if str(type(file)).find('NamedString') > -1:
-            logging.info("Detected NamedString object")
-            # Traktuj plik jako ścieżkę, ale zachowaj informację o nazwie
-            filename = file.name if hasattr(file, 'name') else "unknown.file"
-            try:
-                with open(str(file), 'rb') as f:
-                    file_content = f.read()
-                logging.info(f"Successfully read file content from NamedString as path")
-            except Exception as e:
-                error_msg = f"Could not read NamedString as path: {str(e)}"
-                logging.error(error_msg)
-                return error_msg, None, error_msg
-        else:
-            # Handle different types of file objects
+        # Uzyskaj nazwę i ścieżkę pliku
+        try:
             if hasattr(file, 'name'):
+                # Standardowy przypadek - obiekt ma atrybut name
                 filename = file.name
-            elif isinstance(file, tuple) and len(file) > 1:
-                filename = file[0]  # In some versions, Gradio returns (filename, temppath)
+                # Próbujemy różne sposoby dostępu do zawartości pliku
+                if hasattr(file, 'read'):
+                    # Obiekt ma metodę read()
+                    content = file.read()
+                    temp_path = None
+                elif hasattr(file, '__fspath__') or isinstance(file, str):
+                    # Obiekt jest ścieżką lub można go konwertować na ścieżkę
+                    filepath = str(file)
+                    if os.path.exists(filepath):
+                        with open(filepath, 'rb') as f:
+                            content = f.read()
+                        temp_path = filepath
+                    else:
+                        return f"File not found at path: {filepath}", None, f"Error: File not found"
+                else:
+                    # Nie możemy bezpośrednio odczytać pliku
+                    return f"Cannot read file content from {type(file)}", None, "Error: Cannot read file"
+            elif isinstance(file, tuple) and len(file) >= 2:
+                # Przypadek gdzie file to tuple (filename, filepath)
+                filename = file[0]
+                filepath = file[1]
+                if os.path.exists(filepath):
+                    with open(filepath, 'rb') as f:
+                        content = f.read()
+                    temp_path = filepath
+                else:
+                    return f"File not found at path: {filepath}", None, f"Error: File not found"
             else:
-                filename = "unknown_file"
-                logging.warning(f"Unknown file object type: {type(file)}")
-            
-            logging.info(f"Converting file: {filename}")
-            
-            # Handle different file object types
-            if hasattr(file, 'read'):
-                # File-like object with read method
-                file_content = file.read()
-            elif isinstance(file, tuple) and len(file) > 1 and os.path.exists(file[1]):
-                # Tuple with (name, path)
-                with open(file[1], 'rb') as f:
-                    file_content = f.read()
-            elif isinstance(file, str) and os.path.exists(file):
-                # Direct path to file
-                with open(file, 'rb') as f:
-                    file_content = f.read()
-            else:
-                error_msg = f"Could not read file content from object type: {type(file)}"
-                logging.error(error_msg)
-                return error_msg, None, error_msg
+                # Nie mamy nazwy pliku ani ścieżki
+                return f"Cannot determine file name or path from {type(file)}", None, "Error: Cannot determine file"
+        except Exception as e:
+            error_msg = f"Error accessing file: {str(e)}"
+            logging.exception(error_msg)
+            return error_msg, None, "Error accessing file"
         
-        converter = MultiConverter()
+        # Określ rozszerzenie pliku
         _, file_ext = os.path.splitext(filename)
         file_ext = file_ext.lower()
-        logging.info(f"File extension: {file_ext}")
-        logging.info(f"Read {len(file_content)} bytes from input file")
+        logging.info(f"File name: {filename}, extension: {file_ext}")
         
-        # Create a temporary file
-        with tempfile.NamedTemporaryFile(delete=False) as temp_file:
-            temp_file.write(file_content)
-            temp_file_path = temp_file.name
-            logging.info(f"Created temporary file at: {temp_file_path}")
+        # Utwórz tymczasowy plik, jeśli go nie mamy
+        if temp_path is None:
+            with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+                temp_file.write(content)
+                temp_path = temp_file.name
+            logging.info(f"Created temporary file at: {temp_path}")
         
+        # Konwertuj plik na tekst
         try:
-            result = None
+            converter = MultiConverter()
+            
             if file_ext in [".xlsx", ".xls"]:
                 logging.info("Processing Excel file")
-                result = converter.convert_excel_to_formatted_text(temp_file_path)
+                result = converter.convert_excel_to_formatted_text(temp_path)
             elif file_ext in [".pptx", ".ppt"]:
                 logging.info("Processing PowerPoint file")
-                result = converter.convert_pptx_to_text(temp_file_path, filename)
+                result = converter.convert_pptx_to_text(temp_path, filename)
             elif file_ext == ".pdf":
                 logging.info("Processing PDF file")
-                result = converter.convert_pdf_to_text(temp_file_path, filename)
+                result = converter.convert_pdf_to_text(temp_path, filename)
             elif file_ext in [".docx", ".doc"]:
                 logging.info("Processing Word file")
-                result = converter.convert_docx_to_text(temp_file_path, filename)
+                result = converter.convert_docx_to_text(temp_path, filename)
             else:
                 error_msg = f"Unsupported file format: {file_ext}"
                 logging.error(error_msg)
-                result = error_msg
+                return error_msg, None, f"Error: {error_msg}"
             
-            logging.info(f"Conversion successful, text length: {len(result) if result else 0}")
-            
-            # Create and return file for download
+            # Generuj plik wynikowy
             output_filename = os.path.splitext(filename)[0] + ".txt"
+            output_content = result.encode('utf-8')
+            
+            logging.info(f"Conversion successful, created output file: {output_filename}")
+            
+            # Zwróć wynik jako string, plik do pobrania i status
+            return result, (output_filename, output_content), "Conversion completed successfully"
             
-            # Convert result to bytes for file download
-            if result:
-                file_content = result.encode('utf-8')
-                logging.info(f"Created output file: {output_filename}, size: {len(file_content)} bytes")
-                return result, (output_filename, file_content), result
-            else:
-                logging.warning("No result generated")
-                return "No result generated", None, None
         finally:
-            # Clean up the temporary file
-            if os.path.exists(temp_file_path):
-                logging.info(f"Removing temporary file: {temp_file_path}")
-                os.unlink(temp_file_path)
-            else:
-                logging.warning(f"Temporary file not found for deletion: {temp_file_path}")
+            # Zawsze usuwaj tymczasowy plik, jeśli go utworzyliśmy
+            if temp_path and temp_path != str(file) and os.path.exists(temp_path):
+                try:
+                    os.unlink(temp_path)
+                    logging.info(f"Removed temporary file: {temp_path}")
+                except Exception as e:
+                    logging.warning(f"Could not remove temporary file {temp_path}: {str(e)}")
+    
     except Exception as e:
-        error_msg = f"Error converting file: {str(e)}"
+        error_msg = f"Error during conversion: {str(e)}"
         logging.exception(error_msg)
-        return error_msg, None, None
+        return error_msg, None, f"Error: {error_msg}"
 
 
 # Create Gradio interface