update

.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python3:*)"
+    ]
+  }
+}

app.py

@@ -9,7 +9,7 @@ import random
 from io import BytesIO
 from PIL import Image
 from concurrent.futures import ThreadPoolExecutor
-from datetime import datetime
+from datetime import datetime, timedelta
 from filelock import FileLock 
 from huggingface_hub import HfApi, hf_hub_download
 
@@ -24,6 +24,10 @@ LABEL_FILE = os.path.join(CACHE_DIR, "annotations.csv")
 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")
+LEASE_FILE = os.path.join(CACHE_DIR, "leases.csv")
+LEASE_DURATION_SECONDS = 600
+
+FETCH_SIZE = "w480_h360"
 
 FIXED_IN_SESSION = set()
 MANUAL_EXCLUDE = {"075c8bb8a73c45d71788e711edd9e8d5l", "07a0544f217db88fe2b06fd5d38f02a6l", "6bf16112723de3318c44641958638a56l"}
@@ -59,6 +63,8 @@ def init_files():
                    ["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(LEASE_FILE):
+        pd.DataFrame(columns=["user_id", "group_id", "mode", "leased_at", "expires_at"]).to_csv(LEASE_FILE, index=False)
 
 init_files()
 
@@ -99,6 +105,63 @@ def get_flagged_groups():
     flagged = errors['group_id'].unique().tolist()
     return [g for g in flagged if g not in FIXED_IN_SESSION and g not in MANUAL_EXCLUDE]
 
+def _read_leases():
+    if not os.path.exists(LEASE_FILE) or os.path.getsize(LEASE_FILE) == 0:
+        return pd.DataFrame(columns=["user_id", "group_id", "mode", "leased_at", "expires_at"])
+    try:
+        df = pd.read_csv(LEASE_FILE)
+        df['expires_at'] = pd.to_datetime(df['expires_at'], errors='coerce')
+        return df
+    except:
+        return pd.DataFrame(columns=["user_id", "group_id", "mode", "leased_at", "expires_at"])
+
+def acquire_lease(user_id, group_id, mode):
+    now = datetime.now()
+    expires = now + timedelta(seconds=LEASE_DURATION_SECONDS)
+    with FileLock(LOCK_FILE):
+        df = _read_leases()
+        df = df[df['expires_at'] > now]
+        existing = df[(df['group_id'] == group_id) & (df['user_id'] != user_id)]
+        if not existing.empty:
+            df.to_csv(LEASE_FILE, index=False)
+            return False
+        df = df[df['user_id'] != user_id]
+        new_row = pd.DataFrame([{"user_id": user_id, "group_id": group_id, "mode": mode,
+                                  "leased_at": now.isoformat(), "expires_at": expires.isoformat()}])
+        df = pd.concat([df, new_row], ignore_index=True)
+        df.to_csv(LEASE_FILE, index=False)
+    return True
+
+def release_lease(user_id):
+    with FileLock(LOCK_FILE):
+        df = _read_leases()
+        df = df[df['user_id'] != user_id]
+        df.to_csv(LEASE_FILE, index=False)
+
+def get_leased_group_ids(exclude_user=None):
+    now = datetime.now()
+    with FileLock(LOCK_FILE):
+        df = _read_leases()
+        if df.empty: return set()
+        df = df[df['expires_at'] > now]
+        df.to_csv(LEASE_FILE, index=False)
+    if exclude_user:
+        df = df[df['user_id'] != exclude_user]
+    return set(df['group_id'].unique())
+
+def renew_lease(user_id):
+    if not user_id: return
+    new_expires = (datetime.now() + timedelta(seconds=LEASE_DURATION_SECONDS)).isoformat()
+    with FileLock(LOCK_FILE):
+        df = _read_leases()
+        mask = df['user_id'] == user_id
+        if mask.any():
+            df.loc[mask, 'expires_at'] = new_expires
+            df.to_csv(LEASE_FILE, index=False)
+
+def thumb_url(url):
+    return url.replace("w2048_h1536", FETCH_SIZE)
+
 def get_stats_text():
     all_gids = get_ordered_groups()
     flagged = get_flagged_groups()
@@ -107,29 +170,49 @@ def get_stats_text():
     l_count = len(df_l['group_id'].unique()) if not df_l.empty else 0
     v_count = len(df_v['group_id'].unique()) if not df_v.empty else 0
     err_msg = f" | ⚠️ **Fix:** {len(flagged)}" if flagged else " | ✅ Clean"
-    return f"**Total:** {len(all_gids)} | **Labeled:** {l_count} | **Verified:** {v_count}{err_msg}"
+    active = len(get_leased_group_ids())
+    active_msg = f" | **Active:** {active}" if active > 0 else ""
+    return f"**Total:** {len(all_gids)} | **Labeled:** {l_count} | **Verified:** {v_count}{err_msg}{active_msg}"
 
-def render_workspace(mode, history, specific_index=None, move_back=False):
+def render_workspace(mode, history, user_id="user", specific_index=None, move_back=False):
     all_ordered = get_ordered_groups()
     flagged_pool = get_flagged_groups()
     current_gid = history[-1] if history else None
+    leased_by_others = get_leased_group_ids(exclude_user=user_id)
     target_gid = None
     if specific_index is not None:
-        if 0 <= specific_index < len(all_ordered): target_gid = all_ordered[specific_index]
+        if 0 <= specific_index < len(all_ordered):
+            target_gid = all_ordered[specific_index]
+            acquire_lease(user_id, target_gid, mode)
     elif move_back and len(history) > 1:
         history.pop(); target_gid = history[-1]
+        acquire_lease(user_id, target_gid, mode)
     else:
         if mode == "fix":
-            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]
+            candidates = [g for g in flagged_pool if g != current_gid and g not in leased_by_others]
+            if not candidates:
+                candidates = [g for g in flagged_pool if g not in leased_by_others]
+            if candidates:
+                target_gid = candidates[0]
+                acquire_lease(user_id, target_gid, mode)
         else:
             df_l, df_v = get_clean_df(LABEL_FILE), 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()
-            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: "Done!"}
+            candidates = [g for g in all_ordered if g not in leased_by_others and (
+                (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 acquire_lease(user_id, target_gid, mode):
+                    for c in candidates:
+                        if c != target_gid and acquire_lease(user_id, c, mode):
+                            target_gid = c
+                            break
+                    else:
+                        target_gid = None
+    if not target_gid:
+        msg = "All available properties are currently being worked on. Try again shortly." if leased_by_others else "Done! All properties processed."
+        return {screen_menu: gr.update(visible=True), screen_work: gr.update(visible=False), log_box: msg}
     urls = [u for u in load_all_urls() if target_gid in u][:MAX_IMAGES]
     if not history or history[-1] != target_gid: history.append(target_gid)
     saved_vals = {}
@@ -141,7 +224,7 @@ def render_workspace(mode, history, specific_index=None, move_back=False):
     with ThreadPoolExecutor(max_workers=MAX_IMAGES) as ex:
         def fetch(u):
             try:
-                res = requests.get(u, timeout=3, headers={'User-Agent': 'Mozilla/5.0'})
+                res = requests.get(thumb_url(u), timeout=5, headers={'User-Agent': 'Mozilla/5.0'})
                 img = Image.open(BytesIO(res.content)); img.thumbnail(THUMB_SIZE); return img
             except: return None
         processed_images = list(ex.map(fetch, urls))
@@ -173,7 +256,7 @@ def render_workspace(mode, history, specific_index=None, move_back=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):
+def save_data(mode, history, urls, user_id, *args):
     if not history: return
     gid = history[-1]
     if mode == "fix": FIXED_IN_SESSION.add(gid)
@@ -181,12 +264,13 @@ def save_data(mode, history, urls, *args):
     for i, u in enumerate(urls):
         sc, lbl, chk = args[i*4], args[i*4+1], args[i*4+2]
         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)])
+        if mode in ["label", "fix"]: rows.append([ts, user_id, gid, u, int(sc), clean_lbl])
+        else: rows.append([ts, user_id, gid, u, chk, clean_lbl, int(sc)])
     with FileLock(LOCK_FILE):
         with open(LABEL_FILE if mode in ["label", "fix"] else VERIFY_FILE, "a", newline="") as f: csv.writer(f).writerows(rows)
     sync_push_background(LABEL_FILE if mode in ["label", "fix"] else VERIFY_FILE, os.path.basename(LABEL_FILE if mode in ["label", "fix"] else VERIFY_FILE))
-    return render_workspace(mode, history)
+    release_lease(user_id)
+    return render_workspace(mode, history, user_id)
 
 def refresh_cat():
     all_gids = get_ordered_groups()
@@ -194,17 +278,37 @@ def refresh_cat():
     df_l, df_v = get_clean_df(LABEL_FILE), 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 = [[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)]
+    leased = get_leased_group_ids()
+    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"
+        if gid in leased: status += " [IN USE]"
+        data.append([i+1, status, gid])
     return pd.DataFrame(data, columns=["#", "Status", "ID"])
 
+def do_login(name):
+    name = str(name).strip().lower()
+    if not name:
+        return gr.update(), gr.update(), gr.update(visible=True, value="Please enter your name."), ""
+    return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), name
+
+def renew_lease_handler(user_id):
+    renew_lease(user_id)
+
 with gr.Blocks(theme=gr.themes.Soft(), title="Labeler Pro") as demo:
     state_mode, state_hist, state_urls, state_idx = gr.State("label"), gr.State([]), gr.State([]), gr.State(0)
+    state_user = gr.State("")
     with gr.Row():
         top_stats = gr.Markdown("Loading...")
         btn_home = gr.Button("🏠 Home", size="sm", scale=0)
     with gr.Tabs():
         with gr.Tab("Workspace"):
-            with gr.Group() as screen_menu:
+            with gr.Group() as screen_login:
+                gr.Markdown("# Property Labeler Pro\n### Enter your name to start")
+                user_input = gr.Textbox(label="Your Name / ID", placeholder="e.g., alice")
+                b_login = gr.Button("Start Labeling", variant="primary")
+                login_error = gr.Markdown("", visible=False)
+            with gr.Group(visible=False) as screen_menu:
                 gr.Markdown("# Property Labeler Pro")
                 with gr.Row():
                     b_start_l, b_start_v, b_start_f = gr.Button("Label", variant="primary"), gr.Button("Verify"), gr.Button("🛠 Fix Errors", variant="secondary")
@@ -227,15 +331,21 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Labeler Pro") as demo:
             df_cat = gr.Dataframe(interactive=False)
             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_login.click(do_login, [user_input], [screen_login, screen_menu, login_error, state_user])
+    b_start_l.click(lambda: "label", None, state_mode).then(render_workspace, [state_mode, state_hist, state_user], ALL_IO)
+    b_start_v.click(lambda: "verify", None, state_mode).then(render_workspace, [state_mode, state_hist, state_user], ALL_IO)
+    b_start_f.click(lambda: "fix", None, state_mode).then(render_workspace, [state_mode, state_hist, state_user], ALL_IO)
+    b_save.click(save_data, [state_mode, state_hist, state_urls, state_user] + input_objs, ALL_IO)
+    b_back.click(lambda m, h, u: render_workspace(m, h, u, move_back=True), [state_mode, state_hist, state_user], ALL_IO)
+    def go_home(user_id):
+        release_lease(user_id)
+        return gr.update(visible=True), gr.update(visible=False), []
+    btn_home.click(go_home, [state_user], [screen_menu, screen_work, state_hist])
+    b_go_l.click(lambda: "label", None, state_mode).then(lambda n,m,h,u: render_workspace(m,h,u,int(n)-1), [num_in, state_mode, state_hist, state_user], ALL_IO)
+    b_go_v.click(lambda: "verify", None, state_mode).then(lambda n,m,h,u: render_workspace(m,h,u,int(n)-1), [num_in, state_mode, state_hist, state_user], ALL_IO)
+    b_go_f.click(lambda: "fix", None, state_mode).then(lambda n,m,h,u: render_workspace(m,h,u,int(n)-1), [num_in, state_mode, state_hist, state_user], ALL_IO)
+    for i in range(0, len(input_objs), 4):
+        input_objs[i].change(renew_lease_handler, [state_user], None)
     b_ref_cat.click(refresh_cat, None, df_cat).then(get_stats_text, None, top_stats)
     demo.load(refresh_cat, None, df_cat).then(get_stats_text, None, top_stats)
 demo.queue().launch(server_name="0.0.0.0", server_port=7860)