Create app.py

app.py

@@ -0,0 +1,1348 @@
+import gradio as gr
+from huggingface_hub import HfApi, login
+import uuid 
+from slugify import slugify
+import os
+import json
+import subprocess
+import tempfile
+import requests
+import shutil
+import time
+from pathlib import Path
+from typing import Optional, Dict, List
+
+def is_lfs_pointer_file(filepath):
+    try:
+        with open(filepath, 'rb') as f:
+            header = f.read(100)
+            return header.startswith(b'version https://git-lfs.github.com/spec/v1')
+    except:
+        return False
+
+def remove_lfs_files(folder):
+    removed_files = []
+    for root, dirs, files in os.walk(folder):
+        if '.git' in root:
+            continue
+        for file in files:
+            filepath = os.path.join(root, file)
+            if is_lfs_pointer_file(filepath):
+                os.remove(filepath)
+                removed_files.append(filepath.replace(folder + os.sep, ''))
+    return removed_files
+
+def analyze_repository(src_path: Path) -> Dict:
+    analysis = {
+        "has_requirements": False,
+        "has_readme": False,
+        "main_language": "python",
+        "key_files": [],
+        "dependencies": [],
+        "description": "",
+        "entry_points": [],
+        "model_files": [],
+        "config_files": []
+    }
+    
+    req_file = src_path / "requirements.txt"
+    if req_file.exists():
+        analysis["has_requirements"] = True
+        try:
+            reqs = req_file.read_text(encoding="utf-8").strip().split("\n")
+            cleaned_deps = []
+            for r in reqs:
+                r = r.strip()
+                if r and not r.startswith("#"):
+                    if "opencv-python==4.10.0" in r:
+                        r = "opencv-python>=4.10.0.82"
+                    elif "opencv-python==4.10" in r:
+                        r = "opencv-python>=4.10.0.82"
+                    
+                    if "==" in r and not r.startswith("git+"):
+                        pkg_name = r.split("==")[0]
+                        if pkg_name.lower() in ["torch", "tensorflow", "transformers", "numpy"]:
+                            cleaned_deps.append(r)
+                        else:
+                            version = r.split("==")[1]
+                            if version.count('.') == 1:
+                                version = version + ".0"
+                            cleaned_deps.append(f"{pkg_name}>={version}")
+                    else:
+                        cleaned_deps.append(r)
+            analysis["dependencies"] = cleaned_deps
+        except:
+            analysis["dependencies"] = []
+    
+    for readme_name in ["README.md", "readme.md", "README.rst", "README.txt"]:
+        readme_file = src_path / readme_name
+        if readme_file.exists():
+            analysis["has_readme"] = True
+            try:
+                readme_content = readme_file.read_text(encoding="utf-8")
+                analysis["readme_content"] = readme_content[:5000]
+                lines = readme_content.split("\n")
+                for i, line in enumerate(lines[:10]):
+                    if line.strip() and not line.startswith("#") and not line.startswith("!"):
+                        analysis["description"] = line.strip()
+                        break
+            except:
+                pass
+    
+    py_files = list(src_path.glob("**/*.py"))
+    for py_file in py_files[:20]:
+        if "__pycache__" not in str(py_file) and ".git" not in str(py_file):
+            relative_path = py_file.relative_to(src_path)
+            
+            if any(name in py_file.name for name in ["main.py", "app.py", "demo.py", "run.py", "server.py", "streamlit_app.py"]):
+                analysis["entry_points"].append(str(relative_path))
+            
+            try:
+                content = py_file.read_text(encoding="utf-8")[:1000]
+                if "if __name__" in content and "main" in content:
+                    analysis["entry_points"].append(str(relative_path))
+                
+                if any(lib in content for lib in ["torch", "tensorflow", "transformers", "numpy", "pandas", "cv2", "PIL"]):
+                    analysis["key_files"].append({
+                        "path": str(relative_path),
+                        "preview": content[:500]
+                    })
+            except:
+                pass
+    
+    model_extensions = [".pth", ".pt", ".ckpt", ".h5", ".pb", ".onnx", ".safetensors"]
+    for ext in model_extensions:
+        model_files = list(src_path.glob(f"**/*{ext}"))
+        for mf in model_files[:5]:
+            if ".git" not in str(mf):
+                analysis["model_files"].append(str(mf.relative_to(src_path)))
+    
+    config_patterns = ["config.json", "config.yaml", "config.yml", "*.json", "*.yaml"]
+    for pattern in config_patterns:
+        config_files = list(src_path.glob(pattern))
+        for cf in config_files[:5]:
+            if ".git" not in str(cf):
+                analysis["config_files"].append(str(cf.relative_to(src_path)))
+    
+    return analysis
+
+def generate_gradio_app(repo_url: str, analysis: Dict) -> Dict:
+    context = f"""Repository URL: {repo_url}
+
+Repository Analysis:
+- Description: {analysis.get('description', 'N/A')}
+- Main Dependencies: {', '.join(analysis['dependencies'][:10])}
+- Entry Points: {', '.join(analysis['entry_points'][:5])}
+- Model Files: {', '.join(analysis['model_files'][:3])}
+- Config Files: {', '.join(analysis['config_files'][:3])}
+
+Key Files Found:
+"""
+    
+    for kf in analysis.get('key_files', [])[:3]:
+        context += f"\n--- {kf['path']} ---\n{kf['preview']}\n"
+    
+    if analysis.get('readme_content'):
+        context += f"\n--- README.md (excerpt) ---\n{analysis['readme_content'][:2000]}\n"
+    
+    system_prompt = """You are an expert at creating Gradio apps from GitHub repositories. 
+Your task is to generate a complete, working Gradio interface that demonstrates the main functionality of the repository.
+
+CRITICAL REQUIREMENTS:
+1. The app.py must be FULLY FUNCTIONAL and runnable
+2. DO NOT use 'from agent import' or any repository-specific imports that won't exist
+3. Handle errors gracefully with clear user feedback
+4. Include API key inputs when external services are required
+5. Create intuitive UI components for the main features
+6. Always use gradio>=5.35.0
+
+Return ONLY valid JSON with these exact keys:
+- app_py: Complete Gradio app code
+- requirements_txt: All necessary dependencies including gradio>=5.35.0
+- summary: Brief description of what the app does"""
+    
+    fireworks_key = os.getenv("FIREWORKS_API_KEY")
+    if fireworks_key:
+        try:
+            url = "https://api.fireworks.ai/inference/v1/chat/completions"
+            payload = {
+                "model": "accounts/fireworks/models/qwen3-coder-480b-a35b-instruct",
+                "max_tokens": 4096,
+                "top_p": 1,
+                "top_k": 40,
+                "presence_penalty": 0,
+                "frequency_penalty": 0,
+                "temperature": 0.6,
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"Create a fully functional Gradio app for this repository:\n\n{context[:8000]}"}
+                ]
+            }
+            headers = {
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {fireworks_key.strip()}"
+            }
+            
+            r = requests.post(url, headers=headers, data=json.dumps(payload), timeout=30)
+            
+            if r.status_code == 200:
+                response_text = r.json()["choices"][0]["message"]["content"]
+                print("✅ Fireworks AI로 앱 생성 성공")
+                
+                try:
+                    if "```json" in response_text:
+                        start = response_text.find("```json") + 7
+                        end = response_text.find("```", start)
+                        response_text = response_text[start:end].strip()
+                    elif "```" in response_text:
+                        start = response_text.find("```") + 3
+                        end = response_text.find("```", start)
+                        response_text = response_text[start:end].strip()
+                    
+                    result = json.loads(response_text)
+                    
+                    if not all(key in result for key in ["app_py", "requirements_txt", "summary"]):
+                        raise ValueError("Missing required keys in response")
+                    
+                    if "gradio" not in result.get("requirements_txt", "").lower():
+                        result["requirements_txt"] = "gradio>=5.35.0\n" + result.get("requirements_txt", "")
+                    
+                    return result
+                    
+                except (json.JSONDecodeError, ValueError) as e:
+                    print(f"⚠️ JSON 파싱 오류: {e}")
+                    return None
+        except Exception as e:
+            print(f"⚠️ Fireworks AI API 오류: {e}")
+    
+    print("ℹ️ AI API가 없어 기본 템플릿을 생성합니다.")
+    return create_smart_template(repo_url, analysis)
+
+def create_smart_template(repo_url: str, analysis: Dict) -> Dict:
+    repo_name = Path(repo_url.rstrip("/")).name
+    description = analysis.get("description", "A project deployed from GitHub") if analysis else "A project deployed from GitHub"
+    
+    deps = " ".join(analysis.get("dependencies", [])) if analysis else ""
+    has_cv = any(lib in deps for lib in ["cv2", "PIL", "pillow", "opencv"])
+    has_nlp = any(lib in deps for lib in ["transformers", "nltk", "spacy"])
+    has_3d = any(lib in deps for lib in ["gaussian", "rasterizer", "plyfile", "trimesh"])
+    
+    requirements = ["gradio>=5.35.0"]
+    if analysis and analysis.get("dependencies"):
+        filtered_deps = []
+        for dep in analysis["dependencies"][:15]:
+            if not dep.startswith("git+") and not dep.startswith("-e") and not dep.startswith("file:"):
+                if "==" in dep and dep.split("==")[0].lower() not in ["torch", "tensorflow", "numpy"]:
+                    pkg_name = dep.split("==")[0]
+                    version = dep.split("==")[1]
+                    filtered_deps.append(f"{pkg_name}>={version}")
+                else:
+                    filtered_deps.append(dep)
+        requirements.extend(filtered_deps)
+    
+    if has_3d or "gaussian" in repo_name.lower():
+        app_code = f'''import gradio as gr
+import os
+
+def process_3d(input_file):
+    if input_file is None:
+        return "Please upload a 3D file or image"
+    
+    info = """
+    ## ⚠️ Build Requirements Notice
+    
+    This project requires:
+    1. CUDA-enabled GPU
+    2. Custom C++/CUDA extensions compilation
+    
+    Original repository: {repo_url}
+    """
+    return info
+
+with gr.Blocks(title="{repo_name}") as demo:
+    gr.Markdown(f"""
+    # {repo_name.replace("-", " ").title()}
+    
+    {description}
+    
+    This space was created from: [{repo_url}]({repo_url})
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            input_file = gr.File(label="Upload 3D File or Image")
+            process_btn = gr.Button("Process", variant="primary")
+        
+        with gr.Column():
+            output_info = gr.Markdown()
+    
+    process_btn.click(
+        fn=process_3d,
+        inputs=input_file,
+        outputs=output_info
+    )
+
+if __name__ == "__main__":
+    demo.launch()
+'''
+    elif has_cv:
+        app_code = f'''import gradio as gr
+from PIL import Image
+import numpy as np
+
+def process_image(image):
+    if image is None:
+        return None, "Please upload an image"
+    
+    img_array = np.array(image)
+    processed = Image.fromarray(img_array)
+    
+    info = f"Image shape: {{img_array.shape}}"
+    return processed, info
+
+with gr.Blocks(title="{repo_name}") as demo:
+    gr.Markdown(f"""
+    # {repo_name.replace("-", " ").title()}
+    
+    {description}
+    
+    This space was created from: [{repo_url}]({repo_url})
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(label="Input Image", type="pil")
+            process_btn = gr.Button("Process Image", variant="primary")
+        
+        with gr.Column():
+            output_image = gr.Image(label="Output Image")
+            output_info = gr.Textbox(label="Information")
+    
+    process_btn.click(
+        fn=process_image,
+        inputs=input_image,
+        outputs=[output_image, output_info]
+    )
+
+if __name__ == "__main__":
+    demo.launch()
+'''
+    
+    elif has_nlp:
+        app_code = f'''import gradio as gr
+
+def process_text(text, max_length=100):
+    if not text:
+        return "Please enter some text"
+    
+    word_count = len(text.split())
+    char_count = len(text)
+    
+    result = f"""
+    **Analysis Results:**
+    - Word count: {{word_count}}
+    - Character count: {{char_count}}
+    - Average word length: {{char_count/max(word_count, 1):.1f}}
+    """
+    
+    return result
+
+with gr.Blocks(title="{repo_name}") as demo:
+    gr.Markdown(f"""
+    # {repo_name.replace("-", " ").title()}
+    
+    {description}
+    
+    This space was created from: [{repo_url}]({repo_url})
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            input_text = gr.Textbox(
+                label="Input Text",
+                placeholder="Enter your text here...",
+                lines=5
+            )
+            max_length = gr.Slider(
+                minimum=10, 
+                maximum=500, 
+                value=100,
+                label="Max Length"
+            )
+            process_btn = gr.Button("Process Text", variant="primary")
+        
+        with gr.Column():
+            output_text = gr.Markdown(label="Results")
+    
+    process_btn.click(
+        fn=process_text,
+        inputs=[input_text, max_length],
+        outputs=output_text
+    )
+
+if __name__ == "__main__":
+    demo.launch()
+'''
+    
+    else:
+        app_code = f'''import gradio as gr
+
+def main_function(input_data):
+    if not input_data:
+        return "Please provide input"
+    
+    result = f"Processed successfully! Input received: {{input_data}}"
+    return result
+
+with gr.Blocks(title="{repo_name}") as demo:
+    gr.Markdown(f"""
+    # {repo_name.replace("-", " ").title()}
+    
+    {description}
+    
+    This space was created from: [{repo_url}]({repo_url})
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            input_data = gr.Textbox(
+                label="Input",
+                placeholder="Enter your input here...",
+                lines=3
+            )
+            process_btn = gr.Button("Process", variant="primary")
+        
+        with gr.Column():
+            output_data = gr.Textbox(label="Output")
+    
+    process_btn.click(
+        fn=main_function,
+        inputs=input_data,
+        outputs=output_data
+    )
+
+if __name__ == "__main__":
+    demo.launch()
+'''
+    
+    return {
+        "app_py": app_code,
+        "requirements_txt": "\n".join(requirements),
+        "summary": f"Smart template created for {repo_name}"
+    }
+
+def clone(repo_git, repo_hf, sdk_type, skip_lfs, enable_smart_generation, user_hf_token=None, profile: gr.OAuthProfile = None, oauth_token: gr.OAuthToken = None):
+    # Use temporary directory instead of current working directory
+    temp_base_dir = tempfile.gettempdir()
+    folder_name = str(uuid.uuid4())
+    folder = os.path.join(temp_base_dir, folder_name)
+    
+    # 토큰 우선순위: 1. 사용자 입력 토큰, 2. OAuth 토큰, 3. 환경변수
+    hf_token = None
+    username = None
+    
+    if user_hf_token and user_hf_token.strip():
+        # 사용자가 직접 입력한 토큰 사용
+        hf_token = user_hf_token.strip()
+        yield "🔑 Using provided HuggingFace token..."
+    elif oauth_token and oauth_token.token:
+        # OAuth 토큰 시도 (하지만 Space 생성 권한이 없을 수 있음)
+        hf_token = oauth_token.token
+        username = profile.username if profile else None
+        yield f"🔐 Attempting with OAuth token for @{username}..."
+        yield "⚠️ Note: OAuth may have limited permissions. If Space creation fails, please provide a personal access token."
+    else:
+        # 환경변수 체크
+        hf_token = os.getenv("HF_TOKEN")
+        if not hf_token:
+            yield """❌ Authentication Required!
+            
+Please choose one of these options:
+1. **Recommended**: Enter your HuggingFace token in the field below
+2. Login with the 'Sign in with Hugging Face' button (may have limited permissions)
+3. Set HF_TOKEN in environment variables
+
+To get a token:
+1. Go to https://huggingface.co/settings/tokens
+2. Click 'New token'
+3. Select 'write' role
+4. Copy and paste the token"""
+            return
+    
+    try:
+        yield "🔄 Starting clone process..."
+        
+        # HuggingFace API 인증
+        try:
+            api = HfApi(token=hf_token)
+            user_info = api.whoami()
+            username = user_info["name"]
+            yield f"✅ Authenticated as HuggingFace user: @{username}"
+            
+            # 권한 확인
+            if "write" not in user_info.get("auth", {}).get("accessToken", {}).get("role", ""):
+                yield "⚠️ Warning: Token may not have write permissions. If Space creation fails, please use a token with 'write' role."
+        except Exception as e:
+            if "403" in str(e) or "401" in str(e):
+                yield f"""❌ Authentication failed!
+                
+The token doesn't have sufficient permissions.
+Please create a new token with 'write' access:
+1. Go to https://huggingface.co/settings/tokens
+2. Click 'New token'
+3. Give it a name
+4. Select 'write' role (important!)
+5. Copy and paste the token
+
+Error: {str(e)}"""
+                return
+            else:
+                yield f"❌ HuggingFace authentication failed: {str(e)}"
+                return
+        
+        # URL 정규화 및 검증
+        repo_git = repo_git.strip()
+        
+        # .git 확장자 추가 (필요한 경우)
+        if not repo_git.endswith('.git'):
+            repo_git_with_git = repo_git + '.git'
+        else:
+            repo_git_with_git = repo_git
+        
+        # HTTPS URL로 변환
+        if repo_git.startswith('git@github.com:'):
+            repo_git = repo_git.replace('git@github.com:', 'https://github.com/')
+        elif not repo_git.startswith('http'):
+            yield "❌ Invalid repository URL. Please use HTTPS URL (e.g., https://github.com/username/repo)"
+            return
+        
+        yield f"📥 Cloning repository from {repo_git}..."
+        yield f"   Using temporary directory: {folder}"
+        
+        env = os.environ.copy()
+        env['GIT_LFS_SKIP_SMUDGE'] = '1'
+        
+        # 먼저 .git 없이 시도
+        clone_cmd = ['git', 'clone', '--depth', '1', repo_git, folder]
+        result = subprocess.run(clone_cmd, env=env, capture_output=True, text=True)
+        
+        # 실패하면 .git 추가하여 재시도
+        if result.returncode != 0:
+            if ".git" not in repo_git:
+                yield "   Retrying with .git extension..."
+                clone_cmd = ['git', 'clone', '--depth', '1', repo_git_with_git, folder]
+                result = subprocess.run(clone_cmd, env=env, capture_output=True, text=True)
+            
+            if result.returncode != 0:
+                error_msg = result.stderr
+                if "Repository not found" in error_msg or "fatal: repository" in error_msg:
+                    yield f"❌ Repository not found. Please check:"
+                    yield f"   1. The repository URL is correct"
+                    yield f"   2. The repository is public"
+                    yield f"   3. The repository exists"
+                    yield f"   URL tried: {repo_git}"
+                else:
+                    yield f"❌ Git clone failed: {error_msg[:500]}"
+                if os.path.exists(folder):
+                    shutil.rmtree(folder)
+                return
+        
+        yield "✅ Repository cloned successfully"
+        
+        # Git 클론 재시도 로직 개선
+        if not skip_lfs:
+            yield "📦 Attempting to download LFS files..."
+            try:
+                # Git LFS 설치 확인
+                lfs_check = subprocess.run(['git', 'lfs', 'version'], capture_output=True, text=True)
+                if lfs_check.returncode != 0:
+                    yield "⚠️ Git LFS not installed. Skipping LFS files..."
+                    skip_lfs = True
+                else:
+                    subprocess.run(['git', 'lfs', 'install'], cwd=folder, check=True)
+                    lfs_result = subprocess.run(['git', 'lfs', 'pull'], cwd=folder, capture_output=True, text=True)
+                    
+                    if lfs_result.returncode != 0:
+                        yield f"⚠️ Warning: LFS download failed - {lfs_result.stderr[:200]}"
+                        skip_lfs = True
+                    else:
+                        yield "✅ LFS files downloaded successfully"
+            except Exception as e:
+                yield f"⚠️ LFS error: {str(e)}"
+                skip_lfs = True
+        
+        if skip_lfs:
+            yield "🧹 Removing LFS pointer files..."
+            removed_files = remove_lfs_files(folder)
+            if removed_files:
+                yield f"📝 Removed {len(removed_files)} LFS pointer files"
+        
+        if enable_smart_generation:
+            yield "🔍 Analyzing repository structure..."
+            folder_path = Path(folder)
+            analysis = analyze_repository(folder_path)
+            
+            yield "🤖 Generating smart Gradio app..."
+            generated = generate_gradio_app(repo_git, analysis)
+            
+            if generated and isinstance(generated, dict) and "app_py" in generated:
+                app_path = folder_path / "app.py"
+                app_path.write_text(generated["app_py"], encoding="utf-8")
+                yield "✅ Smart app.py generated"
+                
+                req_path = folder_path / "requirements.txt"
+                existing_reqs = []
+                if req_path.exists():
+                    try:
+                        existing_reqs = req_path.read_text(encoding="utf-8").strip().split("\n")
+                    except:
+                        existing_reqs = []
+                
+                new_reqs = generated["requirements_txt"].strip().split("\n") if generated["requirements_txt"] else []
+                
+                all_reqs = set()
+                git_reqs = []
+                torch_reqs = []
+                regular_reqs = []
+                
+                for req in existing_reqs + new_reqs:
+                    req = req.strip()
+                    if not req or req.startswith("#"):
+                        continue
+                    
+                    if req.startswith("git+"):
+                        git_reqs.append(req)
+                    elif "torch" in req.lower() or "cuda" in req.lower():
+                        torch_reqs.append(req)
+                    else:
+                        regular_reqs.append(req)
+                
+                has_gradio = any("gradio" in req for req in regular_reqs)
+                if not has_gradio:
+                    regular_reqs.append("gradio>=5.35.0")
+                
+                final_reqs = []
+                
+                if torch_reqs:
+                    final_reqs.extend(sorted(set(torch_reqs)))
+                    final_reqs.append("")
+                
+                final_reqs.extend(sorted(set(regular_reqs)))
+                
+                if git_reqs:
+                    final_reqs.append("")
+                    final_reqs.extend(sorted(set(git_reqs)))
+                
+                req_content = "\n".join(final_reqs)
+                req_path.write_text(req_content, encoding="utf-8")
+                yield "✅ Requirements.txt updated"
+                
+                readme_path = folder_path / "README.md"
+                readme_content = f"""---
+title: {repo_hf.replace("-", " ").title()}
+emoji: 🚀
+colorFrom: blue
+colorTo: green
+sdk: {sdk_type}
+sdk_version: "5.35.0"
+app_file: app.py
+pinned: false
+---
+
+# {repo_hf.replace("-", " ").title()}
+
+{analysis.get('description', 'Deployed from GitHub repository')}
+
+Deployed from: {repo_git}
+"""
+                readme_path.write_text(readme_content, encoding="utf-8")
+                yield "✅ README.md created/updated"
+        
+        git_dir = os.path.join(folder, '.git')
+        if os.path.exists(git_dir):
+            shutil.rmtree(git_dir)
+            yield "🧹 Removed .git directory"
+        
+        gitattributes_path = os.path.join(folder, '.gitattributes')
+        if os.path.exists(gitattributes_path):
+            with open(gitattributes_path, 'r') as f:
+                lines = f.readlines()
+            
+            new_lines = []
+            for line in lines:
+                if 'filter=lfs' not in line:
+                    new_lines.append(line)
+            
+            if new_lines:
+                with open(gitattributes_path, 'w') as f:
+                    f.writelines(new_lines)
+            else:
+                os.remove(gitattributes_path)
+        
+        yield "🏗️ Creating Hugging Face Space..."
+        
+        repo_id = f"{username}/{slugify(repo_hf)}"
+        space_created = False
+        
+        for attempt in range(3):
+            try:
+                yield f"   Creating Space: {repo_id} (attempt {attempt + 1}/3)"
+                
+                try:
+                    existing_space = api.space_info(repo_id=repo_id, token=hf_token)
+                    yield f"   ℹ️ Space already exists: {existing_space.id}"
+                    space_created = True
+                    break
+                except:
+                    pass
+                
+                create_result = api.create_repo(
+                    repo_id=repo_id,
+                    repo_type="space",
+                    space_sdk=sdk_type,
+                    exist_ok=True,
+                    private=False,
+                    token=hf_token
+                )
+                
+                time.sleep(3)
+                
+                space_info = api.space_info(repo_id=repo_id, token=hf_token)
+                yield f"   ✅ Space created successfully: {space_info.id}"
+                space_created = True
+                break
+                
+            except Exception as e:
+                error_msg = str(e)
+                
+                if "429" in error_msg or "Too Many Requests" in error_msg:
+                    yield f"❌ Rate Limit Error - Try again in 17-24 hours"
+                    if os.path.exists(folder):
+                        shutil.rmtree(folder)
+                    raise Exception(f"Rate limit reached.")
+                
+                yield f"   ⚠️ Attempt {attempt + 1} failed: {error_msg[:100]}..."
+                if attempt < 2:
+                    yield "   Retrying in 5 seconds..."
+                    time.sleep(5)
+                else:
+                    yield f"   ❌ Failed to create space after 3 attempts"
+                    if os.path.exists(folder):
+                        shutil.rmtree(folder)
+                    raise Exception(f"Could not create space: {error_msg}")
+        
+        if not space_created:
+            if os.path.exists(folder):
+                shutil.rmtree(folder)
+            raise Exception("Failed to create space")
+        
+        folder_size = sum(os.path.getsize(os.path.join(dirpath, filename)) 
+                         for dirpath, dirnames, filenames in os.walk(folder) 
+                         for filename in filenames) / (1024 * 1024)
+        
+        yield f"📊 Folder size: {folder_size:.2f} MB"
+        
+        file_count = sum(len(files) for _, _, files in os.walk(folder))
+        yield f"📁 Total files to upload: {file_count}"
+        
+        upload_success = False
+        max_retries = 3
+        
+        for attempt in range(max_retries):
+            try:
+                if attempt > 0:
+                    yield f"📤 Upload attempt {attempt + 1}/{max_retries}..."
+                    time.sleep(5)
+                
+                if folder_size > 500:
+                    yield "📤 Uploading large folder to Hugging Face..."
+                    api.upload_large_folder(
+                        folder_path=folder,
+                        repo_id=repo_id,
+                        repo_type="space",
+                        token=hf_token,
+                        commit_message="Deploy from GitHub repository",
+                        ignore_patterns=["*.pyc", "__pycache__", ".git*", ".DS_Store", "*.egg-info"]
+                    )
+                else:
+                    yield "📤 Uploading to Hugging Face..."
+                    api.upload_folder(
+                        folder_path=folder,
+                        repo_id=repo_id,
+                        repo_type="space",
+                        token=hf_token,
+                        commit_message="Deploy from GitHub repository",
+                        ignore_patterns=["*.pyc", "__pycache__", ".git*", ".DS_Store", "*.egg-info"]
+                    )
+                
+                upload_success = True
+                yield "✅ Upload completed successfully"
+                break
+                
+            except Exception as upload_error:
+                error_msg = str(upload_error)
+                
+                if "404" in error_msg and attempt < max_retries - 1:
+                    yield f"   ⚠️ Upload failed (404). Retrying..."
+                    time.sleep(10)
+                    
+                    try:
+                        space_info = api.space_info(repo_id=repo_id, token=hf_token)
+                        yield f"   ✅ Space confirmed to exist"
+                    except:
+                        yield "   🔄 Attempting to recreate space..."
+                        try:
+                            api.create_repo(
+                                repo_id=repo_id,
+                                repo_type="space",
+                                space_sdk=sdk_type,
+                                exist_ok=True,
+                                private=False,
+                                token=hf_token
+                            )
+                            yield "   ✅ Space recreated"
+                        except Exception as recreate_error:
+                            yield f"   ❌ Could not recreate space: {str(recreate_error)}"
+                
+                elif "LFS pointer" in error_msg:
+                    yield "❌ Upload failed due to remaining LFS pointer files"
+                    if os.path.exists(folder):
+                        shutil.rmtree(folder)
+                    raise upload_error
+                
+                elif attempt == max_retries - 1:
+                    yield f"❌ Upload failed after {max_retries} attempts"
+                    if os.path.exists(folder):
+                        shutil.rmtree(folder)
+                    raise upload_error
+                else:
+                    yield f"   ⚠️ Upload failed: {error_msg[:100]}..."
+        
+        if not upload_success:
+            if os.path.exists(folder):
+                shutil.rmtree(folder)
+            raise Exception("Upload failed after all retries")
+        
+        # Clean up temporary folder
+        if os.path.exists(folder):
+            shutil.rmtree(folder)
+        
+        space_url = f"https://huggingface.co/spaces/{repo_id}"
+        
+        yield f"""
+✅ **Successfully created Space!**
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🎉 **Your Space is Ready!**
+
+🔗 **Space URL**: {space_url}
+
+📋 **Click here to open**: [{repo_id}]({space_url})
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📊 **Deployment Details:**
+• Space ID: `{repo_id}`
+• Source: {repo_git}
+• SDK: {sdk_type}
+• Smart Generation: {'Enabled' if enable_smart_generation else 'Disabled'}
+• LFS Files: {'Skipped' if skip_lfs else 'Included'}
+
+⏱️ **Next Steps:**
+1. Click the link above to open your Space
+2. Wait 1-2 minutes for initial build
+3. Check "App" tab to see your deployed application
+4. Check "Logs" tab if you encounter any issues
+
+💡 **Tips:**
+• Building may take 2-5 minutes depending on dependencies
+• If build fails, check requirements.txt in "Files" tab
+• You can edit files directly in the Space interface
+"""
+        
+        if skip_lfs:
+            yield "\n⚠️ LFS files were removed."
+        
+        if enable_smart_generation:
+            yield "\n🤖 AI-generated Gradio interface was created"
+    
+    except subprocess.CalledProcessError as e:
+        if os.path.exists(folder):
+            shutil.rmtree(folder)
+        yield f"❌ Git error: {str(e)}"
+    except Exception as e:
+        if os.path.exists(folder):
+            shutil.rmtree(folder)
+        yield f"❌ Error: {str(e)}"
+
+def space_to_github(hf_username, hf_space_name, github_username, github_repo_name, github_token):
+    """Clone HuggingFace Space and push to GitHub"""
+    tmp_dir = None
+    try:
+        # HF Space URL 생성
+        hf_repo_url = f"https://huggingface.co/spaces/{hf_username}/{hf_space_name}.git"
+        
+        # 임시 디렉토리 생성 및 클론
+        tmp_dir = tempfile.mkdtemp()
+        yield f"📥 Cloning HF Space: {hf_username}/{hf_space_name}..."
+        yield f"   Using temporary directory: {tmp_dir}"
+        
+        # Git 클론
+        env = os.environ.copy()
+        env['GIT_LFS_SKIP_SMUDGE'] = '1'  # LFS 파일 스킵
+        
+        clone_cmd = ['git', 'clone', hf_repo_url, tmp_dir]
+        result = subprocess.run(clone_cmd, env=env, capture_output=True, text=True, cwd=tempfile.gettempdir())
+        
+        if result.returncode != 0:
+            raise Exception(f"Clone failed: {result.stderr}")
+        
+        yield "✅ HF Space cloned successfully"
+        
+        # GitHub 인증 및 레포 생성
+        yield "🔐 Authenticating with GitHub..."
+        
+        # GitHub API 호출로 레포 생성
+        headers = {
+            "Authorization": f"token {github_token}",
+            "Accept": "application/vnd.github.v3+json"
+        }
+        
+        # 사용자 정보 가져오기
+        user_response = requests.get("https://api.github.com/user", headers=headers)
+        if user_response.status_code != 200:
+            raise Exception("GitHub authentication failed. Please check your token.")
+        
+        actual_github_username = user_response.json()["login"]
+        
+        # 입력된 username과 실제 username이 다른 경우 처리
+        if github_username.lower() != actual_github_username.lower():
+            yield f"⚠️ Note: Using authenticated user '{actual_github_username}' instead of '{github_username}'"
+            github_username = actual_github_username
+        
+        yield f"✅ Authenticated as GitHub user: {github_username}"
+        
+        # 레포지토리 생성
+        yield f"📦 Creating GitHub repository: {github_repo_name}..."
+        create_data = {
+            "name": github_repo_name,
+            "private": False,
+            "auto_init": False,
+            "description": f"Exported from HuggingFace Space: {hf_username}/{hf_space_name}"
+        }
+        
+        create_response = requests.post(
+            "https://api.github.com/user/repos",
+            headers=headers,
+            json=create_data
+        )
+        
+        if create_response.status_code == 201:
+            repo_info = create_response.json()
+            github_url = repo_info['html_url']
+            yield f"✅ GitHub repository created: {github_url}"
+        elif create_response.status_code == 422:
+            # 레포가 이미 존재함
+            github_url = f"https://github.com/{github_username}/{github_repo_name}"
+            yield f"ℹ️ Repository already exists: {github_url}"
+        else:
+            error_msg = create_response.json().get('message', 'Unknown error')
+            raise Exception(f"Failed to create repository: {error_msg}")
+        
+        # Git remote 변경 및 푸시
+        yield "📤 Pushing to GitHub..."
+        
+        # git 명령어로 remote 변경 및 푸시
+        os.chdir(tmp_dir)
+        
+        # 기존 origin 제거
+        subprocess.run(['git', 'remote', 'remove', 'origin'], capture_output=True)
+        
+        # GitHub remote 추가
+        github_remote_url = f"https://{github_username}:{github_token}@github.com/{github_username}/{github_repo_name}.git"
+        subprocess.run(['git', 'remote', 'add', 'origin', github_remote_url], check=True)
+        
+        # main 브랜치로 푸시
+        push_result = subprocess.run(
+            ['git', 'push', '-u', 'origin', 'HEAD:main', '--force'],
+            capture_output=True,
+            text=True
+        )
+        
+        if push_result.returncode != 0:
+            # master 브랜치로 재시도
+            push_result = subprocess.run(
+                ['git', 'push', '-u', 'origin', 'HEAD:master', '--force'],
+                capture_output=True,
+                text=True
+            )
+            
+            if push_result.returncode != 0:
+                raise Exception(f"Push failed: {push_result.stderr}")
+        
+        yield "✅ Successfully pushed to GitHub!"
+        
+        # 최종 결과 출력 - 클릭 가능한 링크
+        final_url = f"https://github.com/{github_username}/{github_repo_name}"
+        yield f"""
+🎉 **Export Complete!**
+
+📦 **GitHub Repository**: [{final_url}]({final_url})
+
+📋 **Details:**
+- Source: HuggingFace Space `{hf_username}/{hf_space_name}`
+- Destination: GitHub `{github_username}/{github_repo_name}`
+
+🔧 **Next Steps:**
+```bash
+git clone {final_url}.git
+cd {github_repo_name}
+```
+"""
+        
+    except Exception as e:
+        yield f"❌ Error: {str(e)}"
+    finally:
+        # 임시 디렉토리 정리
+        if tmp_dir and os.path.exists(tmp_dir):
+            os.chdir(tempfile.gettempdir())  # 안전한 디렉토리로 이동
+            try:
+                shutil.rmtree(tmp_dir)
+            except:
+                pass  # 정리 실패해도 계속 진행
+
+# CSS styling (keeping the same)
+css = """
+/* Modern Professional UI */
+.container {
+    max-width: 1200px !important;
+    margin: auto;
+    padding: 20px;
+}
+
+/* Gradient backgrounds */
+.main-header {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    padding: 2rem;
+    border-radius: 15px;
+    margin-bottom: 2rem;
+    color: white;
+    text-align: center;
+    box-shadow: 0 10px 30px rgba(0,0,0,0.1);
+}
+
+/* Tab styling */
+.tabs {
+    box-shadow: 0 4px 6px rgba(0,0,0,0.07);
+    border-radius: 12px;
+    overflow: hidden;
+}
+
+/* Card-like sections */
+.input-section {
+    background: white;
+    padding: 25px;
+    border-radius: 12px;
+    box-shadow: 0 2px 12px rgba(0,0,0,0.08);
+    margin-bottom: 20px;
+    border: 1px solid rgba(0,0,0,0.05);
+}
+
+/* Output box styling */
+.output-box {
+    min-height: 400px !important;
+    max-height: 600px !important;
+    overflow-y: auto !important;
+    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace !important;
+    font-size: 13px !important;
+    line-height: 1.6 !important;
+    background: linear-gradient(to bottom, #1e1e1e, #2d2d30) !important;
+    color: #d4d4d4 !important;
+    padding: 20px !important;
+    border-radius: 10px !important;
+    border: 1px solid rgba(255,255,255,0.1) !important;
+}
+
+/* Custom button styling */
+.primary-btn {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+    color: white !important;
+    border: none !important;
+    padding: 12px 30px !important;
+    font-size: 16px !important;
+    font-weight: 600 !important;
+    border-radius: 8px !important;
+    cursor: pointer !important;
+    transition: all 0.3s ease !important;
+    box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4) !important;
+}
+
+.primary-btn:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 6px 20px rgba(102, 126, 234, 0.6) !important;
+}
+
+/* Input field styling */
+input[type="text"], input[type="password"], textarea {
+    border: 2px solid #e2e8f0 !important;
+    border-radius: 8px !important;
+    padding: 10px 15px !important;
+    font-size: 14px !important;
+    transition: all 0.3s ease !important;
+    background: #f8fafc !important;
+}
+
+input[type="text"]:focus, input[type="password"]:focus, textarea:focus {
+    border-color: #667eea !important;
+    box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1) !important;
+    background: white !important;
+}
+
+/* Radio button group styling */
+.radio-group {
+    background: #f8fafc;
+    padding: 15px;
+    border-radius: 8px;
+    border: 1px solid #e2e8f0;
+}
+
+/* Checkbox styling */
+input[type="checkbox"] {
+    width: 20px !important;
+    height: 20px !important;
+    cursor: pointer !important;
+}
+
+/* Label styling */
+label {
+    font-weight: 600 !important;
+    color: #334155 !important;
+    margin-bottom: 8px !important;
+    display: block !important;
+    font-size: 14px !important;
+}
+
+/* Info text styling */
+.info-text {
+    color: #64748b !important;
+    font-size: 13px !important;
+    margin-top: 5px !important;
+}
+
+/* Scrollbar styling */
+.output-box::-webkit-scrollbar {
+    width: 10px;
+}
+
+.output-box::-webkit-scrollbar-track {
+    background: #2d2d30;
+    border-radius: 5px;
+}
+
+.output-box::-webkit-scrollbar-thumb {
+    background: #555;
+    border-radius: 5px;
+}
+
+.output-box::-webkit-scrollbar-thumb:hover {
+    background: #666;
+}
+
+/* Animation */
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(10px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.input-section {
+    animation: fadeIn 0.5s ease;
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+    .container {
+        padding: 10px;
+    }
+    
+    .main-header {
+        padding: 1.5rem;
+    }
+    
+    .input-section {
+        padding: 15px;
+    }
+}
+"""
+
+# Gradio interface (remains the same structure)
+with gr.Blocks(css=css, theme=gr.themes.Soft(
+    primary_hue="purple",
+    secondary_hue="purple",
+    neutral_hue="slate"
+)) as demo:
+    gr.HTML("""
+    <div class="main-header">
+        <h1 style="font-size: 2.5rem; margin: 0; font-weight: 700;">
+            🔄 Repository Converter Pro
+        </h1>
+        <p style="font-size: 1.1rem; margin-top: 10px; opacity: 0.95;">
+            Seamlessly transfer repositories between GitHub and HuggingFace
+        </p>
+    </div>
+    """)
+    
+    # OAuth 로그인 버튼을 상단에 배치
+    with gr.Row():
+        with gr.Column(scale=4):
+            gr.LoginButton()
+        with gr.Column(scale=8):
+            login_status = gr.HTML("""
+            <div style="padding: 10px; background: #fef2f2; border: 1px solid #fecaca; 
+                       border-radius: 8px; margin: 5px 0;">
+                <span style="color: #dc2626;">⚠️ Please login with HuggingFace to continue</span>
+            </div>
+            """)
+    
+    with gr.Tabs(elem_classes="tabs") as main_tabs:
+        with gr.Tab("🚀 GitHub → HF Space", elem_id="tab1"):
+            # 인증 옵션 섹션 추가
+            with gr.Group(elem_classes="input-section"):
+                gr.Markdown("""
+                ### 🔐 Authentication Options
+                **Option 1**: Enter your HuggingFace token (Recommended)  
+                **Option 2**: Use OAuth login (may have limited permissions)
+                """)
+                
+                user_hf_token = gr.Textbox(
+                    label="HuggingFace Access Token (Optional but Recommended)",
+                    type="password",
+                    placeholder="hf_xxxxxxxxxxxxxxxxxxxxx",
+                    info="Get token from: https://huggingface.co/settings/tokens (needs 'write' role)"
+                )
+            
+            with gr.Row():
+                with gr.Column(scale=5):
+                    with gr.Group(elem_classes="input-section"):
+                        gr.Markdown("### 📦 Source Repository")
+                        repo_git = gr.Textbox(
+                            label="GitHub Repository URL",
+                            placeholder="https://github.com/username/repository",
+                            info="Enter the full GitHub repository URL"
+                        )
+                        
+                        gr.Markdown("### 🎯 Destination Settings")
+                        repo_hf = gr.Textbox(
+                            label="HuggingFace Space Name",
+                            placeholder="my-awesome-space",
+                            info="Choose a unique name for your Space"
+                        )
+                        
+                        sdk_choices = gr.Radio(
+                            ["gradio", "streamlit", "docker", "static"],
+                            label="Space SDK Type",
+                            value="gradio",
+                            elem_classes="radio-group"
+                        )
+                        
+                        gr.Markdown("### ⚙️ Advanced Options")
+                        with gr.Row():
+                            skip_lfs = gr.Checkbox(
+                                label="Skip Large Files (LFS)",
+                                value=True,
+                                info="Recommended for faster deployment"
+                            )
+                            enable_smart_generation = gr.Checkbox(
+                                label="🤖 AI-Powered App Generation",
+                                value=False,
+                                info="Generate app.py automatically (requires FIREWORKS_API_KEY)"
+                            )
+                        
+                        btn_to_hf = gr.Button("🚀 Deploy to HuggingFace", 
+                                            variant="primary", 
+                                            elem_classes="primary-btn",
+                                            size="lg")
+                
+                with gr.Column(scale=7):
+                    with gr.Group(elem_classes="input-section"):
+                        gr.Markdown("### 📊 Deployment Progress")
+                        output_to_hf = gr.Textbox(
+                            label="",
+                            lines=20,
+                            elem_classes="output-box",
+                            interactive=False,
+                            show_copy_button=True
+                        )
+            
+            btn_to_hf.click(
+                fn=clone,
+                inputs=[repo_git, repo_hf, sdk_choices, skip_lfs, enable_smart_generation, user_hf_token],
+                outputs=output_to_hf
+            )
+        
+        with gr.Tab("📤 HF Space → GitHub", elem_id="tab2"):
+            with gr.Row():
+                with gr.Column(scale=5):
+                    with gr.Group(elem_classes="input-section"):
+                        gr.Markdown("### 🎯 Source Space")
+                        hf_username = gr.Textbox(
+                            label="HuggingFace Username",
+                            placeholder="your-hf-username",
+                            info="Your HuggingFace account name"
+                        )
+                        hf_space_name = gr.Textbox(
+                            label="Space Name",
+                            placeholder="your-space-name",
+                            info="Name of the Space to export"
+                        )
+                        
+                        gr.Markdown("### 📦 GitHub Destination")
+                        github_username = gr.Textbox(
+                            label="GitHub Username",
+                            placeholder="your-github-username",
+                            info="Your GitHub account name"
+                        )
+                        github_repo_name = gr.Textbox(
+                            label="Repository Name",
+                            placeholder="new-repo-name",
+                            info="Name for the new GitHub repository"
+                        )
+                        
+                        gr.Markdown("### 🔐 Authentication")
+                        github_token = gr.Textbox(
+                            label="GitHub Personal Access Token",
+                            type="password",
+                            placeholder="ghp_xxxxxxxxxxxxxxxxxxxx",
+                            info="Generate at: github.com/settings/tokens (needs 'repo' scope)"
+                        )
+                        
+                        btn_to_github = gr.Button("📤 Export to GitHub", 
+                                                variant="primary", 
+                                                elem_classes="primary-btn",
+                                                size="lg")
+                
+                with gr.Column(scale=7):
+                    with gr.Group(elem_classes="input-section"):
+                        gr.Markdown("### 📊 Export Progress")
+                        output_to_github = gr.Textbox(
+                            label="",
+                            lines=20,
+                            elem_classes="output-box",
+                            interactive=False,
+                            show_copy_button=True
+                        )
+            
+            btn_to_github.click(
+                fn=space_to_github,
+                inputs=[hf_username, hf_space_name, github_username, github_repo_name, github_token],
+                outputs=output_to_github
+            )
+
+if __name__ == "__main__":
+    # OAuth 환경 설정 체크
+    if os.getenv("SPACE_ID"):
+        print("Running on HuggingFace Spaces")
+        print("OAuth callback URL: https://huggingface.co/spaces/" + os.getenv("SPACE_ID"))
+    
+    demo.launch()