update app.py

app.py

@@ -34,7 +34,9 @@ def sync_pull():
     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)
-        except: pass
+            print(f"Successfully pulled {filename}")
+        except Exception as e:
+            print(f"Pull error {filename}: {e}")
 
 def sync_push_background(local_path, remote_filename):
     token = HF_TOKEN if HF_TOKEN and len(HF_TOKEN) > 5 else None
@@ -43,7 +45,9 @@ def sync_push_background(local_path, remote_filename):
         try:
             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: pass
+            print(f"Successfully pushed {remote_filename}")
+        except Exception as e:
+            print(f"Push error {remote_filename}: {e}")
     threading.Thread(target=_push).start()
 
 def init_files():
@@ -78,50 +82,40 @@ def get_ordered_groups():
             groups.append(gid); seen.add(gid)
     return groups
 
-def get_flagged_groups():
-    if not os.path.exists(LABEL_FILE): return []
+def get_clean_df(filepath):
+    if not os.path.exists(filepath): return pd.DataFrame()
     try:
-        df = pd.read_csv(LABEL_FILE)
-        if df.empty: return []
-        df['label'] = df['label'].astype(str).str.strip().str.lower()
-        df['score'] = pd.to_numeric(df['score'], errors='coerce')
+        df = pd.read_csv(filepath)
+        if df.empty: return df
+        if 'label' in df.columns:
+            df['label'] = df['label'].astype(str).str.strip().str.lower()
+        if 'score' in df.columns:
+            df['score'] = pd.to_numeric(df['score'], errors='coerce').fillna(0).astype(int)
         df = df.drop_duplicates(subset=['url'], keep='last')
-        # Logic: Flag if score is 10 AND it's NOT living_room
-        errors = df[(df['score'] == 10) & (df['label'] != 'living_room')]
-        return errors['group_id'].unique().tolist()
-    except: return []
+        return df
+    except:
+        return pd.DataFrame()
+
+def get_flagged_groups():
+    df = get_clean_df(LABEL_FILE)
+    if df.empty: return []
+    errors = df[(df['score'] == 10) & (df['label'] != 'living_room')]
+    return errors['group_id'].unique().tolist()
 
 def get_group_urls(target_gid):
     return [u for u in load_all_urls() if target_gid in u][:MAX_IMAGES]
 
-def get_saved_values(gid, mode):
-    saved_data = {}
-    try:
-        fname = LABEL_FILE if mode in ["label", "fix"] else VERIFY_FILE
-        df = pd.read_csv(fname)
-        df = df.drop_duplicates(subset=['url'], keep='last')
-        rows = df[df['group_id'] == gid]
-        for _, row in rows.iterrows():
-            lbl = str(row['label']).strip().lower() if mode in ["label", "fix"] else str(row['corrected_label']).strip().lower()
-            if mode in ["label", "fix"]:
-                saved_data[row['url']] = {"score": row['score'], "label": lbl}
-            else:
-                saved_data[row['url']] = {"is_correct": row['is_correct'], "label": lbl, "score": row['corrected_score']}
-    except: pass
-    return saved_data
-
 def get_stats_text():
     all_gids = get_ordered_groups()
     flagged = get_flagged_groups()
-    try: 
-        df_l = pd.read_csv(LABEL_FILE).drop_duplicates(subset=['url'], keep='last')
-        l = len(df_l['group_id'].unique())
-    except: l = 0
-    err_msg = f" | ⚠️ **To Fix:** {len(flagged)}" if flagged else ""
-    return f"**Total Properties:** {len(all_gids)} | **Labeled:** {l}{err_msg}"
+    df_l = get_clean_df(LABEL_FILE)
+    l_count = len(df_l['group_id'].unique()) if not df_l.empty else 0
+    err_msg = f" | ⚠️ **Need Fix:** {len(flagged)}" if flagged else " | ✅ No Errors"
+    return f"**Total Properties:** {len(all_gids)} | **Labeled:** {l_count}{err_msg}"
 
 def render_workspace(mode, history, specific_index=None, move_back=False):
     all_ordered = get_ordered_groups()
+    flagged_pool = get_flagged_groups()
     current_gid = history[-1] if history else None
     target_gid = None
 
@@ -131,33 +125,37 @@ def render_workspace(mode, history, specific_index=None, move_back=False):
         history.pop()
         target_gid = history[-1]
     else:
-        flagged_pool = get_flagged_groups()
-        try:
-            df_l = pd.read_csv(LABEL_FILE).drop_duplicates(subset=['url'], keep='last')
-            l_done = set(df_l['group_id'].unique())
-            df_v = pd.read_csv(VERIFY_FILE).drop_duplicates(subset=['url'], keep='last')
-            v_done = set(df_v['group_id'].unique())
-        except: l_done, v_done = set(), set()
+        df_l = get_clean_df(LABEL_FILE)
+        df_v = get_clean_df(VERIFY_FILE)
+        l_done = set(df_l['group_id'].unique()) if not df_l.empty else set()
+        v_done = set(df_v['group_id'].unique()) if not df_v.empty else set()
         
         if mode == "fix":
-            # Deterministic selection for Fix mode to avoid jumping
+            # Don't show the one we just saved
             candidates = [g for g in flagged_pool if g != current_gid]
             if not candidates and flagged_pool: candidates = flagged_pool
             if candidates: target_gid = candidates[0]
         else:
-            # Random selection for Label/Verify mode
             candidates = [g for g in all_ordered if (mode=="label" and g not in l_done) or (mode=="verify" and g in l_done and g not in v_done)]
             if candidates: target_gid = random.choice(candidates)
         
         if not target_gid:
-             return {screen_menu: gr.update(visible=True), screen_work: gr.update(visible=False), log_box: "Mode Complete."}
+             return {screen_menu: gr.update(visible=True), screen_work: gr.update(visible=False), log_box: "🎉 Section Complete!"}
 
     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 {}
-    target_idx = all_ordered.index(target_gid)
+    
+    saved_vals = {}
+    df_mode = get_clean_df(LABEL_FILE if mode in ["label", "fix"] else VERIFY_FILE)
+    if not df_mode.empty:
+        rows = df_mode[df_mode['group_id'] == target_gid]
+        for _, r in rows.iterrows():
+            if mode in ["label", "fix"]:
+                saved_vals[r['url']] = {"score": r['score'], "label": r['label']}
+            else:
+                saved_vals[r['url']] = {"is_correct": r['is_correct'], "label": r['corrected_label'], "score": r['corrected_score']}
 
+    target_idx = all_ordered.index(target_gid)
     with ThreadPoolExecutor(max_workers=MAX_IMAGES) as ex:
         def fetch(u):
             try:
@@ -169,9 +167,9 @@ def render_workspace(mode, history, specific_index=None, move_back=False):
 
     updates = {
         screen_menu: gr.update(visible=False), screen_work: gr.update(visible=True),
-        header_md: f"# {mode.upper()} Property #{target_idx + 1} ({target_gid})",
+        header_md: f"# {mode.upper()} - Property #{target_idx + 1} ({target_gid})",
         state_urls: urls, state_hist: history, state_idx: target_idx,
-        top_stats: get_stats_text(), log_box: f"Loaded {target_gid}"
+        top_stats: get_stats_text(), log_box: f"Loaded group: {target_gid}"
     }
 
     for i in range(MAX_IMAGES):
@@ -180,21 +178,21 @@ def render_workspace(mode, history, specific_index=None, move_back=False):
         if i < len(urls):
             u = urls[i]
             updates[img_objs[i]] = gr.update(value=processed_images[i], visible=True)
-            v_sc = int(float(saved_vals.get(u, {}).get('score', 5)))
+            v_sc = int(saved_vals.get(u, {}).get('score', 5))
             v_lbl = str(saved_vals.get(u, {}).get('label', "living_room")).strip().lower()
+            
             is_err = (v_sc == 10 and v_lbl != "living_room")
             
             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_drp] = gr.update(visible=True, value=v_lbl if v_lbl in ROOM_CLASSES else "living_room", interactive=True)
                 updates[c_chk] = gr.update(visible=False)
-                updates[c_lbl] = gr.update(visible=True if is_err else False, value="<span style='color:red'>⚠️ ERROR: Score 10 must be Living Room</span>")
+                updates[c_lbl] = gr.update(visible=True if is_err else False, value="<span style='color:red; font-weight:bold;'>⚠️ ERROR: Score 10 is ONLY for Living Room</span>")
             else:
-                p_lbl, p_sc = r1_vals.get(u, {}).get('label', "?"), r1_vals.get(u, {}).get('score', "?")
-                updates[c_sld] = gr.update(visible=True, value=v_sc if u in saved_vals else p_sc)
+                updates[c_sld] = gr.update(visible=True, value=v_sc)
                 updates[c_drp] = gr.update(visible=True, value=v_lbl)
                 updates[c_chk] = gr.update(visible=True, value=saved_vals.get(u, {}).get('is_correct', True))
-                updates[c_lbl] = gr.update(visible=True, value=f"Prev: {p_lbl} ({p_sc})")
+                updates[c_lbl] = gr.update(visible=True, value=f"Previous Label: {v_lbl}")
         else:
             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)
@@ -208,35 +206,42 @@ def save_data(mode, history, urls, *args):
         clean_lbl = str(lbl).strip().lower()
         if mode in ["label", "fix"]: rows.append([ts, "user", gid, u, int(sc), clean_lbl])
         else: rows.append([ts, "user", gid, u, chk, clean_lbl, int(sc)])
+    
     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)
+    
     sync_push_background(fname, os.path.basename(fname))
     return render_workspace(mode, history)
 
 def refresh_cat():
     all_gids = get_ordered_groups()
     flagged = set(get_flagged_groups())
-    try:
-        df_l = pd.read_csv(LABEL_FILE).drop_duplicates(subset=['url'], keep='last')
-        l_set = set(df_l['group_id'].unique())
-        df_v = pd.read_csv(VERIFY_FILE).drop_duplicates(subset=['url'], keep='last')
-        v_set = set(df_v['group_id'].unique())
-    except: l_set, v_set = set(), set()
-    data = [[i+1, "⚠️ Fix Needed" if gid in flagged else "✅ Verified" if gid in v_set else "🔵 Labeled" if gid in l_set else "⚪ Pending", gid] for i, gid in enumerate(all_gids)]
+    df_l = get_clean_df(LABEL_FILE)
+    df_v = get_clean_df(VERIFY_FILE)
+    l_set = set(df_l['group_id'].unique()) if not df_l.empty else set()
+    v_set = set(df_v['group_id'].unique()) if not df_v.empty else set()
+    
+    data = []
+    for i, gid in enumerate(all_gids):
+        status = "⚠️ Fix Needed" if gid in flagged else "✅ Verified" if gid in v_set else "🔵 Labeled" if gid in l_set else "⚪ Pending"
+        data.append([i+1, status, gid])
     return pd.DataFrame(data, columns=["#", "Status", "ID"])
 
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
+with gr.Blocks(theme=gr.themes.Soft(), title="Property Labeler Pro") as demo:
     state_mode, state_hist, state_urls, state_idx = gr.State("label"), gr.State([]), gr.State([]), gr.State(0)
     with gr.Row():
-        top_stats = gr.Markdown("Loading...")
+        top_stats = gr.Markdown("Syncing...")
         btn_home = gr.Button("🏠 Home", size="sm", scale=0)
+    
     with gr.Tabs():
         with gr.Tab("Workspace"):
             with gr.Group() as screen_menu:
-                gr.Markdown("# Property Labeler Pro")
+                gr.Markdown("# Welcome to Property Labeler")
                 with gr.Row():
-                    b_start_l, b_start_v, b_start_f = gr.Button("Start Labeling", variant="primary"), gr.Button("Start Verification"), gr.Button("🛠 Fix Errors", variant="secondary")
+                    b_start_l = gr.Button("Label New", variant="primary")
+                    b_start_v = gr.Button("Verify Labels")
+                    b_start_f = gr.Button("🛠 Fix Errors", variant="secondary")
             with gr.Group(visible=False) as screen_work:
                 header_md = gr.Markdown()
                 img_objs, input_objs = [], []
@@ -244,11 +249,16 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                     for i in range(MAX_IMAGES):
                         with gr.Column(min_width=200):
                             img = gr.Image(interactive=False, height=240)
-                            sld, drp, chk, lbl = gr.Slider(1, 10, step=1, label="Score"), gr.Dropdown(ROOM_CLASSES, label="Class"), gr.Checkbox(label="Correct?"), gr.Markdown()
+                            sld = gr.Slider(1, 10, step=1, label="Score")
+                            drp = gr.Dropdown(ROOM_CLASSES, label="Class")
+                            chk = gr.Checkbox(label="Correct?")
+                            lbl = gr.Markdown()
                             img_objs.append(img); input_objs.extend([sld, drp, chk, lbl])
                 with gr.Row():
-                    b_back, b_save = gr.Button("⬅ Back"), gr.Button("💾 Save & Next", variant="primary")
-                log_box = gr.Textbox(label="Log", interactive=False)
+                    b_back = gr.Button("⬅ Back")
+                    b_save = gr.Button("💾 Save & Next", variant="primary")
+                log_box = gr.Textbox(label="Last Action", interactive=False)
+
         with gr.Tab("Catalog"):
             with gr.Row():
                 num_in = gr.Number(value=1, label="Prop #", precision=0)
@@ -257,15 +267,19 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             b_ref_cat = gr.Button("Refresh Catalog")
 
     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_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,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,int(n)-1), [num_in, state_mode, state_hist], ALL_IO)
     b_go_f.click(lambda: "fix", None, state_mode).then(lambda n,m,h: render_workspace(m,h,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)