app.py

import threading
import io
import json
import os
import shutil
import subprocess
import sys
from collections import Counter
from pathlib import Path

import spaces
import gradio as gr
import torch
from PIL import Image, ImageDraw
from transformers import RTDetrForObjectDetection, RTDetrImageProcessor

# Hugging Face Spaces can mount persistent storage at /data.
# DATA_DIR can be overridden in Space Settings -> Variables.
if os.getenv("DATA_DIR"):
    BASE = Path(os.environ["DATA_DIR"])
elif Path("/data").exists() and os.access("/data", os.W_OK):
    BASE = Path("/data") / "icecream_counter"
else:
    BASE = Path("./data")

ROOT = Path(__file__).resolve().parent

# Self-heal the training script if a deployment omitted the training/ directory.
_TRAINING_SCRIPT_B64 = "import argparse
import json
from pathlib import Path

import torch
from PIL import Image
from torch.utils.data import Dataset, DataLoader
from tqdm import tqdm
from transformers import RTDetrImageProcessor, RTDetrForObjectDetection

BASE_MODEL = "PekingU/rtdetr_r50vd"

def load_classes(path):
    return [x.strip() for x in Path(path).read_text().splitlines() if x.strip()]

class COCODetectionDataset(Dataset):
    def __init__(self, image_dir, annotation_file, processor):
        self.image_dir = Path(image_dir)
        self.processor = processor
        coco = json.loads(Path(annotation_file).read_text())
        self.images = {x["id"]: x for x in coco["images"]}
        cats = sorted(coco["categories"], key=lambda x: x["id"])
        self.category_id_to_label = {c["id"]: i for i,c in enumerate(cats)}
        anns = {}
        for a in coco["annotations"]:
            if not a.get("iscrowd", 0):
                anns.setdefault(a["image_id"], []).append(a)
        self.records = []
        for image_id, info in self.images.items():
            self.records.append({
                "image_id": image_id, "file_name": info["file_name"],
                "width": info["width"], "height": info["height"],
                "annotations": anns.get(image_id, [])
            })

    def __len__(self): return len(self.records)

    def __getitem__(self, idx):
        r = self.records[idx]
        image = Image.open(self.image_dir / r["file_name"]).convert("RGB")
        anns = []
        for a in r["annotations"]:
            x,y,w,h = a["bbox"]
            if w <= 0 or h <= 0: continue
            anns.append({
                "id": a["id"], "image_id": int(idx),
                "category_id": self.category_id_to_label[a["category_id"]],
                "bbox": [x,y,w,h], "area": float(a.get("area",w*h)),
                "iscrowd": 0
            })
        encoded = self.processor(
            images=image,
            annotations={"image_id": int(idx), "annotations": anns},
            return_tensors="pt"
        )
        encoded["pixel_values"] = encoded["pixel_values"].squeeze(0)
        if "pixel_mask" in encoded:
            encoded["pixel_mask"] = encoded["pixel_mask"].squeeze(0)
        encoded["labels"] = encoded["labels"][0]
        return encoded

def collate_fn(batch):
    out = {"pixel_values": torch.stack([x["pixel_values"] for x in batch]),
           "labels": [x["labels"] for x in batch]}
    if "pixel_mask" in batch[0]:
        out["pixel_mask"] = torch.stack([x["pixel_mask"] for x in batch])
    return out

def move_to_device(obj, device):
    if torch.is_tensor(obj):
        return obj.to(device)
    if isinstance(obj, dict):
        return {k: move_to_device(v, device) for k, v in obj.items()}
    if isinstance(obj, list):
        return [move_to_device(v, device) for v in obj]
    if isinstance(obj, tuple):
        return tuple(move_to_device(v, device) for v in obj)
    return obj

def evaluate(model, loader, device):
    model.eval(); total=0; n=0
    with torch.no_grad():
        for batch in loader:
            batch=move_to_device(batch, device)
            total += float(model(**batch).loss.item()); n += 1
    model.train()
    return total/max(n,1)


def patch_rtdetr_denoising_device():
    """Work around RT-DETR denoising code creating CPU index tensors on some Transformers releases."""
    try:
        import transformers.models.rt_detr.modeling_rt_detr as rtdetr_mod
        original = rtdetr_mod.get_contrastive_denoising_training_group
        if getattr(original, "_icecream_device_patch", False):
            return

        def wrapped(targets, *args, **kwargs):
            # class_embed is the 4th positional argument in the supported RT-DETR versions.
            class_embed = args[2] if len(args) >= 3 else kwargs.get("class_embed")
            try:
                device = next(class_embed.parameters()).device
            except Exception:
                device = None
            if device is not None:
                for target in targets:
                    if isinstance(target, dict):
                        for key in ("class_labels", "boxes"):
                            value = target.get(key)
                            if torch.is_tensor(value) and value.device != device:
                                target[key] = value.to(device)
            return original(targets, *args, **kwargs)

        wrapped._icecream_device_patch = True
        rtdetr_mod.get_contrastive_denoising_training_group = wrapped
    except Exception as exc:
        print(f"Warning: RT-DETR denoising device patch was not installed: {exc}")

def main():
    p=argparse.ArgumentParser()
    p.add_argument("--train-dir",required=True); p.add_argument("--val-dir",required=True)
    p.add_argument("--classes",required=True); p.add_argument("--output-dir",default="model")
    p.add_argument("--epochs",type=int,default=30); p.add_argument("--batch-size",type=int,default=2)
    p.add_argument("--learning-rate",type=float,default=1e-5); p.add_argument("--weight-decay",type=float,default=1e-4)
    p.add_argument("--num-workers",type=int,default=2)
    a=p.parse_args()

    classes=load_classes(a.classes)
    id2label={i:n for i,n in enumerate(classes)}
    label2id={n:i for i,n in enumerate(classes)}

    proc=RTDetrImageProcessor.from_pretrained(BASE_MODEL)
    train=COCODetectionDataset(Path(a.train_dir)/"images",Path(a.train_dir)/"annotations.json",proc)
    val=COCODetectionDataset(Path(a.val_dir)/"images",Path(a.val_dir)/"annotations.json",proc)

    if len(train)==0 or len(val)==0:
        raise ValueError("Training and validation datasets must contain at least one image.")
    if len(train.category_id_to_label)!=len(classes) or len(val.category_id_to_label)!=len(classes):
        raise ValueError("COCO categories do not match classes.txt. Rebuild the dataset after saving the classes.")

    model=RTDetrForObjectDetection.from_pretrained(
        BASE_MODEL,num_labels=len(classes),id2label=id2label,label2id=label2id,
        ignore_mismatched_sizes=True
    )
    device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)
    patch_rtdetr_denoising_device()

    tr=DataLoader(train,batch_size=a.batch_size,shuffle=True,num_workers=0,collate_fn=collate_fn)
    va=DataLoader(val,batch_size=a.batch_size,shuffle=False,num_workers=0,collate_fn=collate_fn)
    opt=torch.optim.AdamW(model.parameters(),lr=a.learning_rate,weight_decay=a.weight_decay)

    outdir=Path(a.output_dir); outdir.mkdir(parents=True,exist_ok=True)
    best=float("inf")

    for epoch in range(a.epochs):
        model.train(); running=0
        bar=tqdm(tr,desc=f"epoch {epoch+1}/{a.epochs}")
        for step,batch in enumerate(bar):
            batch=move_to_device(batch, device)
            # RT-DETR's loss matcher uses nested target tensors (boxes/classes).
            # Move every tensor in labels to the same device as the model.
            if "labels" in batch:
                # RT-DETR expects every nested target tensor on the same device as the model.
                for target in batch["labels"]:
                    if isinstance(target, dict):
                        for key, value in list(target.items()):
                            if torch.is_tensor(value):
                                target[key] = value.to(device)
            loss=model(**batch).loss
            loss.backward(); opt.step(); opt.zero_grad(set_to_none=True)
            running += float(loss.item())
            bar.set_postfix(loss=f"{running/(step+1):.4f}")
        vl=evaluate(model,va,device)
        print(f"validation_loss={vl:.4f}")
        if vl<best:
            best=vl
            model.save_pretrained(outdir)
            proc.save_pretrained(outdir)
            (outdir/"classes.json").write_text(json.dumps({"id2label":id2label,"label2id":label2id},indent=2))
    model.save_pretrained(outdir); proc.save_pretrained(outdir)

if __name__=="__main__": main()
"
TRAINING_DIR = ROOT / "training"
TRAIN_SCRIPT = TRAINING_DIR / "train.py"
if not TRAIN_SCRIPT.exists():
    TRAINING_DIR.mkdir(parents=True, exist_ok=True)
    TRAIN_SCRIPT.write_bytes(__import__("base64").b64decode(_TRAINING_SCRIPT_B64))
IMAGE_DIR = BASE / "images"
DATASET_FILE = BASE / "dataset.json"
MODEL_DIR = BASE / "model"
GENERATED_DIR = BASE / "generated_dataset"
CLASSES_FILE = BASE / "classes.txt"

IMAGE_DIR.mkdir(parents=True, exist_ok=True)
BASE.mkdir(parents=True, exist_ok=True)
MODEL_DIR.mkdir(parents=True, exist_ok=True)

DEFAULT_CLASSES = [
    "Carnavalita", "Kimo-COno", "Squizz", "Oreo", "Moro",
    "Dulce", "KitKat", "Cadbury", "Mega", "other"
]
if not CLASSES_FILE.exists():
    CLASSES_FILE.write_text("\n".join(DEFAULT_CLASSES) + "\n", encoding="utf-8")

CONFIDENCE_THRESHOLD = float(os.getenv("CONFIDENCE_THRESHOLD", "0.35"))
MAX_IMAGE_MB = int(os.getenv("MAX_IMAGE_MB", "15"))

_training = {"running": False, "message": "not started", "error": None}
_model = None
_processor = None
_model_lock = threading.Lock()
_annotation_click = None


def load_dataset():
    if not DATASET_FILE.exists():
        return {"images": [], "classes": read_classes()}
    try:
        data = json.loads(DATASET_FILE.read_text(encoding="utf-8"))
        data.setdefault("images", [])
        data["classes"] = read_classes()
        return data
    except Exception:
        return {"images": [], "classes": read_classes()}


def save_dataset(data):
    data["classes"] = read_classes()
    tmp = DATASET_FILE.with_suffix(".tmp")
    tmp.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
    tmp.replace(DATASET_FILE)


def read_classes():
    if not CLASSES_FILE.exists():
        return []
    return [x.strip() for x in CLASSES_FILE.read_text(encoding="utf-8").splitlines() if x.strip()]


def image_path(image_id):
    return IMAGE_DIR / f"{image_id}.jpg"


def model_ready():
    return (MODEL_DIR / "config.json").exists()


def load_model():
    global _model, _processor
    if not model_ready():
        raise RuntimeError("No trained model yet. Train the model first.")
    with _model_lock:
        if _model is None:
            _processor = RTDetrImageProcessor.from_pretrained(str(MODEL_DIR))
            _model = RTDetrForObjectDetection.from_pretrained(str(MODEL_DIR))
            _model.to("cuda" if torch.cuda.is_available() else "cpu")
            _model.eval()
    return _processor, _model


def dataset_status():
    data = load_dataset()
    annotated = sum(bool(x.get("annotations")) for x in data["images"])
    return (
        f"**Dataset:** {len(data['images'])} images  |  "
        f"**Annotated:** {annotated}  |  "
        f"**Classes:** {len(read_classes())}  |  "
        f"**Model:** {'READY' if model_ready() else 'NOT TRAINED'}  |  "
        f"**Storage:** `{BASE}`"
    )


def image_choices():
    data = load_dataset()
    return [(x["filename"], x["id"]) for x in data["images"]]


def upload_training_images(files):
    if not files:
        return dataset_status(), gr.update(choices=image_choices()), "No files selected."

    data = load_dataset()
    saved = 0
    skipped = []
    for f in files:
        try:
            # Gradio 6 may return FileData objects or plain dictionaries.
            if isinstance(f, dict):
                raw_path = f.get("path") or f.get("name") or f.get("filepath")
            else:
                raw_path = getattr(f, "path", None) or getattr(f, "name", None) or f
            path = Path(raw_path)
            raw = path.read_bytes()
            if len(raw) > MAX_IMAGE_MB * 1024 * 1024:
                skipped.append(f"{path.name}: over {MAX_IMAGE_MB} MB")
                continue
            im = Image.open(io.BytesIO(raw)).convert("RGB")
            image_id = __import__("uuid").uuid4().hex
            out = image_path(image_id)
            im.save(out, "JPEG", quality=95)
            data["images"].append({
                "id": image_id,
                "filename": path.name,
                "width": im.width,
                "height": im.height,
                "annotations": [],
            })
            saved += 1
        except Exception as e:
            skipped.append(f"{path.name}: {e}")

    save_dataset(data)
    msg = f"Saved {saved} image(s)."
    if skipped:
        msg += "\nSkipped:\n- " + "\n- ".join(skipped)
    return dataset_status(), gr.update(choices=image_choices()), msg


def image_data_uri(image_id):
    import base64
    p = image_path(image_id)
    if not p.exists():
        return ""
    return "data:image/jpeg;base64," + base64.b64encode(p.read_bytes()).decode("ascii")


def annotation_canvas_html(image_id):
    if not image_id:
        return '<div class="anno-empty">Select an image from the Dataset tab.</div>'
    data = load_dataset()
    item = next((x for x in data["images"] if x["id"] == image_id), None)
    if not item:
        return '<div class="anno-empty">Image not found.</div>'
    src = image_data_uri(image_id)
    boxes = json.dumps(item.get("annotations", []), ensure_ascii=False)
    return """<div class="anno-wrap">
<div class="anno-toolbar"><b>Draw boxes directly on the image</b><span>Click + drag + release = create box</span><span>Choose the class first</span></div>
<div class="anno-canvas-wrap"><canvas id="anno-canvas"></canvas></div>
<div class="anno-help" id="anno-hint">Drag from one corner of the object to the opposite corner, then release. The coordinates are filled automatically; click <b>Save Box</b>. Repeat for every object.</div>
</div>
<script>
(function(){
const imgSrc=%s, imageW=%d, imageH=%d, saved=%s;
const canvas=document.getElementById('anno-canvas'); if(!canvas)return;
const ctx=canvas.getContext('2d'), img=new Image(); let drawing=false,sx=0,sy=0,current=null;
function fit(){const maxW=Math.min(1100,window.innerWidth-80),maxH=Math.max(400,window.innerHeight*.62),scale=Math.min(maxW/imageW,maxH/imageH,1);canvas.width=Math.max(1,Math.round(imageW*scale));canvas.height=Math.max(1,Math.round(imageH*scale));canvas.dataset.scale=scale;redraw();}
function redraw(){if(!img.complete)return;const sc=+canvas.dataset.scale||1;ctx.clearRect(0,0,canvas.width,canvas.height);ctx.drawImage(img,0,0,canvas.width,canvas.height);saved.forEach((a,i)=>{const b=a.box||[];const x=b[0]*sc,y=b[1]*sc,w=b[2]*sc,h=b[3]*sc;ctx.strokeStyle='#ff3030';ctx.lineWidth=3;ctx.strokeRect(x,y,w,h);ctx.fillStyle='#ff3030';ctx.fillRect(x,Math.max(0,y-22),120,22);ctx.fillStyle='#fff';ctx.font='14px sans-serif';ctx.fillText((i+1)+'. '+a.class,x+5,Math.max(16,y-6));});if(current){ctx.strokeStyle='#00ff88';ctx.lineWidth=3;ctx.setLineDash([7,5]);ctx.strokeRect(current.x,current.y,current.w,current.h);ctx.setLineDash([]);}}
function pos(e){const r=canvas.getBoundingClientRect();return{x:e.clientX-r.left,y:e.clientY-r.top};}
function setField(id,val){const box=document.querySelector('#'+id);const el=box?.querySelector('input,textarea');if(!el)return;const setter=Object.getOwnPropertyDescriptor(HTMLInputElement.prototype,'value')?.set||Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype,'value')?.set;if(setter)setter.call(el,String(val));else el.value=String(val);el.dispatchEvent(new Event('input',{bubbles:true}));el.dispatchEvent(new Event('change',{bubbles:true}));}
canvas.addEventListener('pointerdown',e=>{e.preventDefault();canvas.setPointerCapture(e.pointerId);const p=pos(e);sx=p.x;sy=p.y;drawing=true;current={x:sx,y:sy,w:0,h:0};redraw();});
canvas.addEventListener('pointermove',e=>{if(!drawing)return;const p=pos(e);current={x:Math.min(sx,p.x),y:Math.min(sy,p.y),w:Math.abs(p.x-sx),h:Math.abs(p.y-sy)};redraw();});
canvas.addEventListener('pointerup',e=>{if(!drawing)return;drawing=false;const p=pos(e),sc=+canvas.dataset.scale||1;const x=Math.min(sx,p.x)/sc,y=Math.min(sy,p.y)/sc,w=Math.abs(p.x-sx)/sc,h=Math.abs(p.y-sy)/sc;current=null;redraw();if(w<3||h<3)return;setField('anno-x',Math.round(x));setField('anno-y',Math.round(y));setField('anno-w',Math.round(w));setField('anno-h',Math.round(h));const hint=document.getElementById('anno-hint');if(hint)hint.textContent='Box created. Click “Save Box” to store it.';});
canvas.addEventListener('pointercancel',()=>{drawing=false;current=null;redraw();});
img.onload=fit;img.src=imgSrc;window.addEventListener('resize',fit);
})();</script>""" % (json.dumps(src), int(item["width"]), int(item["height"]), boxes)



def annotation_preview_image(image_id):
    """Return the real PIL image for Gradio's Image component."""
    if not image_id:
        return None
    p = image_path(image_id)
    if not p.exists():
        return None
    try:
        return Image.open(p).convert("RGB")
    except Exception:
        return None


def annotation_preview_with_boxes(image_id):
    image = annotation_preview_image(image_id)
    if image is None:
        return None
    data = load_dataset()
    item = next((x for x in data["images"] if x["id"] == image_id), None)
    if not item:
        return image
    out = image.copy()
    draw = ImageDraw.Draw(out)
    for i, a in enumerate(item.get("annotations", []), 1):
        x, y, w, h = a["box"]
        draw.rectangle([x, y, x+w, y+h], outline="red", width=5)
        label = f"{i}. {a['class']}"
        y0 = max(0, y-24)
        draw.rectangle([x, y0, x+max(130, len(label)*9), y0+24], fill="red")
        draw.text((x+4, y0+4), label, fill="white")
    return out


def refresh_editor(image_id):
    if not image_id:
        return None, "Select an image.", []
    data=load_dataset()
    item=next((x for x in data["images"] if x["id"]==image_id),None)
    if not item:
        return None,"Image not found.",[]
    return annotation_preview_with_boxes(image_id), f"**{item['filename']}** — {item['width']} × {item['height']} px", item.get("annotations",[])

def draw_annotations(image_id):
    """Render the annotation canvas for the selected image."""
    return annotation_canvas_html(image_id)


def add_annotation(image_id, cls, x, y, w, h):
    if not image_id:return annotation_preview_with_boxes(image_id),"Select an image first.",[]
    if not cls:return annotation_preview_with_boxes(image_id),"Select a class first.",[]
    try:x,y,w,h=map(float,[x,y,w,h])
    except:return annotation_preview_with_boxes(image_id),"Enter box coordinates first.",[]
    if w<=0 or h<=0:return annotation_preview_with_boxes(image_id),"Box must have a width and height.",[]
    data=load_dataset()
    item=next((z for z in data["images"] if z["id"]==image_id),None)
    if not item:return None,"Image not found.",[]
    x=max(0,min(x,item["width"]-1)); y=max(0,min(y,item["height"]-1))
    w=min(w,item["width"]-x); h=min(h,item["height"]-y)
    item.setdefault("annotations",[]).append({"class":cls,"box":[x,y,w,h]})
    save_dataset(data)
    return annotation_preview_with_boxes(image_id),f"Saved {cls}: [{x:.0f}, {y:.0f}, {w:.0f}, {h:.0f}]",item["annotations"]


def remove_annotation(image_id,index):
    if not image_id:return annotation_preview_with_boxes(image_id),"Select an image first.",[]
    data=load_dataset()
    item=next((z for z in data["images"] if z["id"]==image_id),None)
    if not item:return None,"Image not found.",[]
    try:idx=int(index)-1
    except:return annotation_preview_with_boxes(image_id),"Enter an annotation number.",item.get("annotations",[])
    anns=item.get("annotations",[])
    if idx<0 or idx>=len(anns):return annotation_preview_with_boxes(image_id),"Annotation number not found.",anns
    deleted=anns.pop(idx);save_dataset(data)
    return annotation_preview_with_boxes(image_id),f"Deleted annotation {index}: {deleted['class']}",anns


def clear_annotations(image_id):
    if not image_id:return annotation_preview_with_boxes(image_id),"Select an image first.",[]
    data=load_dataset()
    item=next((z for z in data["images"] if z["id"]==image_id),None)
    if not item:return None,"Image not found.",[]
    item["annotations"]=[];save_dataset(data)
    return annotation_preview_with_boxes(image_id),"Annotations cleared.",[]


def save_classes(text):
    classes = [x.strip() for x in (text or "").splitlines() if x.strip()]
    if not classes:
        return "At least one class is required.", gr.update(choices=read_classes()), dataset_status()
    if len(set(classes)) != len(classes):
        return "Classes must be unique.", gr.update(choices=read_classes()), dataset_status()
    CLASSES_FILE.write_text("\n".join(classes) + "\n", encoding="utf-8")
    data = load_dataset()
    save_dataset(data)
    return f"Saved {len(classes)} classes.", gr.update(choices=classes, value=classes[0]), dataset_status()


def handle_annotation_click(image_id, cls, click_state, evt: gr.SelectData):
    """Use two clicks on the real Gradio image to define a box.
    First click = top-left corner, second click = opposite corner.
    This avoids the unreliable HTML canvas/script path and works in Gradio itself.
    """
    if not image_id:
        return 0, 0, 0, 0, [], "Select an image first."
    if not cls:
        return 0, 0, 0, 0, [], "Select a class first."
    data = load_dataset()
    item = next((x for x in data["images"] if x["id"] == image_id), None)
    if not item:
        return 0, 0, 0, 0, [], "Image not found."
    try:
        point = evt.index
        px, py = float(point[0]), float(point[1])
    except Exception:
        return 0, 0, 0, 0, click_state or [], "Could not read the image click position."
    px = max(0, min(px, item["width"] - 1))
    py = max(0, min(py, item["height"] - 1))
    state = list(click_state or [])
    if not state:
        return round(px), round(py), 0, 0, [px, py], f"First corner: ({px:.0f}, {py:.0f}). Now click the opposite corner."
    x0, y0 = state[:2]
    x = min(x0, px); y = min(y0, py)
    w = abs(px - x0); h = abs(py - y0)
    if w < 2 or h < 2:
        return round(x), round(y), 0, 0, [], "Box is too small. Click the first corner again."
    return round(x), round(y), round(w), round(h), [], f"Box ready: [{x:.0f}, {y:.0f}, {w:.0f}, {h:.0f}] for {cls}. Click Save Box."


def build_coco():
    data = load_dataset()
    classes = read_classes()
    if not classes:
        raise RuntimeError("No classes configured.")
    items = [x for x in data["images"] if x.get("annotations")]
    if not items:
        raise RuntimeError("Annotate at least 1 image before training.")

    # With only one annotated image, use it for both training and validation so
    # the first training run is possible. With 2+ images, use an 80/20 split.
    if len(items) == 1:
        train_items, val_items = items, items
    else:
        split = max(1, int(len(items) * 0.8))
        if split >= len(items):
            split = len(items) - 1
        train_items, val_items = items[:split], items[split:]
    category_id = {name: i + 1 for i, name in enumerate(classes)}

    def make_coco(selected):
        images, annotations = [], []
        ann_id = 1
        for item in selected:
            images.append({
                "id": item["id"],
                "file_name": item["id"] + ".jpg",
                "width": item["width"],
                "height": item["height"],
            })
            for ann in item["annotations"]:
                x, y, w, h = ann["box"]
                annotations.append({
                    "id": ann_id,
                    "image_id": item["id"],
                    "category_id": category_id[ann["class"]],
                    "bbox": [x, y, w, h],
                    "area": w*h,
                    "iscrowd": 0,
                })
                ann_id += 1
        return {
            "images": images,
            "annotations": annotations,
            "categories": [{"id": i+1, "name": n} for i, n in enumerate(classes)]
        }

    if GENERATED_DIR.exists():
        shutil.rmtree(GENERATED_DIR)
    for name, selected in [("train", train_items), ("val", val_items)]:
        d = GENERATED_DIR / name
        (d / "images").mkdir(parents=True, exist_ok=True)
        for item in selected:
            shutil.copy2(image_path(item["id"]), d / "images" / f"{item['id']}.jpg")
        (d / "annotations.json").write_text(
            json.dumps(make_coco(selected), indent=2), encoding="utf-8"
        )


def run_training(epochs, batch_size, learning_rate):
    global _training, _model
    try:
        _training = {"running": True, "message": "building COCO dataset", "error": None}
        build_coco()
        _training["message"] = "training RT-DETR"
        cmd = [
            sys.executable, str(TRAIN_SCRIPT),
            "--train-dir", str(GENERATED_DIR / "train"),
            "--val-dir", str(GENERATED_DIR / "val"),
            "--classes", str(CLASSES_FILE),
            "--output-dir", str(MODEL_DIR),
            "--epochs", str(int(epochs)),
            "--batch-size", str(int(batch_size)),
            "--learning-rate", str(float(learning_rate)),
        ]
        result = subprocess.run(cmd, cwd=ROOT, capture_output=True, text=True)
        if result.returncode != 0:
            details = result.stderr.strip() or result.stdout.strip() or f"training process exited with code {result.returncode}"
            raise RuntimeError(details[-12000:])
        _model = None
        _training = {"running": False, "message": "training complete", "error": None}
    except Exception as e:
        _training = {"running": False, "message": "training failed", "error": str(e)}


@spaces.GPU(duration=120)
def start_training(epochs, batch_size, learning_rate):
    """Start training from the Gradio event itself.

    Calling the @spaces.GPU function directly is important on Hugging Face
    ZeroGPU: starting it from a normal Python background thread can bypass the
    GPU allocation context, making the button appear to do nothing.
    """
    global _training
    if _training["running"]:
        return json.dumps(_training, indent=2)
    # Validate parameters before requesting GPU time.
    try:
        epochs = max(1, int(epochs))
        batch_size = max(1, int(batch_size))
        learning_rate = float(learning_rate)
        if learning_rate <= 0:
            raise ValueError("Learning rate must be greater than 0.")
    except Exception as e:
        _training = {"running": False, "message": "training failed", "error": f"Invalid training settings: {e}"}
        return json.dumps(_training, indent=2)

    annotated = sum(bool(x.get("annotations")) for x in load_dataset()["images"])
    if annotated < 1:
        _training = {"running": False, "message": "training failed", "error": "Annotate at least 1 image before training."}
        return json.dumps(_training, indent=2)
    run_training(epochs, batch_size, learning_rate)
    return json.dumps(_training, indent=2)


def training_status():
    return json.dumps(_training, indent=2)


@spaces.GPU(duration=60)
def count_image(image):
    if image is None:
        return None, "Upload an image first.", {}
    if not model_ready():
        return None, "Model is not trained yet. Go to Training.", {}
    try:
        proc, detector = load_model()
        image = image.convert("RGB") if isinstance(image, Image.Image) else Image.fromarray(image).convert("RGB")
        device = next(detector.parameters()).device
        inputs = proc(images=image, return_tensors="pt")
        inputs = {k: v.to(device) if torch.is_tensor(v) else v for k, v in inputs.items()}
        with torch.inference_mode():
            outputs = detector(**inputs)
        target_sizes = torch.tensor([[image.height, image.width]], device=device)
        result = proc.post_process_object_detection(
            outputs, threshold=CONFIDENCE_THRESHOLD, target_sizes=target_sizes
        )[0]

        detections = []
        counts = Counter()
        for score, label, box in zip(result["scores"], result["labels"], result["boxes"]):
            s = float(score.item())
            cls = detector.config.id2label[int(label.item())]
            coords = [round(float(v), 2) for v in box.tolist()]
            detections.append({"class": cls, "confidence": round(s, 4), "box": coords})
            counts[cls] += 1

        out = image.copy()
        draw = ImageDraw.Draw(out)
        for d in detections:
            x1, y1, x2, y2 = d["box"]
            draw.rectangle([x1, y1, x2, y2], outline="red", width=4)
            label = f"{d['class']} {d['confidence']:.2f}"
            draw.rectangle([x1, max(0, y1-22), x1+max(120, len(label)*8), y1], fill="red")
            draw.text((x1+3, max(0, y1-20)), label, fill="white")

        response = {
            "total": len(detections),
            "counts": dict(sorted(counts.items())),
            "detections": detections,
        }
        return out, json.dumps(response, indent=2), response["counts"]
    except Exception as e:
        return None, f"Counting failed: {e}", {}


# ----- Gradio UI -----
CSS = """
.gradio-container { max-width: 1250px !important; }
h1 { margin-bottom: 0.2rem !important; }
.anno-wrap{width:100%}.anno-toolbar{display:flex;gap:14px;flex-wrap:wrap;padding:10px 12px;margin-bottom:8px;border-radius:10px;background:#20242a}.anno-toolbar span{opacity:.85}.anno-canvas-wrap{width:100%;overflow:auto;border:1px solid #555;border-radius:10px;background:#111;padding:8px}.anno-canvas-wrap canvas{display:block;max-width:none;cursor:crosshair;touch-action:none;margin:auto}.anno-help{padding:8px 2px;opacity:.75}.anno-empty{padding:50px;text-align:center;border:1px dashed #777;border-radius:10px}
#annotation-image img { max-height: 650px !important; object-fit: contain !important; }
.status { padding: 10px 14px; border-radius: 10px; }
"""

with gr.Blocks(title="Ice Cream Dataset + Counter") as demo:
    gr.Markdown("# 🍦 Ice Cream Dataset + Counter\nUpload and annotate training images, train RT-DETR, then count ice creams in new images.")
    status = gr.Markdown(dataset_status(), elem_classes="status")

    with gr.Tab("1 · Dataset"):
        gr.Markdown("### Upload training images")
        files = gr.Files(file_count="multiple", file_types=["image"], type="filepath", label="Images")
        upload_btn = gr.Button("Save Images", variant="primary")
        upload_msg = gr.Markdown()
        # Dataset selector
        image_select = gr.Dropdown(choices=image_choices(), label="Training image", interactive=True)
        refresh_btn = gr.Button("Refresh Dataset")
        refresh_btn.click(lambda: (dataset_status(), gr.update(choices=image_choices())), None, [status, image_select])

        gr.Markdown("### Classes")
        class_text = gr.Textbox(value="\n".join(read_classes()), lines=8, label="One class per line")
        save_class_btn = gr.Button("Save Classes")
        class_msg = gr.Markdown()
        # Class dropdown is updated after the Annotate tab creates it.

    with gr.Tab("2 · Annotate"):
        gr.Markdown("### Annotate training images")
        gr.Markdown("Select an image above, choose a class, then **click the first corner and click the opposite corner** of each object. The real uploaded image is shown below. Click **Save Box** after each box.")
        with gr.Row():
            with gr.Column(scale=3):
                annotation_image = gr.Image(value=None, type="pil", interactive=False, label="Training image", height=650, elem_id="annotation-image")
                editor_info = gr.Markdown("Select an image from the Dataset tab.")
            with gr.Column(scale=1):
                ann_class = gr.Dropdown(choices=read_classes(), value=(read_classes()[0] if read_classes() else None), label="Class", interactive=True)
                x = gr.Number(label="X (left)", value=0, precision=0)
                y = gr.Number(label="Y (top)", value=0, precision=0)
                w = gr.Number(label="Width", value=0, precision=0)
                h = gr.Number(label="Height", value=0, precision=0)
                add_btn = gr.Button("💾 Save Box", variant="primary")
                gr.Markdown("**Box method:** click corner 1 → click corner 2 → Save Box.")
                delete_index = gr.Number(label="Annotation # to delete", value=1, precision=0)
                delete_btn = gr.Button("Delete Box")
                clear_btn = gr.Button("Clear All Boxes")
        annotations = gr.JSON(label="Saved annotations")
        ann_msg = gr.Markdown()
        click_state = gr.State([])

        def load_annotation_image(image_id):
            return annotation_preview_with_boxes(image_id), refresh_editor(image_id)[1], refresh_editor(image_id)[2], []

        image_select.change(load_annotation_image, image_select, [annotation_image, editor_info, annotations, click_state])
        annotation_image.select(handle_annotation_click, [image_select, ann_class, click_state], [x, y, w, h, click_state, ann_msg])
        add_btn.click(add_annotation, [image_select, ann_class, x, y, w, h], [annotation_image, ann_msg, annotations])
        delete_btn.click(remove_annotation, [image_select, delete_index], [annotation_image, ann_msg, annotations])
        clear_btn.click(clear_annotations, image_select, [annotation_image, ann_msg, annotations])

    with gr.Tab("3 · Training"):
        gr.Markdown("### Train RT-DETR")
        gr.Markdown("Training runs in the Space process. A GPU Space is strongly recommended for practical training speed.")
        with gr.Row():
            epochs = gr.Number(value=int(os.getenv("EPOCHS", "30")), label="Epochs", precision=0)
            batch = gr.Number(value=int(os.getenv("BATCH_SIZE", "2")), label="Batch size", precision=0)
            lr = gr.Number(value=float(os.getenv("LEARNING_RATE", "1e-5")), label="Learning rate")
        train_btn = gr.Button("🚀 Start Training", variant="primary")
        refresh_train = gr.Button("Refresh Training Status")
        train_out = gr.Code(value=training_status, language="json", label="Training status")
        train_btn.click(start_training, [epochs, batch, lr], train_out)
        refresh_train.click(training_status, None, train_out)

    with gr.Tab("4 · Count"):
        gr.Markdown("### Count ice creams")
        count_in = gr.Image(type="pil", sources=["upload", "clipboard"], label="Image to count")
        count_btn = gr.Button("🍦 Count", variant="primary")
        count_out = gr.Image(label="Detections")
        count_json = gr.Code(language="json", label="Detection details")
        count_table = gr.JSON(label="Counts by class")
        count_btn.click(count_image, count_in, [count_out, count_json, count_table])

    # Correct the upload event now that image_select exists.
    upload_btn.click(
        upload_training_images,
        files,
        [status, image_select, upload_msg],
        preprocess=False,
        queue=False,
    )
    save_class_btn.click(save_classes, class_text, [class_msg, ann_class, status])
    # The earlier placeholder event is harmlessly superseded by this real event.

    demo.load(lambda: (dataset_status(), gr.update(choices=image_choices()), gr.update(choices=read_classes(), value=(read_classes()[0] if read_classes() else None))),
              None, [status, image_select, ann_class])

if __name__ == "__main__":
    demo.queue().launch(
        server_name="0.0.0.0",
        server_port=int(os.getenv("PORT", "7860")),
        css=CSS,
    )