Update app.py

app.py

@@ -7,9 +7,7 @@ from pathlib import Path
 from huggingface_hub import upload_file
 from typing import Optional, Tuple, List, Union
 import logging
-from functools import partial
 import shutil
-import sys
 
 # Configure logging
 logging.basicConfig(
@@ -21,47 +19,17 @@ logger = logging.getLogger(__name__)
 class ImageToDxfConverter:
     def __init__(self):
         """Initialize the converter with configuration."""
-        self.executable_path = self._find_executable()
+        # For Hugging Face Spaces, executable should be in the root directory
+        self.executable_path = Path("SimpleImageToDxfHavePass")
         self.hf_token = os.getenv("HF_TOKEN")
         self.repo_id = "ArrcttacsrjksX/ImageToAutocadData"
         
-        # Validate HF token
-        if not self.hf_token:
-            logger.warning("HF_TOKEN environment variable not set")
-    
-    def _find_executable(self) -> Optional[Path]:
-        """Find the converter executable in various possible locations."""
-        possible_paths = [
-            Path("./SimpleImageToDxfHavePass"),
-            Path("./SimpleImageToDxfHavePass.exe"),
-            Path("/app/SimpleImageToDxfHavePass"),  # Common Docker path
-            Path(os.path.dirname(os.path.abspath(__file__))) / "SimpleImageToDxfHavePass",
-            Path.home() / "SimpleImageToDxfHavePass"
-        ]
-
-        # Add system PATH locations
-        if sys.platform == "win32":
-            if "PATH" in os.environ:
-                for path in os.environ["PATH"].split(os.pathsep):
-                    possible_paths.append(Path(path) / "SimpleImageToDxfHavePass.exe")
-        else:
-            for path in ["/usr/local/bin", "/usr/bin", "/bin"]:
-                possible_paths.append(Path(path) / "SimpleImageToDxfHavePass")
-
-        for path in possible_paths:
-            if path.exists():
-                try:
-                    # Make executable on Unix-like systems
-                    if sys.platform != "win32":
-                        path.chmod(path.stat().st_mode | 0o111)
-                    logger.info(f"Found executable at: {path}")
-                    return path
-                except Exception as e:
-                    logger.warning(f"Found executable at {path} but couldn't set permissions: {e}")
-                    continue
-
-        logger.error("SimpleImageToDxfHavePass executable not found in any standard location")
-        return None
+        # Make executable file executable (Hugging Face Spaces specific)
+        try:
+            os.chmod(self.executable_path, 0o755)
+            logger.info(f"Set executable permissions for {self.executable_path}")
+        except Exception as e:
+            logger.error(f"Failed to set executable permissions: {e}")
 
     def _ensure_directory(self, path: Union[str, Path]) -> Path:
         """Ensure directory exists and return Path object."""
@@ -78,76 +46,15 @@ class ImageToDxfConverter:
             'temp_debug': output_folder / "_debug.png"
         }
 
-    def _execute_conversion(self, command_args: List[str]) -> subprocess.CompletedProcess:
-        """Execute the conversion command with proper error handling."""
-        if not self.executable_path:
-            raise RuntimeError(
-                "SimpleImageToDxfHavePass executable not found. Please ensure it's installed "
-                "and available in your system PATH or in the same directory as the script."
-            )
-
-        try:
-            # Add executable verification step
-            if not os.access(str(self.executable_path), os.X_OK) and sys.platform != "win32":
-                logger.warning(f"Setting executable permissions for {self.executable_path}")
-                os.chmod(str(self.executable_path), 0o755)
-
-            result = subprocess.run(
-                command_args,
-                check=True,
-                capture_output=True,
-                text=True
-            )
-            logger.info(f"Conversion output: {result.stdout}")
-            return result
-        except subprocess.CalledProcessError as e:
-            error_msg = f"Conversion failed: {e.stderr}"
-            logger.error(error_msg)
-            raise RuntimeError(error_msg)
-        except Exception as e:
-            error_msg = f"Unexpected error during conversion: {str(e)}"
-            logger.error(error_msg)
-            raise RuntimeError(error_msg)
-
-    def _upload_to_huggingface(self, 
-                             file_path: Path, 
-                             date_folder: str, 
-                             filename: str) -> Optional[str]:
-        """Upload a file to Hugging Face with error handling."""
-        if not self.hf_token:
-            return None
-            
-        try:
-            repo_path = f"datasets/{self.repo_id}/{date_folder}/{filename}"
-            uploaded_file = upload_file(
-                path_or_fileobj=str(file_path),
-                path_in_repo=repo_path,
-                repo_id=self.repo_id,
-                token=self.hf_token
-            )
-            logger.info(f"Successfully uploaded {filename}")
-            return uploaded_file
-        except Exception as e:
-            logger.error(f"Failed to upload {filename}: {str(e)}")
-            return None
-
     def convert_image(self, 
                      image_path: Optional[str], 
                      output_folder: Optional[str] = None,
                      use_lines: bool = False) -> Tuple[Optional[str], Optional[str], List[str]]:
-        """
-        Convert image to DXF format with improved error handling and logging.
-        """
+        """Convert image to DXF format."""
         try:
             # Input validation
             if not image_path:
-                raise ValueError("No image provided")
-
-            if not self.executable_path:
-                raise RuntimeError(
-                    "SimpleImageToDxfHavePass executable not found. Please ensure it's installed "
-                    "and available in your system PATH or in the same directory as the script."
-                )
+                return "No image provided", None, []
 
             # Setup output directory
             output_dir = self._ensure_directory(output_folder if output_folder else tempfile.mkdtemp())
@@ -155,166 +62,138 @@ class ImageToDxfConverter:
             paths = self._generate_output_paths(output_dir, timestamp)
 
             # Prepare conversion command
-            command_args = [
-                str(self.executable_path),
+            command = [
+                f"./{self.executable_path}",  # Use relative path with ./
                 f"--imagePath={image_path}",
                 f"--outputPath={paths['temp_dxf']}",
                 f"--debug-output={paths['temp_debug']}"
             ]
             if use_lines:
-                command_args.append("--use-lines")
+                command.append("--use-lines")
 
             # Execute conversion
-            self._execute_conversion(command_args)
+            try:
+                result = subprocess.run(
+                    command,
+                    check=True,
+                    capture_output=True,
+                    text=True
+                )
+                logger.info(f"Conversion output: {result.stdout}")
+            except subprocess.CalledProcessError as e:
+                error_msg = f"Conversion failed: {e.stderr}"
+                logger.error(error_msg)
+                return error_msg, None, []
 
             # Move temporary files to final locations
             shutil.move(paths['temp_dxf'], paths['output_dxf'])
-            if use_lines:
+            if use_lines and os.path.exists(paths['temp_debug']):
                 shutil.move(paths['temp_debug'], paths['debug_png'])
 
             # Upload files to Hugging Face
             uploaded_files = []
-            date_folder = timestamp
-            
-            # Upload input image
-            if uploaded_input := self._upload_to_huggingface(
-                Path(image_path), 
-                date_folder, 
-                Path(image_path).name
-            ):
-                uploaded_files.append(uploaded_input)
-
-            # Upload DXF output
-            if uploaded_dxf := self._upload_to_huggingface(
-                paths['output_dxf'], 
-                date_folder, 
-                paths['output_dxf'].name
-            ):
-                uploaded_files.append(uploaded_dxf)
-
-            # Upload debug image if available
-            if use_lines and (uploaded_debug := self._upload_to_huggingface(
-                paths['debug_png'], 
-                date_folder, 
-                paths['debug_png'].name
-            )):
-                uploaded_files.append(uploaded_debug)
+            if self.hf_token:
+                try:
+                    date_folder = timestamp
+                    
+                    # Upload input image
+                    uploaded_input = upload_file(
+                        path_or_fileobj=image_path,
+                        path_in_repo=f"datasets/{self.repo_id}/{date_folder}/{Path(image_path).name}",
+                        repo_id=self.repo_id,
+                        token=self.hf_token
+                    )
+                    uploaded_files.append(uploaded_input)
+
+                    # Upload DXF output
+                    uploaded_dxf = upload_file(
+                        path_or_fileobj=str(paths['output_dxf']),
+                        path_in_repo=f"datasets/{self.repo_id}/{date_folder}/{paths['output_dxf'].name}",
+                        repo_id=self.repo_id,
+                        token=self.hf_token
+                    )
+                    uploaded_files.append(uploaded_dxf)
+
+                    # Upload debug image if available
+                    if use_lines and os.path.exists(paths['debug_png']):
+                        uploaded_debug = upload_file(
+                            path_or_fileobj=str(paths['debug_png']),
+                            path_in_repo=f"datasets/{self.repo_id}/{date_folder}/{paths['debug_png'].name}",
+                            repo_id=self.repo_id,
+                            token=self.hf_token
+                        )
+                        uploaded_files.append(uploaded_debug)
+                except Exception as e:
+                    logger.error(f"Upload failed: {str(e)}")
 
             return (
                 str(paths['output_dxf']),
-                str(paths['debug_png']) if use_lines else None,
+                str(paths['debug_png']) if use_lines and os.path.exists(paths['debug_png']) else None,
                 uploaded_files
             )
 
         except Exception as e:
-            logger.error(f"Conversion failed: {str(e)}")
-            return str(e), None, []
+            error_msg = f"Conversion failed: {str(e)}"
+            logger.error(error_msg)
+            return error_msg, None, []
 
 def create_gradio_interface():
     """Create and configure the Gradio interface."""
     converter = ImageToDxfConverter()
     
-    # Early validation of executable
-    if not converter.executable_path:
-        logger.error("No valid executable found - interface will show error message")
-    
     with gr.Blocks(theme=gr.themes.Soft()) as demo:
-        with gr.Tabs():
-            with gr.TabItem("Image to DXF"):
-                if not converter.executable_path:
-                    gr.Markdown("""
-                    # ⚠️ System Configuration Error
-                    
-                    The SimpleImageToDxfHavePass executable was not found. Please ensure:
-                    1. The executable is in the same directory as this script
-                    2. The executable has proper permissions
-                    3. The executable is available in your system PATH
-                    
-                    Check the logs for more details.
-                    """)
-                else:
-                    gr.Markdown("""
-                    # Image to DXF Converter
-                    Convert your images to DXF format for CAD software.
-                    """)
-                
-                with gr.Row():
-                    with gr.Column(scale=2):
-                        image_input = gr.Image(
-                            type="filepath",
-                            label="Input Image",
-                            elem_id="image_input"
-                        )
-                    with gr.Column(scale=1):
-                        output_folder = gr.Textbox(
-                            label="Output Folder (optional)",
-                            placeholder="Leave blank for temporary folder",
-                            elem_id="output_folder"
-                        )
-                        use_lines_checkbox = gr.Checkbox(
-                            label="Enable line detection",
-                            value=False,
-                            elem_id="use_lines"
-                        )
-                        convert_btn = gr.Button(
-                            "Convert to DXF",
-                            variant="primary",
-                            elem_id="convert_btn",
-                            interactive=bool(converter.executable_path)
-                        )
-
-                with gr.Row():
-                    with gr.Column():
-                        dxf_output = gr.File(
-                            label="DXF Output",
-                            elem_id="dxf_output"
-                        )
-                    with gr.Column():
-                        debug_output = gr.Image(
-                            type="filepath",
-                            label="Debug Preview",
-                            elem_id="debug_output"
-                        )
-                
-                # Add error message display
-                error_output = gr.Textbox(
-                    label="Status",
-                    interactive=False,
-                    visible=True,
-                    elem_id="error_output"
+        gr.Markdown("""
+        # Image to DXF Converter
+        Convert your images to DXF format for CAD software.
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                image_input = gr.Image(
+                    type="filepath",
+                    label="Input Image",
+                    elem_id="image_input"
+                )
+            with gr.Column(scale=1):
+                output_folder = gr.Textbox(
+                    label="Output Folder (optional)",
+                    placeholder="Leave blank for temporary folder",
+                    elem_id="output_folder"
+                )
+                use_lines_checkbox = gr.Checkbox(
+                    label="Enable line detection",
+                    value=False,
+                    elem_id="use_lines"
+                )
+                convert_btn = gr.Button(
+                    "Convert to DXF",
+                    variant="primary"
                 )
 
-            with gr.TabItem("About"):
-                gr.Markdown("""
-                ## Image to DXF Converter
-                
-                This application converts images to DXF format using the SimpleImageToDxfHavePass tool.
-                
-                ### Features:
-                - Supports PNG and JPG input formats
-                - Optional line detection mode
-                - Debug preview output
-                - Automatic file organization
-                - Hugging Face integration for result sharing
-                
-                ### Usage:
-                1. Upload an image
-                2. (Optional) Specify output folder
-                3. Toggle line detection if needed
-                4. Click Convert
-                
-                ### System Requirements:
-                - SimpleImageToDxfHavePass executable must be available
-                - Proper file permissions
-                - HF_TOKEN environment variable for Hugging Face integration
-                """)
+        with gr.Row():
+            with gr.Column():
+                dxf_output = gr.File(
+                    label="DXF Output",
+                    elem_id="dxf_output"
+                )
+            with gr.Column():
+                debug_output = gr.Image(
+                    type="filepath",
+                    label="Debug Preview",
+                    elem_id="debug_output"
+                )
+        
+        status_output = gr.Textbox(
+            label="Status",
+            value="Ready",
+            interactive=False
+        )
 
-        # Setup event handlers
+        # Event handler
         convert_btn.click(
             fn=converter.convert_image,
             inputs=[image_input, output_folder, use_lines_checkbox],
-            outputs=[error_output, debug_output, dxf_output],
-            api_name="convert"
+            outputs=[dxf_output, debug_output, status_output]
         )
 
     return demo
@@ -322,12 +201,10 @@ def create_gradio_interface():
 def main():
     """Main entry point with proper error handling."""
     try:
-        # Create and launch the interface
         demo = create_gradio_interface()
         demo.launch(
             server_name="0.0.0.0",
-            server_port=7860,
-            show_error=True
+            server_port=7860
         )
     except Exception as e:
         logger.critical(f"Application failed to start: {str(e)}")