Create app.py

app.py

@@ -0,0 +1,379 @@
+"""
+Main application file for Hugging Face Space Creator
+Enterprise-grade Gradio application for converting Python code to deployable Gradio apps
+"""
+
+import gradio as gr
+import tempfile
+import os
+import sys
+from pathlib import Path
+
+# Add utils and components to path
+sys.path.append(str(Path(__file__).parent))
+
+from utils.converter import convert_code
+from utils.deployer import deploy_to_space
+from utils.file_handler import (
+    create_zip_archive,
+    read_file_content,
+    parse_notebook,
+    save_individual_file
+)
+from utils.validator import validate_inputs
+
+from components.header import create_header
+from components.sidebar import create_sidebar
+from components.api_guide import create_api_guide
+from components.file_downloader import create_file_download_section
+
+# Constants
+MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
+SUPPORTED_EXTENSIONS = ['.py', '.ipynb', '.txt']
+
+
+class SpaceCreatorApp:
+    """Main application class for Hugging Face Space Creator"""
+    
+    def __init__(self):
+        self.temp_files = []
+        self.current_step = 1
+        self.generated_files = {}
+        
+    def cleanup(self):
+        """Clean up temporary files"""
+        for file_path in self.temp_files:
+            try:
+                if os.path.exists(file_path):
+                    os.remove(file_path)
+            except:
+                pass
+        self.temp_files = []
+    
+    def process_step1(self, input_text, input_file, groq_api_key):
+        """Step 1: Convert code to Gradio app"""
+        try:
+            # Validate inputs
+            validation_errors = validate_inputs(groq_api_key, None, None, "Convert Only")
+            if validation_errors:
+                return None, None, None, None, self._format_errors(validation_errors), 1
+            
+            # Get source code
+            code_content = self._extract_code(input_text, input_file)
+            if not code_content.strip():
+                return None, None, None, None, "Please provide Python code to convert.", 1
+            
+            # Convert code
+            conversion_result = convert_code(code_content, groq_api_key)
+            
+            # Store generated files
+            self.generated_files = {
+                "app.py": conversion_result["app_py"],
+                "requirements.txt": conversion_result["requirements_txt"],
+                "README.md": conversion_result["readme_md"]
+            }
+            
+            # Create individual files for download
+            file_paths = {}
+            for filename, content in self.generated_files.items():
+                file_path = save_individual_file(filename, content)
+                self.temp_files.append(file_path)
+                file_paths[filename] = file_path
+            
+            status = self._create_status_message("success", "Code conversion successful!")
+            return (file_paths["app.py"], file_paths["requirements.txt"], 
+                   file_paths["README.md"], None, status, 2)
+            
+        except Exception as e:
+            error_msg = self._create_status_message("error", f"Conversion failed: {str(e)}")
+            return None, None, None, None, error_msg, 1
+    
+    def process_step2(self, hf_token, space_name, deploy_mode):
+        """Step 2: Deploy to Hugging Face"""
+        try:
+            if deploy_mode != "Deploy to Hugging Face Space":
+                status = self._create_status_message("info", "Skipping deployment as requested.")
+                return None, status, 2
+            
+            # Validate deployment inputs
+            validation_errors = validate_inputs(None, hf_token, space_name, "Deploy")
+            if validation_errors:
+                return None, self._format_errors(validation_errors), 2
+            
+            # Deploy to Hugging Face
+            deploy_url = deploy_to_space(hf_token, space_name, self.generated_files)
+            
+            # Create zip archive of all files
+            zip_bytes = create_zip_archive(self.generated_files)
+            zip_path = save_individual_file("gradio_app_full_package.zip", zip_bytes, binary=True)
+            self.temp_files.append(zip_path)
+            
+            status = self._create_status_message("success", 
+                f"Deployment successful! Space URL: {deploy_url}")
+            return zip_path, status, 3
+            
+        except Exception as e:
+            error_msg = self._create_status_message("error", f"Deployment failed: {str(e)}")
+            return None, error_msg, 2
+    
+    def _extract_code(self, input_text, input_file):
+        """Extract code from text or file"""
+        code_content = ""
+        if input_file is not None:
+            file_content = read_file_content(input_file)
+            if input_file.name.endswith('.ipynb') if hasattr(input_file, 'name') else False:
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.ipynb', delete=False, encoding='utf-8') as tmp:
+                    tmp.write(file_content)
+                    tmp_path = tmp.name
+                try:
+                    code_content = parse_notebook(tmp_path)
+                finally:
+                    os.unlink(tmp_path)
+            else:
+                code_content = file_content
+        elif input_text.strip():
+            code_content = input_text
+        return code_content
+    
+    def _format_errors(self, errors):
+        """Format validation errors"""
+        error_html = '<div class="error-message"><h4>Validation Errors:</h4><ul>'
+        for error in errors:
+            error_html += f'<li>{error}</li>'
+        error_html += '</ul></div>'
+        return error_html
+    
+    def _create_status_message(self, msg_type, message):
+        """Create formatted status message"""
+        icons = {
+            "success": "check_circle",
+            "error": "error",
+            "warning": "warning",
+            "info": "info"
+        }
+        colors = {
+            "success": "#10B981",
+            "error": "#EF4444",
+            "warning": "#F59E0B",
+            "info": "#3B82F6"
+        }
+        
+        return f'''
+        <div class="status-message {msg_type}">
+            <span class="material-icons" style="color: {colors[msg_type]}; vertical-align: middle;">
+                {icons[msg_type]}
+            </span>
+            <span style="vertical-align: middle; margin-left: 8px;">{message}</span>
+        </div>
+        '''
+
+
+def create_app():
+    """Create the Gradio application interface"""
+    app = SpaceCreatorApp()
+    
+    with gr.Blocks(
+        title="Hugging Face Space Creator",
+        theme=gr.themes.Soft(primary_hue="yellow"),
+        css="static/css/style.css"
+    ) as demo:
+        
+        # Custom CSS
+        gr.HTML('<link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">')
+        
+        # Header
+        create_header()
+        
+        with gr.Row():
+            # Sidebar with steps
+            with gr.Column(scale=1, min_width=300):
+                current_step = gr.State(1)
+                sidebar = create_sidebar(current_step)
+            
+            # Main content area
+            with gr.Column(scale=3):
+                # Step 1: Code Input and Conversion
+                with gr.Group(visible=True) as step1_group:
+                    gr.Markdown("### Step 1: Provide Your Code")
+                    
+                    with gr.Tabs():
+                        with gr.Tab("Upload File", id="upload_tab"):
+                            file_input = gr.File(
+                                label="Upload Python or Jupyter Notebook",
+                                file_types=SUPPORTED_EXTENSIONS,
+                                type="filepath"
+                            )
+                        
+                        with gr.Tab("Paste Code", id="paste_tab"):
+                            text_input = gr.Textbox(
+                                label="Python Code",
+                                lines=20,
+                                placeholder="# Paste your Python code here...\n\n# Example:\ndef add(a, b):\n    return a + b\n\ndef greet(name):\n    return f\"Hello, {name}!\"",
+                                elem_id="code_editor"
+                            )
+                    
+                    gr.Markdown("### Step 1b: API Configuration")
+                    with gr.Row():
+                        with gr.Column():
+                            groq_api_key = gr.Textbox(
+                                label="Groq API Key",
+                                type="password",
+                                placeholder="Enter your Groq API key starting with gsk_",
+                                info="Required for AI-powered conversion"
+                            )
+                    
+                    # API Key Creation Guide
+                    api_guide = create_api_guide()
+                    
+                    with gr.Row():
+                        convert_btn = gr.Button(
+                            "Convert Code",
+                            variant="primary",
+                            size="lg",
+                            elem_id="convert_btn"
+                        )
+                
+                # Step 2: Generated Files
+                with gr.Group(visible=False) as step2_group:
+                    gr.Markdown("### Step 2: Generated Files")
+                    
+                    with gr.Row():
+                        with gr.Column():
+                            app_py_download = gr.File(
+                                label="app.py",
+                                file_types=[".py"],
+                                interactive=False
+                            )
+                        
+                        with gr.Column():
+                            requirements_download = gr.File(
+                                label="requirements.txt",
+                                file_types=[".txt"],
+                                interactive=False
+                            )
+                        
+                        with gr.Column():
+                            readme_download = gr.File(
+                                label="README.md",
+                                file_types=[".md"],
+                                interactive=False
+                            )
+                    
+                    gr.Markdown("### Step 2b: Deployment Options")
+                    
+                    with gr.Row():
+                        with gr.Column():
+                            hf_token = gr.Textbox(
+                                label="Hugging Face Token",
+                                type="password",
+                                placeholder="Enter your Hugging Face token starting with hf_",
+                                info="Required for deployment"
+                            )
+                        
+                        with gr.Column():
+                            space_name = gr.Textbox(
+                                label="Space Name",
+                                placeholder="my-gradio-application",
+                                info="Lowercase letters, numbers, and hyphens only"
+                            )
+                    
+                    deploy_mode = gr.Radio(
+                        choices=["Download Only", "Deploy to Hugging Face Space"],
+                        label="Select Action",
+                        value="Download Only",
+                        elem_id="deploy_mode"
+                    )
+                    
+                    with gr.Row():
+                        back_btn_step2 = gr.Button("Back", variant="secondary")
+                        deploy_btn = gr.Button("Proceed to Deployment", variant="primary")
+                
+                # Step 3: Deployment Results
+                with gr.Group(visible=False) as step3_group:
+                    gr.Markdown("### Step 3: Deployment Complete")
+                    
+                    with gr.Row():
+                        with gr.Column():
+                            full_package_download = gr.File(
+                                label="Complete Application Package",
+                                file_types=[".zip"],
+                                interactive=False
+                            )
+                    
+                    deployment_status = gr.Markdown()
+                    
+                    with gr.Row():
+                        back_btn_step3 = gr.Button("Start New Project", variant="secondary")
+                        finish_btn = gr.Button("Finish", variant="primary")
+                
+                # Status output
+                status_output = gr.HTML(
+                    value='<div class="status-container"></div>',
+                    elem_id="status_output"
+                )
+        
+        # Event handlers
+        convert_btn.click(
+            fn=app.process_step1,
+            inputs=[text_input, file_input, groq_api_key],
+            outputs=[
+                app_py_download,
+                requirements_download,
+                readme_download,
+                full_package_download,
+                status_output,
+                current_step
+            ]
+        ).then(
+            fn=lambda step: (gr.update(visible=step==1), gr.update(visible=step==2), gr.update(visible=step==3)),
+            inputs=[current_step],
+            outputs=[step1_group, step2_group, step3_group]
+        )
+        
+        deploy_btn.click(
+            fn=app.process_step2,
+            inputs=[hf_token, space_name, deploy_mode],
+            outputs=[full_package_download, status_output, current_step]
+        ).then(
+            fn=lambda step: (gr.update(visible=step==1), gr.update(visible=step==2), gr.update(visible=step==3)),
+            inputs=[current_step],
+            outputs=[step1_group, step2_group, step3_group]
+        )
+        
+        back_btn_step2.click(
+            fn=lambda: (1, gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)),
+            outputs=[current_step, step1_group, step2_group, step3_group]
+        )
+        
+        back_btn_step3.click(
+            fn=lambda: (1, gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)),
+            outputs=[current_step, step1_group, step2_group, step3_group]
+        ).then(
+            fn=app.cleanup,
+            inputs=None,
+            outputs=None
+        )
+        
+        finish_btn.click(
+            fn=app.cleanup,
+            inputs=None,
+            outputs=None
+        )
+    
+    return demo
+
+
+if __name__ == "__main__":
+    print("Starting Hugging Face Space Creator...")
+    print("=" * 50)
+    print("Enterprise-grade Python to Gradio App Converter")
+    print("=" * 50)
+    
+    app = create_app()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=True,
+        favicon_path=None
+    )