Update app.py

app.py

@@ -69,7 +69,6 @@ DEFAULT_W = {
 logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
 
 _model_cache: dict[str, YOLO] = {}
-
 autoinc = 0  # helper for tmp‑dir names
 
 # ────────────────────────────────────────────────────────────────────────────
@@ -85,12 +84,10 @@ class QCConfig:
     batch_size:  int = BATCH_SIZE
     sample_limit:int = SAMPLE_LIMIT
 
-
 def load_yaml(path: Path) -> Dict:
-    with path.open("r", encoding="utf-8") as f:
+    with path.open('r', encoding='utf-8') as f:
         return yaml.safe_load(f)
 
-
 def parse_label_file(path: Path) -> list[tuple[int, float, float, float, float]]:
     if not path or not path.exists() or path.stat().st_size == 0:
         return []
@@ -102,21 +99,19 @@ def parse_label_file(path: Path) -> list[tuple[int, float, float, float, float]]
     except Exception:
         return []
 
-
 def guess_image_dirs(root: Path) -> List[Path]:
     candidates = [
-        root / "images",
-        root / "train" / "images",
-        root / "valid" / "images",
-        root / "val" / "images",
-        root / "test" / "images",
+        root/'images',
+        root/'train'/'images',
+        root/'valid'/'images',
+        root/'val'  /'images',
+        root/'test' /'images',
     ]
     return [d for d in candidates if d.exists()]
 
-
 def gather_dataset(root: Path, yaml_path: Path | None):
     if yaml_path is None:
-        yamls = list(root.glob("*.yaml"))
+        yamls = list(root.glob('*.yaml'))
         if not yamls:
             raise FileNotFoundError("Dataset YAML not found")
         yaml_path = yamls[0]
@@ -124,15 +119,14 @@ def gather_dataset(root: Path, yaml_path: Path | None):
     img_dirs = guess_image_dirs(root)
     if not img_dirs:
         raise FileNotFoundError("images/ directory missing")
-    imgs = [p for d in img_dirs for p in d.rglob("*.*") if imghdr.what(p)]
-    labels_roots = {d.parent / "labels" for d in img_dirs}
+    imgs = [p for d in img_dirs for p in d.rglob('*.*') if imghdr.what(p)]
+    labels_roots = {d.parent/'labels' for d in img_dirs}
     lbls = [
-        next((lr / f"{p.stem}.txt" for lr in labels_roots if (lr / f"{p.stem}.txt").exists()), None)
+        next((lr/f"{p.stem}.txt" for lr in labels_roots if (lr/f"{p.stem}.txt").exists()), None)
         for p in imgs
     ]
     return imgs, lbls, meta
 
-
 def get_model(weights: str) -> YOLO | None:
     if not weights or YOLO is None:
         return None
@@ -140,249 +134,218 @@ def get_model(weights: str) -> YOLO | None:
         _model_cache[weights] = YOLO(weights)
     return _model_cache[weights]
 
-# ---------------------------------------------------------------------------
-#                   QUALITY‑EVALUATION (UNCHANGED from v3)
-# ---------------------------------------------------------------------------
-# --‑‑  <Functions qc_integrity / qc_class_balance / qc_image_quality ...>
-#  **(unchanged – omitted for brevity; same as your previous v3 script)**
-# ---------------------------------------------------------------------------
-
-# ════════════════════════════════════════════════════════════════════════════
-#                            MERGE  ✦  EDIT  ✦  ZIP
-# ════════════════════════════════════════════════════════════════════════════
-
-# -------------------- Roboflow helpers --------------------
-RF_RE = re.compile(r"https?://universe\.roboflow\.com/([^/]+)/([^/]+)/(.*)")
-
-def parse_roboflow_url(url: str) -> tuple[str, str, int | None]:
-    """
-    Return (workspace, project, version|None) – tolerates many RF URL flavours.
-    Any non‐positive or malformed version is treated as None.
-    """
-    m = RF_RE.match(url.strip())
-    if not m:
-        return None, None, None
-    ws, proj, tail = m.groups()
-    ver: int | None = None
-
-    # explicit "dataset/<number>" in path
-    if tail.startswith("dataset/"):
-        try:
-            v = int(tail.split("dataset/", 1)[1])
-            if v > 0:
-                ver = v
-        except ValueError:
-            pass
-
-    # explicit "?version=<number>" in query
-    if ver is None and "?version=" in url:
-        try:
-            v = int(url.split("?version=", 1)[1])
-            if v > 0:
-                ver = v
-        except ValueError:
-            pass
-
-    return ws, proj, ver
-
-
-def get_latest_version(rf: Roboflow, ws: str, proj: str) -> str | None:
+# ───────── Functions for I/O-bound concurrency ─────────────────────────────
+def _quality_stat_args(args: Tuple[Path, float]) -> Tuple[Path, bool, bool, bool]:
+    path, thr = args
+    if cv2 is None:
+        return path, False, False, False
+    im = cv2.imread(str(path))
+    if im is None:
+        return path, False, False, False
+    gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
+    lap = cv2.Laplacian(gray, cv2.CV_64F).var()
+    mean = gray.mean()
+    return path, lap < thr, mean < 25, mean > 230
+
+def _is_corrupt(path: Path) -> bool:
     try:
-        p = rf.workspace(ws).project(proj)
-        versions = p.versions()
-        vnums = [int(getattr(v, "version_number", getattr(v, "number", 0))) for v in versions]
-        return str(max(vnums)) if vnums else None
-    except Exception as e:
-        logging.warning(f"RF latest‑version lookup failed: {e}")
-        return None
-
-
-def download_roboflow_dataset(
-    url: str,
-    rf_api_key: str,
-    fmt: str = "yolov8",
-) -> Tuple[Path, List[str], List[str]]:
-    """Return (dataset_location, class_names, splits). Caches by folder name."""
-    if Roboflow is None:
-        raise RuntimeError("`roboflow` pip package not installed")
+        with Image.open(path) as im:
+            im.verify()
+        return False
+    except Exception:
+        return True
+
+# ───────────────── Quality Checks ──────────────────────────────────────────
+def qc_integrity(imgs: List[Path], lbls: List[Path], cfg: QCConfig) -> Dict:
+    missing = [i for i, l in zip(imgs, lbls) if l is None]
+    corrupt = []
+    sample = imgs[:cfg.sample_limit]
+    with ThreadPoolExecutor(max_workers=cfg.cpu_count) as ex:
+        fut = {ex.submit(_is_corrupt, p): p for p in sample}
+        for f in as_completed(fut):
+            if f.result():
+                corrupt.append(fut[f])
+    score = 100 - (len(missing) + len(corrupt)) / max(len(imgs), 1) * 100
+    return {
+        "name": "Integrity",
+        "score": max(score, 0),
+        "details": {
+            "missing_label_files": [str(p) for p in missing],
+            "corrupt_images":       [str(p) for p in corrupt],
+        }
+    }
 
-    ws, proj, ver = parse_roboflow_url(url)
-    if not (ws and proj):
-        raise ValueError(f"Bad Roboflow URL: {url!r}")
+def qc_class_balance(lbls: List[Path], cfg: QCConfig) -> Dict:
+    counts, boxes = Counter(), []
+    for l in lbls[:cfg.sample_limit]:
+        bs = parse_label_file(l) if l else []
+        boxes.append(len(bs))
+        counts.update(b[0] for b in bs)
+    if not counts:
+        return {"name":"Class balance","score":0,"details":"No labels"}
+    bal = min(counts.values()) / max(counts.values()) * 100
+    return {
+        "name":"Class balance",
+        "score":bal,
+        "details":{
+            "class_counts": dict(counts),
+            "boxes_per_image": {
+                "min": min(boxes),
+                "max": max(boxes),
+                "mean": float(np.mean(boxes))
+            }
+        }
+    }
 
-    rf = Roboflow(api_key=rf_api_key)
+def qc_image_quality(imgs: List[Path], cfg: QCConfig) -> Dict:
+    if cv2 is None:
+        return {"name":"Image quality","score":100,"details":"cv2 missing"}
+    blurry, dark, bright = [], [], []
+    sample = imgs[:cfg.sample_limit]
+    with ThreadPoolExecutor(max_workers=cfg.cpu_count) as ex:
+        args = [(p, cfg.blur_thr) for p in sample]
+        for p, isb, isd, isB in ex.map(_quality_stat_args, args):
+            if isb: blurry.append(p)
+            if isd: dark.append(p)
+            if isB: bright.append(p)
+    bad = len({*blurry, *dark, *bright})
+    score = 100 - bad / max(len(sample), 1) * 100
+    return {
+        "name":"Image quality",
+        "score":score,
+        "details":{
+            "blurry": [str(p) for p in blurry],
+            "dark":   [str(p) for p in dark],
+            "bright": [str(p) for p in bright]
+        }
+    }
 
-    # if no explicit version or invalid, fetch latest
-    if not ver or ver <= 0:
-        latest = get_latest_version(rf, ws, proj)
-        if latest is None:
-            raise RuntimeError("Could not resolve latest Roboflow version")
+def qc_duplicates(imgs: List[Path], cfg: QCConfig) -> Dict:
+    if fastdup is not None and len(imgs) > 50:
         try:
-            ver = int(latest)
-        except ValueError:
-            raise RuntimeError(f"Invalid latest version returned: {latest!r}")
-
-    ds_dir = TMP_ROOT / f"{ws}_{proj}_v{ver}"
-    if ds_dir.exists():
-        yaml_path = ds_dir / "data.yaml"
-        class_names = load_yaml(yaml_path).get("names", []) if yaml_path.exists() else []
-        splits = [s for s in ("train","valid","test") if (ds_dir / s).exists()]
-        return ds_dir, class_names, splits
-
-    ds_dir.mkdir(parents=True, exist_ok=True)
-    rf.workspace(ws).project(proj).version(ver).download(fmt, location=str(ds_dir))
-
-    yaml_path = ds_dir / "data.yaml"
-    class_names = load_yaml(yaml_path).get("names", []) if yaml_path.exists() else []
-    splits = [s for s in ("train","valid","test") if (ds_dir / s).exists()]
-    return ds_dir, class_names, splits
-
-
-# -------------------- Merge helpers (adapted from Streamlit) --------------
-
-def gather_class_counts(dataset_info_list, class_name_mapping):
-    counts = Counter()
-    for dloc, class_names, splits, _ in dataset_info_list:
-        for split in splits:
-            labels_dir = Path(dloc) / split / "labels"
-            if not labels_dir.exists():
-                continue
-            for lp in labels_dir.rglob("*.txt"):
-                for cls_id, *_ in parse_label_file(lp):
-                    orig = class_names[int(cls_id)] if int(cls_id) < len(class_names) else None
-                    if orig is None:
+            fd = fastdup.create(
+                input_dir=str(Path(imgs[0]).parent.parent),
+                work_dir=str(TMP_ROOT / "fastdup")
+            )
+            fd.run()
+            try:
+                cc = fd.connected_components_grouped(sort_by="comp_size", ascending=False)
+                clusters = cc["files"].tolist() if "files" in cc.columns else cc.groupby("component")["filename"].apply(list).tolist()
+            except Exception:
+                clusters = fd.connected_components()
+            dup = sum(len(c) - 1 for c in clusters)
+            score = max(0.0, 100 - dup / len(imgs) * 100)
+            return {"name":"Duplicates","score":score,"details":{"groups":clusters[:50]}}
+        except Exception as e:
+            return {"name":"Duplicates","score":100.0,"details":{"fastdup_error":str(e)}}
+    return {"name":"Duplicates","score":100.0,"details":{"note":"skipped"}}
+
+def _rel_iou(b1, b2):
+    x1, y1, w1, h1 = b1
+    x2, y2, w2, h2 = b2
+    xa1, ya1 = x1-w1/2, y1-h1/2
+    xa2, ya2 = x1+w1/2, y1+h1/2
+    xb1, yb1 = x2-w2/2, y2-h2/2
+    xb2, yb2 = x2+w2/2, y2+h2/2
+    ix1 = max(xa1, xb1); iy1 = max(ya1, yb1)
+    ix2 = min(xa2, xb2); iy2 = min(ya2, yb2)
+    inter = max(ix2-ix1,0)*max(iy2-iy1,0)
+    union = w1*h1 + w2*h2 - inter
+    return inter/union if union else 0.0
+
+def qc_model_qa(imgs: List[Path], lbls: List[Path], cfg: QCConfig) -> Dict:
+    model = get_model(cfg.weights)
+    if model is None:
+        return {"name":"Model QA","score":100,"details":"skipped"}
+    ious, mism = [], []
+    sample = imgs[:cfg.sample_limit]
+    for i in range(0, len(sample), cfg.batch_size):
+        batch = sample[i:i+cfg.batch_size]
+        results = model.predict(batch, verbose=False, half=True, dynamic=True)
+        for p, res in zip(batch, results):
+            gt = parse_label_file(Path(p).parent.parent/'labels'/f"{Path(p).stem}.txt")
+            for cls, x, y, w, h in gt:
+                best = 0.0
+                for b, c, conf in zip(res.boxes.xywh.cpu().numpy(),
+                                      res.boxes.cls.cpu().numpy(),
+                                      res.boxes.conf.cpu().numpy()):
+                    if conf < cfg.conf_thr or int(c) != cls:
                         continue
-                    merged = class_name_mapping.get(orig, orig)
-                    counts[merged] += 1
-    return dict(counts)
-
-
-def _process_label_file(label_path: Path, class_names_dataset, class_name_mapping):
-    im_name = label_path.stem + label_path.suffix.replace(".txt", ".jpg")
-    img_classes = set()
-    for cls_id, *_ in parse_label_file(label_path):
-        if 0 <= cls_id < len(class_names_dataset):
-            orig = class_names_dataset[int(cls_id)]
-            new  = class_name_mapping.get(orig, orig)
-            img_classes.add(new)
-    return im_name, img_classes
-
-
-def merge_datasets(
-    dataset_info_list: List[Tuple[str, List[str], List[str], str]],
-    class_map_df: pd.DataFrame,
-    out_dir: Path = Path("merged_dataset"),
-    seed: int = 1234,
-) -> Path:
-    """Return path to merged dataset ready for training/eval."""
-    random.seed(seed)
-    if out_dir.exists():
-        shutil.rmtree(out_dir, onerror=lambda f, p, _: (os.chmod(p, stat.S_IWRITE), f(p)))
-    (out_dir / "train/images").mkdir(parents=True, exist_ok=True)
-    (out_dir / "train/labels").mkdir(parents=True, exist_ok=True)
-    (out_dir / "valid/images").mkdir(parents=True, exist_ok=True)
-    (out_dir / "valid/labels").mkdir(parents=True, exist_ok=True)
-
-    class_name_mapping = {
-        row["original_class"]: row["new_name"] if not row["remove"] else "__REMOVED__"
-        for _, row in class_map_df.iterrows()
-    }
-    limits_per_merged = {
-        row["new_name"]: int(row["max_images"])
-        for _, row in class_map_df.iterrows()
-        if not row["remove"]
-    }
-    active_classes = [c for c in sorted(set(class_name_mapping.values())) if c != "__REMOVED__"]
-    id_map = {cls: idx for idx, cls in enumerate(active_classes)}
-
-    image_to_classes: dict[str, set[str]] = {}
-    image_to_label: dict[str, Path] = {}
-    class_to_images: dict[str, set[str]] = {c: set() for c in active_classes}
-
-    for dloc, class_names_dataset, splits, _ in dataset_info_list:
-        for split in splits:
-            labels_root = Path(dloc) / split / "labels"
-            if not labels_root.exists():
-                continue
-            for lp in labels_root.rglob("*.txt"):
-                im_name, cls_set = _process_label_file(lp, class_names_dataset, class_name_mapping)
-                cls_set = {c for c in cls_set if c in active_classes}
-                if not cls_set:
-                    continue
-                img_path = str(lp).replace("labels", "images").replace(".txt", ".jpg")
-                image_to_classes[img_path] = cls_set
-                image_to_label[img_path]   = lp
-                for c in cls_set:
-                    class_to_images[c].add(img_path)
-
-    selected_images: set[str] = set()
-    counters = {c: 0 for c in active_classes}
-    shuffle_pool = [img for imgs in class_to_images.values() for img in imgs]
-    random.shuffle(shuffle_pool)
-
-    for img in shuffle_pool:
-        cls_set = image_to_classes[img]
-        if any(counters[c] >= limits_per_merged.get(c, 0) for c in cls_set):
-            continue
-        selected_images.add(img)
-        for c in cls_set:
-            counters[c] += 1
-
-    for img in selected_images:
-        split = "train" if random.random() < 0.9 else "valid"
-        dst_img = out_dir / split / "images" / Path(img).name
-        dst_img.parent.mkdir(parents=True, exist_ok=True)
-        shutil.copy(img, dst_img)
-
-        lp_src = image_to_label[img]
-        dst_label = out_dir / split / "labels" / Path(lp_src).name
-        dst_label.parent.mkdir(parents=True, exist_ok=True)
-        with open(lp_src, "r") as f:
-            lines = f.readlines()
-        new_lines = []
-        for line in lines:
-            parts = line.strip().split()
-            if not parts:
-                continue
-            cid = int(parts[0])
-            dloc_match = next((cl for dloc2, cl, _, _ in dataset_info_list if str(lp_src).startswith(dloc2)), None)
-            if dloc_match is None:
-                continue
-            orig_cls_name = dloc_match[cid] if cid < len(dloc_match) else None
-            if orig_cls_name is None:
-                continue
-            merged_cls_name = class_name_mapping.get(orig_cls_name, orig_cls_name)
-            if merged_cls_name not in active_classes:
-                continue
-            new_id = id_map[merged_cls_name]
-            new_lines.append(" ".join([str(new_id)] + parts[1:]))
-        if new_lines:
-            with open(dst_label, "w") as f:
-                f.write("\n".join(new_lines))
-        else:
-            (out_dir / split / "images" / Path(img).name).unlink(missing_ok=True)
-
-    data_yaml = {
-        "path": str(out_dir.resolve()),
-        "train": "train/images",
-        "val": "valid/images",
-        "nc": len(active_classes),
-        "names": active_classes,
-    }
-    with open(out_dir / "data.yaml", "w") as f:
-        yaml.safe_dump(data_yaml, f)
-
-    return out_dir
-
-
-def zip_directory(folder: Path) -> bytes:
-    buf = io.BytesIO()
-    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
-        for file in folder.rglob("*"):
-            zf.write(file, arcname=file.relative_to(folder))
-    buf.seek(0)
-    return buf.getvalue()
-
+                    best = max(best, _rel_iou((x,y,w,h), tuple(b)))
+                ious.append(best)
+                if best < cfg.iou_thr:
+                    mism.append(str(p))
+    miou = float(np.mean(ious)) if ious else 1.0
+    return {"name":"Model QA","score":miou*100,"details":{"mean_iou":miou,"mismatches":mism[:50]}}
+
+def qc_label_issues(imgs: List[Path], lbls: List[Path], cfg: QCConfig) -> Dict:
+    if get_noise_indices is None:
+        return {"name":"Label issues","score":100,"details":"skipped"}
+    labels, idxs = [], []
+    sample = imgs[:cfg.sample_limit]
+    for i, p in enumerate(sample):
+        bs = parse_label_file(lbls[i]) if lbls[i] else []
+        for cls, *_ in bs:
+            labels.append(int(cls)); idxs.append(i)
+    if not labels:
+        return {"name":"Label issues","score":100,"details":"no GT"}
+    labels_arr = np.array(labels)
+    uniq       = sorted(set(labels_arr))
+    probs      = np.eye(len(uniq))[np.searchsorted(uniq, labels_arr)]
+    noise      = get_noise_indices(labels=labels_arr, probabilities=probs)
+    flags      = sorted({idxs[n] for n in noise})
+    files      = [str(sample[i]) for i in flags]
+    score      = 100 - len(flags)/len(labels)*100
+    return {"name":"Label issues","score":score,"details":{"files":files[:50]}}
+
+def aggregate(results: List[Dict]) -> float:
+    return sum(DEFAULT_W[r["name"]]*r["score"] for r in results)
+
+# ───────────────── Roboflow TXT‑loading logic (from v3) ────────────────────
+RF_RE = re.compile(r"https?://universe\.roboflow\.com/([^/]+)/([^/]+)/dataset/(\d+)")
+
+def download_rf_dataset(url: str, rf_api: Roboflow, dest: Path) -> Path:
+    m = RF_RE.match(url.strip())
+    if not m:
+        raise ValueError(f"Bad RF URL: {url}")
+    ws, proj, ver = m.groups()
+    ds_dir = dest / f"{ws}_{proj}_v{ver}"
+    if ds_dir.exists():
+        return ds_dir
+    pr = rf_api.workspace(ws).project(proj)
+    pr.version(int(ver)).download("yolov8", location=str(ds_dir))
+    return ds_dir
+
+def run_quality(
+    root: Path,
+    yaml_file: Path | None,
+    weights: Path | None,
+    cfg: QCConfig,
+    run_dup: bool,
+    run_modelqa: bool
+) -> Tuple[str, pd.DataFrame]:
+    imgs, lbls, meta = gather_dataset(root, yaml_file)
+    results = [
+        qc_integrity(imgs, lbls, cfg),
+        qc_class_balance(lbls, cfg),
+        qc_image_quality(imgs, cfg),
+        qc_duplicates(imgs, cfg)      if run_dup     else {"name":"Duplicates","score":100,"details":"skipped"},
+        qc_model_qa(imgs, lbls, cfg)  if run_modelqa else {"name":"Model QA","score":100,"details":"skipped"},
+        qc_label_issues(imgs, lbls, cfg) if run_modelqa else {"name":"Label issues","score":100,"details":"skipped"},
+    ]
+    final = aggregate(results)
+    md = [f"## **{meta.get('name', root.name)}** — Score {final:.1f}/100"]
+    for r in results:
+        md.append(f"### {r['name']}  {r['score']:.1f}")
+        md.append("<details><summary>details</summary>\n```json")
+        md.append(json.dumps(r["details"], indent=2))
+        md.append("```\n</details>\n")
+    df = pd.DataFrame.from_dict(
+        next(r for r in results if r["name"]=="Class balance")["details"]["class_counts"],
+        orient="index", columns=["count"]
+    )
+    df.index.name = "class"
+    return "\n".join(md), df
 
 # ════════════════════════════════════════════════════════════════════════════
 #                                 UI LAYER
@@ -393,7 +356,6 @@ with gr.Blocks(css="#classdf td{min-width:120px}") as demo:
     _Evaluate • Merge • Edit • Download_
     """)
 
-    # ------------------------------ EVALUATE TAB --------------------------
     with gr.Tab("Evaluate"):
         with gr.Row():
             api_in     = gr.Textbox(label="Roboflow API key", type="password")
@@ -404,27 +366,74 @@ with gr.Blocks(css="#classdf td{min-width:120px}") as demo:
         with gr.Row():
             yaml_in    = gr.File(label="Custom YAML", file_types=['.yaml'])
             weights_in = gr.File(label="YOLO weights (.pt)")
-        blur_sl  = gr.Slider(0.0, 500.0, value=100.0, label="Blur threshold")
-        iou_sl   = gr.Slider(0.0, 1.0,   value=0.5,   label="IOU threshold")
-        conf_sl  = gr.Slider(0.0, 1.0,   value=0.25,  label="Min detection confidence")
-        run_dup  = gr.Checkbox(label="Check duplicates (fastdup)")
-        run_qa   = gr.Checkbox(label="Run Model QA & cleanlab")
-        run_eval = gr.Button("Run Evaluation")
-        out_md   = gr.Markdown()
-        out_df   = gr.Dataframe(label="Class distribution")
-
-        def _evaluate_cb(api_key, url_txt, zip_file, server_path, yaml_file, weights,
-                         blur_thr, iou_thr, conf_thr, run_dup, run_modelqa):
-            return "Evaluation disabled in this trimmed snippet.", pd.DataFrame()
+        blur_sl    = gr.Slider(0.0, 500.0, value=100.0, label="Blur threshold")
+        iou_sl     = gr.Slider(0.0, 1.0,   value=0.5,   label="IOU threshold")
+        conf_sl    = gr.Slider(0.0, 1.0,   value=0.25,  label="Min detection confidence")
+        run_dup    = gr.Checkbox(label="Check duplicates (fastdup)", value=False)
+        run_modelqa= gr.Checkbox(label="Run Model QA & cleanlab", value=False)
+        run_eval   = gr.Button("Run Evaluation")
+        out_md     = gr.Markdown()
+        out_df     = gr.Dataframe()
+
+        def _evaluate_cb(
+            api_key, url_txt, zip_file, server_path, yaml_file, weights,
+            blur_thr, iou_thr, conf_thr, run_dup, run_modelqa
+        ):
+            reports, dfs = [], []
+            cfg = QCConfig(blur_thr, iou_thr, conf_thr, weights.name if weights else None)
+            rf = Roboflow(api_key) if api_key and Roboflow else None
+
+            # Roboflow URLs via .txt
+            if url_txt:
+                for line in Path(url_txt.name).read_text().splitlines():
+                    if not line.strip():
+                        continue
+                    try:
+                        ds = download_rf_dataset(line, rf, TMP_ROOT)
+                        md, df = run_quality(
+                            ds, None,
+                            Path(weights.name) if weights else None,
+                            cfg, run_dup, run_modelqa
+                        )
+                        reports.append(md); dfs.append(df)
+                    except Exception as e:
+                        reports.append(f"### {line}\n⚠️ {e}")
+
+            # ZIP upload
+            if zip_file:
+                tmp = Path(tempfile.mkdtemp())
+                shutil.unpack_archive(zip_file.name, tmp)
+                md, df = run_quality(
+                    tmp,
+                    Path(yaml_file.name) if yaml_file else None,
+                    Path(weights.name) if weights else None,
+                    cfg, run_dup, run_modelqa
+                )
+                reports.append(md); dfs.append(df)
+                shutil.rmtree(tmp, ignore_errors=True)
+
+            # Server path
+            if server_path:
+                ds = Path(server_path)
+                md, df = run_quality(
+                    ds,
+                    Path(yaml_file.name) if yaml_file else None,
+                    Path(weights.name) if weights else None,
+                    cfg, run_dup, run_modelqa
+                )
+                reports.append(md); dfs.append(df)
+
+            summary  = "\n---\n".join(reports) if reports else ""
+            combined = pd.concat(dfs).groupby(level=0).sum() if dfs else pd.DataFrame()
+            return summary, combined
 
         run_eval.click(
             _evaluate_cb,
-            [api_in, url_txt, zip_in, path_in, yaml_in, weights_in,
-             blur_sl, iou_sl, conf_sl, run_dup, run_qa],
-            [out_md, out_df]
+            inputs=[api_in, url_txt, zip_in, path_in, yaml_in, weights_in,
+                    blur_sl, iou_sl, conf_sl, run_dup, run_modelqa],
+            outputs=[out_md, out_df]
         )
 
-    # ------------------------------ MERGE TAB -----------------------------
     with gr.Tab("Merge / Edit"):
         gr.Markdown("### 1️⃣ Load one or more datasets")
         rf_key   = gr.Textbox(label="Roboflow API key", type="password")
@@ -436,15 +445,15 @@ with gr.Blocks(css="#classdf td{min-width:120px}") as demo:
 
         def _load_cb(rf_key, rf_urls_file, zip_files):
             global autoinc
-            info_list = []
-            log_lines = []
+            info_list, log_lines = [], []
 
-            if rf_urls_file is not None:
+            if rf_urls_file:
                 for url in Path(rf_urls_file.name).read_text().splitlines():
                     if not url.strip():
                         continue
                     try:
-                        ds, names, splits = download_roboflow_dataset(url, rf_key)
+                        ds = download_rf_dataset(url, Roboflow(rf_key), TMP_ROOT)
+                        names, splits = load_yaml(ds/"data.yaml").get("names", []), [s for s in ("train","valid","test") if (ds/s).exists()]
                         info_list.append((str(ds), names, splits, Path(ds).name))
                         log_lines.append(f"✔️ RF dataset **{Path(ds).name}** loaded ({len(names)} classes)")
                     except Exception as e:
@@ -455,11 +464,11 @@ with gr.Blocks(css="#classdf td{min-width:120px}") as demo:
                 tmp = TMP_ROOT / f"zip_{autoinc}"
                 tmp.mkdir(parents=True, exist_ok=True)
                 shutil.unpack_archive(f.name, tmp)
-                yaml_path = next(tmp.rglob("*.yaml"), None)
-                if yaml_path is None:
+                yaml_p = next(tmp.rglob("*.yaml"), None)
+                if not yaml_p:
                     continue
-                names = load_yaml(yaml_path).get("names", [])
-                splits = [s for s in ("train","valid","test") if (tmp / s).exists()]
+                names = load_yaml(yaml_p).get("names", [])
+                splits= [s for s in ("train","valid","test") if (tmp/s).exists()]
                 info_list.append((str(tmp), names, splits, tmp.name))
                 log_lines.append(f"✔️ ZIP **{tmp.name}** loaded")
 
@@ -469,22 +478,19 @@ with gr.Blocks(css="#classdf td{min-width:120px}") as demo:
 
         gr.Markdown("### 2️⃣ Edit class mapping / limits / removal")
         class_df = gr.Dataframe(
-            headers=["original_class", "new_name", "max_images", "remove"],
-            datatype=["str", "str", "number", "bool"],
+            headers=["original_class","new_name","max_images","remove"],
+            datatype=["str","str","number","bool"],
             interactive=True, elem_id="classdf"
         )
         refresh_btn = gr.Button("Build class table from loaded datasets")
 
         def _build_class_df(ds_info):
-            class_names_all = []
-            for _dloc, names, _spl, _ in ds_info:
-                class_names_all.extend(names)
-            class_names_all = sorted(set(class_names_all))
+            all_names = sorted({n for _, names, _, _ in ds_info for n in names})
             return pd.DataFrame({
-                "original_class": class_names_all,
-                "new_name":       class_names_all,
-                "max_images":     [99999] * len(class_names_all),
-                "remove":         [False]  * len(class_names_all),
+                "original_class": all_names,
+                "new_name":       all_names,
+                "max_images":     [99999]*len(all_names),
+                "remove":         [False]*len(all_names),
             })
 
         refresh_btn.click(_build_class_df, [ds_state], [class_df])
@@ -498,13 +504,9 @@ with gr.Blocks(css="#classdf td{min-width:120px}") as demo:
                 return None, "⚠️ Load datasets first."
             out_dir = merge_datasets(ds_info, class_df)
             zip_path = shutil.make_archive(str(out_dir), "zip", out_dir)
-            return zip_path, (
-                f"✅ Merged dataset created at **{out_dir}** with "
-                f"{len(list(Path(out_dir).rglob('*.jpg')))} images."
-            )
+            return zip_path, f"✅ Merged dataset at **{out_dir}** with {len(list(Path(out_dir).rglob('*.jpg')))} images."
 
         merge_btn.click(_merge_cb, [ds_state, class_df], [zip_out, merge_log])
 
-
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)))