Add GitHub to HF Spaces importer app

app.py

@@ -0,0 +1,316 @@
+import gradio as gr
+import subprocess
+import tempfile
+import shutil
+import os
+import re
+from huggingface_hub import HfApi
+
+
+def validate_github_url(url):
+    """Validate and normalize GitHub URL."""
+    url = url.strip()
+    pattern = r"^https?://github\.com/[\w\-\.]+/[\w\-\.]+(/.*)?$"
+    if not re.match(pattern, url):
+        return None
+    # Remove trailing .git and slashes
+    url = re.sub(r"\.git$", "", url)
+    url = url.rstrip("/")
+    return url
+
+
+def extract_repo_name(github_url):
+    """Extract owner/repo from GitHub URL."""
+    parts = github_url.rstrip("/").split("/")
+    if len(parts) >= 5:
+        return parts[3], parts[4].replace(".git", "")
+    return None, None
+
+
+def detect_sdk(tmpdir):
+    """Auto-detect the best SDK for the project."""
+    files = os.listdir(tmpdir)
+    filenames_lower = [f.lower() for f in files]
+
+    # Check for Dockerfile
+    if "dockerfile" in filenames_lower or "Dockerfile" in files:
+        return "docker"
+
+    # Check for Gradio
+    for root, dirs, fnames in os.walk(tmpdir):
+        for fname in fnames:
+            if fname.endswith(".py"):
+                try:
+                    content = open(os.path.join(root, fname), "r", errors="replace").read()
+                    if "import gradio" in content or "from gradio" in content:
+                        return "gradio"
+                    if "import streamlit" in content or "from streamlit" in content:
+                        return "streamlit"
+                except:
+                    pass
+
+    # Check requirements.txt
+    req_path = os.path.join(tmpdir, "requirements.txt")
+    if os.path.exists(req_path):
+        try:
+            reqs = open(req_path, "r").read().lower()
+            if "gradio" in reqs:
+                return "gradio"
+            if "streamlit" in reqs:
+                return "streamlit"
+        except:
+            pass
+
+    # Check for static site files
+    if "index.html" in filenames_lower:
+        return "static"
+
+    return "gradio"  # Default
+
+
+def list_files_preview(tmpdir, max_files=50):
+    """Create a file tree preview."""
+    lines = []
+    count = 0
+    for root, dirs, files in os.walk(tmpdir):
+        # Skip hidden dirs
+        dirs[:] = [d for d in dirs if not d.startswith(".")]
+        level = root.replace(tmpdir, "").count(os.sep)
+        indent = "  " * level
+        dirname = os.path.basename(root)
+        if level > 0:
+            lines.append(f"{indent}📁 {dirname}/")
+        for f in sorted(files):
+            if count >= max_files:
+                lines.append(f"\n... and more files (showing first {max_files})")
+                return "\n".join(lines)
+            file_indent = "  " * (level + 1)
+            fpath = os.path.join(root, f)
+            size = os.path.getsize(fpath)
+            size_str = f"{size / 1024:.1f}KB" if size > 1024 else f"{size}B"
+            lines.append(f"{file_indent}📄 {f} ({size_str})")
+            count += 1
+    return "\n".join(lines) if lines else "(empty repository)"
+
+
+def import_github_to_hf(github_url, hf_space_id, sdk_choice, hf_token, private, branch):
+    """Clone a GitHub repo and push it to a Hugging Face Space."""
+    # Validate inputs
+    if not github_url or not github_url.strip():
+        yield "❌ Please enter a GitHub repository URL.", ""
+        return
+
+    github_url = validate_github_url(github_url)
+    if github_url is None:
+        yield "❌ Invalid GitHub URL. Expected format: `https://github.com/owner/repo`", ""
+        return
+
+    if not hf_token or not hf_token.strip():
+        yield "❌ Please enter your Hugging Face token.", ""
+        return
+
+    owner, repo_name = extract_repo_name(github_url)
+    if not owner or not repo_name:
+        yield "❌ Could not parse owner/repo from URL.", ""
+        return
+
+    # Default space name
+    if not hf_space_id or not hf_space_id.strip():
+        try:
+            api = HfApi(token=hf_token.strip())
+            user_info = api.whoami()
+            username = user_info.get("name", user_info.get("user", "user"))
+            hf_space_id = f"{username}/{repo_name}"
+        except Exception as e:
+            yield f"❌ Could not determine your HF username: {e}", ""
+            return
+
+    hf_space_id = hf_space_id.strip()
+
+    yield f"🔄 **Step 1/4:** Cloning `{github_url}`...", ""
+
+    # Clone
+    tmpdir = tempfile.mkdtemp()
+    try:
+        clone_cmd = ["git", "clone", "--depth=1"]
+        if branch and branch.strip():
+            clone_cmd += ["-b", branch.strip()]
+        clone_cmd += [github_url, tmpdir]
+
+        result = subprocess.run(
+            clone_cmd,
+            capture_output=True, text=True, timeout=120,
+        )
+        if result.returncode != 0:
+            yield f"❌ Git clone failed:\n```\n{result.stderr}\n```", ""
+            return
+
+        # Remove .git directory
+        git_dir = os.path.join(tmpdir, ".git")
+        if os.path.exists(git_dir):
+            shutil.rmtree(git_dir)
+
+        # File preview
+        file_tree = list_files_preview(tmpdir)
+
+        yield f"✅ **Step 1/4:** Cloned successfully.\n🔄 **Step 2/4:** Detecting SDK...", f"```\n{file_tree}\n```"
+
+        # Detect or use chosen SDK
+        if sdk_choice == "auto-detect":
+            detected_sdk = detect_sdk(tmpdir)
+            sdk_to_use = detected_sdk
+            sdk_msg = f"Auto-detected: **{detected_sdk}**"
+        else:
+            sdk_to_use = sdk_choice
+            sdk_msg = f"Using selected: **{sdk_choice}**"
+
+        yield (
+            f"✅ **Step 1/4:** Cloned successfully.\n"
+            f"✅ **Step 2/4:** {sdk_msg}\n"
+            f"🔄 **Step 3/4:** Creating Space `{hf_space_id}`...",
+            f"```\n{file_tree}\n```"
+        )
+
+        # Create Space
+        api = HfApi(token=hf_token.strip())
+        try:
+            api.create_repo(
+                repo_id=hf_space_id,
+                repo_type="space",
+                space_sdk=sdk_to_use,
+                private=private,
+                exist_ok=True,
+            )
+        except Exception as e:
+            yield f"❌ Failed to create Space: {e}", f"```\n{file_tree}\n```"
+            return
+
+        yield (
+            f"✅ **Step 1/4:** Cloned successfully.\n"
+            f"✅ **Step 2/4:** {sdk_msg}\n"
+            f"✅ **Step 3/4:** Space created.\n"
+            f"🔄 **Step 4/4:** Uploading files to `{hf_space_id}`...",
+            f"```\n{file_tree}\n```"
+        )
+
+        # Upload
+        try:
+            api.upload_folder(
+                folder_path=tmpdir,
+                repo_id=hf_space_id,
+                repo_type="space",
+                commit_message=f"Import from {github_url}",
+                ignore_patterns=[
+                    "*.pyc", "__pycache__/", ".git/", ".gitignore",
+                    ".env", ".env.*", "*.log", ".DS_Store", "node_modules/",
+                ],
+            )
+        except Exception as e:
+            yield f"❌ Failed to upload files: {e}", f"```\n{file_tree}\n```"
+            return
+
+        space_url = f"https://huggingface.co/spaces/{hf_space_id}"
+
+        yield (
+            f"## ✅ Import Complete!\n\n"
+            f"| Detail | Value |\n"
+            f"|--------|-------|\n"
+            f"| **Source** | [{github_url}]({github_url}) |\n"
+            f"| **Space** | [{hf_space_id}]({space_url}) |\n"
+            f"| **SDK** | {sdk_to_use} |\n"
+            f"| **Visibility** | {'Private 🔒' if private else 'Public 🌍'} |\n\n"
+            f"🔗 **[Open your Space →]({space_url})**",
+            f"```\n{file_tree}\n```"
+        )
+
+    except subprocess.TimeoutExpired:
+        yield "❌ Git clone timed out after 120 seconds. The repository may be too large.", ""
+    except Exception as e:
+        yield f"❌ Unexpected error: {e}", ""
+    finally:
+        if os.path.exists(tmpdir):
+            shutil.rmtree(tmpdir, ignore_errors=True)
+
+
+# ─── Gradio UI ───────────────────────────────────────────
+
+with gr.Blocks(
+    title="🚀 GitHub → HF Spaces Importer",
+    theme=gr.themes.Soft(),
+) as demo:
+    gr.Markdown("""
+# 🚀 GitHub → Hugging Face Spaces Importer
+
+Import any public GitHub repository directly into a Hugging Face Space. 
+The tool clones the repo, auto-detects the SDK, creates the Space, and uploads all files.
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            github_url_input = gr.Textbox(
+                label="GitHub Repository URL",
+                placeholder="https://github.com/owner/repo",
+                info="Public GitHub repository URL",
+            )
+        with gr.Column(scale=1):
+            branch_input = gr.Textbox(
+                label="Branch (optional)",
+                placeholder="main",
+                info="Leave empty for default branch",
+            )
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            space_id_input = gr.Textbox(
+                label="HF Space ID (optional)",
+                placeholder="your-username/space-name",
+                info="Leave empty to auto-generate from repo name",
+            )
+        with gr.Column(scale=1):
+            sdk_dropdown = gr.Dropdown(
+                choices=["auto-detect", "gradio", "streamlit", "docker", "static"],
+                value="auto-detect",
+                label="Space SDK",
+                info="Auto-detect scans for framework imports",
+            )
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            token_input = gr.Textbox(
+                label="Hugging Face Token",
+                type="password",
+                placeholder="hf_...",
+                info="Needs write access. Get one at huggingface.co/settings/tokens",
+            )
+        with gr.Column(scale=1):
+            private_checkbox = gr.Checkbox(
+                label="Private Space",
+                value=False,
+            )
+
+    import_btn = gr.Button("🚀 Import to Hugging Face Spaces", variant="primary", size="lg")
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            status_output = gr.Markdown(label="Status")
+        with gr.Column(scale=1):
+            files_output = gr.Markdown(label="Repository Files")
+
+    gr.Markdown("""
+---
+### ℹ️ Notes
+- Only **public** GitHub repositories are supported (no authentication for GitHub).
+- Your HF token needs **write** permissions to create Spaces.
+- Large repositories may take longer to clone and upload.
+- The `.git` directory and common non-essential files (`.env`, `node_modules`, etc.) are excluded.
+- SDK auto-detection checks for Gradio/Streamlit imports, Dockerfiles, and `index.html`.
+    """)
+
+    import_btn.click(
+        fn=import_github_to_hf,
+        inputs=[github_url_input, space_id_input, sdk_dropdown, token_input, private_checkbox, branch_input],
+        outputs=[status_output, files_output],
+    )
+
+if __name__ == "__main__":
+    demo.launch()