Upload app(47).py

Backup/app(47).py

@@ -0,0 +1,200 @@
+import gradio as gr
+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
+import shutil
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class ImageToDxfConverter:
+    def __init__(self):
+        """Initialize the converter with configuration."""
+        # 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"
+        
+        # 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."""
+        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 convert_image(self, 
+                     image_path: Optional[str], 
+                     use_lines: bool = False) -> Tuple[Optional[str], Optional[str], List[str]]:
+        """Convert image to DXF format."""
+        try:
+            # Input validation
+            if not image_path:
+                return None, None, []
+
+            # Setup output directory with fixed path
+            output_dir = self._ensure_directory("OutputPDF")
+            timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+            paths = self._generate_output_paths(output_dir, timestamp)
+
+            # Prepare conversion command
+            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.append("--use-lines")
+
+            # Execute conversion
+            try:
+                result = subprocess.run(
+                    command,
+                    check=True,
+                    capture_output=True,
+                    text=True
+                )
+                logger.info(f"Conversion output: {result.stdout}")
+            except subprocess.CalledProcessError as e:
+                logger.error(f"Conversion failed: {e.stderr}")
+                return None, None, []
+
+            # Move temporary files to final locations
+            shutil.move(paths['temp_dxf'], paths['output_dxf'])
+            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 = []
+            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 and os.path.exists(paths['debug_png']) 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:
+        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):
+                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.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"
+                )
+
+        # Event handler
+        convert_btn.click(
+            fn=converter.convert_image,
+            inputs=[image_input, use_lines_checkbox],
+            outputs=[dxf_output, debug_output]
+        )
+
+    return demo
+
+def main():
+    """Main entry point with proper error handling."""
+    try:
+        demo = create_gradio_interface()
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860
+        )
+    except Exception as e:
+        logger.critical(f"Application failed to start: {str(e)}")
+        raise
+
+if __name__ == "__main__":
+    main()