Create deployment.py

deployment.py

@@ -0,0 +1,826 @@
+"""
+Deployment utilities for Hugging Face Spaces and project management.
+"""
+
+import os
+import re
+import ast
+import tempfile
+import time
+import webbrowser
+import urllib.parse
+from typing import Optional, List, Dict, Tuple, Union
+import gradio as gr
+from huggingface_hub import HfApi, duplicate_space, list_repo_files
+import requests
+
+from utils import get_inference_client
+from code_processing import parse_transformers_js_output, parse_svelte_output, parse_multipage_html_output, validate_and_autofix_files
+from web_utils import check_hf_space_url, parse_repo_or_model_url
+
+class DependencyManager:
+    """Handles Python dependency extraction and requirements.txt generation"""
+    
+    @staticmethod
+    def extract_import_statements(code: str) -> List[str]:
+        """Extract import statements from generated code"""
+        import_statements = []
+        
+        # Built-in Python modules to exclude
+        builtin_modules = {
+            'os', 'sys', 'json', 'time', 'datetime', 'random', 'math', 're', 'collections',
+            'itertools', 'functools', 'pathlib', 'urllib', 'http', 'email', 'html', 'xml',
+            'csv', 'tempfile', 'shutil', 'subprocess', 'threading', 'multiprocessing',
+            'asyncio', 'logging', 'typing', 'base64', 'hashlib', 'secrets', 'uuid',
+            'copy', 'pickle', 'io', 'contextlib', 'warnings', 'sqlite3', 'gzip', 'zipfile',
+            'tarfile', 'socket', 'ssl', 'platform', 'getpass', 'pwd', 'grp', 'stat',
+            'glob', 'fnmatch', 'linecache', 'traceback', 'inspect', 'keyword', 'token',
+            'tokenize', 'ast', 'code', 'codeop', 'dis', 'py_compile', 'compileall',
+            'importlib', 'pkgutil', 'modulefinder', 'runpy', 'site', 'sysconfig'
+        }
+        
+        try:
+            # Try to parse as Python AST
+            tree = ast.parse(code)
+            
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        module_name = alias.name.split('.')[0]
+                        if module_name not in builtin_modules and not module_name.startswith('_'):
+                            import_statements.append(f"import {alias.name}")
+                
+                elif isinstance(node, ast.ImportFrom):
+                    if node.module:
+                        module_name = node.module.split('.')[0]
+                        if module_name not in builtin_modules and not module_name.startswith('_'):
+                            names = [alias.name for alias in node.names]
+                            import_statements.append(f"from {node.module} import {', '.join(names)}")
+        
+        except SyntaxError:
+            # Fallback: use regex to find import statements
+            for line in code.split('\n'):
+                line = line.strip()
+                if line.startswith('import ') or line.startswith('from '):
+                    # Check if it's not a builtin module
+                    if line.startswith('import '):
+                        module_name = line.split()[1].split('.')[0]
+                    elif line.startswith('from '):
+                        module_name = line.split()[1].split('.')[0]
+                    
+                    if module_name not in builtin_modules and not module_name.startswith('_'):
+                        import_statements.append(line)
+        
+        return list(set(import_statements))  # Remove duplicates
+    
+    @staticmethod
+    def generate_requirements_txt_with_llm(import_statements: List[str]) -> str:
+        """Generate requirements.txt content using LLM based on import statements"""
+        if not import_statements:
+            return "# No additional dependencies required\n"
+        
+        try:
+            client = get_inference_client("Qwen/Qwen3-Coder-480B-A35B-Instruct", "auto")
+            
+            imports_text = '\n'.join(import_statements)
+            
+            prompt = f"""Based on the following Python import statements, generate a comprehensive requirements.txt file with all necessary and commonly used related packages:
+
+{imports_text}
+
+Instructions:
+- Include the direct packages needed for the imports
+- Include commonly used companion packages and dependencies for better functionality
+- Use correct PyPI package names (e.g., cv2 -> opencv-python, PIL -> Pillow, sklearn -> scikit-learn)
+- Examples of comprehensive dependencies:
+  * transformers often needs: accelerate, torch, tokenizers, datasets
+  * gradio often needs: requests, Pillow for image handling
+  * pandas often needs: numpy, openpyxl for Excel files
+  * matplotlib often needs: numpy, pillow for image saving
+  * sklearn often needs: numpy, scipy, joblib
+  * streamlit often needs: pandas, numpy, requests
+  * opencv-python often needs: numpy, pillow
+  * fastapi often needs: uvicorn, pydantic
+  * torch often needs: torchvision, torchaudio (if doing computer vision/audio)
+- Include packages for common file formats if relevant (openpyxl, python-docx, PyPDF2)
+- Do not include Python built-in modules
+- Do not specify versions unless there are known compatibility issues
+- One package per line
+- If no external packages are needed, return "# No additional dependencies required"
+
+Generate a comprehensive requirements.txt that ensures the application will work smoothly:"""
+
+            messages = [
+                {"role": "system", "content": "You are a Python packaging expert specializing in creating comprehensive, production-ready requirements.txt files. Your goal is to ensure applications work smoothly by including not just direct dependencies but also commonly needed companion packages, popular extensions, and supporting libraries that developers typically need together."},
+                {"role": "user", "content": prompt}
+            ]
+            
+            response = client.chat.completions.create(
+                model="Qwen/Qwen3-Coder-480B-A35B-Instruct",
+                messages=messages,
+                max_tokens=1024,
+                temperature=0.1
+            )
+            
+            requirements_content = response.choices[0].message.content.strip()
+            
+            # Clean up the response
+            if '```' in requirements_content:
+                lines = requirements_content.split('\n')
+                in_code_block = False
+                clean_lines = []
+                for line in lines:
+                    if line.strip().startswith('```'):
+                        in_code_block = not in_code_block
+                        continue
+                    if in_code_block:
+                        clean_lines.append(line)
+                requirements_content = '\n'.join(clean_lines).strip()
+            
+            # Ensure it ends with a newline
+            if requirements_content and not requirements_content.endswith('\n'):
+                requirements_content += '\n'
+                
+            return requirements_content if requirements_content else "# No additional dependencies required\n"
+            
+        except Exception as e:
+            print(f"[Dependencies] LLM generation failed, using fallback: {e}")
+            # Fallback: simple extraction with basic mapping
+            return DependencyManager._generate_requirements_fallback(import_statements)
+    
+    @staticmethod
+    def _generate_requirements_fallback(import_statements: List[str]) -> str:
+        """Fallback requirements generation with basic mapping"""
+        dependencies = set()
+        special_cases = {
+            'cv2': 'opencv-python',
+            'PIL': 'Pillow', 
+            'sklearn': 'scikit-learn',
+            'skimage': 'scikit-image',
+            'bs4': 'beautifulsoup4'
+        }
+        
+        for stmt in import_statements:
+            if stmt.startswith('import '):
+                module_name = stmt.split()[1].split('.')[0]
+                package_name = special_cases.get(module_name, module_name)
+                dependencies.add(package_name)
+            elif stmt.startswith('from '):
+                module_name = stmt.split()[1].split('.')[0]
+                package_name = special_cases.get(module_name, module_name)
+                dependencies.add(package_name)
+        
+        if dependencies:
+            return '\n'.join(sorted(dependencies)) + '\n'
+        else:
+            return "# No additional dependencies required\n"
+
+class SpaceManager:
+    """Handles Hugging Face Space operations"""
+    
+    @staticmethod
+    def add_anycoder_tag_to_readme(api: HfApi, repo_id: str) -> None:
+        """Download existing README, add anycoder tag, and upload back"""
+        try:
+            # Download the existing README
+            readme_path = api.hf_hub_download(
+                repo_id=repo_id,
+                filename="README.md",
+                repo_type="space"
+            )
+            
+            # Read the existing README content
+            with open(readme_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            # Parse frontmatter and content
+            if content.startswith('---'):
+                # Split frontmatter and body
+                parts = content.split('---', 2)
+                if len(parts) >= 3:
+                    frontmatter = parts[1].strip()
+                    body = parts[2] if len(parts) > 2 else ""
+                    
+                    # Check if tags already exist
+                    if 'tags:' in frontmatter:
+                        # Add anycoder to existing tags if not present
+                        if '- anycoder' not in frontmatter:
+                            frontmatter = re.sub(r'(tags:\s*\n(?:\s*-\s*[^\n]+\n)*)', r'\1- anycoder\n', frontmatter)
+                    else:
+                        # Add tags section with anycoder
+                        frontmatter += '\ntags:\n- anycoder'
+                    
+                    # Reconstruct the README
+                    new_content = f"---\n{frontmatter}\n---{body}"
+                else:
+                    # Malformed frontmatter, just add tags at the end of frontmatter
+                    new_content = content.replace('---', '---\ntags:\n- anycoder\n---', 1)
+            else:
+                # No frontmatter, add it at the beginning
+                new_content = f"---\ntags:\n- anycoder\n---\n\n{content}"
+            
+            # Upload the modified README
+            with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False, encoding='utf-8') as f:
+                f.write(new_content)
+                temp_path = f.name
+            
+            api.upload_file(
+                path_or_fileobj=temp_path,
+                path_in_repo="README.md",
+                repo_id=repo_id,
+                repo_type="space"
+            )
+            
+            os.unlink(temp_path)
+            print(f"[SpaceManager] Added anycoder tag to {repo_id}")
+            
+        except Exception as e:
+            print(f"[SpaceManager] Could not modify README.md: {e}")
+
+class ProjectImporter:
+    """Handles importing projects from various sources"""
+    
+    @staticmethod
+    def fetch_hf_space_content(username: str, project_name: str) -> str:
+        """Fetch content from a Hugging Face Space"""
+        try:
+            api = HfApi()
+            space_info = api.space_info(f"{username}/{project_name}")
+            
+            # Try to fetch the main file based on SDK
+            sdk = space_info.sdk
+            main_file = None
+            
+            # Define file patterns based on SDK
+            if sdk == "static":
+                file_patterns = ["index.html"]
+            elif sdk == "gradio":
+                file_patterns = ["app.py", "main.py", "gradio_app.py"]
+            elif sdk == "streamlit":
+                file_patterns = [
+                    "streamlit_app.py", "src/streamlit_app.py", "app.py", "src/app.py", 
+                    "main.py", "src/main.py", "Home.py", "src/Home.py", 
+                    "🏠_Home.py", "src/🏠_Home.py", "1_🏠_Home.py", "src/1_🏠_Home.py"
+                ]
+            else:
+                file_patterns = [
+                    "app.py", "src/app.py", "index.html", "streamlit_app.py", 
+                    "src/streamlit_app.py", "main.py", "src/main.py", "Home.py", "src/Home.py"
+                ]
+            
+            # Try to find and download the main file
+            for file in file_patterns:
+                try:
+                    content = api.hf_hub_download(
+                        repo_id=f"{username}/{project_name}",
+                        filename=file,
+                        repo_type="space"
+                    )
+                    main_file = file
+                    break
+                except:
+                    continue
+            
+            # If no main file found, list repository files and find Python files
+            if not main_file and sdk in ["streamlit", "gradio"]:
+                try:
+                    files = list_repo_files(repo_id=f"{username}/{project_name}", repo_type="space")
+                    
+                    # Look for Python files that might be the main file
+                    python_files = [f for f in files if f.endswith('.py') and not f.startswith('.') and 
+                                  (('/' not in f) or f.startswith('src/'))]
+                    
+                    for py_file in python_files:
+                        try:
+                            content = api.hf_hub_download(
+                                repo_id=f"{username}/{project_name}",
+                                filename=py_file,
+                                repo_type="space"
+                            )
+                            main_file = py_file
+                            break
+                        except:
+                            continue
+                except:
+                    pass
+            
+            if main_file:
+                content = api.hf_hub_download(
+                    repo_id=f"{username}/{project_name}",
+                    filename=main_file,
+                    repo_type="space"
+                )
+                
+                # Read the file content
+                with open(content, 'r', encoding='utf-8') as f:
+                    file_content = f.read()
+                
+                return f"""IMPORTED PROJECT FROM HUGGING FACE SPACE
+==============================================
+
+Space: {username}/{project_name}
+SDK: {sdk}
+Main File: {main_file}
+
+{file_content}"""
+            else:
+                # Try to get more information about available files
+                try:
+                    files = list_repo_files(repo_id=f"{username}/{project_name}", repo_type="space")
+                    available_files = [f for f in files if not f.startswith('.') and not f.endswith('.md')]
+                    return f"Error: Could not find main file in space {username}/{project_name}.\n\nSDK: {sdk}\nAvailable files: {', '.join(available_files[:10])}{'...' if len(available_files) > 10 else ''}\n\nTried looking for: {', '.join(file_patterns)}"
+                except:
+                    return f"Error: Could not find main file in space {username}/{project_name}. Expected files for {sdk} SDK: {', '.join(file_patterns) if 'file_patterns' in locals() else 'standard files'}"
+                
+        except Exception as e:
+            return f"Error fetching space content: {str(e)}"
+    
+    @staticmethod
+    def load_project_from_url(url: str) -> Tuple[str, str]:
+        """Load project from Hugging Face Space URL"""
+        # Validate URL
+        is_valid, username, project_name = check_hf_space_url(url)
+        
+        if not is_valid:
+            return "Error: Please enter a valid Hugging Face Spaces URL.\n\nExpected format: https://huggingface.co/spaces/username/project", ""
+        
+        # Fetch content
+        content = ProjectImporter.fetch_hf_space_content(username, project_name)
+        
+        if content.startswith("Error:"):
+            return content, ""
+        
+        # Extract the actual code content by removing metadata
+        lines = content.split('\n')
+        code_start = 0
+        for i, line in enumerate(lines):
+            # Skip metadata lines and find the start of actual code
+            if (line.strip() and 
+                not line.startswith('=') and 
+                not line.startswith('IMPORTED PROJECT') and
+                not line.startswith('Space:') and
+                not line.startswith('SDK:') and
+                not line.startswith('Main File:')):
+                code_start = i
+                break
+        
+        code_content = '\n'.join(lines[code_start:])
+        
+        return f"✅ Successfully imported project from {username}/{project_name}", code_content
+
+class Deployer:
+    """Handles deployment to various platforms"""
+    
+    def __init__(self):
+        self.dependency_manager = DependencyManager()
+        self.space_manager = SpaceManager()
+    
+    def deploy_to_user_space(self, code: str, space_name: str, sdk_name: str,
+                           profile: Optional[gr.OAuthProfile] = None, 
+                           token: Optional[gr.OAuthToken] = None) -> str:
+        """Deploy code to user's Hugging Face Space"""
+        if not code or not code.strip():
+            return "No code to deploy."
+        
+        if profile is None or token is None:
+            return "Please log in with your Hugging Face account to deploy to your own Space."
+        
+        # Check token validity
+        if not token.token or token.token == "hf_":
+            return "Error: Invalid token. Please log in again with your Hugging Face account to get a valid write token."
+        
+        # Determine if this is an update or new space
+        is_update = "/" in space_name.strip()
+        if is_update:
+            repo_id = space_name.strip()
+            space_username = repo_id.split('/')[0]
+            if space_username != profile.username:
+                return f"Error: You can only update your own spaces. This space belongs to {space_username}."
+        else:
+            repo_id = f"{profile.username}/{space_name.strip()}"
+        
+        # Verify access for updates
+        if is_update:
+            try:
+                api = HfApi(token=token.token)
+                space_info = api.space_info(repo_id)
+                if not space_info:
+                    return f"Error: Could not access space {repo_id}. Please check your permissions."
+            except Exception as e:
+                return f"Error: No write access to space {repo_id}. Error: {str(e)}"
+        
+        # Route to appropriate deployment method
+        try:
+            if sdk_name == "Streamlit (Python)":
+                return self._deploy_streamlit(code, repo_id, is_update, token)
+            elif sdk_name == "Transformers.js":
+                return self._deploy_transformers_js(code, repo_id, is_update, token)
+            elif sdk_name == "Svelte":
+                return self._deploy_svelte(code, repo_id, is_update, token)
+            elif sdk_name == "Static (HTML)":
+                return self._deploy_static_html(code, repo_id, is_update, token)
+            else:  # Gradio (Python)
+                return self._deploy_gradio(code, repo_id, is_update, token)
+        except Exception as e:
+            return f"Error during deployment: {str(e)}"
+    
+    def _deploy_streamlit(self, code: str, repo_id: str, is_update: bool, token) -> str:
+        """Deploy Streamlit app"""
+        api = HfApi(token=token.token)
+        
+        try:
+            if not is_update:
+                # Duplicate template space
+                duplicated_repo = duplicate_space(
+                    from_id="streamlit/streamlit-template-space",
+                    to_id=repo_id.split('/')[-1],
+                    token=token.token,
+                    exist_ok=True
+                )
+            
+            # Generate and upload requirements.txt
+            import_statements = self.dependency_manager.extract_import_statements(code)
+            requirements_content = self.dependency_manager.generate_requirements_txt_with_llm(import_statements)
+            
+            # Upload requirements.txt
+            with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
+                f.write(requirements_content)
+                requirements_temp_path = f.name
+            
+            try:
+                api.upload_file(
+                    path_or_fileobj=requirements_temp_path,
+                    path_in_repo="requirements.txt",
+                    repo_id=repo_id,
+                    repo_type="space"
+                )
+            finally:
+                os.unlink(requirements_temp_path)
+            
+            # Add anycoder tag
+            self.space_manager.add_anycoder_tag_to_readme(api, repo_id)
+            
+            # Upload the main Streamlit app
+            with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
+                f.write(code)
+                temp_path = f.name
+            
+            try:
+                api.upload_file(
+                    path_or_fileobj=temp_path,
+                    path_in_repo="src/streamlit_app.py",
+                    repo_id=repo_id,
+                    repo_type="space"
+                )
+                
+                space_url = f"https://huggingface.co/spaces/{repo_id}"
+                action_text = "Updated" if is_update else "Deployed"
+                return f"✅ {action_text}! [Open your Space here]({space_url})"
+                
+            finally:
+                os.unlink(temp_path)
+                
+        except Exception as e:
+            error_msg = str(e)
+            if "403 Forbidden" in error_msg:
+                return f"Error: Permission denied. Please ensure you have write access to {repo_id}."
+            else:
+                action_verb = "updating" if is_update else "creating"
+                return f"Error {action_verb} Streamlit space: {error_msg}"
+    
+    def _deploy_transformers_js(self, code: str, repo_id: str, is_update: bool, token) -> str:
+        """Deploy Transformers.js app"""
+        api = HfApi(token=token.token)
+        
+        try:
+            if not is_update:
+                # Duplicate template space
+                duplicated_repo = duplicate_space(
+                    from_id="static-templates/transformers.js",
+                    to_id=repo_id,
+                    token=token.token,
+                    exist_ok=True
+                )
+            
+            # Parse transformers.js output
+            files = parse_transformers_js_output(code)
+            if not all(files.values()):
+                return "Error: Could not parse transformers.js output. Please regenerate the code."
+            
+            # Upload the three files
+            files_to_upload = [
+                ("index.html", files['index.html']),
+                ("index.js", files['index.js']),
+                ("style.css", files['style.css'])
+            ]
+            
+            for file_name, file_content in files_to_upload:
+                with tempfile.NamedTemporaryFile("w", suffix=f".{file_name.split('.')[-1]}", delete=False) as f:
+                    f.write(file_content)
+                    temp_path = f.name
+                
+                try:
+                    api.upload_file(
+                        path_or_fileobj=temp_path,
+                        path_in_repo=file_name,
+                        repo_id=repo_id,
+                        repo_type="space"
+                    )
+                finally:
+                    os.unlink(temp_path)
+            
+            # Add anycoder tag
+            self.space_manager.add_anycoder_tag_to_readme(api, repo_id)
+            
+            # Restart space if updating
+            if is_update:
+                try:
+                    api.restart_space(repo_id=repo_id)
+                except Exception as restart_error:
+                    print(f"[Deploy] Could not restart space after update: {restart_error}")
+            
+            space_url = f"https://huggingface.co/spaces/{repo_id}"
+            action_text = "Updated" if is_update else "Deployed"
+            return f"✅ {action_text}! [Open your Transformers.js Space here]({space_url})"
+            
+        except Exception as e:
+            error_msg = str(e)
+            if "403 Forbidden" in error_msg:
+                return f"Error: Permission denied. Please ensure you have write access to {repo_id}."
+            else:
+                action_verb = "updating" if is_update else "creating"
+                return f"Error {action_verb} Transformers.js space: {error_msg}"
+    
+    def _deploy_svelte(self, code: str, repo_id: str, is_update: bool, token) -> str:
+        """Deploy Svelte app"""
+        if is_update:
+            return "Error: Svelte space updates not yet supported. Please create a new space."
+        
+        api = HfApi(token=token.token)
+        
+        try:
+            # Duplicate template space
+            duplicated_repo = duplicate_space(
+                from_id="static-templates/svelte",
+                to_id=repo_id,
+                token=token.token,
+                exist_ok=True
+            )
+            
+            # Parse Svelte output
+            files = parse_svelte_output(code)
+            if not files['src/App.svelte']:
+                return "Error: Could not parse Svelte output. Please regenerate the code."
+            
+            # Upload src/App.svelte
+            with tempfile.NamedTemporaryFile("w", suffix=".svelte", delete=False) as f:
+                f.write(files['src/App.svelte'])
+                temp_path = f.name
+            
+            try:
+                api.upload_file(
+                    path_or_fileobj=temp_path,
+                    path_in_repo="src/App.svelte",
+                    repo_id=repo_id,
+                    repo_type="space"
+                )
+            finally:
+                os.unlink(temp_path)
+            
+            # Upload src/app.css if present
+            if files['src/app.css']:
+                with tempfile.NamedTemporaryFile("w", suffix=".css", delete=False) as f:
+                    f.write(files['src/app.css'])
+                    temp_path = f.name
+                
+                try:
+                    api.upload_file(
+                        path_or_fileobj=temp_path,
+                        path_in_repo="src/app.css",
+                        repo_id=repo_id,
+                        repo_type="space"
+                    )
+                finally:
+                    os.unlink(temp_path)
+            
+            # Add anycoder tag
+            self.space_manager.add_anycoder_tag_to_readme(api, repo_id)
+            
+            space_url = f"https://huggingface.co/spaces/{repo_id}"
+            return f"✅ Deployed! [Open your Svelte Space here]({space_url})"
+            
+        except Exception as e:
+            return f"Error creating Svelte space: {str(e)}"
+    
+    def _deploy_static_html(self, code: str, repo_id: str, is_update: bool, token) -> str:
+        """Deploy static HTML app"""
+        api = HfApi(token=token.token)
+        
+        try:
+            if not is_update:
+                # Create the static space
+                api.create_repo(
+                    repo_id=repo_id,
+                    repo_type="space",
+                    space_sdk="static",
+                    exist_ok=True
+                )
+            
+            # Add anycoder tag
+            self.space_manager.add_anycoder_tag_to_readme(api, repo_id)
+            
+            # Detect multi-file structure
+            files = parse_multipage_html_output(code)
+            files = validate_and_autofix_files(files)
+            
+            if isinstance(files, dict) and files.get('index.html'):
+                # Multi-file deployment
+                with tempfile.TemporaryDirectory() as tmpdir:
+                    # Write each file preserving subdirectories
+                    for rel_path, content in files.items():
+                        safe_rel_path = rel_path.strip().lstrip('/')
+                        abs_path = os.path.join(tmpdir, safe_rel_path)
+                        os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+                        with open(abs_path, 'w') as fh:
+                            fh.write(content)
+                    
+                    # Upload the entire folder
+                    api.upload_folder(
+                        folder_path=tmpdir,
+                        repo_id=repo_id,
+                        repo_type="space"
+                    )
+            else:
+                # Single HTML file deployment
+                with tempfile.NamedTemporaryFile("w", suffix=".html", delete=False) as f:
+                    f.write(code)
+                    temp_path = f.name
+                
+                try:
+                    api.upload_file(
+                        path_or_fileobj=temp_path,
+                        path_in_repo="index.html",
+                        repo_id=repo_id,
+                        repo_type="space"
+                    )
+                finally:
+                    os.unlink(temp_path)
+            
+            space_url = f"https://huggingface.co/spaces/{repo_id}"
+            action_text = "Updated" if is_update else "Deployed"
+            return f"✅ {action_text}! [Open your Space here]({space_url})"
+            
+        except Exception as e:
+            error_msg = str(e)
+            if "403 Forbidden" in error_msg:
+                return f"Error: Permission denied. Please ensure you have write access to {repo_id}."
+            else:
+                return f"Error deploying static HTML: {error_msg}"
+    
+    def _deploy_gradio(self, code: str, repo_id: str, is_update: bool, token) -> str:
+        """Deploy Gradio app"""
+        api = HfApi(token=token.token)
+        
+        try:
+            if not is_update:
+                # Create the Gradio space
+                api.create_repo(
+                    repo_id=repo_id,
+                    repo_type="space",
+                    space_sdk="gradio",
+                    exist_ok=True
+                )
+            
+            # Generate and upload requirements.txt
+            import_statements = self.dependency_manager.extract_import_statements(code)
+            requirements_content = self.dependency_manager.generate_requirements_txt_with_llm(import_statements)
+            
+            with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
+                f.write(requirements_content)
+                requirements_temp_path = f.name
+            
+            try:
+                api.upload_file(
+                    path_or_fileobj=requirements_temp_path,
+                    path_in_repo="requirements.txt",
+                    repo_id=repo_id,
+                    repo_type="space"
+                )
+            finally:
+                os.unlink(requirements_temp_path)
+            
+            # Add anycoder tag
+            self.space_manager.add_anycoder_tag_to_readme(api, repo_id)
+            
+            # Upload the main app.py file
+            with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
+                f.write(code)
+                temp_path = f.name
+            
+            try:
+                api.upload_file(
+                    path_or_fileobj=temp_path,
+                    path_in_repo="app.py",
+                    repo_id=repo_id,
+                    repo_type="space"
+                )
+                
+                space_url = f"https://huggingface.co/spaces/{repo_id}"
+                action_text = "Updated" if is_update else "Deployed"
+                return f"✅ {action_text}! [Open your Space here]({space_url})"
+                
+            finally:
+                os.unlink(temp_path)
+                
+        except Exception as e:
+            error_msg = str(e)
+            if "403 Forbidden" in error_msg:
+                return f"Error: Permission denied. Please ensure you have write access to {repo_id}."
+            else:
+                return f"Error deploying Gradio app: {error_msg}"
+    
+    def deploy_to_spaces(self, code: str) -> None:
+        """Deploy using the old method (opens in new tab)"""
+        if not code or not code.strip():
+            return
+        
+        # Wrap HTML in Gradio app
+        app_py = self._wrap_html_in_gradio_app(code.strip())
+        base_url = "https://huggingface.co/new-space"
+        params = urllib.parse.urlencode({
+            "name": "new-space",
+            "sdk": "gradio"
+        })
+        files_params = urllib.parse.urlencode({
+            "files[0][path]": "app.py",
+            "files[0][content]": app_py
+        })
+        full_url = f"{base_url}?{params}&{files_params}"
+        webbrowser.open_new_tab(full_url)
+    
+    def deploy_to_spaces_static(self, code: str) -> None:
+        """Deploy using static SDK (opens in new tab)"""
+        if not code or not code.strip():
+            return
+        
+        base_url = "https://huggingface.co/new-space"
+        params = urllib.parse.urlencode({
+            "name": "new-space",
+            "sdk": "static"
+        })
+        files_params = urllib.parse.urlencode({
+            "files[0][path]": "index.html",
+            "files[0][content]": code.strip()
+        })
+        full_url = f"{base_url}?{params}&{files_params}"
+        webbrowser.open_new_tab(full_url)
+    
+    def _wrap_html_in_gradio_app(self, html_code: str) -> str:
+        """Wrap HTML code in a Gradio app"""
+        # Escape triple quotes for safe embedding
+        safe_html = html_code.replace('"""', r'\"\"\"')
+        
+        # Extract import statements and generate requirements.txt comment
+        import_statements = self.dependency_manager.extract_import_statements(html_code)
+        requirements_comment = ""
+        if import_statements:
+            requirements_content = self.dependency_manager.generate_requirements_txt_with_llm(import_statements)
+            requirements_comment = (
+                "# Generated requirements.txt content (create this file manually if needed):\n"
+                + '\n'.join(f"# {line}" for line in requirements_content.strip().split('\n')) + '\n\n'
+            )
+        
+        return (
+            f'{requirements_comment}'
+            'import gradio as gr\n\n'
+            'def show_html():\n'
+            f'    return """{safe_html}"""\n\n'
+            'demo = gr.Interface(fn=show_html, inputs=None, outputs=gr.HTML())\n\n'
+            'if __name__ == "__main__":\n'
+            '    demo.launch()\n'
+        )
+
+# Global deployer instance
+deployer = Deployer()
+project_importer = ProjectImporter()
+
+# Export main functions
+def deploy_to_user_space(code: str, space_name: str, sdk_name: str,
+                        profile: Optional[gr.OAuthProfile] = None, 
+                        token: Optional[gr.OAuthToken] = None) -> str:
+    return deployer.deploy_to_user_space(code, space_name, sdk_name, profile, token)
+
+def deploy_to_spaces(code: str) -> None:
+    return deployer.deploy_to_spaces(code)
+
+def deploy_to_spaces_static(code: str) -> None:
+    return deployer.deploy_to_spaces_static(code)
+
+def load_project_from_url(url: str) -> Tuple[str, str]:
+    return project_importer.load_project_from_url(url)
+
+def extract_import_statements(code: str) -> List[str]:
+    return deployer.dependency_manager.extract_import_statements(code)
+
+def generate_requirements_txt_with_llm(import_statements: List[str]) -> str:
+    return deployer.dependency_manager.generate_requirements_txt_with_llm(import_statements)