Update app.py

app.py

@@ -3,135 +3,267 @@ import subprocess
 import os
 import tempfile
 import datetime
+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
 
-def convert_image_to_dxf(image_file, output_folder=None, use_lines=False):
-    try:
-        # Validate input image
-        if image_file is None:
-            return "No image provided", None, None
-        
-        # Define output folder, using a temp directory if none is specified
-        if not output_folder:
-            output_folder = tempfile.mkdtemp()
-        else:
-            os.makedirs(output_folder, exist_ok=True)
-        
-        # Generate the date-based output file name
-        current_date = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
-        image_path = image_file
-        output_path = os.path.join(output_folder, f"{current_date}_output.dxf")
-        debug_output_path = os.path.join(output_folder, f"{current_date}_debug.png")
-        output_pathsimple = os.path.join(output_folder, "_output.dxf")
-        debug_output_pathsimple = os.path.join(output_folder, "_debug.png")
-        # Prepare the command arguments
-        command_args = ["./SimpleImageToDxfHavePass"]
-        
-        # Add --use-lines if the checkbox is checked
-        if use_lines:
-            command_args.append("--use-lines")
-        
-        # Add other arguments
-        command_args.extend([f"--imagePath={image_path}", f"--outputPath={output_pathsimple}", f"--debug-output={debug_output_pathsimple}"])
-        
-        # Execute conversion command
-        result = subprocess.run(
-            command_args,
-            check=True,
-            capture_output=True
-        )
-        
-        # Log stdout for debugging
-        print(result.stdout.decode('utf-8'))
-        
-        # Check if conversion was successful
-        if not os.path.exists(output_path):
-            return "Conversion failed: DXF file was not created.", None, None
-        
-        # Prepare folder structure for upload
-        date_folder = f"{current_date}"
-        
-        # Hugging Face token
-        hf_token = os.getenv("HF_TOKEN")
-        if not hf_token:
-            return "Hugging Face token not found", None, None
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class ImageToDxfConverter:
+    def __init__(self, executable_path: str = "./SimpleImageToDxfHavePass"):
+        """Initialize the converter with configuration."""
+        self.executable_path = Path(executable_path)
+        self.hf_token = os.getenv("HF_TOKEN")
+        self.repo_id = "ArrcttacsrjksX/ImageToAutocadData"
         
-        # Upload input image, output DXF, and optionally debug image to Hugging Face in a date-based folder
-        uploaded_files = []
+        # Validate executable exists
+        if not self.executable_path.exists():
+            raise FileNotFoundError(f"Executable not found: {executable_path}")
         
-        # Upload input image
-        uploaded_input = upload_file(
-            path_or_fileobj=image_path,
-            path_in_repo=f"datasets/ArrcttacsrjksX/ImageToAutocadData/{date_folder}/{os.path.basename(image_path)}",
-            repo_id="ArrcttacsrjksX/ImageToAutocadData",
-            token=hf_token
-        )
-        uploaded_files.append(uploaded_input)
-
-        # Upload DXF output
-        uploaded_dxf = upload_file(
-            path_or_fileobj=output_path,
-            path_in_repo=f"datasets/ArrcttacsrjksX/ImageToAutocadData/{date_folder}/{os.path.basename(output_path)}",
-            repo_id="ArrcttacsrjksX/ImageToAutocadData",
-            token=hf_token
-        )
-        uploaded_files.append(uploaded_dxf)
-
-        # If the checkbox is ticked, upload debug image
-        if use_lines:
-            uploaded_debug = upload_file(
-                path_or_fileobj=debug_output_path,
-                path_in_repo=f"datasets/ArrcttacsrjksX/ImageToAutocadData/{date_folder}/{os.path.basename(debug_output_path)}",
-                repo_id="ArrcttacsrjksX/ImageToAutocadData",
-                token=hf_token
+        # Validate HF token
+        if not self.hf_token:
+            logger.warning("HF_TOKEN environment variable not set")
+    
+    def _ensure_directory(self, path: Union[str, Path]) -> Path:
+        """Ensure directory exists and return Path object."""
+        path = Path(path)
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+
+    def _generate_output_paths(self, output_folder: Path, timestamp: str) -> dict:
+        """Generate all required output paths."""
+        return {
+            'output_dxf': output_folder / f"{timestamp}_output.dxf",
+            'debug_png': output_folder / f"{timestamp}_debug.png",
+            'temp_dxf': output_folder / "_output.dxf",
+            'temp_debug': output_folder / "_debug.png"
+        }
+
+    def _execute_conversion(self, command_args: List[str]) -> subprocess.CompletedProcess:
+        """Execute the conversion command with proper error handling."""
+        try:
+            result = subprocess.run(
+                command_args,
+                check=True,
+                capture_output=True,
+                text=True
             )
-            uploaded_files.append(uploaded_debug)
+            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)
 
-        # Return files directly for download in Gradio interface
-        return output_path, debug_output_path if use_lines else None, uploaded_files
-    
-    except subprocess.CalledProcessError as e:
-        error_msg = f"Error converting image to DXF: {e.stderr.decode('utf-8') if e.stderr else e}"
-        return error_msg, None, None
+    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 main():
-    with gr.Blocks() as demo:
+    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.
+        """
+        try:
+            # Input validation
+            if not image_path:
+                raise ValueError("No image provided")
+
+            # Setup output directory
+            output_dir = self._ensure_directory(output_folder if output_folder else tempfile.mkdtemp())
+            timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+            paths = self._generate_output_paths(output_dir, timestamp)
+
+            # Prepare conversion command
+            command_args = [
+                str(self.executable_path),
+                f"--imagePath={image_path}",
+                f"--outputPath={paths['temp_dxf']}",
+                f"--debug-output={paths['temp_debug']}"
+            ]
+            if use_lines:
+                command_args.append("--use-lines")
+
+            # Execute conversion
+            self._execute_conversion(command_args)
+
+            # Move temporary files to final locations
+            shutil.move(paths['temp_dxf'], paths['output_dxf'])
+            if use_lines:
+                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)
+
+            return (
+                str(paths['output_dxf']),
+                str(paths['debug_png']) if use_lines else None,
+                uploaded_files
+            )
+
+        except Exception as e:
+            logger.error(f"Conversion failed: {str(e)}")
+            return None, None, []
+
+def create_gradio_interface():
+    """Create and configure the Gradio interface."""
+    converter = ImageToDxfConverter()
+    
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
         with gr.Tabs():
-            # Tab for conversion
             with gr.TabItem("Image to DXF"):
-                gr.Markdown("# SimpleImageToDxfHavePass")
+                gr.Markdown("""
+                # Image to DXF Converter
+                Convert your images to DXF format for CAD software.
+                """)
                 
-                # Input row for image and optional output folder
                 with gr.Row():
-                    image_input = gr.Image(type="filepath", label="Input Image (PNG/JPG)")
-                    output_folder = gr.Textbox(label="Output Folder (optional)", placeholder="Leave blank to use a temporary folder")
-                
-                # Checkbox to decide whether to use --use-lines
-                use_lines_checkbox = gr.Checkbox(label="Use --use-lines for conversion", value=False)  # Default is False
-                
-                # Outputs: Debug image and DXF file download link
+                    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"
+                        )
+
                 with gr.Row():
-                    debug_output = gr.Image(type="filepath", label="Debug Output Preview")
-                    dxf_output = gr.File(label="DXF File Download")
+                    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"
+                        )
                 
-                # Conversion button with event binding
-                convert_btn = gr.Button("Convert to DXF")
-                convert_btn.click(
-                    convert_image_to_dxf, 
-                    inputs=[image_input, output_folder, use_lines_checkbox], 
-                    outputs=[dxf_output, debug_output, dxf_output]
+                # Add error message display
+                error_output = gr.Textbox(
+                    label="Status",
+                    interactive=False,
+                    visible=False,
+                    elem_id="error_output"
                 )
-            
-            # About tab
+
             with gr.TabItem("About"):
-                gr.Markdown("This Gradio app allows users to convert an image to a DXF file using the SimpleImageToDxfHavePass command-line tool.")
+                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
+                """)
 
-    demo.launch(share=True)
+        # Setup event handlers
+        convert_btn.click(
+            fn=converter.convert_image,
+            inputs=[image_input, output_folder, use_lines_checkbox],
+            outputs=[dxf_output, debug_output, error_output],
+            api_name="convert"
+        )
 
-if __name__ == "__main__":
+    return demo
+
+def main():
+    """Main entry point with proper error handling."""
     try:
-        subprocess.run(['chmod', '+x', './SimpleImageToDxfHavePass'], check=True)
-    except subprocess.CalledProcessError as e:
-        print(f"Error setting permissions: {e}")
-        exit(1)
-    main()
+        # Ensure executable permissions
+        executable = Path("./SimpleImageToDxfHavePass")
+        if executable.exists():
+            executable.chmod(0o755)
+        
+        # Create and launch the interface
+        demo = create_gradio_interface()
+        demo.launch(
+            share=True,
+            server_name="0.0.0.0",
+            server_port=7860,
+            show_error=True
+        )
+    except Exception as e:
+        logger.critical(f"Application failed to start: {str(e)}")
+        raise
+
+if __name__ == "__main__":
+    main()