update app.py

app.py

@@ -25,350 +25,225 @@ VERIFY_FILE = os.path.join(CACHE_DIR, "verifications.csv")
 SKIP_FILE = os.path.join(CACHE_DIR, "skipped.csv")
 LOCK_FILE = os.path.join(CACHE_DIR, "data.lock")
 
+MAX_IMAGES = 6
+THUMB_SIZE = (350, 350)
+ROOM_CLASSES = ["living_room", "bedroom", "kitchen", "bathroom", "dining_room", "outdoor", "other"]
+
 def sync_pull():
     print(f"🔄 Syncing from {DATASET_REPO_ID}...")
     token = HF_TOKEN if HF_TOKEN and len(HF_TOKEN) > 5 else None
-    
     for filename in ["annotations.csv", "verifications.csv", "skipped.csv"]:
         try:
-            hf_hub_download(
-                repo_id=DATASET_REPO_ID,
-                filename=filename,
-                repo_type="dataset",
-                local_dir=CACHE_DIR,
-                token=token
-            )
+            hf_hub_download(repo_id=DATASET_REPO_ID, filename=filename, repo_type="dataset", local_dir=CACHE_DIR, token=token)
             print(f"✅ Loaded {filename}")
         except Exception as e:
             print(f"ℹ️ {filename} sync info: {e}")
 
-MAX_IMAGES = 6
-THUMB_SIZE = (350, 350)
-ROOM_CLASSES = ["living_room", "bedroom", "kitchen", "bathroom", "dining_room", "outdoor", "other"]
-
-
 def sync_push_background(local_path, remote_filename):
-    if not HF_TOKEN: return
+    token = HF_TOKEN if HF_TOKEN and len(HF_TOKEN) > 5 else None
+    if not token: return
     def _push():
         try:
-            api = HfApi(token=HF_TOKEN)
-            api.upload_file(
-                path_or_fileobj=local_path,
-                path_in_repo=remote_filename,
-                repo_id=DATASET_REPO_ID,
-                repo_type="dataset",
-                commit_message=f"Update {remote_filename}"
-            )
-            print(f"☁️ Synced {remote_filename}")
-        except Exception as e:
-            print(f"❌ Sync failed: {e}")
+            api = HfApi(token=token)
+            api.upload_file(path_or_fileobj=local_path, path_in_repo=remote_filename, repo_id=DATASET_REPO_ID, repo_type="dataset")
+        except Exception as e: print(f"❌ Sync failed: {e}")
     threading.Thread(target=_push).start()
 
 def init_files():
     sync_pull()
     for f in [LABEL_FILE, VERIFY_FILE, SKIP_FILE]:
         if not os.path.exists(f):
-            if f == LABEL_FILE: 
-                cols = ["timestamp", "user", "group_id", "url", "score", "label"]
-            elif f == VERIFY_FILE: 
-                cols = ["timestamp", "user", "group_id", "url", "is_correct", "corrected_label", "corrected_score"]
-            else: 
-                cols = ["timestamp", "user", "group_id"]
+            cols = ["timestamp", "user", "group_id", "url", "score", "label"] if f == LABEL_FILE else \
+                   ["timestamp", "user", "group_id", "url", "is_correct", "corrected_label", "corrected_score"] if f == VERIFY_FILE else \
+                   ["timestamp", "user", "group_id"]
             pd.DataFrame(columns=cols).to_csv(f, index=False)
-            
-    if not os.path.exists(URL_FILE):
-        print(f"⚠️ {URL_FILE} not found in root! Please upload it.")
 
 init_files()
 
-def get_image_optimized(url):
-    if not url: return None
-    try:
-        headers = {'User-Agent': 'Mozilla/5.0'}
-        response = requests.get(url, headers=headers, timeout=3)
-        if response.status_code == 200:
-            img = Image.open(BytesIO(response.content))
-            img.thumbnail(THUMB_SIZE, Image.Resampling.LANCZOS)
-            return img
-    except: pass
-    return url 
-
 def load_all_urls():
     urls = []
-    if not os.path.exists(URL_FILE):
-        return urls
-    
+    if not os.path.exists(URL_FILE): return urls
     try:
         with open(URL_FILE, 'r') as f:
             data = json.load(f)
             if "groups" in data:
-                for group in data["groups"]:
-                    urls.extend(group.get("images", []))
-            elif isinstance(data, dict):
-                for rows in data.values():
-                    if isinstance(rows, list):
-                        for row in rows:
-                            if "unstaged_images" in row:
-                                urls.append(row["unstaged_images"])
-    except Exception as e:
-        print(f"Error loading URLs: {e}")
+                for group in data["groups"]: urls.extend(group.get("images", []))
+    except: pass
     return urls
 
 def get_ordered_groups():
     groups = []
     seen = set()
-    all_urls = load_all_urls()
-    for u in all_urls:
-        if u:
-            try: gid = u.split("-m")[0].split("/")[-1]
-            except: gid = "unknown"
-            if gid not in seen:
-                groups.append(gid)
-                seen.add(gid)
+    for u in load_all_urls():
+        try: gid = u.split("-m")[0].split("/")[-1]
+        except: gid = "unknown"
+        if gid not in seen:
+            groups.append(gid); seen.add(gid)
     return groups
 
+def get_flagged_groups():
+    if not os.path.exists(LABEL_FILE): return []
+    try:
+        df = pd.read_csv(LABEL_FILE)
+        errors = df[(df['score'] == 10) & (df['label'] != 'living_room')]
+        return errors['group_id'].unique().tolist()
+    except: return []
+
+def get_stats_text():
+    all_gids = get_ordered_groups()
+    flagged = get_flagged_groups()
+    try: l = len(pd.read_csv(LABEL_FILE)['group_id'].unique())
+    except: l = 0
+    err_msg = f" | ⚠️ **Errors to Fix:** {len(flagged)}" if flagged else ""
+    return f"**Total Properties:** {len(all_gids)} | **Labeled:** {l}{err_msg}"
+
 def get_group_urls(target_gid):
-    urls = []
-    all_urls = load_all_urls()
-    for u in all_urls:
-        if u and target_gid in u:
-            urls.append(u)
-    return urls[:MAX_IMAGES]
+    return [u for u in load_all_urls() if target_gid in u][:MAX_IMAGES]
 
 def get_saved_values(gid, mode):
     saved_data = {}
     try:
-        filename = LABEL_FILE if mode == "label" else VERIFY_FILE
-        if os.path.exists(filename):
-            df = pd.read_csv(filename)
-            rows = df[df['group_id'] == gid]
-            for _, row in rows.iterrows():
-                if mode == "label":
-                    saved_data[row['url']] = {"score": row['score'], "label": row['label']}
-                else:
-                    sc = row['corrected_score'] if 'corrected_score' in row else 5
-                    saved_data[row['url']] = {"is_correct": row['is_correct'], "label": row['corrected_label'], "score": sc}
+        fname = LABEL_FILE if mode in ["label", "fix"] else VERIFY_FILE
+        df = pd.read_csv(fname)
+        rows = df[df['group_id'] == gid]
+        for _, row in rows.iterrows():
+            if mode in ["label", "fix"]:
+                saved_data[row['url']] = {"score": row['score'], "label": row['label']}
+            else:
+                saved_data[row['url']] = {"is_correct": row['is_correct'], "label": row['corrected_label'], "score": row['corrected_score']}
     except: pass
     return saved_data
 
-def get_stats_text():
-    all_gids = get_ordered_groups()
-    try: l = len(pd.read_csv(LABEL_FILE)['group_id'].unique())
-    except: l = 0
-    try: v = len(pd.read_csv(VERIFY_FILE)['group_id'].unique())
-    except: v = 0
-    return f"**Total Properties:** {len(all_gids)} | **Labeled:** {l} | **Verified:** {v}"
-
 def render_workspace(mode, history, specific_index=None, move_back=False):
-    all_groups = get_ordered_groups()
+    if mode == "fix":
+        all_groups = get_flagged_groups()
+        if not all_groups:
+            return {screen_menu: gr.update(visible=True), screen_work: gr.update(visible=False), log_box: "🎉 No more errors found!"}
+    else:
+        all_groups = get_ordered_groups()
+
     total_groups = len(all_groups)
     
-    try: l_done = set(pd.read_csv(LABEL_FILE)['group_id'].unique())
-    except: l_done = set()
-    try: v_done = set(pd.read_csv(VERIFY_FILE)['group_id'].unique())
-    except: v_done = set()
-    try: s_done = set(pd.read_csv(SKIP_FILE)['group_id'].unique())
-    except: s_done = set()
-
     target_gid = None
-    target_idx = -1
-
     if specific_index is not None:
-        if 0 <= specific_index < total_groups:
-            target_gid = all_groups[specific_index]
-            target_idx = specific_index
-        else:
-            return {log_box: "End of list."}
-
+        if 0 <= specific_index < total_groups: target_gid = all_groups[specific_index]
+        else: return {log_box: "Index out of range."}
     elif move_back and len(history) > 1:
-        history.pop()
-        target_gid = history[-1]
-        try: target_idx = all_groups.index(target_gid)
-        except: target_idx = 0
-        
+        history.pop(); target_gid = history[-1]
     else:
-        candidates = []
-        for i, gid in enumerate(all_groups):
-            if gid in s_done: continue
-            is_ready = False
-            if mode == "label" and gid not in l_done: is_ready = True
-            elif mode == "verify" and gid in l_done and gid not in v_done: is_ready = True
-            
-            if is_ready:
-                candidates.append((i, gid))
+        try: done = set(pd.read_csv(VERIFY_FILE if mode == "verify" else LABEL_FILE)['group_id'].unique())
+        except: done = set()
         
+        candidates = [g for g in all_groups if g not in done] if mode != "fix" else all_groups
         if not candidates:
-             return {screen_menu: gr.update(visible=True), screen_work: gr.update(visible=False), log_box: "No more tasks found."}
-        
-        target_idx, target_gid = random.choice(candidates)
+             return {screen_menu: gr.update(visible=True), screen_work: gr.update(visible=False), log_box: "All items completed in this mode."}
+        target_gid = candidates[0]
 
     urls = get_group_urls(target_gid)
-    if not history or history[-1] != target_gid:
-        history.append(target_gid)
-        
-    saved_vals = get_saved_values(target_gid, mode)
-    r1_vals = get_saved_values(target_gid, "label") if mode == "verify" else {}
-
-    processed_images = [None] * MAX_IMAGES
-    with ThreadPoolExecutor(max_workers=MAX_IMAGES) as executor:
-        futures = {executor.submit(get_image_optimized, u): i for i, u in enumerate(urls)}
-        for future in futures:
-            processed_images[futures[future]] = future.result()
-
-    header = f"# Property #{target_idx + 1} (ID: {target_gid})"
+    if not history or history[-1] != target_gid: history.append(target_gid)
     
+    saved_vals = get_saved_values(target_gid, mode)
+    target_idx = all_groups.index(target_gid)
+
+    with ThreadPoolExecutor(max_workers=MAX_IMAGES) as ex:
+        def get_img(u):
+            try:
+                r = requests.get(u, timeout=3, headers={'User-Agent': 'Mozilla/5.0'})
+                img = Image.open(BytesIO(r.content))
+                img.thumbnail(THUMB_SIZE); return img
+            except: return None
+        processed_images = list(ex.map(get_img, urls))
+
+    header = f"# {'🛠 FIX MODE' if mode == 'fix' else 'Property'} #{target_idx + 1} (ID: {target_gid})"
     updates = {
-        screen_menu: gr.update(visible=False),
-        screen_work: gr.update(visible=True),
-        header_md: header,
-        state_urls: urls,
-        state_hist: history,
-        state_idx: target_idx,
-        top_stats: get_stats_text(),
-        log_box: f"Loaded group {target_gid}"
+        screen_menu: gr.update(visible=False), screen_work: gr.update(visible=True),
+        header_md: header, state_urls: urls, state_hist: history, state_idx: target_idx,
+        top_stats: get_stats_text(), log_box: f"Mode: {mode} | ID: {target_gid}"
     }
 
     for i in range(MAX_IMAGES):
-        img_c = img_objs[i]
         base = i * 4
-        c_sld, c_drp, c_chk, c_lbl = input_objs[base], input_objs[base+1], input_objs[base+2], input_objs[base+3]
-        
+        c_sld, c_drp, c_chk, c_lbl = input_objs[base:base+4]
         if i < len(urls):
             u = urls[i]
-            img_data = processed_images[i]
-            updates[img_c] = gr.update(value=img_data, visible=True)
+            updates[img_objs[i]] = gr.update(value=processed_images[i], visible=True)
             v_sc = saved_vals.get(u, {}).get('score', 5)
-            v_lbl = saved_vals.get(u, {}).get('label', ROOM_CLASSES[0])
-            v_chk = saved_vals.get(u, {}).get('is_correct', True)
+            v_lbl = saved_vals.get(u, {}).get('label', "living_room")
             
-            if mode == "label":
+            is_error = (v_sc == 10 and v_lbl != "living_room")
+            error_border = "⚠️ INCORRECT (Score 10 only for Living Room)" if is_error else ""
+
+            if mode in ["label", "fix"]:
                 updates[c_sld] = gr.update(visible=True, value=v_sc, interactive=True)
                 updates[c_drp] = gr.update(visible=True, value=v_lbl, interactive=True)
                 updates[c_chk] = gr.update(visible=False)
-                updates[c_lbl] = gr.update(visible=False)
-            else:
-                prev_lbl = r1_vals.get(u, {}).get('label', "Unknown")
-                prev_sc = r1_vals.get(u, {}).get('score', 0)
-                
-                display_score = v_sc if u in saved_vals else prev_sc
-                
-                updates[c_sld] = gr.update(visible=True, value=display_score, interactive=True) 
-                updates[c_lbl] = gr.update(visible=True, value=f"**Labeled:** {prev_lbl} | **Score:** {prev_sc}")
-                updates[c_drp] = gr.update(visible=True, value=v_lbl, interactive=True)
-                updates[c_chk] = gr.update(visible=True, value=v_chk, interactive=True)
+                updates[c_lbl] = gr.update(visible=True if is_error else False, value=f"<span style='color:red'>{error_border}</span>")
+            else: 
+                updates[c_sld] = gr.update(visible=True, value=v_sc)
+                updates[c_chk] = gr.update(visible=True, value=True)
+                updates[c_lbl] = gr.update(visible=True, value=f"Prev: {v_lbl} ({v_sc})")
+                updates[c_drp] = gr.update(visible=True, value=v_lbl)
         else:
-            updates[img_c] = gr.update(value=None, visible=False)
-            updates[c_sld] = gr.update(visible=False)
-            updates[c_drp] = gr.update(visible=False)
-            updates[c_chk] = gr.update(visible=False)
-            updates[c_lbl] = gr.update(visible=False)
+            updates[img_objs[i]] = gr.update(visible=False)
+            for obj in [c_sld, c_drp, c_chk, c_lbl]: updates[obj] = gr.update(visible=False)
+            
     return updates
 
 def save_data(mode, history, urls, *args):
     if not history: return
-    gid = history[-1]
-    ts = datetime.now().isoformat()
-    rows = []
+    gid = history[-1]; ts = datetime.now().isoformat(); rows = []
     for i, u in enumerate(urls):
-        base = i * 4
-        sc, lbl, chk = args[base], args[base+1], args[base+2]
-        if mode == "label": 
-            rows.append([ts, "user", gid, u, sc, lbl])
-        else: 
-            rows.append([ts, "user", gid, u, chk, lbl, sc])
+        sc, lbl, chk = args[i*4], args[i*4+1], args[i*4+2]
+        if mode in ["label", "fix"]: rows.append([ts, "user", gid, u, sc, lbl])
+        else: rows.append([ts, "user", gid, u, chk, lbl, sc])
         
-    fname = LABEL_FILE if mode == "label" else VERIFY_FILE
+    fname = LABEL_FILE if mode in ["label", "fix"] else VERIFY_FILE
     with FileLock(LOCK_FILE):
-        with open(fname, "a", newline="") as f:
-            csv.writer(f).writerows(rows)
-    remote_filename = os.path.basename(fname)
-    sync_push_background(fname, remote_filename)
-    return render_workspace(mode, history)
-
-def skip_group(idx, history, mode):
-    if history:
-        gid = history[-1]
-        with FileLock(LOCK_FILE):
-            with open(SKIP_FILE, "a", newline="") as f:
-                csv.writer(f).writerow([datetime.now().isoformat(), "user", gid])
-        sync_push_background(SKIP_FILE, "skipped.csv")
+        with open(fname, "a", newline="") as f: csv.writer(f).writerows(rows)
+    sync_push_background(fname, os.path.basename(fname))
     return render_workspace(mode, history)
 
-def refresh_cat():
-    all_gids = get_ordered_groups()
-    try: l_set = set(pd.read_csv(LABEL_FILE)['group_id'].unique())
-    except: l_set = set()
-    try: v_set = set(pd.read_csv(VERIFY_FILE)['group_id'].unique())
-    except: v_set = set()
-    data = []
-    for i, gid in enumerate(all_gids):
-        s = "⚪ Pending"
-        if gid in v_set: s = "✅ Verified"
-        elif gid in l_set: s = "🔵 Labeled"
-        data.append([i+1, s, gid])
-    return pd.DataFrame(data, columns=["#", "Status", "ID"])
-
-with gr.Blocks(theme=gr.themes.Soft(), title="Labeling Tool") as demo:
-    state_mode = gr.State("label")
-    state_hist = gr.State([])
-    state_urls = gr.State([])
-    state_idx = gr.State(0)
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    state_mode, state_hist, state_urls, state_idx = gr.State("label"), gr.State([]), gr.State([]), gr.State(0)
     
-    with gr.Row(variant="panel"):
-        top_stats = gr.Markdown("Loading stats...")
-        btn_home = gr.Button("🏠 Home", size="sm", scale=0)
-
-    with gr.Tabs():
-        with gr.Tab("Workspace", id=0):
-            with gr.Group() as screen_menu:
-                gr.Markdown("# Welcome! 👋")
-                gr.Markdown("Persistent & Compatible Version")
-                with gr.Row():
-                    b_start_l = gr.Button("Start Labeling", variant="primary")
-                    b_start_v = gr.Button("Start Verification")
-            
-            with gr.Group(visible=False) as screen_work:
-                header_md = gr.Markdown()
-                img_objs, input_objs = [], []
-                with gr.Row():
-                    for i in range(MAX_IMAGES):
-                        with gr.Column(min_width=250):
-                            img = gr.Image(interactive=False, height=280, show_label=False)
-                            with gr.Group():
-                                sld = gr.Slider(1, 10, step=1, label="Score", visible=False)
-                                lbl = gr.Markdown(visible=False)
-                                drp = gr.Dropdown(ROOM_CLASSES, label="Class", visible=False, interactive=True)
-                                chk = gr.Checkbox(label="Correct?", value=True, visible=False)
-                                
-                                drp.select(fn=lambda: False, outputs=chk)
-                                
-                            img_objs.append(img)
-                            input_objs.extend([sld, drp, chk, lbl])
-                with gr.Row():
-                    b_back = gr.Button("⬅ Back")
-                    b_skip = gr.Button("Skip ➡")
-                    b_save = gr.Button("💾 Save & Next", variant="primary")
-                log_box = gr.Textbox(label="Log", interactive=False, max_lines=1)
-
-        with gr.Tab("Catalog", id=1):
-            with gr.Row():
-                num_in = gr.Number(value=1, label="Property #", precision=0)
-                b_go_l = gr.Button("Go (Label)")
-                b_go_v = gr.Button("Go (Verify)")
-            df_cat = gr.Dataframe(interactive=False)
-            b_ref_cat = gr.Button("Refresh")
+    with gr.Row():
+        top_stats = gr.Markdown("Loading...")
+        btn_home = gr.Button("🏠 Home", size="sm")
+
+    with gr.Group() as screen_menu:
+        gr.Markdown("# Property Labeler Pro")
+        with gr.Row():
+            b_start_l = gr.Button("Start Labeling", variant="primary")
+            b_start_v = gr.Button("Start Verification")
+            b_start_f = gr.Button("🛠 Fix Errors (Score 10 Check)", variant="secondary")
+    
+    with gr.Group(visible=False) as screen_work:
+        header_md = gr.Markdown()
+        img_objs, input_objs = [], []
+        with gr.Row():
+            for i in range(MAX_IMAGES):
+                with gr.Column():
+                    img = gr.Image(interactive=False, height=250)
+                    sld = gr.Slider(1, 10, step=1, label="Score")
+                    lbl = gr.Markdown(visible=False)
+                    drp = gr.Dropdown(ROOM_CLASSES, label="Class")
+                    chk = gr.Checkbox(label="Correct?", value=True, visible=False)
+                    img_objs.append(img); input_objs.extend([sld, drp, chk, lbl])
+        with gr.Row():
+            b_back = gr.Button("⬅ Back")
+            b_save = gr.Button("💾 Save & Next", variant="primary")
+        log_box = gr.Textbox(label="Status", interactive=False)
 
     ALL_IO = [screen_menu, screen_work, header_md, state_urls, state_hist, state_idx, top_stats, log_box] + img_objs + input_objs
     
     b_start_l.click(lambda: "label", None, state_mode).then(render_workspace, [state_mode, state_hist], ALL_IO)
     b_start_v.click(lambda: "verify", None, state_mode).then(render_workspace, [state_mode, state_hist], ALL_IO)
+    b_start_f.click(lambda: "fix", None, state_mode).then(render_workspace, [state_mode, state_hist], ALL_IO)
+    
     b_save.click(save_data, [state_mode, state_hist, state_urls] + input_objs, ALL_IO)
-    b_skip.click(skip_group, [state_idx, state_hist, state_mode], ALL_IO)
     b_back.click(lambda m, h: render_workspace(m, h, move_back=True), [state_mode, state_hist], ALL_IO)
     btn_home.click(lambda: {screen_menu: gr.update(visible=True), screen_work: gr.update(visible=False), state_hist: []}, None, [screen_menu, screen_work, state_hist])
-    b_go_l.click(lambda: "label", None, state_mode).then(lambda n, m, h: render_workspace(m, h, specific_index=int(n)-1), [num_in, state_mode, state_hist], ALL_IO)
-    b_go_v.click(lambda: "verify", None, state_mode).then(lambda n, m, h: render_workspace(m, h, specific_index=int(n)-1), [num_in, state_mode, state_hist], ALL_IO)
-    b_ref_cat.click(refresh_cat, None, df_cat)
-    demo.load(refresh_cat, None, df_cat).then(get_stats_text, None, top_stats)
+
+    demo.load(get_stats_text, None, top_stats)
 
 demo.queue().launch(server_name="0.0.0.0", server_port=7860)