Upload folder using huggingface_hub

code/huggingface/push.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import logging
 import os
+import re
 import tempfile
 import zipfile
 from pathlib import Path
@@ -17,6 +18,141 @@ from code.config.constants import MODEL_ID
 
 logger = logging.getLogger(__name__)
 
+# ─── Import-to-Package Mapping ──────────────────────────────────────────
+
+IMPORT_TO_PACKAGE: dict[str, str] = {
+    "gradio": "gradio>=4.0.0",
+    "flask": "flask>=3.0.0",
+    "django": "django>=4.2.0",
+    "fastapi": "fastapi>=0.100.0",
+    "uvicorn": "uvicorn>=0.23.0",
+    "streamlit": "streamlit>=1.28.0",
+    "matplotlib": "matplotlib>=3.8.0",
+    "PIL": "Pillow>=10.0.0",
+    "Pillow": "Pillow>=10.0.0",
+    "numpy": "numpy>=1.24.0",
+    "pandas": "pandas>=2.0.0",
+    "scipy": "scipy>=1.11.0",
+    "sklearn": "scikit-learn>=1.3.0",
+    "scikit_learn": "scikit-learn>=1.3.0",
+    "torch": "torch>=2.1.0",
+    "tensorflow": "tensorflow>=2.14.0",
+    "transformers": "transformers>=4.35.0",
+    "requests": "requests>=2.31.0",
+    "beautifulsoup4": "beautifulsoup4>=4.12.0",
+    "bs4": "beautifulsoup4>=4.12.0",
+    "selenium": "selenium>=4.15.0",
+    "sqlalchemy": "sqlalchemy>=2.0.0",
+    "pydantic": "pydantic>=2.0.0",
+    "httpx": "httpx>=0.25.0",
+    "aiohttp": "aiohttp>=3.9.0",
+    "opencv": "opencv-python-headless>=4.8.0",
+    "cv2": "opencv-python-headless>=4.8.0",
+    "plotly": "plotly>=5.18.0",
+    "seaborn": "seaborn>=0.13.0",
+    "wordcloud": "wordcloud>=1.9.0",
+    "networkx": "networkx>=3.2.0",
+    "sympy": "sympy>=1.12",
+    "Pillow": "Pillow>=10.0.0",
+    "skimage": "scikit-image>=0.21.0",
+    "soundfile": "soundfile>=0.12.0",
+    "pydub": "pydub>=0.25.1",
+    "moviepy": "moviepy>=1.0.3",
+    "openpyxl": "openpyxl>=3.1.0",
+    "xlsxwriter": "xlsxwriter>=3.1.0",
+    "python-docx": "python-docx>=0.8.11",
+    "docx": "python-docx>=0.8.11",
+    "reportlab": "reportlab>=4.0.0",
+    "jinja2": "jinja2>=3.1.0",
+    "wtforms": "wtforms>=3.1.0",
+    "flask_sqlalchemy": "flask-sqlalchemy>=3.1.0",
+    "flask_login": "flask-login>=0.6.0",
+    "flask_wtf": "flask-wtf>=1.2.0",
+    "flask_cors": "flask-cors>=4.0.0",
+}
+
+
+def _scan_imports(code: str) -> list[str]:
+    """Scan Python code for import statements and return package names."""
+    packages = set()
+
+    # Match: import xxx
+    for m in re.finditer(r"^\s*import\s+([a-zA-Z_][\w.]*)", code, re.MULTILINE):
+        top_level = m.group(1).split(".")[0]
+        packages.add(top_level)
+
+    # Match: from xxx import ...
+    for m in re.finditer(r"^\s*from\s+([a-zA-Z_][\w.]*)", code, re.MULTILINE):
+        top_level = m.group(1).split(".")[0]
+        packages.add(top_level)
+
+    return sorted(packages)
+
+
+def generate_requirements(code: str) -> str:
+    """Generate requirements.txt content from code by scanning imports.
+
+    Returns a newline-separated string of pip package specs.
+    """
+    packages = _scan_imports(code)
+    reqs: list[str] = []
+
+    for pkg in packages:
+        if pkg in IMPORT_TO_PACKAGE:
+            req_spec = IMPORT_TO_PACKAGE[pkg]
+            if req_spec not in reqs:
+                reqs.append(req_spec)
+        # Skip stdlib modules (os, sys, json, re, math, etc.)
+
+    # Always include gradio for Gradio apps if not already
+    if "import gradio" in code or "from gradio" in code:
+        if "gradio" not in [r.split(">=")[0].split("[")[0] for r in reqs]:
+            reqs.insert(0, "gradio>=4.0.0")
+
+    return "\n".join(reqs) + "\n" if reqs else ""
+
+
+def _find_entry_point(files: dict[str, str]) -> str:
+    """Find the main entry point file for a project.
+
+    Looks for app.py, main.py, or any Python file with a launcher pattern.
+    """
+    # Priority order for entry points
+    candidates = ["app.py", "main.py", "index.py", "server.py", "run.py"]
+    for c in candidates:
+        if c in files:
+            return c
+
+    # Look for any .py file with if __name__ == "__main__" or .launch()
+    for fname, content in files.items():
+        if fname.endswith(".py"):
+            if "__main__" in content or ".launch(" in content or "app.run(" in content:
+                return fname
+
+    # Fall back to first .py file
+    for fname in files:
+        if fname.endswith(".py"):
+            return fname
+
+    # Fall back to first file
+    return next(iter(files), "app.py")
+
+
+def _detect_sdk(files: dict[str, str], entry: str) -> str:
+    """Auto-detect the best Space SDK from the project files."""
+    all_code = "\n".join(files.values())
+
+    if "import streamlit" in all_code or "from streamlit" in all_code:
+        return "streamlit"
+    if "import gradio" in all_code or "from gradio" in all_code:
+        return "gradio"
+    if any(f.endswith(".html") for f in files):
+        return "static"
+    if entry.endswith(".py"):
+        return "gradio"  # Default Python to Gradio SDK
+
+    return "static"
+
 
 def create_project_zip(files: dict[str, str], project_name: str) -> str:
     """Create a ZIP file from extracted project files.
@@ -59,6 +195,14 @@ def push_to_huggingface(
             name = repo_name
             repo_name = f"{namespace}/{name}"
 
+        # Find entry point and auto-detect SDK
+        entry_point = _find_entry_point(files)
+        detected_sdk = _detect_sdk(files, entry_point)
+
+        # Use detected SDK if user left it as "static" but project is Python
+        if space_sdk == "static" and detected_sdk != "static":
+            space_sdk = detected_sdk
+
         try:
             if is_space:
                 create_repo(
@@ -79,12 +223,30 @@ def push_to_huggingface(
             logger.warning("Repo creation warning: %s", e)
 
         with tempfile.TemporaryDirectory(prefix="hf_push_") as tmp_dir:
+            # Write all project files
             for filepath, content in files.items():
                 full_path = os.path.join(tmp_dir, filepath)
                 os.makedirs(os.path.dirname(full_path), exist_ok=True)
                 Path(full_path).write_text(content, encoding="utf-8")
 
-            # Add README if not present
+            # Ensure the entry point is named app.py for HF Spaces
+            if entry_point != "app.py" and entry_point.endswith(".py") and is_space:
+                src = os.path.join(tmp_dir, entry_point)
+                dst = os.path.join(tmp_dir, "app.py")
+                if os.path.exists(src) and not os.path.exists(dst):
+                    import shutil
+                    shutil.copy2(src, dst)
+
+            # Determine app_file for README
+            app_file = "app.py" if is_space and space_sdk in ("gradio", "streamlit") else entry_point
+            if is_space and space_sdk == "static":
+                # For static spaces, look for index.html
+                if "index.html" in files:
+                    app_file = "index.html"
+                elif any(f.endswith(".html") for f in files):
+                    app_file = next(f for f in files if f.endswith(".html"))
+
+            # Add README.md if not present
             readme_path = os.path.join(tmp_dir, "README.md")
             if not os.path.exists(readme_path):
                 readme_content = f"""---
@@ -93,7 +255,8 @@ emoji: 🚀
 colorFrom: blue
 colorTo: purple
 sdk: {space_sdk}
-app_file: app.py
+app_file: {app_file}
+pinned: false
 ---
 
 # {name}
@@ -101,23 +264,49 @@ app_file: app.py
 Generated by Fullstack Code Builder using {MODEL_ID}.
 """
                 Path(readme_path).write_text(readme_content, encoding="utf-8")
+            else:
+                # Update app_file in existing README to match entry point
+                existing = Path(readme_path).read_text(encoding="utf-8")
+                if "app_file:" in existing:
+                    existing = re.sub(
+                        r"app_file:\s*\S+", f"app_file: {app_file}", existing
+                    )
+                if "sdk:" in existing:
+                    existing = re.sub(
+                        r"sdk:\s*\S+", f"sdk: {space_sdk}", existing
+                    )
+                Path(readme_path).write_text(existing, encoding="utf-8")
 
-            # Add requirements.txt for Python/Gradio projects
+            # Add/merge requirements.txt for Python projects
             req_path = os.path.join(tmp_dir, "requirements.txt")
-            if not os.path.exists(req_path):
-                has_python = any(f.endswith(".py") for f in files.keys())
-                if has_python:
-                    reqs = ["gradio>=4.0.0"]
-                    all_code = "\n".join(files.values())
-                    if "matplotlib" in all_code:
-                        reqs.append("matplotlib>=3.8")
-                    if "PIL" in all_code or "Pillow" in all_code:
-                        reqs.append("Pillow>=10.0")
-                    if "numpy" in all_code:
-                        reqs.append("numpy>=1.24")
-                    if "pandas" in all_code:
-                        reqs.append("pandas>=2.0")
-                    Path(req_path).write_text("\n".join(reqs) + "\n", encoding="utf-8")
+            has_python = any(f.endswith(".py") for f in files.keys())
+
+            if has_python:
+                # Scan all Python code for imports
+                all_py_code = "\n".join(
+                    content for fname, content in files.items()
+                    if fname.endswith(".py")
+                )
+                auto_reqs = generate_requirements(all_py_code)
+
+                if os.path.exists(req_path):
+                    # Merge with existing requirements.txt
+                    existing_reqs = Path(req_path).read_text(encoding="utf-8").strip()
+                    merged = set()
+                    for line in (existing_reqs + "\n" + auto_reqs).splitlines():
+                        line = line.strip()
+                        if line and not line.startswith("#"):
+                            # Normalize: take the package name (before >=, ==, etc.)
+                            pkg_name = re.split(r"[><=!~]", line)[0].strip().lower()
+                            # Keep the more specific version spec
+                            merged.add(line)
+
+                    Path(req_path).write_text("\n".join(sorted(merged)) + "\n", encoding="utf-8")
+                elif auto_reqs:
+                    Path(req_path).write_text(auto_reqs, encoding="utf-8")
+                else:
+                    # Minimal requirements for Python Spaces
+                    Path(req_path).write_text("gradio>=4.0.0\n", encoding="utf-8")
 
             api.upload_folder(
                 folder_path=tmp_dir,

code/server/routes.py

@@ -406,7 +406,22 @@ def handle_chat(
 
     # Register code for download
     download_url = None
-    project_files = multi_files if multi_files else {}
+    project_files = dict(multi_files) if multi_files else {}
+
+    # Rename main.py → app.py for Python/Gradio projects (HF Spaces expects app.py)
+    if project_files and "main.py" in project_files and "app.py" not in project_files:
+        if target == "python" or is_gradio:
+            project_files["app.py"] = project_files.pop("main.py")
+
+    # If project_files is empty but we have single code, add it
+    if not project_files and code:
+        if target == "python":
+            fname = "app.py" if (is_gradio or is_gradio_code(code)) else "main.py"
+        elif target in {"web", "html", "javascript"}:
+            fname = "index.html"
+        else:
+            fname = f"main.{fence_lang or 'txt'}"
+        project_files = {fname: code}
 
     if project_files:
         project_name = "generated-project"
@@ -466,23 +481,16 @@ def handle_push_hf(
     """Push generated project to HuggingFace Hub."""
     try:
         execution_context = json.loads(exec_context_json) if exec_context_json else {}
-        project_files = execution_context.get("project_files", {})
-
-        if not project_files:
-            code = execution_context.get("code", "")
-            if not code:
-                yield json.dumps({
-                    "success": False,
-                    "message": "No code to push. Generate some code first.",
-                    "url": "",
-                })
-                return
+        project_files = dict(execution_context.get("project_files", {}) or {})
+        code = execution_context.get("code", "")
 
+        # If project_files is empty but we have code, build files from code
+        if not project_files and code:
             lang = execution_context.get("language", "python")
             is_gradio = execution_context.get("is_gradio", False)
             ext_map = {
                 "python": "app.py", "py": "app.py",
-                "javascript": "index.js", "js": "index.js",
+                "javascript": "index.html", "js": "index.html",
                 "html": "index.html", "web": "index.html",
                 "typescript": "index.ts", "ts": "index.ts",
             }
@@ -493,6 +501,18 @@ def handle_push_hf(
             if is_gradio or is_gradio_code(code):
                 space_sdk = "gradio"
 
+        # If still no files, try extracting from the raw response
+        if not project_files and code:
+            project_files = extract_multi_file(code)
+
+        if not project_files:
+            yield json.dumps({
+                "success": False,
+                "message": "No code to push. Generate some code first.",
+                "url": "",
+            })
+            return
+
         project_name = repo_name.split("/")[-1] if "/" in repo_name else repo_name
 
         result = push_to_huggingface(