Update app.py

app.py

@@ -48,7 +48,7 @@ def convert_seg_to_bbox(api_key: str, dataset_url: str, split_ratios=(0.8, 0.1,
     cat_ids     = sorted(c['id'] for c in coco.get('categories', []))
     id_to_index = {cid: idx for idx, cid in enumerate(cat_ids)}
 
-    # flatten & convert
+    # flatten & convert to YOLO bboxes
     out_root = tempfile.mkdtemp(prefix="yolov8_")
     flat_img = os.path.join(out_root, "flat_images")
     flat_lbl = os.path.join(out_root, "flat_labels")
@@ -58,26 +58,25 @@ def convert_seg_to_bbox(api_key: str, dataset_url: str, split_ratios=(0.8, 0.1,
     annos = {}
     for anno in coco['annotations']:
         img_id = anno['image_id']
-        poly   = anno['segmentation'][0]
-        xs, ys = poly[0::2], poly[1::2]
+        xs, ys = anno['segmentation'][0][0::2], anno['segmentation'][0][1::2]
         xmin, xmax = min(xs), max(xs)
         ymin, ymax = min(ys), max(ys)
-        w, h     = xmax - xmin, ymax - ymin
-        cx, cy   = xmin + w/2, ymin + h/2
+        w, h       = xmax - xmin, ymax - ymin
+        cx, cy     = xmin + w/2, ymin + h/2
 
-        iw, ih   = images_info[img_id]['width'], images_info[img_id]['height']
-        line     = (
+        iw, ih = images_info[img_id]['width'], images_info[img_id]['height']
+        line = (
             f"{id_to_index[anno['category_id']]} "
             f"{cx/iw:.6f} {cy/ih:.6f} {w/iw:.6f} {h/ih:.6f}"
         )
         annos.setdefault(img_id, []).append(line)
 
     name_to_id = {img['file_name']: img['id'] for img in coco['images']}
-    file_paths = {}
-    for dp, _, files in os.walk(root):
-        for f in files:
-            if f in name_to_id:
-                file_paths[f] = os.path.join(dp, f)
+    file_paths = {
+        f: os.path.join(dp, f)
+        for dp, _, files in os.walk(root) for f in files
+        if f in name_to_id
+    }
 
     for fname, img_id in name_to_id.items():
         src = file_paths.get(fname)
@@ -87,7 +86,7 @@ def convert_seg_to_bbox(api_key: str, dataset_url: str, split_ratios=(0.8, 0.1,
         with open(os.path.join(flat_lbl, fname.rsplit('.',1)[0] + ".txt"), 'w') as lf:
             lf.write("\n".join(annos.get(img_id, [])))
 
-    # split
+    # split into train/valid/test
     all_files = sorted(f for f in os.listdir(flat_img)
                        if f.lower().endswith(('.jpg','.png','.jpeg')))
     random.shuffle(all_files)
@@ -108,16 +107,14 @@ def convert_seg_to_bbox(api_key: str, dataset_url: str, split_ratios=(0.8, 0.1,
         os.makedirs(idir, exist_ok=True)
         os.makedirs(ldir, exist_ok=True)
         for fn in files:
-            shutil.move(os.path.join(flat_img, fn),
-                        os.path.join(idir, fn))
+            shutil.move(os.path.join(flat_img, fn), os.path.join(idir, fn))
             lbl = fn.rsplit('.',1)[0] + ".txt"
-            shutil.move(os.path.join(flat_lbl, lbl),
-                        os.path.join(ldir, lbl))
+            shutil.move(os.path.join(flat_lbl, lbl), os.path.join(ldir, lbl))
 
     shutil.rmtree(flat_img)
     shutil.rmtree(flat_lbl)
 
-    # prepare visuals
+    # before/after visuals
     before, after = [], []
     sample = random.sample(list(name_to_id.keys()), min(5, len(name_to_id)))
     for fname in sample:
@@ -159,76 +156,73 @@ def upload_and_train_detection(
     rf = Roboflow(api_key=api_key)
     ws = rf.workspace(workspace)
 
-    # 1) Try to fetch existing project
+    # 1) Try fetch existing project
     try:
         proj = ws.project(project_slug)
     except Exception as e:
         if "does not exist" in str(e).lower():
             proj = ws.create_project(
-                project_slug,
-                annotation=project_type,
-                project_type=project_type,
-                project_license=project_license
+                name=project_slug,
+                type=project_type,
+                annotation=project_slug,
+                license=project_license
             )
         else:
             raise
 
-    # 2) If it exists but is NOT object-detection, make a fresh slug
-    if getattr(proj, "annotation", None) != project_type:
+    # 2) If the type mismatches, spin up a fresh <slug>-v2 :contentReference[oaicite:0]{index=0}
+    if getattr(proj, "type", None) != project_type:
         new_slug = project_slug + "-v2"
         proj = ws.create_project(
-            new_slug,
-            annotation=project_type,
-            project_type=project_type,
-            project_license=project_license
+            name=new_slug,
+            type=project_type,
+            annotation=new_slug,
+            license=project_license
         )
         project_slug = new_slug
 
-    # 3) Upload train/val/test
+    # 3) Upload your train/valid/test
     ws.upload_dataset(
         dataset_path,
         project_slug,
-        project_license=project_license,
+        license=project_license,
         project_type=project_type
     )
 
-    # 4) Generate new version & train, with fallback on unsupported-request errors
+    # 4) Generate a new version with the documented signature :contentReference[oaicite:1]{index=1}
     try:
-        version_num = proj.generate_version(settings={
-            "augmentation": {},
-            "preprocessing": {},
-        })
+        new_version = proj.generate_version(
+            preprocessing={},
+            augmentation={}
+        )
     except RuntimeError as e:
         msg = str(e).lower()
         if "unsupported request" in msg or "does not exist" in msg:
+            # fallback to <slug>-v3
             suffix = "-v3" if project_slug.endswith("-v2") else "-v2"
             new_slug = project_slug + suffix
             proj = ws.create_project(
-                new_slug,
-                annotation=project_type,
-                project_type=project_type,
-                project_license=project_license
+                name=new_slug,
+                type=project_type,
+                annotation=new_slug,
+                license=project_license
             )
             project_slug = new_slug
-            ws.upload_dataset(
-                dataset_path,
-                project_slug,
-                project_license=project_license,
-                project_type=project_type
+            ws.upload_dataset(dataset_path, project_slug,
+                              license=project_license,
+                              project_type=project_type)
+            new_version = proj.generate_version(
+                preprocessing={},
+                augmentation={}
             )
-            version_num = proj.generate_version(settings={
-                "augmentation": {},
-                "preprocessing": {},
-            })
         else:
             raise
 
-    # 5) Kick off training
-    proj.version(str(version_num)).train()
+    # 5) Kick off training (asynchronously) :contentReference[oaicite:2]{index=2}
+    model = proj.version(new_version).train()
 
-    # 6) Return the hosted endpoint
-    m = proj.version(str(version_num)).model
-    return f"{m['base_url']}{m['id']}?api_key={api_key}"
+    # 6) Return the hosted endpoint URL
+    return f"{model['base_url']}{model['id']}?api_key={api_key}"
 
 
 # --- Gradio UI ---