Upload 12 files

README.md

@@ -1,12 +1,38 @@
----
-title: Pydeploy Studio
-emoji: 🔥
-colorFrom: purple
-colorTo: red
-sdk: gradio
-sdk_version: 6.2.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Hugging Face Space Creator
+
+An enterprise-grade application for converting Python code into deployable Gradio web applications with one-click deployment to Hugging Face Spaces.
+
+## Features
+
+### 🚀 **Core Features**
+- **AI-Powered Conversion**: Convert Python/Notebook code to complete Gradio apps using Groq's Llama 3.3
+- **Enterprise-Grade UI**: Professional, responsive interface with step-by-step workflow
+- **Individual File Downloads**: Download each component separately (app.py, requirements.txt, README.md)
+- **One-Click Deployment**: Direct deployment to Hugging Face Spaces
+- **Secure API Handling**: User-provided API keys with no storage
+
+### 🛡️ **Security**
+- User-managed API keys (Groq & Hugging Face)
+- No key storage or logging
+- Input validation and sanitization
+- Secure file handling
+
+### 📊 **Enterprise Ready**
+- Modular architecture
+- Comprehensive error handling
+- Detailed logging
+- Scalable design
+
+## Installation
+
+### Prerequisites
+- Python 3.8 or higher
+- Groq API Key (for conversion)
+- Hugging Face Write Token (for deployment)
+
+### Quick Start
+
+1. Clone the repository:
+```bash
+git clone <repository-url>
+cd huggingface-space-creator

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
+    )

components/api_guide.py

@@ -0,0 +1,130 @@
+"""
+API key creation guide component
+"""
+
+import gradio as gr
+
+
+def create_api_guide():
+    """Create API key creation guide with expandable sections"""
+    
+    with gr.Accordion("Need help creating API keys?", open=False):
+        gr.Markdown("### Step-by-Step API Key Creation Guide")
+        
+        with gr.Tabs():
+            # Groq API Key Guide
+            with gr.Tab("Groq API Key"):
+                groq_guide = '''
+                <div class="api-guide">
+                    <h4>Creating a Groq API Key</h4>
+                    <ol>
+                        <li>Go to <a href="https://console.groq.com" target="_blank">Groq Console</a></li>
+                        <li>Sign up or log in to your account</li>
+                        <li>Navigate to <strong>API Keys</strong> section</li>
+                        <li>Click on <strong>Create API Key</strong></li>
+                        <li>Give your key a descriptive name</li>
+                        <li>Copy the generated key (starts with <code>gsk_</code>)</li>
+                        <li>Paste it in the Groq API Key field above</li>
+                    </ol>
+                    
+                    <div class="note">
+                        <span class="material-icons">info</span>
+                        <p>Keep your API key secure and never share it publicly.</p>
+                    </div>
+                    
+                    <div class="resources">
+                        <h5>Additional Resources:</h5>
+                        <ul>
+                            <li><a href="https://groq.com" target="_blank">Groq Official Website</a></li>
+                            <li><a href="https://console.groq.com/docs/quickstart" target="_blank">Groq Quickstart Guide</a></li>
+                            <li><a href="https://console.groq.com/docs/authentication" target="_blank">Authentication Documentation</a></li>
+                        </ul>
+                    </div>
+                </div>
+                '''
+                gr.HTML(groq_guide)
+            
+            # Hugging Face Token Guide
+            with gr.Tab("Hugging Face Token"):
+                hf_guide = '''
+                <div class="api-guide">
+                    <h4>Creating a Hugging Face Token</h4>
+                    <ol>
+                        <li>Go to <a href="https://huggingface.co" target="_blank">Hugging Face</a></li>
+                        <li>Sign up or log in to your account</li>
+                        <li>Click on your profile picture → <strong>Settings</strong></li>
+                        <li>Navigate to <strong>Access Tokens</strong></li>
+                        <li>Click on <strong>New Token</strong></li>
+                        <li>Select token type: <strong>Write</strong></li>
+                        <li>Give your token a descriptive name</li>
+                        <li>Copy the generated token (starts with <code>hf_</code>)</li>
+                        <li>Paste it in the Hugging Face Token field above</li>
+                    </ol>
+                    
+                    <div class="note">
+                        <span class="material-icons">warning</span>
+                        <p>Write token is required for creating and updating Spaces.</p>
+                    </div>
+                    
+                    <div class="resources">
+                        <h5>Additional Resources:</h5>
+                        <ul>
+                            <li><a href="https://huggingface.co/docs/hub/security-tokens" target="_blank">Token Security Guide</a></li>
+                            <li><a href="https://huggingface.co/docs/hub/spaces-overview" target="_blank">Spaces Documentation</a></li>
+                            <li><a href="https://huggingface.co/docs/hub/spaces-sdks" target="_blank">SDK Reference</a></li>
+                        </ul>
+                    </div>
+                </div>
+                '''
+                gr.HTML(hf_guide)
+            
+            # Best Practices
+            with gr.Tab("Best Practices"):
+                practices_guide = '''
+                <div class="api-guide">
+                    <h4>API Key Security Best Practices</h4>
+                    
+                    <div class="security-tip">
+                        <span class="material-icons">lock</span>
+                        <div>
+                            <strong>Key Rotation</strong>
+                            <p>Regularly rotate your API keys (every 90 days recommended).</p>
+                        </div>
+                    </div>
+                    
+                    <div class="security-tip">
+                        <span class="material-icons">visibility_off</span>
+                        <div>
+                            <strong>Never Expose Keys</strong>
+                            <p>Never commit API keys to version control or share in public forums.</p>
+                        </div>
+                    </div>
+                    
+                    <div class="security-tip">
+                        <span class="material-icons">shield</span>
+                        <div>
+                            <strong>Use Environment Variables</strong>
+                            <p>Store keys in environment variables instead of hardcoding.</p>
+                        </div>
+                    </div>
+                    
+                    <div class="security-tip">
+                        <span class="material-icons">notifications</span>
+                        <div>
+                            <strong>Monitor Usage</strong>
+                            <p>Regularly check API usage and set up alerts for unusual activity.</p>
+                        </div>
+                    </div>
+                    
+                    <div class="security-tip">
+                        <span class="material-icons">delete</span>
+                        <div>
+                            <strong>Revoke Unused Keys</strong>
+                            <p>Immediately revoke keys that are no longer needed.</p>
+                        </div>
+                    </div>
+                </div>
+                '''
+                gr.HTML(practices_guide)
+    
+    return None

components/file_downloader.py

@@ -0,0 +1,87 @@
+"""
+File download components
+"""
+
+import gradio as gr
+
+
+def create_file_download_section():
+    """Create file download section with individual file options"""
+    
+    with gr.Column(elem_classes="download-section"):
+        gr.Markdown("### Generated Files")
+        
+        with gr.Row():
+            # app.py download
+            with gr.Column(scale=1):
+                app_download = gr.File(
+                    label="app.py",
+                    file_types=[".py"],
+                    interactive=False,
+                    elem_classes="file-download"
+                )
+                
+                gr.HTML('''
+                <div class="file-info">
+                    <span class="material-icons">description</span>
+                    <span>Main application file</span>
+                </div>
+                ''')
+            
+            # requirements.txt download
+            with gr.Column(scale=1):
+                requirements_download = gr.File(
+                    label="requirements.txt",
+                    file_types=[".txt"],
+                    interactive=False,
+                    elem_classes="file-download"
+                )
+                
+                gr.HTML('''
+                <div class="file-info">
+                    <span class="material-icons">list</span>
+                    <span>Dependencies list</span>
+                </div>
+                ''')
+            
+            # README.md download
+            with gr.Column(scale=1):
+                readme_download = gr.File(
+                    label="README.md",
+                    file_types=[".md"],
+                    interactive=False,
+                    elem_classes="file-download"
+                )
+                
+                gr.HTML('''
+                <div class="file-info">
+                    <span class="material-icons">article</span>
+                    <span>Documentation</span>
+                </div>
+                ''')
+        
+        # Full package download
+        gr.Markdown("### Complete Package")
+        
+        with gr.Row():
+            with gr.Column():
+                full_package_download = gr.File(
+                    label="Full Application Package",
+                    file_types=[".zip"],
+                    interactive=False,
+                    elem_classes="full-download"
+                )
+                
+                gr.HTML('''
+                <div class="package-info">
+                    <span class="material-icons">folder_zip</span>
+                    <span>Contains all files for deployment</span>
+                </div>
+                ''')
+    
+    return {
+        "app_download": app_download,
+        "requirements_download": requirements_download,
+        "readme_download": readme_download,
+        "full_package_download": full_package_download
+    }

components/header.py

@@ -0,0 +1,30 @@
+"""
+Header component for the application
+"""
+
+import gradio as gr
+
+
+def create_header():
+    """Create the application header"""
+    
+    header_html = """
+    <div class="header-container">
+        <div class="header-content">
+            <div class="logo-section">
+                <span class="material-icons logo-icon">rocket_launch</span>
+                <div class="logo-text">
+                    <h1>Hugging Face Space Creator</h1>
+                    <p class="tagline">Enterprise-grade Python to Gradio Application Converter</p>
+                </div>
+            </div>
+            <div class="header-badge">
+                <span class="material-icons">verified</span>
+                <span>Enterprise Ready</span>
+            </div>
+        </div>
+        <div class="header-divider"></div>
+    </div>
+    """
+    
+    gr.HTML(header_html)

components/sidebar.py

@@ -0,0 +1,81 @@
+"""
+Sidebar component with step-by-step guide
+"""
+
+import gradio as gr
+
+
+def create_sidebar(current_step):
+    """Create the sidebar with progress steps"""
+    
+    with gr.Column(elem_classes="sidebar"):
+        gr.Markdown("### Workflow Steps")
+        
+        # Step indicators
+        steps = [
+            {"number": 1, "title": "Provide Code", "description": "Upload or paste your Python code"},
+            {"number": 2, "title": "Generate Files", "description": "Download individual components"},
+            {"number": 3, "title": "Deploy", "description": "Deploy to Hugging Face"}
+        ]
+        
+        step_html = '<div class="steps-container">'
+        for step in steps:
+            active_class = "active" if step["number"] == current_step.value else ""
+            step_html += f'''
+            <div class="step {active_class}">
+                <div class="step-number">{step["number"]}</div>
+                <div class="step-content">
+                    <div class="step-title">{step["title"]}</div>
+                    <div class="step-description">{step["description"]}</div>
+                </div>
+            </div>
+            '''
+        step_html += '</div>'
+        
+        gr.HTML(step_html)
+        
+        # Quick tips
+        gr.Markdown("### Quick Tips")
+        
+        tips_html = '''
+        <div class="tips-container">
+            <div class="tip">
+                <span class="material-icons tip-icon">code</span>
+                <div class="tip-content">
+                    <strong>Clean Code</strong>
+                    <p>Ensure your Python code is well-structured for better conversion results.</p>
+                </div>
+            </div>
+            <div class="tip">
+                <span class="material-icons tip-icon">security</span>
+                <div class="tip-content">
+                    <strong>API Security</strong>
+                    <p>Your API keys are used only for conversion and are not stored.</p>
+                </div>
+            </div>
+            <div class="tip">
+                <span class="material-icons tip-icon">cloud_upload</span>
+                <div class="tip-content">
+                    <strong>Easy Deployment</strong>
+                    <p>Deploy with one click to Hugging Face Spaces.</p>
+                </div>
+            </div>
+        </div>
+        '''
+        
+        gr.HTML(tips_html)
+        
+        # System requirements
+        gr.Markdown("### System Requirements")
+        requirements_html = '''
+        <div class="requirements">
+            <ul>
+                <li>Python 3.8 or higher</li>
+                <li>Valid Groq API Key</li>
+                <li>Hugging Face Account (for deployment)</li>
+                <li>Internet connection</li>
+            </ul>
+        </div>
+        '''
+        
+        gr.HTML(requirements_html)

requirements.txt

@@ -0,0 +1,10 @@
+gradio>=6.2.0
+langchain-groq>=0.1.0
+huggingface-hub>=0.20.0
+python-dotenv>=1.0.0
+nbconvert>=7.0.0
+beautifulsoup4>=4.12.0
+requests>=2.31.0
+pillow>=10.0.0
+markdown>=3.5.0
+pyyaml>=6.0

static/css/style.css

@@ -0,0 +1,664 @@
+/* Main Theme Variables */
+:root {
+    --primary-yellow: #FFC107;
+    --primary-yellow-dark: #FFA000;
+    --primary-yellow-light: #FFECB3;
+    --secondary-blue: #2196F3;
+    --secondary-purple: #9C27B0;
+    --success-green: #10B981;
+    --error-red: #EF4444;
+    --warning-orange: #F59E0B;
+    --info-blue: #3B82F6;
+    --gray-50: #F9FAFB;
+    --gray-100: #F3F4F6;
+    --gray-200: #E5E7EB;
+    --gray-300: #D1D5DB;
+    --gray-400: #9CA3AF;
+    --gray-500: #6B7280;
+    --gray-600: #4B5563;
+    --gray-700: #374151;
+    --gray-800: #1F2937;
+    --gray-900: #111827;
+    --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+    --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+    --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.1);
+    --shadow-xl: 0 20px 25px -5px rgba(0, 0, 0, 0.1);
+    --radius-sm: 0.375rem;
+    --radius-md: 0.5rem;
+    --radius-lg: 0.75rem;
+    --radius-xl: 1rem;
+}
+
+/* Global Styles */
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    min-height: 100vh;
+    margin: 0;
+    padding: 20px;
+}
+
+.gradio-container {
+    max-width: 1400px !important;
+    margin: 0 auto !important;
+    background: white !important;
+    border-radius: var(--radius-xl) !important;
+    box-shadow: var(--shadow-xl) !important;
+    overflow: hidden !important;
+    min-height: 90vh !important;
+}
+
+/* Header Styles */
+.header-container {
+    background: linear-gradient(90deg, var(--gray-900) 0%, var(--gray-800) 100%);
+    color: white;
+    padding: 2rem 2.5rem;
+    position: relative;
+    overflow: hidden;
+}
+
+.header-container::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    right: 0;
+    width: 300px;
+    height: 300px;
+    background: linear-gradient(45deg, var(--primary-yellow) 0%, transparent 70%);
+    border-radius: 50%;
+    opacity: 0.1;
+}
+
+.header-content {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    position: relative;
+    z-index: 1;
+}
+
+.logo-section {
+    display: flex;
+    align-items: center;
+    gap: 1.5rem;
+}
+
+.logo-icon {
+    font-size: 3.5rem !important;
+    color: var(--primary-yellow);
+    background: rgba(255, 193, 7, 0.1);
+    padding: 1rem;
+    border-radius: var(--radius-lg);
+    border: 2px solid rgba(255, 193, 7, 0.3);
+}
+
+.logo-text h1 {
+    margin: 0;
+    font-size: 2.25rem;
+    font-weight: 700;
+    background: linear-gradient(90deg, var(--primary-yellow) 0%, #FFD700 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+}
+
+.tagline {
+    margin: 0.5rem 0 0 0;
+    color: var(--gray-300);
+    font-size: 1.1rem;
+    font-weight: 400;
+}
+
+.header-badge {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    background: rgba(255, 193, 7, 0.1);
+    padding: 0.75rem 1.5rem;
+    border-radius: var(--radius-lg);
+    border: 1px solid rgba(255, 193, 7, 0.3);
+    font-weight: 600;
+    color: var(--primary-yellow);
+}
+
+.header-badge .material-icons {
+    font-size: 1.25rem;
+}
+
+.header-divider {
+    height: 4px;
+    background: linear-gradient(90deg, var(--primary-yellow) 0%, var(--secondary-blue) 50%, var(--secondary-purple) 100%);
+    margin-top: 1.5rem;
+    border-radius: 2px;
+}
+
+/* Sidebar Styles */
+.sidebar {
+    background: var(--gray-50);
+    padding: 2rem 1.5rem !important;
+    border-right: 1px solid var(--gray-200);
+    height: 100%;
+    min-height: calc(90vh - 200px);
+}
+
+.steps-container {
+    margin: 2rem 0;
+}
+
+.step {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    padding: 1.25rem;
+    margin-bottom: 1rem;
+    background: white;
+    border-radius: var(--radius-lg);
+    border: 1px solid var(--gray-200);
+    transition: all 0.3s ease;
+    cursor: pointer;
+}
+
+.step:hover {
+    transform: translateY(-2px);
+    box-shadow: var(--shadow-md);
+    border-color: var(--primary-yellow);
+}
+
+.step.active {
+    background: linear-gradient(135deg, var(--primary-yellow-light) 0%, #FFF8E1 100%);
+    border-color: var(--primary-yellow);
+    border-left: 4px solid var(--primary-yellow);
+}
+
+.step-number {
+    width: 2.5rem;
+    height: 2.5rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--gray-100);
+    color: var(--gray-700);
+    border-radius: 50%;
+    font-weight: 700;
+    font-size: 1.1rem;
+    transition: all 0.3s ease;
+}
+
+.step.active .step-number {
+    background: var(--primary-yellow);
+    color: white;
+}
+
+.step-content {
+    flex: 1;
+}
+
+.step-title {
+    font-weight: 600;
+    color: var(--gray-800);
+    margin-bottom: 0.25rem;
+    font-size: 1.1rem;
+}
+
+.step.active .step-title {
+    color: var(--gray-900);
+}
+
+.step-description {
+    font-size: 0.875rem;
+    color: var(--gray-600);
+}
+
+.tips-container {
+    margin: 2rem 0;
+}
+
+.tip {
+    display: flex;
+    align-items: flex-start;
+    gap: 1rem;
+    padding: 1rem;
+    margin-bottom: 1rem;
+    background: white;
+    border-radius: var(--radius-lg);
+    border: 1px solid var(--gray-200);
+}
+
+.tip-icon {
+    color: var(--primary-yellow);
+    font-size: 1.5rem !important;
+    margin-top: 0.25rem;
+}
+
+.tip-content strong {
+    display: block;
+    color: var(--gray-800);
+    margin-bottom: 0.25rem;
+}
+
+.tip-content p {
+    margin: 0;
+    font-size: 0.875rem;
+    color: var(--gray-600);
+    line-height: 1.5;
+}
+
+.requirements ul {
+    margin: 0;
+    padding-left: 1.5rem;
+}
+
+.requirements li {
+    margin-bottom: 0.5rem;
+    color: var(--gray-700);
+    font-size: 0.875rem;
+}
+
+/* API Guide Styles */
+.api-guide {
+    padding: 1.5rem;
+    background: var(--gray-50);
+    border-radius: var(--radius-lg);
+    margin: 1rem 0;
+}
+
+.api-guide h4 {
+    margin-top: 0;
+    color: var(--gray-800);
+    border-bottom: 2px solid var(--primary-yellow);
+    padding-bottom: 0.5rem;
+}
+
+.api-guide ol {
+    margin: 1rem 0 1.5rem 0;
+    padding-left: 1.5rem;
+}
+
+.api-guide li {
+    margin-bottom: 0.75rem;
+    color: var(--gray-700);
+    line-height: 1.6;
+}
+
+.api-guide code {
+    background: var(--gray-200);
+    padding: 0.125rem 0.375rem;
+    border-radius: var(--radius-sm);
+    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+    font-size: 0.875rem;
+}
+
+.note {
+    display: flex;
+    align-items: flex-start;
+    gap: 0.75rem;
+    padding: 1rem;
+    background: rgba(59, 130, 246, 0.1);
+    border-radius: var(--radius-md);
+    border-left: 4px solid var(--info-blue);
+    margin: 1.5rem 0;
+}
+
+.note .material-icons {
+    color: var(--info-blue);
+    margin-top: 0.125rem;
+}
+
+.note p {
+    margin: 0;
+    color: var(--gray-700);
+    font-size: 0.875rem;
+}
+
+.security-tip {
+    display: flex;
+    align-items: flex-start;
+    gap: 1rem;
+    padding: 1rem;
+    margin-bottom: 1rem;
+    background: white;
+    border-radius: var(--radius-md);
+    border: 1px solid var(--gray-200);
+}
+
+.security-tip .material-icons {
+    color: var(--primary-yellow);
+    font-size: 1.5rem !important;
+    margin-top: 0.125rem;
+}
+
+.security-tip strong {
+    display: block;
+    color: var(--gray-800);
+    margin-bottom: 0.25rem;
+}
+
+.security-tip p {
+    margin: 0;
+    font-size: 0.875rem;
+    color: var(--gray-600);
+    line-height: 1.5;
+}
+
+.resources h5 {
+    margin: 1.5rem 0 0.75rem 0;
+    color: var(--gray-800);
+}
+
+.resources ul {
+    margin: 0;
+    padding-left: 1.5rem;
+}
+
+.resources li {
+    margin-bottom: 0.5rem;
+}
+
+.resources a {
+    color: var(--secondary-blue);
+    text-decoration: none;
+    transition: color 0.2s ease;
+}
+
+.resources a:hover {
+    color: var(--primary-yellow);
+    text-decoration: underline;
+}
+
+/* Download Section Styles */
+.download-section {
+    padding: 2rem !important;
+}
+
+.file-download {
+    margin-bottom: 0.5rem !important;
+}
+
+.file-info {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.75rem;
+    background: var(--gray-50);
+    border-radius: var(--radius-md);
+    font-size: 0.875rem;
+    color: var(--gray-700);
+}
+
+.file-info .material-icons {
+    color: var(--primary-yellow);
+    font-size: 1.125rem !important;
+}
+
+.full-download {
+    margin-top: 1rem !important;
+}
+
+.package-info {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 1rem;
+    background: linear-gradient(135deg, var(--primary-yellow-light) 0%, #FFF8E1 100%);
+    border-radius: var(--radius-md);
+    border: 2px solid var(--primary-yellow);
+    font-weight: 600;
+    color: var(--gray-800);
+    margin-top: 0.5rem;
+}
+
+.package-info .material-icons {
+    color: var(--primary-yellow);
+    font-size: 1.5rem !important;
+}
+
+/* Status Messages */
+.status-container {
+    padding: 1.5rem;
+    border-radius: var(--radius-lg);
+    margin: 1.5rem 0;
+    background: var(--gray-50);
+    border: 1px solid var(--gray-200);
+}
+
+.status-message {
+    display: flex;
+    align-items: center;
+    padding: 1rem 1.25rem;
+    border-radius: var(--radius-md);
+    background: white;
+    border-left: 4px solid;
+    margin-bottom: 1rem;
+    animation: slideIn 0.3s ease;
+}
+
+@keyframes slideIn {
+    from {
+        opacity: 0;
+        transform: translateY(-10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.status-message.success {
+    border-left-color: var(--success-green);
+}
+
+.status-message.error {
+    border-left-color: var(--error-red);
+}
+
+.status-message.warning {
+    border-left-color: var(--warning-orange);
+}
+
+.status-message.info {
+    border-left-color: var(--info-blue);
+}
+
+.status-message .material-icons {
+    font-size: 1.5rem !important;
+    margin-right: 0.75rem;
+}
+
+.error-message {
+    padding: 1.5rem;
+    background: linear-gradient(135deg, rgba(239, 68, 68, 0.1) 0%, rgba(239, 68, 68, 0.05) 100%);
+    border-radius: var(--radius-lg);
+    border: 1px solid var(--error-red);
+    margin: 1.5rem 0;
+}
+
+.error-message h4 {
+    margin-top: 0;
+    color: var(--error-red);
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.error-message ul {
+    margin: 0.75rem 0 0 0;
+    padding-left: 1.5rem;
+}
+
+.error-message li {
+    margin-bottom: 0.5rem;
+    color: var(--gray-700);
+}
+
+/* Button Styles */
+button {
+    transition: all 0.3s ease !important;
+}
+
+button:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: var(--shadow-md) !important;
+}
+
+button.primary {
+    background: linear-gradient(90deg, var(--primary-yellow) 0%, var(--primary-yellow-dark) 100%) !important;
+    border: none !important;
+    color: var(--gray-900) !important;
+    font-weight: 600 !important;
+}
+
+button.secondary {
+    background: white !important;
+    border: 2px solid var(--gray-300) !important;
+    color: var(--gray-700) !important;
+    font-weight: 600 !important;
+}
+
+/* Form Styles */
+input, textarea, select {
+    border-radius: var(--radius-md) !important;
+    border: 1px solid var(--gray-300) !important;
+    transition: all 0.3s ease !important;
+}
+
+input:focus, textarea:focus, select:focus {
+    border-color: var(--primary-yellow) !important;
+    box-shadow: 0 0 0 3px rgba(255, 193, 7, 0.1) !important;
+    outline: none !important;
+}
+
+/* Tab Styles */
+.tab-nav {
+    border-bottom: 2px solid var(--gray-200) !important;
+}
+
+.tab-nav button {
+    border-radius: var(--radius-md) var(--radius-md) 0 0 !important;
+    margin-right: 0.25rem !important;
+}
+
+.tab-nav button.selected {
+    background: linear-gradient(135deg, var(--primary-yellow-light) 0%, #FFF8E1 100%) !important;
+    border-color: var(--primary-yellow) !important;
+    border-bottom-color: transparent !important;
+    color: var(--gray-900) !important;
+    font-weight: 600 !important;
+}
+
+/* Code Editor */
+#code_editor {
+    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace !important;
+    font-size: 0.875rem !important;
+    line-height: 1.6 !important;
+    background: var(--gray-50) !important;
+    border: 1px solid var(--gray-300) !important;
+    border-radius: var(--radius-lg) !important;
+    padding: 1.5rem !important;
+}
+
+/* Responsive Design */
+@media (max-width: 1024px) {
+    .gradio-container {
+        padding: 0.5rem !important;
+    }
+    
+    .header-content {
+        flex-direction: column;
+        gap: 1.5rem;
+        text-align: center;
+    }
+    
+    .logo-section {
+        flex-direction: column;
+        text-align: center;
+    }
+    
+    .sidebar {
+        padding: 1rem !important;
+    }
+    
+    .step {
+        flex-direction: column;
+        text-align: center;
+        padding: 1rem;
+    }
+    
+    .step-number {
+        margin-bottom: 0.5rem;
+    }
+}
+
+@media (max-width: 768px) {
+    body {
+        padding: 10px;
+    }
+    
+    .logo-text h1 {
+        font-size: 1.75rem;
+    }
+    
+    .header-badge {
+        width: 100%;
+        justify-content: center;
+    }
+    
+    .api-guide {
+        padding: 1rem;
+    }
+}
+
+/* Animation for success states */
+@keyframes pulse {
+    0%, 100% {
+        opacity: 1;
+    }
+    50% {
+        opacity: 0.8;
+    }
+}
+
+.success-pulse {
+    animation: pulse 2s infinite;
+}
+
+/* Loading State */
+.loading {
+    position: relative;
+    pointer-events: none;
+}
+
+.loading::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(255, 255, 255, 0.8);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: inherit;
+    z-index: 10;
+}
+
+.loading::before {
+    content: '';
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    width: 2.5rem;
+    height: 2.5rem;
+    margin: -1.25rem 0 0 -1.25rem;
+    border: 3px solid var(--gray-300);
+    border-top-color: var(--primary-yellow);
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+    z-index: 11;
+}
+
+@keyframes spin {
+    to {
+        transform: rotate(360deg);
+    }
+}

utils/converter.py

@@ -0,0 +1,329 @@
+"""
+Core conversion logic for transforming Python code to Gradio apps
+"""
+
+import re
+import traceback
+from typing import Dict, Any
+from langchain_groq import ChatGroq
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+
+
+def convert_code(input_code: str, groq_api_key: str, model_name: str = "llama-3.3-70b-versatile") -> Dict[str, str]:
+    """
+    Converts input Python/IPYNB code into a Gradio app structure.
+    """
+    
+    # Validate API key
+    if not groq_api_key:
+        raise ValueError("Groq API Key is required for conversion.")
+    
+    if not groq_api_key.startswith('gsk_'):
+        raise ValueError("Invalid Groq API Key. It should start with 'gsk_'")
+    
+    try:
+        # Initialize Groq client
+        chat = ChatGroq(
+            temperature=0.1,
+            model_name=model_name,
+            api_key=groq_api_key,
+            max_retries=2,
+            timeout=30
+        )
+    except Exception as e:
+        raise ValueError(f"Failed to initialize Groq client: {str(e)}")
+    
+    # System prompt for conversion - UPDATED with Gradio 6.2.0
+    system_prompt = """You are an expert Python developer specializing in Gradio and Hugging Face Spaces. 
+    Your task is to convert the provided Python code into a deployable Gradio web application.
+    
+    Return your response in this exact format:
+    
+    ===APP_PY===
+    [Complete app.py code here - NO markdown backticks or ```python]
+    ===APP_PY_END===
+    
+    ===REQUIREMENTS_TXT===
+    [Requirements.txt content here, one dependency per line - NO markdown backticks]
+    ===REQUIREMENTS_TXT_END===
+    
+    ===README_MD===
+    [README.md content here with proper YAML frontmatter]
+    ===README_MD_END===
+    
+    CRITICAL RULES:
+    1. app.py MUST be valid Python code ONLY
+    2. requirements.txt MUST be plain text
+    3. README.md MUST have YAML frontmatter at the top
+    4. Include all necessary imports in app.py
+    5. Always include: if __name__ == "__main__": demo.launch()
+    6. requirements.txt must include: gradio>=6.2.0  # CHANGED FROM 4.0.0 TO 6.2.0
+    
+    YAML frontmatter template:
+    ---
+    title: Generated Gradio App
+    emoji: 🚀
+    colorFrom: blue
+    colorTo: purple
+    sdk: gradio
+    sdk_version: "6.2.0"  # CHANGED FROM 4.0.0 TO 6.2.0
+    app_file: app.py
+    pinned: false
+    ---
+    
+    Do NOT include markdown code blocks (```) in any output.
+    """
+    
+    human_template = """Convert this Python code to a complete Gradio app.
+    
+    Code to convert:
+    ```python
+    {code}
+    ```"""
+    
+    # Create the chain
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", system_prompt),
+        ("human", human_template)
+    ])
+    
+    chain = prompt | chat | StrOutputParser()
+    
+    try:
+        # Invoke the chain
+        response = chain.invoke({"code": input_code[:50000]})
+        
+        # Parse the response
+        result = parse_llm_response(response)
+        
+        # Clean and validate outputs
+        result = clean_all_outputs(result)
+        result = post_process_conversion(result, input_code)
+        
+        return result
+        
+    except Exception as e:
+        print(f"Conversion error: {e}")
+        print(f"Traceback: {traceback.format_exc()}")
+        return create_basic_template(input_code)
+
+
+def parse_llm_response(response: str) -> Dict[str, str]:
+    """Parse the LLM response into structured components"""
+    
+    result = {
+        "app_py": "",
+        "requirements_txt": "",
+        "readme_md": ""
+    }
+    
+    patterns = [
+        (r'===APP_PY===(.*?)===APP_PY_END===', "app_py"),
+        (r'===REQUIREMENTS_TXT===(.*?)===REQUIREMENTS_TXT_END===', "requirements_txt"),
+        (r'===README_MD===(.*?)===README_MD_END===', "readme_md")
+    ]
+    
+    for pattern, key in patterns:
+        match = re.search(pattern, response, re.DOTALL)
+        if match:
+            result[key] = match.group(1).strip()
+    
+    return result
+
+
+def clean_all_outputs(result: Dict[str, str]) -> Dict[str, str]:
+    """Clean markdown backticks from all outputs"""
+    
+    for key in ["app_py", "requirements_txt", "readme_md"]:
+        if key in result and result[key]:
+            content = result[key]
+            
+            # Remove markdown code blocks
+            content = re.sub(r'^```(python|py)?\s*', '', content, flags=re.IGNORECASE)
+            content = re.sub(r'\s*```$', '', content)
+            content = re.sub(r'```(python|py)?\s*(.*?)\s*```', r'\2', content, flags=re.DOTALL | re.IGNORECASE)
+            
+            # Remove any remaining stray backticks
+            content = content.replace('```', '')
+            
+            # Strip whitespace
+            content = content.strip()
+            
+            result[key] = content
+    
+    return result
+
+
+def post_process_conversion(result: Dict[str, str], original_code: str) -> Dict[str, str]:
+    """Post-process and validate the conversion result"""
+    
+    # Ensure app.py is valid Python
+    if not result.get("app_py"):
+        result["app_py"] = create_basic_app_template(original_code)
+    
+    # Ensure requirements.txt is clean
+    result["requirements_txt"] = clean_requirements(result.get("requirements_txt", ""))
+    
+    # Ensure README has proper format
+    result["readme_md"] = clean_readme(result.get("readme_md", ""))
+    
+    return result
+
+
+def clean_requirements(req_text: str) -> str:
+    """Clean and format requirements.txt content"""
+    if not req_text:
+        return "gradio>=6.2.0\nlangchain-groq>=0.1.0\nhuggingface-hub>=0.20.0"  # UPDATED
+    
+    # Remove any markdown
+    req_text = re.sub(r'```.*?\n', '', req_text, flags=re.DOTALL)
+    req_text = req_text.replace('```', '')
+    
+    lines = []
+    for line in req_text.strip().split('\n'):
+        line = line.strip()
+        if line and not line.startswith('#') and not line.startswith('==='):
+            line = re.sub(r'[\[\]"\']', '', line)
+            if line:
+                lines.append(line)
+    
+    # Ensure essential packages are included - UPDATED VERSION
+    essential_packages = ["gradio>=6.2.0", "langchain-groq>=0.1.0", "huggingface-hub>=0.20.0"]  # UPDATED
+    for package in essential_packages:
+        if not any(package.split('>=')[0] in line.lower() for line in lines):
+            lines.insert(0, package)
+    
+    # Remove duplicates and sort
+    return "\n".join(sorted(set(lines)))
+
+
+def clean_readme(readme_text: str) -> str:
+    """Clean README.md to ensure proper format"""
+    if not readme_text:
+        return create_default_readme()
+    
+    # Remove markdown code blocks
+    readme_text = re.sub(r'```.*?\n', '', readme_text, flags=re.DOTALL)
+    readme_text = readme_text.replace('```', '')
+    
+    # Check for proper YAML frontmatter
+    if not re.search(r'^---\s*$', readme_text.strip(), re.MULTILINE):
+        return create_default_readme()
+    
+    # Update sdk_version in frontmatter if it's 4.0.0
+    readme_text = re.sub(
+        r'sdk_version:\s*["\']4\.0\.0["\']',
+        'sdk_version: "6.2.0"',
+        readme_text
+    )
+    
+    # Update gradio version in requirements if mentioned
+    readme_text = re.sub(
+        r'gradio>=4\.0\.0',
+        'gradio>=6.2.0',
+        readme_text
+    )
+    
+    return readme_text.strip()
+
+
+def create_default_readme() -> str:
+    """Create a default README with proper YAML frontmatter"""
+    return """---
+title: Generated Gradio App
+emoji: 🚀
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: "6.2.0"  # UPDATED
+app_file: app.py
+pinned: false
+---
+
+# Generated Gradio Application
+
+This application was automatically generated using the Hugging Face Space Creator.
+
+## Features
+
+- User-friendly interface built with Gradio 6.2.0
+- Ready for deployment on Hugging Face Spaces
+- Includes all necessary dependencies
+
+## How to Use
+
+1. Launch the application
+2. Enter your inputs in the provided fields
+3. Click submit to see results
+
+## Deployment
+
+To deploy this application on Hugging Face Spaces:
+
+1. Create a new Space on Hugging Face
+2. Select Gradio as the SDK
+3. Upload the generated files
+4. Your app will be live automatically
+
+## Requirements
+
+All dependencies are listed in requirements.txt
+"""
+
+
+def create_basic_app_template(input_code: str) -> str:
+    """Create a basic, guaranteed-valid app.py template"""
+    code_snippet = input_code[:1000]
+    
+    return f'''import gradio as gr
+
+# Original code snippet
+{code_snippet}
+
+# Gradio interface
+def process_input(input_text):
+    try:
+        # Process the input
+        return f"Processed: {{input_text}}"
+    except Exception as e:
+        return f"Error: {{str(e)}}"
+
+# Create the Gradio app
+with gr.Blocks(title="Generated Application", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# Generated Application")
+    
+    with gr.Row():
+        with gr.Column():
+            input_box = gr.Textbox(
+                label="Input Text",
+                placeholder="Enter text to process...",
+                lines=3
+            )
+            submit_btn = gr.Button("Process", variant="primary")
+    
+    with gr.Row():
+        output_box = gr.Textbox(
+            label="Output",
+            interactive=False,
+            lines=5
+        )
+    
+    submit_btn.click(
+        fn=process_input,
+        inputs=[input_box],
+        outputs=[output_box]
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=False)
+'''
+
+
+def create_basic_template(input_code: str) -> Dict[str, str]:
+    """Create a basic template when conversion fails"""
+    return {
+        "app_py": create_basic_app_template(input_code),
+        "requirements_txt": "gradio>=6.2.0\nlangchain-groq>=0.1.0\nhuggingface-hub>=0.20.0",  # UPDATED
+        "readme_md": create_default_readme()
+    }

utils/deployer.py

@@ -0,0 +1,82 @@
+"""
+Deployment logic for Hugging Face Spaces
+"""
+
+import re
+from typing import Dict, Optional
+from huggingface_hub import HfApi
+
+
+def deploy_to_space(
+    token: str,
+    space_name: str,
+    files: Dict[str, str],
+    username: Optional[str] = None
+) -> str:
+    """
+    Deploys the given files to a Hugging Face Space.
+    Returns the URL of the deployed space.
+    """
+    
+    # Validate inputs
+    if not token:
+        raise ValueError("Hugging Face Token is required.")
+    
+    if not token.startswith('hf_'):
+        raise ValueError("Invalid Hugging Face token. Should start with 'hf_'")
+    
+    if not space_name:
+        raise ValueError("Space name is required.")
+    
+    # Validate space name format
+    if not re.match(r'^[a-z0-9-]{3,30}$', space_name):
+        raise ValueError(
+            "Space name must be 3-30 characters, lowercase letters, numbers, and hyphens only."
+        )
+    
+    # Initialize Hugging Face API
+    api = HfApi(token=token)
+    
+    try:
+        # Get user information
+        user_info = api.whoami()
+        if not username:
+            username = user_info['name']
+    except Exception as e:
+        raise ValueError(f"Invalid Token: {str(e)}")
+    
+    # Create repository ID
+    repo_id = f"{username}/{space_name}"
+    
+    try:
+        # Create or update the Space
+        api.create_repo(
+            repo_id=repo_id,
+            repo_type="space",
+            space_sdk="gradio",
+            exist_ok=True,
+            private=False
+        )
+    except Exception as e:
+        print(f"Note: {e}")
+    
+    try:
+        # Upload files
+        for filename, content in files.items():
+            # Ensure app.py is clean
+            if filename == "app.py":
+                if '```' in content:
+                    content = content.replace('```', '')
+            
+            api.upload_file(
+                path_or_fileobj=content.encode('utf-8'),
+                path_in_repo=filename,
+                repo_id=repo_id,
+                repo_type="space",
+                commit_message=f"Add {filename} via Space Creator"
+            )
+        
+        return f"https://huggingface.co/spaces/{repo_id}"
+        
+    except Exception as e:
+        raise RuntimeError(f"Deployment failed: {str(e)}")

utils/file_handler.py

@@ -0,0 +1,105 @@
+"""
+File handling utilities
+"""
+
+import io
+import json
+import zipfile
+import tempfile
+import os
+from pathlib import Path
+from typing import Union, Dict, Any
+
+
+def create_zip_archive(files: Dict[str, Union[str, bytes]]) -> bytes:
+    """Creates a zip archive in memory from a dictionary of filename: content."""
+    zip_buffer = io.BytesIO()
+    
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        for filename, content in files.items():
+            if isinstance(content, str):
+                content = content.encode('utf-8')
+            zip_file.writestr(filename, content)
+    
+    zip_buffer.seek(0)
+    return zip_buffer.getvalue()
+
+
+def read_file_content(file_obj) -> str:
+    """Read content from Gradio file object or path."""
+    if file_obj is None:
+        return ""
+    
+    try:
+        if hasattr(file_obj, 'read'):
+            content = file_obj.read()
+            if isinstance(content, bytes):
+                return content.decode('utf-8', errors='ignore')
+            return str(content)
+        elif isinstance(file_obj, (str, Path)):
+            path = Path(file_obj)
+            if path.exists():
+                return path.read_text(encoding='utf-8', errors='ignore')
+    except Exception as e:
+        print(f"Error reading file: {e}")
+    
+    return ""
+
+
+def parse_notebook(file_path: str) -> str:
+    """Extracts code cells from a Jupyter notebook file."""
+    try:
+        import nbformat
+        with open(file_path, 'r', encoding='utf-8') as f:
+            nb = nbformat.read(f, as_version=4)
+        
+        code_cells = []
+        for cell in nb.cells:
+            if cell.cell_type == 'code':
+                source = cell.source
+                if source.strip():
+                    code_cells.append(source)
+        
+        return '\n\n'.join(code_cells)
+    except Exception as e:
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            code_cells = []
+            for cell in data.get('cells', []):
+                if cell.get('cell_type') == 'code':
+                    source = cell.get('source', '')
+                    if isinstance(source, list):
+                        source = ''.join(source)
+                    if source.strip():
+                        code_cells.append(source)
+            
+            return '\n\n'.join(code_cells)
+        except Exception:
+            return ""
+
+
+def save_individual_file(filename: str, content: Union[str, bytes], binary: bool = False) -> str:
+    """Save an individual file to temporary storage and return the path."""
+    temp_dir = tempfile.mkdtemp()
+    file_path = os.path.join(temp_dir, filename)
+    
+    if binary:
+        with open(file_path, 'wb') as f:
+            f.write(content)
+    else:
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+    
+    return file_path
+
+
+def cleanup_temp_files(file_paths: list):
+    """Clean up temporary files."""
+    for file_path in file_paths:
+        try:
+            if os.path.exists(file_path):
+                os.remove(file_path)
+        except:
+            pass

utils/validator.py

@@ -0,0 +1,78 @@
+"""
+Input validation utilities
+"""
+
+import re
+from typing import List
+
+
+def validate_inputs(
+    groq_key: str = None,
+    hf_token: str = None,
+    space_name: str = None,
+    mode: str = "Convert Only"
+) -> List[str]:
+    """
+    Validate all inputs before processing.
+    Returns a list of error messages.
+    """
+    errors = []
+    
+    # Groq API Key validation
+    if mode in ["Convert Only", "Convert & Deploy"]:
+        if not groq_key:
+            errors.append("Groq API Key is required for conversion")
+        elif not groq_key.startswith('gsk_'):
+            errors.append("Groq API Key should start with 'gsk_'")
+        elif len(groq_key) < 40:
+            errors.append("Invalid Groq API Key format")
+    
+    # Hugging Face Token validation for deployment
+    if mode == "Deploy" and hf_token:
+        if not hf_token.startswith('hf_'):
+            errors.append("Hugging Face token should start with 'hf_'")
+        elif len(hf_token) < 10:
+            errors.append("Invalid Hugging Face token format")
+    
+    # Space Name validation for deployment
+    if mode == "Deploy" and space_name:
+        if len(space_name) < 3 or len(space_name) > 30:
+            errors.append("Space name must be 3-30 characters")
+        elif not re.match(r'^[a-z0-9-]+$', space_name):
+            errors.append("Space name can only contain lowercase letters, numbers, and hyphens")
+        elif space_name.startswith('-') or space_name.endswith('-'):
+            errors.append("Space name cannot start or end with a hyphen")
+        elif '--' in space_name:
+            errors.append("Space name cannot contain consecutive hyphens")
+    
+    return errors
+
+
+def validate_python_code(code: str) -> List[str]:
+    """
+    Validate Python code for common issues.
+    Returns a list of warnings (not errors).
+    """
+    warnings = []
+    
+    if not code.strip():
+        warnings.append("Code is empty")
+        return warnings
+    
+    # Check for basic Python syntax markers
+    if 'import' not in code and 'def' not in code and 'class' not in code:
+        warnings.append("Code may not be valid Python (missing imports, functions, or classes)")
+    
+    # Check for potentially dangerous imports
+    dangerous_imports = ['os.system', 'subprocess', 'eval', 'exec', '__import__']
+    for dangerous in dangerous_imports:
+        if dangerous in code:
+            warnings.append(f"Code contains potentially dangerous operation: {dangerous}")
+    
+    return warnings
+
+
+def validate_file_size(file_size: int, max_size_mb: int = 10) -> bool:
+    """Validate file size."""
+    max_size_bytes = max_size_mb * 1024 * 1024
+    return file_size <= max_size_bytes