Delete llm_parser.py

llm_parser.py

@@ -1,167 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import re
-from functools import lru_cache
-from typing import Any
-
-from parser import PromptSpec, merge_prompt_specs, parse_prompt
-
-try:
-    import spaces  # type: ignore
-except Exception:  # pragma: no cover
-    class _SpacesShim:
-        @staticmethod
-        def GPU(*args, **kwargs):
-            def decorator(fn):
-                return fn
-            return decorator
-
-    spaces = _SpacesShim()  # type: ignore
-
-
-DEFAULT_LOCAL_MODEL = os.getenv("PB3D_LOCAL_MODEL", "Qwen/Qwen2.5-1.5B-Instruct")
-MODEL_PRESETS = {
-    "Qwen 2.5 1.5B": "Qwen/Qwen2.5-1.5B-Instruct",
-    "SmolLM2 1.7B": "HuggingFaceTB/SmolLM2-1.7B-Instruct",
-}
-
-JSON_SCHEMA_HINT = {
-    "object_type": ["cargo_hauler", "fighter", "shuttle", "freighter", "dropship", "drone"],
-    "scale": ["small", "medium", "large"],
-    "hull_style": ["boxy", "rounded", "sleek"],
-    "engine_count": "integer 1-6",
-    "wing_span": "float 0.0-0.6",
-    "cargo_ratio": "float 0.0-0.65",
-    "cockpit_ratio": "float 0.10-0.30",
-    "fin_height": "float 0.0-0.3",
-    "landing_gear": "boolean",
-    "asymmetry": "float 0.0-0.2",
-    "notes": "short string",
-}
-
-
-def _clamp(value: float, low: float, high: float) -> float:
-    return max(low, min(high, value))
-
-
-@lru_cache(maxsize=2)
-def _load_generation_components(model_id: str):
-    from transformers import AutoModelForCausalLM, AutoTokenizer
-    import torch
-
-    tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
-    if tokenizer.pad_token is None:
-        tokenizer.pad_token = tokenizer.eos_token
-
-    has_cuda = torch.cuda.is_available()
-    torch_dtype = torch.bfloat16 if has_cuda else torch.float32
-    model = AutoModelForCausalLM.from_pretrained(
-        model_id,
-        torch_dtype=torch_dtype,
-        device_map="auto",
-        low_cpu_mem_usage=True,
-        trust_remote_code=True,
-    )
-    return tokenizer, model
-
-
-@spaces.GPU(duration=45)
-def _generate_structured_json(prompt: str, model_id: str) -> dict[str, Any]:
-    import torch
-
-    tokenizer, model = _load_generation_components(model_id)
-
-    system = (
-        "You are a compact design parser for a procedural 3D generator. "
-        "Convert the user request into a single JSON object and output JSON only."
-    )
-    user = (
-        "Return a JSON object using this schema: "
-        f"{json.dumps(JSON_SCHEMA_HINT)}\n"
-        "Rules: choose the closest allowed enum values, stay conservative, infer hard-surface sci-fi vehicle structure, "
-        "never explain anything, never use markdown fences, and keep notes brief.\n"
-        f"Prompt: {prompt}"
-    )
-
-    messages = [
-        {"role": "system", "content": system},
-        {"role": "user", "content": user},
-    ]
-
-    if hasattr(tokenizer, "apply_chat_template"):
-        rendered = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    else:
-        rendered = f"System: {system}\nUser: {user}\nAssistant:"
-
-    inputs = tokenizer(rendered, return_tensors="pt")
-    model_device = getattr(model, "device", None)
-    if model_device is not None:
-        inputs = {k: v.to(model_device) for k, v in inputs.items()}
-
-    with torch.no_grad():
-        output = model.generate(
-            **inputs,
-            max_new_tokens=220,
-            do_sample=False,
-            temperature=None,
-            top_p=None,
-            repetition_penalty=1.02,
-            pad_token_id=tokenizer.pad_token_id,
-            eos_token_id=tokenizer.eos_token_id,
-        )
-
-    new_tokens = output[0][inputs["input_ids"].shape[1]:]
-    text = tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
-
-    match = re.search(r"\{.*\}", text, flags=re.S)
-    if not match:
-        raise ValueError("Local model did not return JSON.")
-    return json.loads(match.group(0))
-
-
-def _normalize_llm_payload(payload: dict[str, Any], original_prompt: str) -> PromptSpec:
-    def get_str(name: str, default: str) -> str:
-        value = str(payload.get(name, default)).strip().lower()
-        return value or default
-
-    def get_int(name: str, default: int, low: int, high: int) -> int:
-        try:
-            return int(_clamp(int(payload.get(name, default)), low, high))
-        except Exception:
-            return default
-
-    def get_float(name: str, default: float, low: float, high: float) -> float:
-        try:
-            return float(_clamp(float(payload.get(name, default)), low, high))
-        except Exception:
-            return default
-
-    landing_raw = payload.get("landing_gear", True)
-    if isinstance(landing_raw, bool):
-        landing_gear = landing_raw
-    else:
-        landing_gear = str(landing_raw).strip().lower() in {"1", "true", "yes", "y"}
-
-    return PromptSpec(
-        object_type=get_str("object_type", "cargo_hauler"),
-        scale=get_str("scale", "small"),
-        hull_style=get_str("hull_style", "boxy"),
-        engine_count=get_int("engine_count", 2, 1, 6),
-        wing_span=get_float("wing_span", 0.2, 0.0, 0.6),
-        cargo_ratio=get_float("cargo_ratio", 0.38, 0.0, 0.65),
-        cockpit_ratio=get_float("cockpit_ratio", 0.18, 0.10, 0.30),
-        fin_height=get_float("fin_height", 0.0, 0.0, 0.3),
-        landing_gear=landing_gear,
-        asymmetry=get_float("asymmetry", 0.0, 0.0, 0.2),
-        notes=str(payload.get("notes", original_prompt)).strip() or original_prompt,
-    )
-
-
-def parse_prompt_with_local_llm(prompt: str, model_id: str | None = None) -> PromptSpec:
-    model_id = model_id or DEFAULT_LOCAL_MODEL
-    heuristic = parse_prompt(prompt)
-    payload = _generate_structured_json(prompt=prompt, model_id=model_id)
-    llm_spec = _normalize_llm_payload(payload, original_prompt=prompt)
-    return merge_prompt_specs(heuristic, llm_spec)