Upload 10 files

src/jobs.py

@@ -16,6 +16,21 @@ from .worker_payload import (
 
 SPACE_SLUG_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{1,95}$")
 
+AUTO_SPACE_HARDWARE_CHOICES = {"zero-a10g", "cpu-basic", "t4-small", "t4-medium", "a10g-small", "a10g-large", "l4x1", "l40sx1"}
+DEFAULT_PREFERRED_SPACE_HARDWARE = "zero-a10g"
+DEFAULT_FALLBACK_SPACE_HARDWARE = "a10g-large"
+
+def normalize_auto_space_hardware(value: str | None, *, default: str) -> str:
+    """Return a hardware flavor safe for automatic Space fallback.
+
+    Expensive or restricted tiers such as A100/H200 are intentionally not used
+    by the automatic fallback path. Users can still select them manually in the
+    generated Space settings if their account or organization is allowed to.
+    """
+    candidate = (value or default).strip()
+    return candidate if candidate in AUTO_SPACE_HARDWARE_CHOICES else default
+
+
 
 def _base_env(*, run_id: str, username: str, bucket_source: str, worker_script_b64: str) -> dict[str, str]:
     return {
@@ -141,8 +156,8 @@ def launch_universal_model_card_job(
     env["TARGET_SPACE_ID"] = target_space_id
     env["MODEL_ID"] = clean_model_id
     env["PI_MODEL"] = (pi_model or "Qwen/Qwen3-Coder-Next").strip()
-    env["PREFERRED_SPACE_HARDWARE"] = (preferred_space_hardware or "zero-a10g").strip()
-    env["FALLBACK_SPACE_HARDWARE"] = (fallback_space_hardware or "l40sx1").strip()
+    env["PREFERRED_SPACE_HARDWARE"] = normalize_auto_space_hardware(preferred_space_hardware, default=DEFAULT_PREFERRED_SPACE_HARDWARE)
+    env["FALLBACK_SPACE_HARDWARE"] = normalize_auto_space_hardware(fallback_space_hardware, default=DEFAULT_FALLBACK_SPACE_HARDWARE)
     env["ALLOW_FIXED_GPU_FALLBACK"] = "true" if allow_fixed_gpu_fallback else "false"
     env["IMPLEMENTATION_MODE"] = (implementation_mode or "full-inference-gated").strip()
     env["EXPECTED_OUTPUT_TYPE"] = (expected_output_type or "any").strip()

src/model_scan.py

@@ -0,0 +1,351 @@
+from __future__ import annotations
+
+import json
+import re
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from huggingface_hub import HfApi, hf_hub_download
+
+MODEL_ID_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*$")
+SMALL_CONFIG_MAX_BYTES = 2_000_000
+WEIGHT_EXTENSIONS = (".safetensors", ".bin", ".pt", ".pth", ".ckpt", ".onnx", ".gguf")
+RISKY_SERIALIZATION_EXTENSIONS = (".bin", ".pt", ".pth", ".ckpt", ".pkl", ".pickle", ".joblib")
+PYTHON_EXTENSIONS = (".py",)
+DIFFUSERS_EXAMPLE_RE = re.compile(r"(from\s+diffusers\s+import|DiffusionPipeline\.from_pretrained|AutoPipelineFor(?:Text2Image|Image2Image|Inpainting)\.from_pretrained|StableDiffusion(?:XL)?Pipeline\.from_pretrained|FluxPipeline\.from_pretrained|ZImagePipeline)", re.IGNORECASE)
+GENERIC_INFERENCE_EXAMPLE_RE = re.compile(r"(from_pretrained\s*\(|gradio_client|pipeline\s*\(|pipe\s*\(|predict\s*\()", re.IGNORECASE)
+DIFFUSERS_PIPELINE_CLASSES = {
+    "DiffusionPipeline",
+    "StableDiffusionPipeline",
+    "StableDiffusionXLPipeline",
+    "StableDiffusionImg2ImgPipeline",
+    "StableDiffusionInpaintPipeline",
+    "AutoPipelineForText2Image",
+    "AutoPipelineForImage2Image",
+    "AutoPipelineForInpainting",
+    "FluxPipeline",
+    "ZImagePipeline",
+}
+
+
+def normalize_model_id(value: str | None) -> str:
+    cleaned = (value or "").strip()
+    cleaned = cleaned.replace("https://huggingface.co/", "")
+    cleaned = cleaned.split("?", 1)[0].split("#", 1)[0].strip("/")
+    if not MODEL_ID_RE.match(cleaned):
+        raise ValueError("Model ID must look like owner/name or a Hugging Face model URL.")
+    return cleaned
+
+
+def _get(obj: Any, name: str, default: Any = None) -> Any:
+    if isinstance(obj, dict):
+        return obj.get(name, default)
+    return getattr(obj, name, default)
+
+
+def _sibling_name(sibling: Any) -> str:
+    return str(_get(sibling, "rfilename", _get(sibling, "path", _get(sibling, "name", ""))) or "")
+
+
+def _sibling_size(sibling: Any) -> int | None:
+    value = _get(sibling, "size", None)
+    try:
+        return int(value) if value is not None else None
+    except Exception:
+        return None
+
+
+def _read_small_json(repo_id: str, filename: str, *, token: str | None, max_bytes: int = SMALL_CONFIG_MAX_BYTES) -> dict[str, Any]:
+    try:
+        with tempfile.TemporaryDirectory(prefix="asf-model-scan-") as tmp:
+            path = hf_hub_download(repo_id=repo_id, filename=filename, repo_type="model", token=token, local_dir=tmp)
+            p = Path(path)
+            if p.stat().st_size > max_bytes:
+                return {}
+            return json.loads(p.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def _read_small_text(repo_id: str, filename: str, *, token: str | None, max_bytes: int = SMALL_CONFIG_MAX_BYTES) -> str:
+    try:
+        with tempfile.TemporaryDirectory(prefix="asf-model-scan-") as tmp:
+            path = hf_hub_download(repo_id=repo_id, filename=filename, repo_type="model", token=token, local_dir=tmp)
+            p = Path(path)
+            if p.stat().st_size > max_bytes:
+                return ""
+            return p.read_text(encoding="utf-8", errors="replace")
+    except Exception:
+        return ""
+
+
+def _model_index_pipeline_class(model_index: dict[str, Any]) -> str:
+    value = model_index.get("_class_name") or model_index.get("pipeline_class") or ""
+    return str(value or "")
+
+
+def _extract_model_card_signals(readme: str, model_index: dict[str, Any]) -> dict[str, Any]:
+    text = readme or ""
+    diffusers_example = bool(DIFFUSERS_EXAMPLE_RE.search(text))
+    inference_example = diffusers_example or bool(GENERIC_INFERENCE_EXAMPLE_RE.search(text))
+    pipeline_class = _model_index_pipeline_class(model_index)
+    if not pipeline_class and text:
+        for name in sorted(DIFFUSERS_PIPELINE_CLASSES, key=len, reverse=True):
+            if name in text:
+                pipeline_class = name
+                break
+    runtime_hints = []
+    lower = text.lower()
+    for label, patterns in [
+        ("bfloat16", ("bfloat16", "bf16")),
+        ("float16", ("float16", "fp16")),
+        ("device_map", ("device_map",)),
+        ("cuda", ("cuda", ".to(\"cuda\")", ".to('cuda')")),
+        ("offload", ("offload", "enable_model_cpu_offload")),
+        ("num_inference_steps", ("num_inference_steps", "inference steps")),
+    ]:
+        if any(p in lower for p in patterns):
+            runtime_hints.append(label)
+    return {
+        "has_inference_example": inference_example,
+        "has_diffusers_example": diffusers_example,
+        "pipeline_class": pipeline_class,
+        "runtime_hints": runtime_hints[:8],
+    }
+
+
+def _classify(score: int, *, blocking: bool = False) -> str:
+    if blocking:
+        return "unsupported"
+    if score >= 75:
+        return "safe"
+    if score >= 45:
+        return "caution"
+    return "risky"
+
+
+def analyze_model_metadata(
+    *,
+    model_id: str,
+    pipeline_tag: str | None = None,
+    library_name: str | None = None,
+    tags: list[str] | None = None,
+    siblings: list[Any] | None = None,
+    gated: Any = None,
+    private: Any = None,
+    card_data: dict[str, Any] | None = None,
+    config: dict[str, Any] | None = None,
+    model_index: dict[str, Any] | None = None,
+    readme: str | None = None,
+) -> dict[str, Any]:
+    """Pure heuristic model-card scan used by the API and tests.
+
+    It intentionally does not claim to be a security scanner. It summarizes
+    common signals that predict whether an autonomous Space build is likely to
+    be safe, supported, and worth spending compute on.
+    """
+    tags = [str(t) for t in (tags or []) if t]
+    files = [_sibling_name(s) for s in (siblings or []) if _sibling_name(s)]
+    lower_files = [f.lower() for f in files]
+    config = config or {}
+    model_index = model_index or {}
+    readme = readme or ""
+    card_signals = _extract_model_card_signals(readme, model_index)
+    has_inference_example = bool(card_signals["has_inference_example"])
+    has_diffusers_example = bool(card_signals["has_diffusers_example"])
+    pipeline_class = str(card_signals["pipeline_class"] or "")
+    runtime_hints = list(card_signals["runtime_hints"] or [])
+
+    score = 50
+    good: list[str] = []
+    risk: list[str] = []
+    recommendations: list[str] = []
+
+    has_safetensors = any(f.endswith(".safetensors") for f in lower_files)
+    has_risky_serialization = any(f.endswith(RISKY_SERIALIZATION_EXTENSIONS) for f in lower_files)
+    has_weight_file = any(f.endswith(WEIGHT_EXTENSIONS) for f in lower_files)
+    has_python = any(f.endswith(PYTHON_EXTENSIONS) for f in lower_files)
+    has_config = "config.json" in lower_files
+    has_model_index = "model_index.json" in lower_files
+    has_readme = bool(readme.strip()) or any(f in {"readme.md", "README.md".lower()} for f in lower_files)
+    custom_code = bool(config.get("auto_map")) or "custom_code" in tags or "trust_remote_code" in tags or has_python
+
+    if pipeline_tag:
+        score += 12
+        good.append(f"Pipeline tag detected: {pipeline_tag}.")
+    else:
+        score -= 12
+        risk.append("No pipeline tag detected; task type may be ambiguous for an autonomous builder.")
+
+    if library_name:
+        score += 10
+        good.append(f"Library detected: {library_name}.")
+    elif model_index:
+        score += 6
+        good.append("Diffusers-style model_index.json detected.")
+    else:
+        score -= 8
+        risk.append("No library metadata detected.")
+
+    if has_safetensors:
+        score += 18
+        good.append("Safetensors weights are available.")
+    elif has_weight_file:
+        score -= 10
+        risk.append("No safetensors file detected; weights may use less safe or less portable formats.")
+    else:
+        score -= 18
+        risk.append("No obvious model weight file detected in the repository listing.")
+
+    if has_risky_serialization:
+        score -= 14
+        risk.append("Repository includes pickle-like or PyTorch pickle serialization files (.bin/.pt/.pth/.ckpt/.pkl).")
+
+    if custom_code:
+        score -= 22
+        risk.append("Custom code or trust_remote_code is likely required.")
+        recommendations.append("Review code manually before using Strict inference or paid hardware.")
+
+    if gated in {True, "auto", "manual"} or str(gated).lower() in {"true", "auto", "manual"}:
+        score -= 18
+        risk.append("Model appears gated; the Job may fail unless the signed-in account has accepted access terms.")
+        recommendations.append("Confirm model access with the same Hugging Face account before launching.")
+
+    if private:
+        score -= 8
+        risk.append("Model is private; ensure the OAuth token has access.")
+
+    if has_config or has_model_index:
+        score += 8
+        good.append("Standard config metadata is present.")
+    else:
+        score -= 8
+        risk.append("No config.json or model_index.json detected.")
+
+    is_diffusers = (library_name or "").lower() == "diffusers" or "diffusers" in {t.lower() for t in tags} or bool(model_index)
+    if is_diffusers and has_model_index:
+        score += 8
+        good.append("Diffusers repository structure detected.")
+    if pipeline_class:
+        score += 5
+        good.append(f"Pipeline class detected: {pipeline_class}.")
+    if has_diffusers_example:
+        score += 12
+        good.append("Model card includes a runnable Diffusers example.")
+    elif has_inference_example:
+        score += 7
+        good.append("Model card includes an inference example.")
+    elif has_readme:
+        score -= 5
+        risk.append("No clear runnable inference example found in the model card.")
+    if runtime_hints:
+        score += 4
+        good.append("Model card provides runtime hints: " + ", ".join(runtime_hints) + ".")
+
+    if has_readme and len(readme.strip()) > 400:
+        score += 6
+        good.append("Model card documentation is present.")
+    elif not has_readme:
+        score -= 8
+        risk.append("README/model card appears missing.")
+    else:
+        score -= 4
+        risk.append("Model card documentation appears very short.")
+
+    task = (pipeline_tag or "").lower()
+    library = (library_name or "").lower()
+    unsupported = False
+    if task in {"reinforcement-learning", "robotics"}:
+        unsupported = True
+        risk.append(f"Task '{pipeline_tag}' is not a good fit for automatic Gradio Space generation.")
+    if "gguf" in tags or any(f.endswith(".gguf") for f in lower_files):
+        score -= 10
+        risk.append("GGUF assets may need a custom llama.cpp runtime rather than the standard Transformers/Diffusers path.")
+    if library in {"adapter-transformers"}:
+        score -= 8
+        risk.append(f"Library '{library_name}' may require custom integration.")
+
+    # A clear Diffusers model card with safetensors and a runnable example is a strong
+    # positive signal. Do not downgrade it just because the model may be large; size
+    # affects hardware planning, not whether the card is healthy for autonomous build.
+    if is_diffusers and has_safetensors and has_diffusers_example and has_model_index and not custom_code and not unsupported:
+        score = max(score, 82)
+
+    score = max(0, min(100, score))
+    verdict = _classify(score, blocking=unsupported)
+    if not recommendations:
+        if verdict == "safe":
+            recommendations.append("Good candidate for Strict inference.")
+        elif verdict == "caution":
+            recommendations.append("Use Best effort inference if the model card lacks a clear runnable example.")
+        elif verdict == "risky":
+            recommendations.append("Prefer Best effort or Demo scaffold until the risky signals are reviewed.")
+        else:
+            recommendations.append("Do not launch automatically; inspect manually first.")
+
+    return {
+        "ok": True,
+        "model_id": model_id,
+        "verdict": verdict,
+        "score": score,
+        "summary": {
+            "safe": "Looks like a good candidate for an autonomous build.",
+            "caution": "Usable, but review the caution signals before spending compute.",
+            "risky": "Risky for an autonomous paid build; review before launching.",
+            "unsupported": "Not a good fit for the automated builder.",
+        }[verdict],
+        "good_signals": good[:8],
+        "risk_signals": risk[:10],
+        "recommendations": recommendations[:6],
+        "metadata": {
+            "pipeline_tag": pipeline_tag or "",
+            "library_name": library_name or "",
+            "tags": tags[:30],
+            "gated": gated,
+            "private": bool(private),
+            "file_count": len(files),
+            "has_safetensors": has_safetensors,
+            "has_risky_serialization": has_risky_serialization,
+            "has_custom_code_signal": custom_code,
+            "has_inference_example": has_inference_example,
+            "has_diffusers_example": has_diffusers_example,
+            "pipeline_class": pipeline_class,
+            "runtime_hints": runtime_hints,
+            "diffusers_standard": bool(is_diffusers and has_model_index and has_safetensors),
+        },
+    }
+
+
+def scan_model_card(model_id_or_url: str, *, token: str | None = None) -> dict[str, Any]:
+    model_id = normalize_model_id(model_id_or_url)
+    api = HfApi(token=token)
+    try:
+        info = api.model_info(model_id, files_metadata=True, token=token)
+    except TypeError:
+        info = api.model_info(model_id, token=token)
+
+    siblings = list(_get(info, "siblings", []) or [])
+    files = {_sibling_name(s).lower(): s for s in siblings if _sibling_name(s)}
+    config = _read_small_json(model_id, "config.json", token=token) if "config.json" in files else {}
+    model_index = _read_small_json(model_id, "model_index.json", token=token) if "model_index.json" in files else {}
+    readme = _read_small_text(model_id, "README.md", token=token) if "readme.md" in files else ""
+    card_data = _get(info, "card_data", _get(info, "cardData", {})) or {}
+    if not isinstance(card_data, dict):
+        try:
+            card_data = dict(card_data)
+        except Exception:
+            card_data = {}
+    return analyze_model_metadata(
+        model_id=model_id,
+        pipeline_tag=_get(info, "pipeline_tag", None),
+        library_name=_get(info, "library_name", None),
+        tags=list(_get(info, "tags", []) or []),
+        siblings=siblings,
+        gated=_get(info, "gated", None),
+        private=_get(info, "private", False),
+        card_data=card_data,
+        config=config,
+        model_index=model_index,
+        readme=readme,
+    )

src/worker_payload.py

@@ -23,6 +23,9 @@ from textwrap import dedent
 
 TARGET_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{1,95}/[A-Za-z0-9][A-Za-z0-9._-]{1,95}$")
 GIST_URL = "https://gist.github.com/gary149/2aba2962375fa9ca56bb9ef53f00b73d"
+AUTO_SPACE_HARDWARE_CHOICES = {"zero-a10g", "cpu-basic", "t4-small", "t4-medium", "a10g-small", "a10g-large", "l4x1", "l40sx1"}
+DEFAULT_PREFERRED_SPACE_HARDWARE = "zero-a10g"
+DEFAULT_FALLBACK_SPACE_HARDWARE = "a10g-large"
 DEFAULT_MODEL_ID = "sshleifer/tiny-gpt2"
 
 
@@ -829,8 +832,15 @@ def request_hardware(api, target_space_id: str, hardware: str, token: str, event
     return {"phase": "post_create_request", "requested": True, "hardware": hardware, "ok": False, "attempts": retries, "error": last_error, "manual_action_required": False}
 
 
+def normalize_auto_space_hardware(value: str | None, default: str) -> str:
+    candidate = (value or default).strip()
+    return candidate if candidate in AUTO_SPACE_HARDWARE_CHOICES else default
+
+
 def build_hardware_sequence(preferred_hardware: str, fallback_hardware: str, allow_fixed_gpu_fallback: bool) -> list[str]:
     sequence = []
+    preferred_hardware = normalize_auto_space_hardware(preferred_hardware, DEFAULT_PREFERRED_SPACE_HARDWARE)
+    fallback_hardware = normalize_auto_space_hardware(fallback_hardware, DEFAULT_FALLBACK_SPACE_HARDWARE)
     for hw in ["zero-a10g", preferred_hardware, fallback_hardware if allow_fixed_gpu_fallback else None]:
         value = (hw or "").strip()
         if value and value not in sequence:
@@ -971,7 +981,7 @@ Non-negotiable safety and product constraints:
 - Do not delete any user resources.
 - Do not print secrets or tokens.
 - Work only inside the current workspace.
-- The wrapper will create the private Space, request hardware best-effort, upload files, and validate the live app. Do not create/delete repos yourself in this builder worker.
+- The wrapper will create the private Space, request allowed hardware best-effort, upload files, and validate the live app. Do not create/delete repos yourself in this builder worker.
 - Preserve a cheap health endpoint named `health` with `api_name="health"`. It must not load weights, run GPU work, or download large files.
 - Do not pin huggingface_hub below 1.0. Use huggingface_hub>=0.34.0,<2.0.0 unless the model card requires a narrower compatible range. If transformers>=5 is used, keep huggingface_hub compatible with it, for example huggingface_hub>=1.5.0,<2.0.0.
 - README.md frontmatter must remain valid; if it uses short_description, it must be 60 characters or fewer.
@@ -981,7 +991,7 @@ Implementation contract:
 - Try to implement the closest real inference path for the model card using evidence from README, model metadata, config files, and repo files.
 - You may choose an appropriate Gradio UI for the task: text, image, audio, video, multimodal, embeddings, classification, etc.
 - If the model is standard and feasible, implement a real generate/predict function and expose it as a Gradio endpoint.
-- If the model requires GPU, add ZeroGPU-compatible `@spaces.GPU(...)` only around the inference function. Do not decorate health.
+- If the model requires GPU, add ZeroGPU-compatible `@spaces.GPU(...)` only around the inference function. Do not decorate health. Do not assume dedicated A100/H200 hardware is available automatically; if such hardware is needed, document it as a manual requirement.
 - If the model requires special dependencies, include them only when needed and document risks.
 - Investigate compatibility fallbacks before declaring a blocker: PyTorch SDPA, xformers, HF Kernels where relevant, CPU/offload/lazy loading, smaller resolution/steps, safe smoke-test inputs.
 - If real inference is impossible or unsafe in a Space, write TECHNICAL_BLOCKERS.json with concrete evidence for every blocker.
@@ -1264,8 +1274,8 @@ def main():
     target_space_id = os.environ.get("TARGET_SPACE_ID", "")
     model_id = sanitize_model_id(os.environ.get("MODEL_ID", DEFAULT_MODEL_ID))
     pi_model = os.environ.get("PI_MODEL", "Qwen/Qwen3-Coder-Next")
-    preferred_hardware = os.environ.get("PREFERRED_SPACE_HARDWARE", "zero-a10g")
-    fallback_hardware = os.environ.get("FALLBACK_SPACE_HARDWARE", "l40sx1")
+    preferred_hardware = normalize_auto_space_hardware(os.environ.get("PREFERRED_SPACE_HARDWARE"), DEFAULT_PREFERRED_SPACE_HARDWARE)
+    fallback_hardware = normalize_auto_space_hardware(os.environ.get("FALLBACK_SPACE_HARDWARE"), DEFAULT_FALLBACK_SPACE_HARDWARE)
     allow_fixed_gpu_fallback = os.environ.get("ALLOW_FIXED_GPU_FALLBACK", "true").lower() in {"1", "true", "yes", "on"}
     implementation_mode = os.environ.get("IMPLEMENTATION_MODE", "full-inference-attempt")
     expected_output_type = os.environ.get("EXPECTED_OUTPUT_TYPE", "any")