Delete app-backup.py

app-backup.py

@@ -1,1625 +0,0 @@
-import gradio as gr
-from huggingface_hub import HfApi, create_repo
-from git import Repo
-import uuid 
-from slugify import slugify
-import os
-import sys
-import json
-import argparse
-import subprocess
-import tempfile
-import textwrap
-import requests
-import shutil
-import time
-from pathlib import Path
-from typing import Optional, Dict, List, Tuple
-
-# ========== LFS 처리 함수 (첫 번째 코드에서) ========== #
-def is_lfs_pointer_file(filepath):
-    """Check if a file is a Git LFS pointer file."""
-    # Initialize analysis
-    analysis = {}
-    
-    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):
-    """Remove all LFS pointer files from the repository."""
-    removed_files = []
-    for root, dirs, files in os.walk(folder):
-        # Skip .git directory
-        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
-
-# ========== Repository 분석 함수 (두 번째 코드에서) ========== #
-def analyze_repository(src_path: Path) -> Dict:
-    """레포지토리 구조와 내용을 분석하여 정보 추출"""
-    analysis = {
-        "has_requirements": False,
-        "has_readme": False,
-        "has_setup_py": False,
-        "main_language": "python",
-        "key_files": [],
-        "dependencies": [],
-        "description": "",
-        "installation_steps": [],
-        "usage_examples": [],
-        "model_files": [],
-        "data_files": [],
-        "config_files": [],
-        "entry_points": []
-    }
-    
-    # requirements.txt 분석
-    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]
-                            # 버전이 x.y 형식이면 x.y.0으로 변경
-                            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"] = []
-    
-    # README 분석
-    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]  # 처음 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
-                
-                # 설치 방법 찾기
-                install_section = False
-                usage_section = False
-                for line in lines:
-                    if "install" in line.lower() and "#" in line:
-                        install_section = True
-                        usage_section = False
-                        continue
-                    elif "usage" in line.lower() and "#" in line:
-                        usage_section = True
-                        install_section = False
-                        continue
-                    elif "#" in line:
-                        install_section = False
-                        usage_section = False
-                    
-                    if install_section and line.strip():
-                        analysis["installation_steps"].append(line.strip())
-                    elif usage_section and line.strip():
-                        analysis["usage_examples"].append(line.strip())
-            except:
-                pass
-    
-    # 주요 Python 파일 찾기
-    py_files = list(src_path.glob("**/*.py"))
-    for py_file in py_files[:20]:  # 최대 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))
-                
-                # 주요 import 확인
-                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
-
-# ========== Brave Search 헬퍼 (두 번째 코드에서) ========== #
-def search_repo_info(repo_url: str) -> str:
-    """Brave Search로 레포지토리 정보 수집"""
-    api_key = os.getenv("BAPI_TOKEN")
-    if not api_key:
-        return ""
-    
-    api_key = api_key.strip()
-    headers = {"X-Subscription-Token": api_key, "Accept": "application/json"}
-    
-    # 레포지토리 이름 추출
-    repo_parts = repo_url.rstrip("/").split("/")
-    if len(repo_parts) >= 2:
-        repo_name = f"{repo_parts[-2]}/{repo_parts[-1]}"
-    else:
-        return ""
-    
-    # 검색 쿼리들
-    queries = [
-        f'"{repo_name}" github tutorial',
-        f'"{repo_name}" usage example',
-        f'"{repo_name}" gradio streamlit demo'
-    ]
-    
-    search_results = []
-    for query in queries:
-        params = {"q": query, "count": 3}
-        try:
-            resp = requests.get(
-                "https://api.search.brave.com/res/v1/web/search",
-                headers=headers, 
-                params=params, 
-                timeout=10
-            )
-            if resp.status_code == 200:
-                results = resp.json().get("web", {}).get("results", [])
-                for r in results:
-                    search_results.append({
-                        "title": r.get("title", ""),
-                        "description": r.get("description", ""),
-                        "url": r.get("url", "")
-                    })
-        except:
-            continue
-    
-    # 검색 결과를 텍스트로 변환
-    search_text = f"Search results for {repo_name}:\n"
-    for r in search_results[:5]:
-        search_text += f"\n- {r['title']}: {r['description']}\n"
-    
-    return search_text
-
-# ========== AI 생성 헬퍼 (두 번째 코드에서) ========== #
-def generate_gradio_app(repo_url: str, analysis: Dict, search_info: str = "") -> Dict:
-    """AI로 실제 동작하는 Gradio 앱 생성"""
-    
-    # 컨텍스트 준비
-    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"
-    
-    if search_info:
-        context += f"\n--- Web Search Results ---\n{search_info}\n"
-    
-    # Installation steps
-    if analysis['installation_steps']:
-        context += f"\nInstallation Steps:\n"
-        for step in analysis['installation_steps'][:5]:
-            context += f"- {step}\n"
-    
-    # Usage examples
-    if analysis['usage_examples']:
-        context += f"\nUsage Examples:\n"
-        for ex in analysis['usage_examples'][:5]:
-            context += f"- {ex}\n"
-    
-    # System prompt
-    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. Include helpful descriptions and examples
-7. Always use gradio>=5.35.0
-8. If the project requires external APIs (OpenAI, Anthropic, etc), include:
-   - API key input fields
-   - Clear instructions on how to obtain keys
-   - Environment variable setup guidance
-   - Graceful handling when keys are missing
-
-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"""
-    
-    # OpenAI 시도
-    openai_key = os.getenv("OPENAI_API_KEY")
-    if openai_key:
-        try:
-            headers = {
-                "Authorization": f"Bearer {openai_key.strip()}",
-                "Content-Type": "application/json"
-            }
-            
-            payload = {
-                "model": "gpt-4o-mini",
-                "messages": [
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": f"Create a fully functional Gradio app for this repository:\n\n{context[:8000]}"}
-                ],
-                "temperature": 0.3,
-                "max_tokens": 4000
-            }
-            
-            r = requests.post(
-                "https://api.openai.com/v1/chat/completions",
-                json=payload,
-                headers=headers,
-                timeout=30
-            )
-            
-            if r.status_code == 200:
-                response_text = r.json()["choices"][0]["message"]["content"]
-                print("✅ OpenAI API로 스마트 앱 생성 성공")
-                
-                # JSON 파싱
-                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"⚠️ OpenAI API 오류: {e}")
-    
-    # Friendli 시도
-    friendli_token = os.getenv("FRIENDLI_TOKEN")
-    if friendli_token:
-        try:
-            headers = {
-                "Authorization": f"Bearer {friendli_token.strip()}",
-                "Content-Type": "application/json"
-            }
-            
-            payload = {
-                "model": "meta-llama-3.1-70b-instruct",
-                "messages": [
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": f"Create a Gradio app:\n{context[:6000]}"}
-                ],
-                "max_tokens": 4000,
-                "temperature": 0.3
-            }
-            
-            for endpoint in [
-                "https://api.friendli.ai/v1/chat/completions",
-                "https://api.friendli.ai/dedicated/v1/chat/completions"
-            ]:
-                r = requests.post(endpoint, json=payload, headers=headers, timeout=30)
-                if r.status_code == 200:
-                    response_text = r.json()["choices"][0]["message"]["content"]
-                    print("✅ Friendli API로 스마트 앱 생성 ���공")
-                    
-                    if "```json" in response_text:
-                        start = response_text.find("```json") + 7
-                        end = response_text.find("```", start)
-                        response_text = response_text[start:end].strip()
-                    
-                    result = json.loads(response_text)
-                    
-                    if "gradio" not in result.get("requirements_txt", "").lower():
-                        result["requirements_txt"] = "gradio>=5.35.0\n" + result.get("requirements_txt", "")
-                    
-                    return result
-        except Exception as e:
-            print(f"⚠️ Friendli 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_ml = any(lib in deps for lib in ["torch", "tensorflow", "transformers", "scikit-learn"])
-    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_audio = any(lib in deps for lib in ["librosa", "soundfile", "pyaudio"])
-    has_3d = any(lib in deps for lib in ["gaussian", "rasterizer", "plyfile", "trimesh"])
-    
-    # 기본 requirements - git 의존성 제외
-    requirements = ["gradio>=5.35.0"]
-    if analysis and analysis.get("dependencies"):
-        # git+ 의존성과 로컬 의존성 제외
-        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():
-        # 3D/Gaussian Splatting 앱
-        app_code = f'''import gradio as gr
-import os
-import sys
-
-# Repository: {repo_url}
-# {description}
-
-# Note: This project requires CUDA-enabled GPU and complex build dependencies
-# The original repository uses custom CUDA extensions that need compilation
-
-def process_3d(input_file):
-    """3D processing function - placeholder for actual implementation"""
-    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
-    3. Specific versions of PyTorch with CUDA support
-    
-    The git dependencies in requirements.txt need PyTorch to be installed first.
-    
-    For full functionality:
-    1. Install PyTorch with CUDA: `pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118`
-    2. Install build tools: `apt-get install build-essential python3-dev ninja-build`
-    3. Then install other requirements
-    
-    Original repository: {repo_url}
-    """
-    
-    return info
-
-# Gradio interface
-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})
-    
-    **Note**: This project has complex build requirements. See below for details.
-    """)
-    
-    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
-
-# Repository: {repo_url}
-# {description}
-
-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
-
-# Gradio 인터페이스 생성
-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
-
-# Repository: {repo_url}
-# {description}
-
-def process_text(text, max_length=100):
-    """텍스트 처리 함수 - 실제 구현으로 교체 필요"""
-    if not text:
-        return "Please enter some text"
-    
-    # 여기에 실제 NLP 처리 로직 구현
-    
-    # 데모용 간단한 처리
-    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
-
-# Gradio 인터페이스 생성
-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
-
-# Repository: {repo_url}
-# {description}
-
-def main_function(input_data):
-    """메인 처리 함수 - 실제 구현으로 교체 필요"""
-    if not input_data:
-        return "Please provide input"
-    
-    # 여기에 실제 처리 로직 구현
-    
-    result = f"Processed successfully! Input received: {input_data}"
-    return result
-
-# Gradio 인터페이스 생성
-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}"
-    }
-
-# ========== 통합된 메인 clone 함수 ========== #
-def clone(repo_git, repo_hf, sdk_type, skip_lfs, enable_smart_generation):
-    """GitHub 레포지토리를 HuggingFace Space로 복제하고 스마트하게 app.py 생성"""
-    folder = str(uuid.uuid4())
-    
-    # 환경변수에서 HF_TOKEN 가져오기
-    hf_token = os.getenv("HF_TOKEN")
-    if not hf_token:
-        yield "❌ Error: HF_TOKEN not found in environment variables. Please set it in the Space settings."
-        return
-    
-    try:
-        # Initialize progress messages
-        yield "🔄 Starting clone process..."
-        
-        # Get user info
-        api = HfApi(token=hf_token)
-        try:
-            user_info = api.whoami()
-            username = user_info["name"]
-            yield f"✅ Authenticated as: {username}"
-        except Exception as e:
-            yield f"❌ Authentication failed: {str(e)}"
-            return
-        
-        # Clone the repository
-        yield f"📥 Cloning repository from {repo_git}..."
-        
-        env = os.environ.copy()
-        
-        # Always skip LFS download initially to avoid errors
-        env['GIT_LFS_SKIP_SMUDGE'] = '1'
-        clone_cmd = ['git', 'clone', '--recurse-submodules', repo_git, folder]
-        subprocess.run(clone_cmd, check=True, env=env)
-        
-        if not skip_lfs:
-            # Try to pull LFS files
-            yield "📦 Attempting to download LFS files..."
-            try:
-                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}"
-                    yield "⚠️ Will remove LFS pointer files to prevent upload errors..."
-                    skip_lfs = True  # Force LFS skip
-                else:
-                    yield "✅ LFS files downloaded successfully"
-            except Exception as e:
-                yield f"⚠️ LFS error: {str(e)}"
-                yield "⚠️ Will remove LFS pointer files to prevent upload errors..."
-                skip_lfs = True  # Force LFS skip
-        
-        # If we're skipping LFS, remove all LFS pointer files
-        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"
-                # Show first few removed files
-                for file in removed_files[:5]:
-                    yield f"  - {file}"
-                if len(removed_files) > 5:
-                    yield f"  ... and {len(removed_files) - 5} more files"
-        
-        # 스마트 생성이 활성화된 경우
-        if enable_smart_generation:
-            yield "🔍 Analyzing repository structure..."
-            folder_path = Path(folder)
-            analysis = analyze_repository(folder_path)
-            
-            yield "🔍 Searching for additional information..."
-            search_info = search_repo_info(repo_git)
-            
-            yield "🤖 Generating smart Gradio app..."
-            generated = generate_gradio_app(repo_git, analysis, search_info)
-            
-            if generated and isinstance(generated, dict) and "app_py" in generated:
-                # app.py 생성/덮어쓰기
-                app_path = folder_path / "app.py"
-                app_path.write_text(generated["app_py"], encoding="utf-8")
-                yield "✅ Smart app.py generated"
-                
-                # requirements.txt 업데이트 - 의존성 순서 최적화
-                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
-                    
-                    # git+ 의존성은 따로 관리
-                    if req.startswith("git+"):
-                        git_reqs.append(req)
-                    # torch 관련 의존성은 먼저 설치
-                    elif "torch" in req.lower() or "cuda" in req.lower():
-                        torch_reqs.append(req)
-                    else:
-                        regular_reqs.append(req)
-                
-                # gradio 버전 확인 및 추가
-                has_gradio = any("gradio" in req for req in regular_reqs)
-                if not has_gradio:
-                    regular_reqs.append("gradio>=5.35.0")
-                
-                # 최종 requirements.txt 생성 (순서 중요)
-                final_reqs = []
-                
-                # 1. torch 관련 먼저
-                if torch_reqs:
-                    final_reqs.extend(sorted(set(torch_reqs)))
-                    final_reqs.append("")  # 빈 줄
-                
-                # 2. 일반 의존성
-                final_reqs.extend(sorted(set(regular_reqs)))
-                
-                # 3. git 의존성은 마지막에 (torch가 필요한 경우가 많음)
-                if git_reqs:
-                    final_reqs.append("")  # 빈 줄
-                    final_reqs.append("# Git dependencies (installed last)")
-                    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 with optimized dependency order"
-                
-                # README.md 업데이트 - 항상 생성하여 올바른 형식 보장
-                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}
-
-## Features
-This Space provides a Gradio interface for the repository's main functionality.
-The app.py was automatically generated based on repository analysis.
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-"""
-                readme_path.write_text(readme_content, encoding="utf-8")
-                yield "✅ README.md created/updated"
-        else:
-            # 스마트 생성이 비활성화된 경우에도 README.md 확인 및 생성
-            readme_path = Path(folder) / "README.md"
-            if not readme_path.exists():
-                # 기본 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()}
-
-Deployed from: {repo_git}
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-"""
-                readme_path.write_text(readme_content, encoding="utf-8")
-                yield "✅ README.md created with required configuration"
-        
-        # requirements.txt 확인 및 문제 해결
-        req_path = Path(folder) / "requirements.txt"
-        if req_path.exists():
-            try:
-                req_content = req_path.read_text(encoding="utf-8")
-                lines = req_content.strip().split("\n")
-                
-                # 의존성 분류 및 중복 제거
-                torch_deps = []
-                git_deps = []
-                regular_deps = []
-                problem_git_deps = []  # torch가 필요한 git 의존성
-                seen_packages = {}  # 패키지명 -> 전체 의존성 매핑
-                
-                for line in lines:
-                    line = line.strip()
-                    if not line or line.startswith("#"):
-                        continue
-                    
-                    if line.startswith("git+"):
-                        # git 의존성 중 CUDA/컴파일이 필요한 경우 확인
-                        cuda_keywords = ["gaussian", "rasterizer", "diff-", "cuda", "nvdiffrast", "tiny-cuda"]
-                        if any(keyword in line.lower() for keyword in cuda_keywords):
-                            problem_git_deps.append(line)
-                        else:
-                            git_deps.append(line)
-                    else:
-                        # 패키지명 추출 (버전 지정자 제거)
-                        pkg_name = line.split("==")[0].split(">=")[0].split("<=")[0].split(">")[0].split("<")[0].split("~=")[0].split("[")[0].strip()
-                        
-                        # 특별한 설치가 필요한 패키지들
-                        special_install_packages = ["pytorch3d", "torch-scatter", "torch-sparse", "torch-geometric", "tiny-cuda-nn"]
-                        
-                        if pkg_name in special_install_packages:
-                            problem_git_deps.append(f"# {line} # Requires special installation")
-                            yield f"   → Marked {pkg_name} for special handling"
-                            continue
-                        
-                        # 특정 패키지의 잘못된 버전 수정
-                        if pkg_name == "opencv-python":
-                            if "==4.10.0" in line or "==4.10" in line:
-                                line = "opencv-python>=4.10.0.82"
-                                yield "📝 Fixed opencv-python version (4.10.0 → 4.10.0.82)"
-                        
-                        # 중복 체크
-                        if pkg_name in seen_packages:
-                            # 이미 있는 패키지면 버전 비교
-                            existing = seen_packages[pkg_name]
-                            # 더 구체적인 버전을 선택 (== > >= > 버전 없음)
-                            if "==" in line and "==" not in existing:
-                                seen_packages[pkg_name] = line
-                            elif "==" not in existing and ">=" in line and ">=" not in existing:
-                                seen_packages[pkg_name] = line
-                            # 같은 수준이면 더 최신 버전 선택
-                            elif "==" in line and "==" in existing:
-                                try:
-                                    new_ver = line.split("==")[1]
-                                    old_ver = existing.split("==")[1]
-                                    # 버전 비교 (간단한 문자열 비교)
-                                    if new_ver > old_ver:
-                                        seen_packages[pkg_name] = line
-                                except:
-                                    pass
-                            yield f"   → Resolved duplicate: {pkg_name} - using {seen_packages[pkg_name]}"
-                        else:
-                            seen_packages[pkg_name] = line
-                
-                # 분류된 의존성으로 재구성
-                for pkg_name, dep_line in seen_packages.items():
-                    if any(t in pkg_name.lower() for t in ["torch==", "torch>=", "torch~=", "torch<", "torch>", "torch[", "torchvision", "torchaudio"]):
-                        torch_deps.append(dep_line)
-                    else:
-                        regular_deps.append(dep_line)
-                
-                # gradio 버전 확인
-                has_gradio = any("gradio" in pkg for pkg in seen_packages.keys())
-                if not has_gradio:
-                    regular_deps.append("gradio>=5.35.0")
-                    seen_packages["gradio"] = "gradio>=5.35.0"
-                
-                # torch가 없으면 추가 (CUDA 의존성이 있는 경우)
-                torch_packages = [p for p in seen_packages.keys() if p == "torch"]
-                if not torch_packages and (problem_git_deps or any("torch" in dep for dep in git_deps)):
-                    torch_deps.append("torch>=2.0.0")
-                    yield "⚠️ Added torch dependency for git packages"
-                
-                # CPU 버전 torch로 대체 제안
-                cpu_torch_suggested = False
-                for i, dep in enumerate(torch_deps):
-                    if "torch==" in dep or "torch>=" in dep:
-                        # CUDA 버전이 명시되어 있으면 CPU 버전 제안
-                        if "+cu" in dep:
-                            torch_deps[i] = dep.split("+cu")[0]
-                            cpu_torch_suggested = True
-                
-                if cpu_torch_suggested:
-                    yield "ℹ️ Converted torch to CPU version for HuggingFace Spaces compatibility"
-                
-                # 재정렬된 requirements.txt 작성
-                new_lines = []
-                
-                # 1. 먼저 torch 설치
-                if torch_deps:
-                    new_lines.append("# PyTorch - Must be installed first")
-                    new_lines.extend(sorted(set(torch_deps)))
-                    new_lines.append("")
-                
-                # 2. 일반 의존성
-                if regular_deps:
-                    # 특별한 설치가 필요한 패키지들
-                    special_packages = {
-                        "pytorch3d": "# pytorch3d requires special installation from https://github.com/facebookresearch/pytorch3d/blob/main/INSTALL.md",
-                        "torch-scatter": "# torch-scatter requires matching torch version",
-                        "torch-sparse": "# torch-sparse requires matching torch version",
-                        "torch-geometric": "# torch-geometric requires special installation"
-                    }
-                    
-                    # 추가 버전 검증 및 수정
-                    validated_deps = []
-                    problematic_versions = {
-                        "opencv-python": {
-                            "4.10.0": "4.10.0.84",
-                            "4.10": "4.10.0.84",
-                            "4.9.0": "4.9.0.80",
-                            "4.8.0": "4.8.0.76"
-                        },
-                        "pillow": {
-                            "10.0": "10.0.0",
-                            "9.5": "9.5.0"
-                        }
-                    }
-                    
-                    skipped_packages = []
-                    
-                    for dep in regular_deps:
-                        pkg_name = dep.split("==")[0].split(">=")[0].split("[")[0].strip()
-                        
-                        # 특별한 설치가 필요한 패키지는 주석 처리
-                        if pkg_name in special_packages:
-                            skipped_packages.append(f"# {dep} {special_packages[pkg_name]}")
-                            yield f"   → Commented out {pkg_name} (requires special installation)"
-                            continue
-                        
-                        # 버전 수정이 필요한 패키지 처리
-                        if pkg_name in problematic_versions and "==" in dep:
-                            version = dep.split("==")[1].strip()
-                            if version in problematic_versions[pkg_name]:
-                                new_version = problematic_versions[pkg_name][version]
-                                new_dep = f"{pkg_name}>={new_version}"
-                                validated_deps.append(new_dep)
-                                yield f"   → Fixed version: {dep} → {new_dep}"
-                            else:
-                                validated_deps.append(dep)
-                        else:
-                            validated_deps.append(dep)
-                    
-                    new_lines.append("# Core dependencies")  
-                    # opencv-python 중복 제거 확인
-                    deduped_regular = []
-                    seen = set()
-                    for dep in sorted(validated_deps):
-                        pkg_name = dep.split("==")[0].split(">=")[0].split("<=")[0].split(">")[0].split("<")[0].split("~=")[0].split("[")[0].strip()
-                        if pkg_name not in seen:
-                            deduped_regular.append(dep)
-                            seen.add(pkg_name)
-                    new_lines.extend(deduped_regular)
-                    new_lines.append("")
-                    
-                    # 특별한 설치가 필요한 패키지들을 주석으로 추가
-                    if skipped_packages:
-                        new_lines.append("# ⚠️ The following packages require special installation:")
-                        new_lines.extend(skipped_packages)
-                        new_lines.append("")
-                
-                # 3. 일반 git 의존성
-                if git_deps:
-                    new_lines.append("# Git dependencies")
-                    new_lines.extend(sorted(set(git_deps)))
-                    new_lines.append("")
-                
-                # 문제가 되는 git 의존성과 특수 패키지는 주석 처리
-                if problem_git_deps:
-                    new_lines.append("")
-                    new_lines.append("# ⚠️ CUDA-dependent packages and special installations")
-                    new_lines.append("# These packages require special installation methods:")
-                    new_lines.append("# - pytorch3d: Install from https://github.com/facebookresearch/pytorch3d/blob/main/INSTALL.md")
-                    new_lines.append("# - CUDA packages: Require CUDA toolkit and GPU environment")
-                    new_lines.append("#")
-                    for dep in problem_git_deps:
-                        if not dep.startswith("#"):
-                            new_lines.append(f"# {dep}")
-                        else:
-                            new_lines.append(dep)
-                    
-                    # 경고 메시지 출력
-                    yield f"⚠️ Commented out {len(problem_git_deps)} packages requiring special installation"
-                
-                # 빈 줄 제거하고 정리
-                final_lines = []
-                for i, line in enumerate(new_lines):
-                    # 주석 다음에 바로 내용이 있는지 확인
-                    if line.strip() and not (i > 0 and new_lines[i-1].startswith("#") and line == ""):
-                        final_lines.append(line)
-                    elif line == "" and i < len(new_lines) - 1:  # 중간의 빈 줄은 유지
-                        final_lines.append(line)
-                
-                req_path.write_text("\n".join(final_lines), encoding="utf-8")
-                
-                # 의존성 개수 통계
-                total_deps = len(torch_deps) + len(regular_deps) + len(git_deps) + len(problem_git_deps)
-                yield f"✅ Reorganized requirements.txt - Total {total_deps} dependencies (duplicates removed)"
-                if torch_deps:
-                    yield f"   - PyTorch packages: {len(torch_deps)}"
-                if regular_deps:
-                    yield f"   - Regular packages: {len(set(regular_deps))}"
-                if git_deps or problem_git_deps:
-                    yield f"   - Git dependencies: {len(git_deps + problem_git_deps)} ({len(problem_git_deps)} commented)"
-                
-                # pre-requirements.txt는 더 이상 필요하지 않음 (통합된 requirements.txt 사용)
-                # packages.txt도 HF Spaces 기본 환경에서는 불필요
-                
-                # README.md에 로컬 실행 가이드 추가
-                if problem_git_deps:
-                    readme_path = Path(folder) / "README.md"
-                    if readme_path.exists():
-                        try:
-                            existing_readme = readme_path.read_text(encoding="utf-8")
-                            
-                            # YAML 헤더 이후에 로컬 실행 가이드 추가
-                            if "---" in existing_readme:
-                                parts = existing_readme.split("---", 2)
-                                if len(parts) >= 3:
-                                    yaml_header = parts[1]
-                                    content = parts[2]
-                                    
-                                    # repo_id가 정의되지 않았으므로 repo_hf와 username 사용
-                                    repo_id = f"{username}/{slugify(repo_hf)}"
-                                    
-                                    local_guide = f"""
-## ⚠️ GPU/CUDA Requirements
-
-This project contains CUDA-dependent packages that cannot run on standard HuggingFace Spaces (CPU environment).
-
-### Running Locally with GPU
-
-```bash
-# Install CUDA Toolkit (if not installed)
-# Visit: https://developer.nvidia.com/cuda-downloads
-
-# Clone this Space
-git clone https://huggingface.co/spaces/{repo_id}
-cd {repo_id.split('/')[-1]}
-
-# Install PyTorch with CUDA
-pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118
-
-# Uncomment CUDA dependencies in requirements.txt
-# Then install all requirements
-pip install -r requirements.txt
-```
-
-### Enabling GPU on HuggingFace Spaces
-
-To use GPU on this Space:
-1. Go to Settings → Hardware
-2. Select GPU (T4 or A10G) 
-3. Costs apply for GPU usage
-
----
-
-"""
-                                    new_readme = f"---{yaml_header}---\n{local_guide}{content}"
-                                    readme_path.write_text(new_readme, encoding="utf-8")
-                                    yield "📝 Added GPU setup guide to README.md"
-                        except Exception as e:
-                            yield f"⚠️ Could not update README with GPU guide: {str(e)}"
-            except Exception as e:
-                yield f"⚠️ Error processing requirements.txt: {str(e)}"
-        
-        # Remove .git directory to save space and avoid issues
-        git_dir = os.path.join(folder, '.git')
-        if os.path.exists(git_dir):
-            shutil.rmtree(git_dir)
-            yield "🧹 Removed .git directory"
-        
-        # Also clean up .gitattributes to remove LFS tracking
-        gitattributes_path = os.path.join(folder, '.gitattributes')
-        if os.path.exists(gitattributes_path):
-            yield "🧹 Cleaning .gitattributes file..."
-            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:
-                # Remove empty .gitattributes
-                os.remove(gitattributes_path)
-        
-        # 기존 README가 있는지 확인하고 Space 헤더가 없으면 추가
-        readme_path = Path(folder) / "README.md"
-        if readme_path.exists():
-            try:
-                existing_content = readme_path.read_text(encoding="utf-8")
-                # YAML 헤더가 없으면 추가
-                if not existing_content.strip().startswith("---"):
-                    yaml_header = 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
----
-
-"""
-                    new_content = yaml_header + existing_content
-                    readme_path.write_text(new_content, encoding="utf-8")
-                    yield "✅ Updated README.md with Space configuration"
-            except Exception as e:
-                yield f"⚠️ Could not update README.md: {str(e)}"
-        
-        # Create the HuggingFace repo with retries
-        yield "🏗️ Creating Hugging Face Space..."
-        
-        repo_id = f"{username}/{slugify(repo_hf)}"
-        space_created = False
-        
-        # Space 생성 시도
-        for attempt in range(3):
-            try:
-                yield f"   Creating Space: {repo_id} (attempt {attempt + 1}/3)"
-                
-                # 먼저 기존 Space가 있는지 확인
-                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:
-                    # Space가 없으면 생성
-                    pass
-                
-                # Space 생성
-                create_result = api.create_repo(
-                    repo_id=repo_id,
-                    repo_type="space",
-                    space_sdk=sdk_type,
-                    exist_ok=True,
-                    private=False,
-                    token=hf_token
-                )
-                
-                # 생성 후 잠시 대기
-                import time
-                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)
-                
-                # Rate limit 에러 처리
-                if "429" in error_msg or "Too Many Requests" in error_msg:
-                    yield f"""
-❌ **Rate Limit Error**
-
-You have reached the HuggingFace API rate limit for creating Spaces.
-
-**What this means:**
-- New users have limited Space creation quotas
-- You need to wait before creating more Spaces (usually 17-24 hours)
-- Your limits will increase over time as you use HuggingFace
-
-**Solutions:**
-1. **Wait**: Try again in 17-24 hours
-2. **Use existing Space**: Update an existing Space instead of creating a new one
-3. **Contact HuggingFace**: Email [email protected] if you need immediate access
-4. **Alternative**: Create the Space manually on HuggingFace and upload the files
-
-**Manual Space Creation Steps:**
-1. Go to https://huggingface.co/new-space
-2. Create a Space named: `{repo_hf}`
-3. Select SDK: {sdk_type}
-4. After creation, use the "Files" tab to upload your repository contents
-
-Repository has been cloned to local folder and is ready for manual upload.
-"""
-                    # Rate limit의 경우 재시도하지 않음
-                    raise Exception(f"Rate limit reached. Please try again later or create the Space manually.")
-                
-                yield f"   ⚠️ Attempt {attempt + 1} failed: {error_msg[:100]}..."
-                if attempt < 2:
-                    yield "   Retrying in 5 seconds..."
-                    import time
-                    time.sleep(5)
-                else:
-                    yield f"   ❌ Failed to create space after 3 attempts"
-                    raise Exception(f"Could not create space: {error_msg}")
-        
-        if not space_created:
-            raise Exception("Failed to create space")
-        
-        # Check folder size
-        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)  # Size in MB
-        
-        yield f"📊 Folder size: {folder_size:.2f} MB"
-        
-        # Count remaining files
-        file_count = sum(len(files) for _, _, files in os.walk(folder))
-        yield f"📁 Total files to upload: {file_count}"
-        
-        # Upload to HuggingFace with retry logic
-        upload_success = False
-        max_retries = 3
-        
-        for attempt in range(max_retries):
-            try:
-                if attempt > 0:
-                    yield f"📤 Upload attempt {attempt + 1}/{max_retries}..."
-                    import time
-                    time.sleep(5)  # 재시도 전 대기
-                
-                if folder_size > 500:  # If larger than 500MB, use upload_large_folder
-                    yield "📤 Uploading large folder to Hugging Face (this may take several minutes)..."
-                    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). Space might not be ready yet."
-                    yield "   Waiting 10 seconds before retry..."
-                    import time
-                    time.sleep(10)
-                    
-                    # Space 다시 확인
-                    try:
-                        space_info = api.space_info(repo_id=repo_id, token=hf_token)
-                        yield f"   ✅ Space confirmed to exist"
-                    except:
-                        # Space 재생성 시도
-                        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"
-                    yield "🔍 Searching for remaining LFS pointers..."
-                    
-                    # Do another scan for LFS files
-                    lfs_count = 0
-                    for root, dirs, files in os.walk(folder):
-                        for file in files:
-                            filepath = os.path.join(root, file)
-                            if is_lfs_pointer_file(filepath):
-                                lfs_count += 1
-                                if lfs_count <= 5:  # 처음 5개만 표시
-                                    yield f"  Found LFS pointer: {filepath.replace(folder + os.sep, '')}"
-                    if lfs_count > 5:
-                        yield f"  ... and {lfs_count - 5} more LFS pointer files"
-                    raise upload_error
-                
-                elif attempt == max_retries - 1:
-                    yield f"❌ Upload failed after {max_retries} attempts: {error_msg[:200]}..."
-                    raise upload_error
-                else:
-                    yield f"   ⚠️ Upload failed: {error_msg[:100]}..."
-        
-        if not upload_success:
-            raise Exception("Upload failed after all retries")
-        
-        # Clean up the temporary folder
-        shutil.rmtree(folder)
-        
-        space_url = f"https://huggingface.co/spaces/{repo_id}"
-        
-        # 성공 메시지와 상세 정보 출력
-        yield f"""
-✅ **Successfully created Space!**
-
-🔗 **Your Space URL**: {space_url}
-
-📋 **Deployment Summary:**
-- **Space ID**: `{repo_id}`
-- **Source Repository**: {repo_git}
-- **SDK Type**: {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 visit your Space
-2. Wait 2-3 minutes for the initial build to complete
-3. Check the "Logs" tab if you encounter any issues
-4. The Space will automatically rebuild when you make changes
-
-💡 **Tips:**
-- If the build fails, check the requirements.txt file
-- For GPU-required projects, enable GPU in Space Settings
-- You can edit files directly in the Space's Files tab
-"""
-        
-        if skip_lfs:
-            yield "\n⚠️ **Note**: LFS files were removed. The Space may be missing some large files (videos, models, etc.)"
-        
-        if enable_smart_generation:
-            yield "\n🤖 **Smart Generation**: An AI-generated Gradio interface was created based on repository analysis"
-        
-        # 추가 안내사항
-        if any(dep.startswith("git+") for dep in analysis.get("dependencies", [])) if enable_smart_generation else False:
-            yield "\n⚠️ **Build Notice**: This repository contains git dependencies that may take longer to build"
-    
-    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)}"
-
-# Custom CSS for better styling
-css = """
-.container {
-    max-width: 900px;
-    margin: auto;
-    padding: 20px;
-}
-.output-box {
-    min-height: 100px;
-    max-height: 400px;
-    overflow-y: auto;
-    font-family: monospace;
-    font-size: 14px;
-    line-height: 1.5;
-}
-.warning-box {
-    background-color: #fff3cd;
-    border: 1px solid #ffeaa7;
-    border-radius: 4px;
-    padding: 12px;
-    margin: 10px 0;
-}
-.error-box {
-    background-color: #f8d7da;
-    border: 1px solid #f5c6cb;
-    border-radius: 4px;
-    padding: 12px;
-    margin: 10px 0;
-}
-.info-box {
-    background-color: #d1ecf1;
-    border: 1px solid #bee5eb;
-    border-radius: 4px;
-    padding: 12px;
-    margin: 10px 0;
-}
-"""
-
-with gr.Blocks(css=css) as demo:
-    gr.Markdown("# 🚀 Smart GitHub to Hugging Face Space Cloner")
-    gr.Markdown("""
-    Clone any public GitHub repository and convert it to a Hugging Face Space!
-    
-    **Features:**
-    - ✅ Automatic handling of Git LFS issues
-    - ✅ Removes problematic LFS pointer files
-    - ✅ Progress updates during cloning
-    - ✅ Support for large repositories
-    - 🤖 **NEW: Smart app.py generation with AI analysis**
-    """)
-    
-    # Check for HF_TOKEN
-    if not os.getenv("HF_TOKEN"):
-        gr.Markdown("""
-        <div class="error-box">
-        <strong>❌ HF_TOKEN Required</strong><br>
-        Please set the HF_TOKEN environment variable in your Space settings:
-        <ol>
-            <li>Go to your Space Settings</li>
-            <li>Navigate to "Variables and secrets"</li>
-            <li>Add a new secret: Name = <code>HF_TOKEN</code>, Value = your Hugging Face write token</li>
-            <li>Get a token from: <a href="https://huggingface.co/settings/tokens" target="_blank">https://huggingface.co/settings/tokens</a></li>
-        </ol>
-        </div>
-        """)
-    else:
-        gr.Markdown("""
-        <div class="info-box">
-        <strong>✅ HF_TOKEN Found</strong><br>
-        Ready to clone repositories to your Hugging Face account.
-        </div>
-        """)
-        
-        # Rate limit 경고 추가
-        gr.Markdown("""
-        <div class="warning-box">
-        <strong>⚠️ Rate Limits for New Users</strong><br>
-        New HuggingFace users have limited Space creation quotas:
-        <ul>
-            <li>You can create only a few Spaces per day initially</li>
-            <li>Limits increase over time with account activity</li>
-            <li>If you hit the limit, wait 17-24 hours or update existing Spaces</li>
-            <li>Contact [email protected] for immediate access needs</li>
-        </ul>
-        </div>
-        """)
-    
-    with gr.Row():
-        with gr.Column():
-            repo_git = gr.Textbox(
-                label="GitHub Repository URL",
-                placeholder="https://github.com/username/repository",
-                info="Enter the full URL of the GitHub repository"
-            )
-            repo_hf = gr.Textbox(
-                label="Hugging Face Space Name",
-                placeholder="my-awesome-space",
-                info="Choose a name for your new Space (will be slugified)"
-            )
-            sdk_choices = gr.Radio(
-                ["gradio", "streamlit", "docker", "static"],
-                label="Space SDK",
-                value="gradio",
-                info="Select the SDK type for your Space"
-            )
-            skip_lfs = gr.Checkbox(
-                label="Skip Git LFS files",
-                value=True,  # Default to True due to common LFS issues
-                info="Recommended if the repo has large files (videos, models, datasets)"
-            )
-            enable_smart_generation = gr.Checkbox(
-                label="🤖 Enable Smart app.py Generation (Beta)",
-                value=False,
-                info="Analyze repository and generate working Gradio interface with AI"
-            )
-            
-            gr.Markdown("""
-            <div class="warning-box">
-            <strong>⚠️ About Git LFS</strong><br>
-            Many repos use Git LFS for large files. If these files are missing or causing errors, 
-            keeping "Skip Git LFS files" checked will remove them and allow successful cloning.
-            </div>
-            """)
-            
-            # Smart Generation 정보
-            gr.Markdown("""
-            <div class="info-box">
-            <strong>🤖 About Smart Generation</strong><br>
-            When enabled, the system will:
-            <ul>
-                <li>Analyze repository structure and dependencies</li>
-                <li>Search for usage examples and documentation</li>
-                <li>Generate a working Gradio interface using AI</li>
-                <li>Create appropriate requirements.txt</li>
-            </ul>
-            <br>
-            <strong>Required Environment Variables:</strong><br>
-            - <code>OPENAI_API_KEY</code> or <code>FRIENDLI_TOKEN</code> for AI generation<br>
-            - <code>BAPI_TOKEN</code> for web search (optional)
-            </div>
-            """)
-            
-            btn = gr.Button("🎯 Clone Repository", variant="primary")
-            
-        with gr.Column():
-            output = gr.Textbox(
-                label="Progress",
-                lines=15,
-                elem_classes=["output-box"],
-                interactive=False,
-                show_copy_button=True
-            )
-    
-    gr.Markdown("""
-    ### 📝 Instructions:
-    1. **Setup**: Make sure HF_TOKEN is set in your Space settings
-    2. **Repository URL**: Enter the full GitHub repository URL
-    3. **Space Name**: Choose a name for your new Space
-    4. **SDK**: Select the appropriate SDK for your Space
-    5. **LFS Files**: Keep "Skip Git LFS files" checked if unsure
-    6. **Smart Generation**: Enable to automatically create working app.py
-    7. **Clone**: Click "Clone Repository" and monitor progress
-    
-    ### 🚨 Troubleshooting:
-    
-    <div class="error-box">
-    <strong>LFS pointer file errors?</strong><br>
-    Make sure "Skip Git LFS files" is checked. This removes large file pointers that can cause upload failures.
-    </div>
-    
-    - **Missing files after cloning**: The repository used Git LFS for large files that are no longer available
-    - **Slow uploads**: Large repositories take time. Consider using a smaller repository or removing unnecessary files
-    - **Space doesn't work**: Check if removed LFS files were essential (models, data, etc.) and add them manually
-    - **Smart Generation issues**: Make sure you have the required API keys set in environment variables
-    """)
-    
-    btn.click(
-        fn=clone,
-        inputs=[repo_git, repo_hf, sdk_choices, skip_lfs, enable_smart_generation],
-        outputs=output
-    )
-    
-    # 성공 사례 및 팁
-    gr.Markdown("""
-    ### 🌟 Success Tips:
-    
-    1. **For ML/AI Projects**: Enable GPU in Space Settings after deployment
-    2. **For Large Files**: Use Git LFS or host models on HuggingFace Hub
-    3. **For Complex Dependencies**: Check build logs and adjust requirements.txt
-    4. **For Private APIs**: Add secrets in Space Settings (Settings → Variables and secrets)
-    
-    ### 📊 Supported Project Types:
-    - 🤖 Machine Learning models (PyTorch, TensorFlow, Transformers)
-    - 🖼️ Computer Vision applications  
-    - 📝 NLP and text processing
-    - 🎵 Audio processing and generation
-    - 📈 Data visualization and analysis
-    - 🎮 Interactive demos and games
-    """)
-
-if __name__ == "__main__":
-    demo.launch()