pearmut 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

pearmut/assignment.py

@@ -1,5 +1,4 @@
 import collections
-import copy
 import random
 import statistics
 from typing import Any
@@ -12,9 +11,19 @@ from .utils import (
     check_validation_threshold,
     get_db_log,
     get_db_log_item,
+    is_form_document,
     save_db_payload,
 )
 
+# Public campaign info fields that are sent to the client
+CAMPAIGN_INFO_PUBLIC = {
+    "protocol",
+    "sliders",
+    "textfield",
+    "show_model_names",
+    "mqm_categories",
+}
+
 
 def _get_instructions(tasks_data: dict, campaign_id: str) -> str:
     """Get instructions: custom if provided, else protocol default, else empty."""
@@ -24,7 +33,6 @@ def _get_instructions(tasks_data: dict, campaign_id: str) -> str:
     return PROTOCOL_INSTRUCTIONS.get(campaign_info.get("protocol", ""), "")
 
 
-
 def _completed_response(
     tasks_data: dict,
     progress_data: dict,
@@ -56,6 +64,7 @@ def _completed_response(
         content={
             "status": "goodbye",
             "progress": progress,
+            "progress_welcome": user_progress["progress_welcome"],
             "time": user_progress["time"],
             "token": token,
             "instructions_goodbye": instructions_goodbye,
@@ -116,12 +125,34 @@ def get_i_item_taskbased(
     user_id: str,
     data_all: dict,
     progress_data: dict,
-    item_i: int,
+    item_i: int | str,  # Can be int or str like "welcome_0"
 ) -> JSONResponse:
     """
     Get specific item for task-based protocol.
     """
     user_progress = progress_data[campaign_id][user_id]
+    progress_welcome = user_progress["progress_welcome"]
+
+    # if welcome_X, payload is from data_welcome[X], otherwise data[user][X]
+    if isinstance(item_i, str) and item_i.startswith("welcome_"):
+        actual_index = int(item_i.split("_")[1])
+        if actual_index < 0 or actual_index >= len(
+            data_all[campaign_id]["data_welcome"]
+        ):
+            return JSONResponse(
+                content="Welcome item index out of range", status_code=400
+            )
+        payload = data_all[campaign_id]["data_welcome"][actual_index]
+    else:
+        # Prevent accessing regular items unless all welcome items are complete
+        if not all(progress_welcome):
+            return JSONResponse(
+                content="Complete all welcome items before accessing regular items",
+                status_code=400,
+            )
+        if item_i < 0 or item_i >= len(data_all[campaign_id]["data"][user_id]):
+            return JSONResponse(content="Item index out of range", status_code=400)
+        payload = data_all[campaign_id]["data"][user_id][item_i]
 
     # try to get existing annotations if any
     items_existing = get_db_log_item(campaign_id, user_id, item_i)
@@ -133,13 +164,13 @@ def get_i_item_taskbased(
         if "comment" in latest_item:
             payload_existing["comment"] = latest_item["comment"]
 
-    if item_i < 0 or item_i >= len(data_all[campaign_id]["data"][user_id]):
-        return JSONResponse(content="Item index out of range", status_code=400)
+    is_form = is_form_document(payload)
 
     return JSONResponse(
         content={
-            "status": "ok",
+            "status": "form" if is_form else "ok",
             "progress": user_progress["progress"],
+            "progress_welcome": progress_welcome,
             "time": user_progress["time"],
             "info": {
                 "item_i": item_i,
@@ -148,9 +179,9 @@ def get_i_item_taskbased(
             | {
                 k: v
                 for k, v in data_all[campaign_id]["info"].items()
-                if k in {"protocol", "sliders"}
+                if k in CAMPAIGN_INFO_PUBLIC
             },
-            "payload": data_all[campaign_id]["data"][user_id][item_i],
+            "payload": payload,
         }
         | ({"payload_existing": payload_existing} if payload_existing else {}),
         status_code=200,
@@ -162,16 +193,37 @@ def get_i_item_singlestream(
     user_id: str,
     data_all: dict,
     progress_data: dict,
-    item_i: int,
+    item_i: int | str,  # Can be int or str like "welcome_0"
 ) -> JSONResponse:
     """
     Get specific item for single-stream assignment.
     """
     user_progress = progress_data[campaign_id][user_id]
+    progress_welcome = user_progress["progress_welcome"]
+
+    # Convert welcome_X string to integer index
+    actual_index = item_i
+    is_welcome_item = isinstance(item_i, str) and item_i.startswith("welcome_")
+    if is_welcome_item:
+        actual_index = int(item_i.split("_")[1])
+        # Validate against total number of welcome items
+        if actual_index < 0 or actual_index >= len(progress_welcome):
+            return JSONResponse(
+                content="Welcome item index out of range", status_code=400
+            )
+    else:
+        # Prevent accessing regular items unless all welcome items are complete
+        if not all(progress_welcome):
+            return JSONResponse(
+                content="Complete all welcome items before accessing regular items",
+                status_code=400,
+            )
 
     # try to get existing annotations if any
-    # note the None user_id since it is shared
-    items_existing = get_db_log_item(campaign_id, None, item_i)
+    # use user_id for welcome items (per-user), None for shared items
+    items_existing = get_db_log_item(
+        campaign_id, user_id if is_welcome_item else None, item_i
+    )
     payload_existing = None
     if items_existing:
         # get the latest ones
@@ -180,13 +232,17 @@ def get_i_item_singlestream(
         if "comment" in latest_item:
             payload_existing["comment"] = latest_item["comment"]
 
-    if item_i < 0 or item_i >= len(data_all[campaign_id]["data"]):
+    if actual_index < 0 or actual_index >= len(data_all[campaign_id]["data"]):
         return JSONResponse(content="Item index out of range", status_code=400)
 
+    payload = data_all[campaign_id]["data"][actual_index]
+    is_form = is_form_document(payload)
+
     return JSONResponse(
         content={
-            "status": "ok",
+            "status": "form" if is_form else "ok",
             "progress": user_progress["progress"],
+            "progress_welcome": progress_welcome,
             "time": user_progress["time"],
             "info": {
                 "item_i": item_i,
@@ -195,9 +251,9 @@ def get_i_item_singlestream(
             | {
                 k: v
                 for k, v in data_all[campaign_id]["info"].items()
-                if k in {"protocol", "sliders"}
+                if k in CAMPAIGN_INFO_PUBLIC
             },
-            "payload": data_all[campaign_id]["data"][item_i],
+            "payload": payload,
         }
         | ({"payload_existing": payload_existing} if payload_existing else {}),
         status_code=200,
@@ -214,11 +270,56 @@ def get_next_item_taskbased(
     Get the next item for task-based assignment.
     """
     user_progress = progress_data[campaign_id][user_id]
-    if all(user_progress["progress"]):
+    progress_welcome = user_progress["progress_welcome"]
+
+    # Check if there are incomplete welcome items first
+    if not all(progress_welcome):
+        # Find first incomplete welcome item
+        item_i = next(i for i, v in enumerate(progress_welcome) if not v)
+        item_id = f"welcome_{item_i}"
+
+        # try to get existing annotations if any
+        items_existing = get_db_log_item(campaign_id, user_id, item_id)
+        payload_existing = None
+        if items_existing:
+            # get the latest ones
+            latest_item = items_existing[-1]
+            payload_existing = {"annotation": latest_item["annotation"]}
+            if "comment" in latest_item:
+                payload_existing["comment"] = latest_item["comment"]
+
+        payload = data_all[campaign_id]["data_welcome"][item_i]
+        is_form = is_form_document(payload)
+
+        return JSONResponse(
+            content={
+                "status": "form" if is_form else "ok",
+                "progress": user_progress["progress"],
+                "progress_welcome": progress_welcome,
+                "time": user_progress["time"],
+                "info": {
+                    "item_i": item_id,
+                    "instructions": _get_instructions(data_all, campaign_id),
+                }
+                | {
+                    k: v
+                    for k, v in data_all[campaign_id]["info"].items()
+                    if k in {"protocol", "sliders", "textfield", "show_model_names"}
+                },
+                "payload": payload,
+            }
+            | ({"payload_existing": payload_existing} if payload_existing else {}),
+            status_code=200,
+        )
+
+    # All welcome items complete, proceed with regular items
+    if all(v == "completed" for v in user_progress["progress"]):
         return _completed_response(data_all, progress_data, campaign_id, user_id)
 
     # find first incomplete item
-    item_i = min([i for i, v in enumerate(user_progress["progress"]) if not v])
+    item_i = min(
+        [i for i, v in enumerate(user_progress["progress"]) if v != "completed"]
+    )
 
     # try to get existing annotations if any
     items_existing = get_db_log_item(campaign_id, user_id, item_i)
@@ -230,10 +331,14 @@ def get_next_item_taskbased(
         if "comment" in latest_item:
             payload_existing["comment"] = latest_item["comment"]
 
+    payload = data_all[campaign_id]["data"][user_id][item_i]
+    is_form = is_form_document(payload)
+
     return JSONResponse(
         content={
-            "status": "ok",
+            "status": "form" if is_form else "ok",
             "progress": user_progress["progress"],
+            "progress_welcome": progress_welcome,
             "time": user_progress["time"],
             "info": {
                 "item_i": item_i,
@@ -242,7 +347,7 @@ def get_next_item_taskbased(
             | {
                 k: v
                 for k, v in data_all[campaign_id]["info"].items()
-                if k in {"protocol", "sliders"}
+                if k in CAMPAIGN_INFO_PUBLIC
             },
             "payload": data_all[campaign_id]["data"][user_id][item_i],
         }
@@ -267,12 +372,64 @@ def get_next_item_singlestream(
     """
     user_progress = progress_data[campaign_id][user_id]
     progress = user_progress["progress"]
+    progress_welcome = user_progress["progress_welcome"]
+
+    # Check if there are incomplete welcome items first - must complete all before proceeding
+    if not all(progress_welcome):
+        # Find first incomplete welcome item (sequential, not random)
+        item_i = next(i for i, v in enumerate(progress_welcome) if not v)
+        item_id = f"welcome_{item_i}"
+
+        # try to get existing annotations if any
+        # note the user_id since welcome items are per-user
+        items_existing = get_db_log_item(campaign_id, user_id, item_id)
+        payload_existing = None
+        if items_existing:
+            # get the latest ones
+            latest_item = items_existing[-1]
+            payload_existing = {"annotation": latest_item["annotation"]}
+            if "comment" in latest_item:
+                payload_existing["comment"] = latest_item["comment"]
+
+        payload = data_all[campaign_id]["data"][item_i]
+        is_form = is_form_document(payload)
 
-    if all(progress):
+        return JSONResponse(
+            content={
+                "status": "form" if is_form else "ok",
+                "time": user_progress["time"],
+                "progress": progress,
+                "progress_welcome": progress_welcome,
+                "info": {
+                    "item_i": item_id,
+                    "instructions": _get_instructions(data_all, campaign_id),
+                }
+                | {
+                    k: v
+                    for k, v in data_all[campaign_id]["info"].items()
+                    if k in {"protocol", "sliders", "textfield", "show_model_names"}
+                },
+                "payload": payload,
+            }
+            | ({"payload_existing": payload_existing} if payload_existing else {}),
+            status_code=200,
+        )
+
+    # All welcome items complete, proceed with regular items
+    # Check if user reached docs_per_user limit (if specified)
+    if (
+        docs_per_user := data_all[campaign_id]["info"].get("docs_per_user")
+    ) is not None:
+        completed_docs = sum(v == "completed" for v in progress if v)
+        if completed_docs >= docs_per_user:
+            return _completed_response(data_all, progress_data, campaign_id, user_id)
+    elif all(v in {"completed", "completed_foreign"} for v in progress):
         return _completed_response(data_all, progress_data, campaign_id, user_id)
 
     # find a random incomplete item
-    incomplete_indices = [i for i, v in enumerate(progress) if not v]
+    incomplete_indices = [
+        i for i, v in enumerate(progress) if v not in {"completed", "completed_foreign"}
+    ]
     item_i = random.choice(incomplete_indices)
 
     # try to get existing annotations if any
@@ -286,11 +443,15 @@ def get_next_item_singlestream(
         if "comment" in latest_item:
             payload_existing["comment"] = latest_item["comment"]
 
+    payload = data_all[campaign_id]["data"][item_i]
+    is_form = is_form_document(payload)
+
     return JSONResponse(
         content={
-            "status": "ok",
+            "status": "form" if is_form else "ok",
             "time": user_progress["time"],
             "progress": progress,
+            "progress_welcome": progress_welcome,
             "info": {
                 "item_i": item_i,
                 "instructions": _get_instructions(data_all, campaign_id),
@@ -298,9 +459,9 @@ def get_next_item_singlestream(
             | {
                 k: v
                 for k, v in data_all[campaign_id]["info"].items()
-                if k in {"protocol", "sliders"}
+                if k in CAMPAIGN_INFO_PUBLIC
             },
-            "payload": data_all[campaign_id]["data"][item_i],
+            "payload": payload,
         }
         | ({"payload_existing": payload_existing} if payload_existing else {}),
         status_code=200,
@@ -320,8 +481,8 @@ def get_next_item_dynamic(
 
     In this mode, items are selected based on the current performance of models:
     1. Contrastive comparison: `dynamic_contrastive_models` models are randomly selected and shown per item
-    2. First phase: Each model gets `dynamic_first` annotations with fully random selection
-    3. After first phase: Top `dynamic_top` models are identified, K randomly selected from them
+    2. Warmup phase: Each model gets `dynamic_warmup` annotations with fully random selection
+    3. After warmup phase: Top `dynamic_top` models are identified, K randomly selected from them
     4. Items with least annotations for the selected models are prioritized
     5. With probability `dynamic_backoff`, uniformly random selection is used instead
     """
@@ -329,18 +490,69 @@ def get_next_item_dynamic(
 
     user_progress = progress_data[campaign_id][user_id]
     campaign_data = tasks_data[campaign_id]
+    progress_welcome = user_progress["progress_welcome"]
+
+    # Check if there are incomplete welcome items first - must complete all before proceeding
+    if not all(progress_welcome):
+        # Find first incomplete welcome item (sequential)
+        item_i = next(i for i, v in enumerate(progress_welcome) if not v)
+        item_id = f"welcome_{item_i}"
+
+        # try to get existing annotations if any
+        # note the user_id since welcome items are per-user
+        items_existing = get_db_log_item(campaign_id, user_id, item_id)
+        payload_existing = None
+        if items_existing:
+            # get the latest ones
+            latest_item = items_existing[-1]
+            payload_existing = {"annotation": latest_item["annotation"]}
+            if "comment" in latest_item:
+                payload_existing["comment"] = latest_item["comment"]
+
+        return JSONResponse(
+            content={
+                "status": "ok",
+                "time": user_progress["time"],
+                "progress": user_progress["progress"],
+                "progress_welcome": progress_welcome,
+                "info": {
+                    "item_i": item_id,
+                    "instructions": _get_instructions(campaign_data, campaign_id),
+                }
+                | {
+                    k: v
+                    for k, v in campaign_data["info"].items()
+                    if k in {"protocol", "sliders", "textfield", "show_model_names"}
+                },
+                "payload": campaign_data["data"][item_i],
+            }
+            | ({"payload_existing": payload_existing} if payload_existing else {}),
+            status_code=200,
+        )
 
     # Get all unique models in the campaign (all items must have all models)
     all_models = list(set(campaign_data["data"][0][0]["tgt"].keys()))
 
-    # Check if completed (all models completed for all items)
-    # NOTE: this will rarely trigger but we don't have a good way to know when to end anyway for now
-    if all(len(v) == len(all_models) for v in user_progress["progress"]):
+    # Check if completed
+    # First check if docs_per_user limit is reached
+    if (docs_per_user := campaign_data["info"].get("docs_per_user")) is not None:
+        # Count specifically number of annotations across models
+        completed_docs = sum(
+            v == "completed" for mv in user_progress["progress"] for v in mv.values()
+        )
+        if completed_docs >= docs_per_user:
+            return _completed_response(tasks_data, progress_data, campaign_id, user_id)
+    # Otherwise check if all models completed for all items
+    elif all(
+        v in {"completed", "completed_foreign"}
+        for mv in user_progress["progress"]
+        for v in mv.values()
+    ):
         return _completed_response(tasks_data, progress_data, campaign_id, user_id)
 
     # Get configuration parameters
     dynamic_top = campaign_data["info"].get("dynamic_top", 2)
-    dynamic_first = campaign_data["info"].get("dynamic_first", 5)
+    dynamic_warmup = campaign_data["info"].get("dynamic_warmup", 5)
     dynamic_contrastive_models = campaign_data["info"].get(
         "dynamic_contrastive_models", 1
     )
@@ -360,18 +572,18 @@ def get_next_item_dynamic(
                     model_total_counts[model] += 1
 
     # Check if we're still in the first phase (collecting initial data)
-    in_first_phase = any(
-        model_total_counts.get(model, 0) < dynamic_first for model in all_models
+    in_warmup_phase = any(
+        model_total_counts.get(model, 0) < dynamic_warmup for model in all_models
     )
 
     # Select which models to show
-    if in_first_phase:
+    if in_warmup_phase:
         # First phase or backoff: select models that don't have enough annotations yet
         selected_models = random.sample(
             [
                 model
                 for model in all_models
-                if model_total_counts.get(model, 0) < dynamic_first
+                if model_total_counts.get(model, 0) < dynamic_warmup
             ],
             k=min(dynamic_contrastive_models, len(all_models)),
         )
@@ -405,20 +617,19 @@ def get_next_item_dynamic(
             top_models, k=min(dynamic_contrastive_models, len(top_models))
         )
 
-    # Find incomplete items for the selected models (items where not all selected models are done)
-    item_annotation_counts = {
-        i: sum(model in completed_models for model in selected_models)
-        for i, completed_models in enumerate(user_progress["progress"])
-    }
-
-    # Select item with minimum annotations (with random tiebreaking)
-    min_annotations = min(item_annotation_counts.values())
-    items_with_min = [
-        item_i
-        for item_i, count in item_annotation_counts.items()
-        if count == min_annotations
+    # Find incomplete items (None or completed_foreign status)
+    incomplete_indices = [
+        i
+        for i, mv in enumerate(user_progress["progress"])
+        if not all(v in {"completed", "completed_foreign"} for v in mv.values())
     ]
-    item_i = random.choice(items_with_min)
+
+    # If no incomplete items, user (and everyone) is done
+    if not incomplete_indices:
+        return _completed_response(tasks_data, progress_data, campaign_id, user_id)
+
+    # Select a random incomplete item
+    item_i = random.choice(incomplete_indices)
 
     # Prune the payload to only include selected models
     original_item = campaign_data["data"][item_i]
@@ -459,7 +670,7 @@ def get_next_item_dynamic(
             | {
                 k: v
                 for k, v in campaign_data["info"].items()
-                if k in {"protocol", "sliders"}
+                if k in CAMPAIGN_INFO_PUBLIC
             },
             "payload": pruned_item,
         },
@@ -475,16 +686,17 @@ def _reset_user_time(progress_data: dict, campaign_id: str, user_id: str) -> Non
     progress_data[campaign_id][user_id]["validations"] = {}
 
 
-def _get_user_annotated_items(campaign_id: str, user_id: str) -> set[int]:
+def _get_user_annotated_items(campaign_id: str, user_id: str) -> set[int | str]:
     """
     Get the set of item indices that a specific user has annotated.
-    
+
     Args:
         campaign_id: The campaign identifier
         user_id: The user identifier
-        
+
     Returns:
-        Set of item indices (item_i) that the user has annotated
+        Set of item indices (item_i) that the user has annotated.
+        Can include both int indices for regular items and string IDs like "welcome_0" for welcome items.
     """
     log = get_db_log(campaign_id)
     user_items = set()
@@ -504,9 +716,16 @@ def reset_task(
     """
     Reset the task progress for the user in the specified campaign.
     Saves a reset marker to mask existing annotations.
+
+    Note: Dynamic assignment does not support user-level deletion.
     """
     assignment = tasks_data[campaign_id]["info"]["assignment"]
-    if assignment == "task-based":
+    if assignment == "dynamic":
+        return JSONResponse(
+            content="User-level deletion is not supported for dynamic assignments",
+            status_code=400,
+        )
+    elif assignment == "task-based":
         # Save reset marker for this user to mask existing annotations
         num_items = len(tasks_data[campaign_id]["data"][user_id])
         for item_i in range(num_items):
@@ -514,49 +733,42 @@ def reset_task(
                 campaign_id,
                 {"user_id": user_id, "item_i": item_i, "annotation": RESET_MARKER},
             )
-        progress_data[campaign_id][user_id]["progress"] = [False] * num_items
+        progress_data[campaign_id][user_id]["progress"] = [None] * num_items
+        # Reset welcome items progress if it exists
+        if "progress_welcome" in progress_data[campaign_id][user_id]:
+            num_welcome = len(progress_data[campaign_id][user_id]["progress_welcome"])
+            progress_data[campaign_id][user_id]["progress_welcome"] = [
+                False
+            ] * num_welcome
         _reset_user_time(progress_data, campaign_id, user_id)
         return JSONResponse(content="ok", status_code=200)
     elif assignment == "single-stream":
-        # Find all items that this user has annotated
-        user_items = _get_user_annotated_items(campaign_id, user_id)
-        
-        # Save reset markers only for items this user has touched
-        for item_i in user_items:
-            save_db_payload(
-                campaign_id,
-                {"user_id": user_id, "item_i": item_i, "annotation": RESET_MARKER},
-            )
-        
-        # Reset only the touched items in all users' progress (shared pool)
-        for uid in progress_data[campaign_id]:
-            for item_i in user_items:
-                progress_data[campaign_id][uid]["progress"][item_i] = False
-        
-        # Reset only the specified user's time
-        _reset_user_time(progress_data, campaign_id, user_id)
-        return JSONResponse(content="ok", status_code=200)
-    elif assignment == "dynamic":
-        # Find all items that this user has annotated
-        user_items = _get_user_annotated_items(campaign_id, user_id)
-        
-        # Save reset markers only for items this user has touched
-        for item_i in user_items:
+        # Find all items that this user has annotated (has "completed")
+        user_items_to_reset = [
+            i
+            for i, status in enumerate(progress_data[campaign_id][user_id]["progress"])
+            if status == "completed"
+        ]
+
+        # Save reset markers for all items this user has touched
+        for item_i in user_items_to_reset:
             save_db_payload(
                 campaign_id,
                 {"user_id": user_id, "item_i": item_i, "annotation": RESET_MARKER},
             )
 
-        progress_data_user = copy.deepcopy(progress_data[campaign_id][user_id]["progress"])
-        
-        # Reset only the touched items in all users' progress (shared pool, use lists to track models)
+        # Reset the touched regular items in all users' progress (shared pool)
         for uid in progress_data[campaign_id]:
-            for item_i in user_items:
-                progress_data[campaign_id][uid]["progress"][item_i] = [
-                    x for x in progress_data[campaign_id][uid]["progress"][item_i]
-                    if x not in progress_data_user[item_i]
-                ]
-        
+            for item_i in user_items_to_reset:
+                progress_data[campaign_id][uid]["progress"][item_i] = None
+
+        # Reset all welcome items progress for this user (per-user, not shared)
+        if "progress_welcome" in progress_data[campaign_id][user_id]:
+            num_welcome = len(progress_data[campaign_id][user_id]["progress_welcome"])
+            progress_data[campaign_id][user_id]["progress_welcome"] = [
+                False
+            ] * num_welcome
+
         # Reset only the specified user's time
         _reset_user_time(progress_data, campaign_id, user_id)
         return JSONResponse(content="ok", status_code=200)
@@ -571,35 +783,58 @@ def update_progress(
     user_id: str,
     tasks_data: dict,
     progress_data: dict,
-    item_i: int,
+    item_i: int | str,  # Can be int or str like "welcome_0"
     payload: Any,
 ) -> JSONResponse:
     """
     Log the user's response for the specified item in the campaign.
     """
+    # Check if it's a welcome item
+    if isinstance(item_i, str) and item_i.startswith("welcome_"):
+        welcome_index = int(item_i.split("_")[1])
+        # Update only this user's progress_welcome (not shared)
+        progress_data[campaign_id][user_id]["progress_welcome"][welcome_index] = (
+            "completed"
+        )
+        return JSONResponse(content={"status": "ok"}, status_code=200)
+
     assignment = tasks_data[campaign_id]["info"]["assignment"]
     if assignment == "task-based":
-        # even if it's already set it should be fine
-        progress_data[campaign_id][user_id]["progress"][item_i] = True
+        # Mark as completed for this user
+        progress_data[campaign_id][user_id]["progress"][item_i] = "completed"
         return JSONResponse(content={"status": "ok"}, status_code=200)
     elif assignment == "single-stream":
-        # progress all users
+        # Mark as completed for the current user, completed_foreign for others
         for uid in progress_data[campaign_id]:
-            progress_data[campaign_id][uid]["progress"][item_i] = True
+            current_status = progress_data[campaign_id][uid]["progress"][item_i]
+            if uid == user_id:
+                # User who completed it gets "completed"
+                progress_data[campaign_id][uid]["progress"][item_i] = "completed"
+            elif current_status is None:
+                # Other users get "completed_foreign" if not already completed
+                progress_data[campaign_id][uid]["progress"][item_i] = (
+                    "completed_foreign"
+                )
+            # If already "completed", keep it as "completed"
         return JSONResponse(content="ok", status_code=200)
-    elif assignment == "dynamic":
-        # For dynamic, track which models were annotated
-        # Extract models from the payload annotation
-        annotated_models = []
-        if "annotation" in payload:
-            for annotation_item in payload.get("annotation", []):
-                if isinstance(annotation_item, dict):
-                    annotated_models.extend(annotation_item.keys())
-
-        # Update progress for all users (shared pool)
-        for uid in progress_data[campaign_id]:
-            # Add the newly annotated models
-            progress_data[campaign_id][uid]["progress"][item_i].extend(annotated_models)
+    if assignment == "dynamic":
+        # Mark as completed for the current user, completed_foreign for others
+        for model in payload["annotation"][0].keys():
+            for uid in progress_data[campaign_id]:
+                current_status = progress_data[campaign_id][uid]["progress"][item_i][
+                    model
+                ]
+                if uid == user_id:
+                    # User who completed it gets "completed"
+                    progress_data[campaign_id][uid]["progress"][item_i][model] = (
+                        "completed"
+                    )
+                elif current_status is None:
+                    # Other users get "completed_foreign" if not already completed
+                    progress_data[campaign_id][uid]["progress"][item_i][model] = (
+                        "completed_foreign"
+                    )
+                # If already "completed", keep it as "completed"
         return JSONResponse(content="ok", status_code=200)
     else:
         return JSONResponse(content="Unknown campaign assignment type", status_code=400)