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

pearmut/cli.py

@@ -23,31 +23,39 @@ def _run(args_unknown):
 
     args = argparse.ArgumentParser()
     args.add_argument(
-        "--port", type=int, default=8001,
-        help="Port to run the server on"
+        "--port", type=int, default=8001, help="Port to run the server on"
     )
     args.add_argument(
-        "--server", default="http://localhost:8001",
-        help="Prefix server URL for protocol links"
+        "--server",
+        default="http://localhost:8001",
+        help="Prefix server URL for protocol links",
     )
     args = args.parse_args(args_unknown)
 
     # print access dashboard URL for all campaigns
     if tasks_data:
-        dashboard_url = args.server + "/dashboard.html?" + "&".join([
-            f"campaign_id={urllib.parse.quote_plus(campaign_id)}&token={campaign_data["token"]}"
-            for campaign_id, campaign_data in tasks_data.items()
-        ])
-        print("\033[92mNow serving Pearmut, use the following URL to access the everything-dashboard:\033[0m")
-        print("🍐", dashboard_url+"\n", flush=True)
-    
+        dashboard_url = (
+            args.server
+            + "/dashboard.html?"
+            + "&".join(
+                [
+                    f"campaign_id={urllib.parse.quote_plus(campaign_id)}&token={campaign_data["token"]}"
+                    for campaign_id, campaign_data in tasks_data.items()
+                ]
+            )
+        )
+        print(
+            "\033[92mNow serving Pearmut, use the following URL to access the everything-dashboard:\033[0m"
+        )
+        print("🍐", dashboard_url + "\n", flush=True)
+
     # disable startup message
     uvicorn.config.LOGGING_CONFIG["loggers"]["uvicorn.error"]["level"] = "WARNING"
     # set time logging
     uvicorn.config.LOGGING_CONFIG["formatters"]["access"]["datefmt"] = "%Y-%m-%d %H:%M"
-    uvicorn.config.LOGGING_CONFIG["formatters"]["access"]["fmt"] = (
-        '%(asctime)s %(levelprefix)s %(client_addr)s - %(request_line)s %(status_code)s'
-    )
+    uvicorn.config.LOGGING_CONFIG["formatters"]["access"][
+        "fmt"
+    ] = "%(asctime)s %(levelprefix)s %(client_addr)s - %(request_line)s %(status_code)s"
     uvicorn.run(
         app,
         host="0.0.0.0",
@@ -59,9 +67,9 @@ def _run(args_unknown):
 def _validate_item_structure(items):
     """
     Validate that items have the correct structure.
-    Items should be lists of dictionaries with 'src' and 'tgt' keys.
+    Items should be lists of dictionaries with 'tgt' and optionally 'src' and/or 'ref' keys.
     The 'tgt' field should be a dictionary mapping model names to translations.
-    
+
     Args:
         items: List of item dictionaries to validate
     """
@@ -70,71 +78,91 @@ def _validate_item_structure(items):
 
     for item in items:
         if not isinstance(item, dict):
-            raise ValueError("Each item must be a dictionary with 'src' and 'tgt' keys")
-        if 'src' not in item or 'tgt' not in item:
-            raise ValueError("Each item must contain 'src' and 'tgt' keys")
-        
-        # Validate src is always a string
-        if not isinstance(item['src'], str):
+            raise ValueError("Each item must be a dictionary with 'tgt' key")
+        if "tgt" not in item:
+            raise ValueError("Each item must contain 'tgt' key")
+
+        # Validate src is a string if present
+        if "src" in item and not isinstance(item["src"], str):
             raise ValueError("Item 'src' must be a string")
-        
+
+        # Validate ref is a string if present
+        if "ref" in item and not isinstance(item["ref"], str):
+            raise ValueError("Item 'ref' must be a string")
+
         # Validate tgt is a dictionary (basic template with model names)
-        if isinstance(item['tgt'], str):
+        if isinstance(item["tgt"], str):
             # String not allowed - suggest using dictionary (don't include user input to prevent injection)
-            raise ValueError("Item 'tgt' must be a dictionary mapping model names to translations. For single translation, use {\"default\": \"your_translation\"}")
-        elif isinstance(item['tgt'], dict):
+            raise ValueError(
+                'Item \'tgt\' must be a dictionary mapping model names to translations. For single translation, use {"default": "your_translation"}'
+            )
+        elif isinstance(item["tgt"], dict):
             # Dictionary mapping model names to translations
             # Validate that model names don't contain only numbers (JavaScript ordering issue)
-            for model_name, translation in item['tgt'].items():
+            for model_name, translation in item["tgt"].items():
                 if not isinstance(model_name, str):
                     raise ValueError("Model names in 'tgt' dictionary must be strings")
                 if model_name.isdigit():
-                    raise ValueError(f"Model name '{model_name}' cannot be only numeric digits (would cause issues in JS/TS)")
+                    raise ValueError(
+                        f"Model name '{model_name}' cannot be only numeric digits (would cause issues in JS/TS)"
+                    )
                 if not isinstance(translation, str):
-                    raise ValueError(f"Translation for model '{model_name}' must be a string")
+                    raise ValueError(
+                        f"Translation for model '{model_name}' must be a string"
+                    )
         else:
-            raise ValueError("Item 'tgt' must be a dictionary mapping model names to translations")
-        
+            raise ValueError(
+                "Item 'tgt' must be a dictionary mapping model names to translations"
+            )
+
         # Validate error_spans structure if present
-        if 'error_spans' in item:
-            if not isinstance(item['error_spans'], dict):
-                raise ValueError("'error_spans' must be a dictionary mapping model names to error span lists")
-            for model_name, spans in item['error_spans'].items():
+        if "error_spans" in item:
+            if not isinstance(item["error_spans"], dict):
+                raise ValueError(
+                    "'error_spans' must be a dictionary mapping model names to error span lists"
+                )
+            for model_name, spans in item["error_spans"].items():
                 if not isinstance(spans, list):
-                    raise ValueError(f"Error spans for model '{model_name}' must be a list")
-        
+                    raise ValueError(
+                        f"Error spans for model '{model_name}' must be a list"
+                    )
+
         # Validate validation structure if present
-        if 'validation' in item:
-            if not isinstance(item['validation'], dict):
-                raise ValueError("'validation' must be a dictionary mapping model names to validation rules")
-            for model_name, val_rule in item['validation'].items():
+        if "validation" in item:
+            if not isinstance(item["validation"], dict):
+                raise ValueError(
+                    "'validation' must be a dictionary mapping model names to validation rules"
+                )
+            for model_name, val_rule in item["validation"].items():
                 if not isinstance(val_rule, dict):
-                    raise ValueError(f"Validation rule for model '{model_name}' must be a dictionary")
+                    raise ValueError(
+                        f"Validation rule for model '{model_name}' must be a dictionary"
+                    )
 
 
 def _validate_document_models(doc):
     """
     Validate that all items in a document have the same model outputs.
-    
+
     Args:
         doc: List of items in a document
-        
+
     Returns:
         None if valid
-        
+
     Raises:
         ValueError: If items have different model outputs
     """
     # Get model names from the first item
     first_item = doc[0]
-    first_models = set(first_item['tgt'].keys())
-    
+    first_models = set(first_item["tgt"].keys())
+
     # Check all other items have the same model names
     for i, item in enumerate(doc[1:], start=1):
-        if 'tgt' not in item or not isinstance(item['tgt'], dict):
+        if "tgt" not in item or not isinstance(item["tgt"], dict):
             continue
-        
-        item_models = set(item['tgt'].keys())
+
+        item_models = set(item["tgt"].keys())
         if item_models != first_models:
             raise ValueError(
                 f"Document contains items with different model outputs. "
@@ -147,71 +175,69 @@ def _validate_document_models(doc):
 def _shuffle_campaign_data(campaign_data, rng):
     """
     Shuffle campaign data at the document level in-place
-    
+
     For each document, randomly shuffles the order of models in the tgt dictionary.
-    
+
     Args:
         campaign_data: The campaign data dictionary
         rng: Random number generator with campaign-specific seed
     """
+
     def shuffle_document(doc):
         """Shuffle a single document (list of items) by reordering models in tgt dict."""
         # Validate that all items have the same models
         _validate_document_models(doc)
-        
+
         # Get all model names from the first item's tgt dict
         first_item = doc[0]
-        model_names = list(first_item['tgt'].keys())
+        model_names = list(first_item["tgt"].keys())
         rng.shuffle(model_names)
-        
+
         # Reorder tgt dict for all items in the document
         for item in doc:
-            if 'tgt' in item and isinstance(item['tgt'], dict):
-                item["tgt"] = {
-                    model: item["tgt"][model]
-                    for model in model_names
-                }
-    
+            if "tgt" in item and isinstance(item["tgt"], dict):
+                item["tgt"] = {model: item["tgt"][model] for model in model_names}
+
     assignment = campaign_data["info"]["assignment"]
-    
+
     if assignment == "task-based":
         # After transformation, data is a dict mapping user_id -> tasks
         for user_id, task in campaign_data["data"].items():
             for doc in task:
                 shuffle_document(doc)
-    elif assignment == "single-stream":
+    elif assignment in ["single-stream", "dynamic"]:
         # Shuffle each document in the shared pool
         for doc in campaign_data["data"]:
             shuffle_document(doc)
 
 
-def _add_single_campaign(data_file, overwrite, server):
+def _add_single_campaign(campaign_data, overwrite, server):
     """
-    Add a single campaign from a JSON data file.
+    Add a single campaign from campaign data dictionary.
     """
     import random
 
     import wonderwords
 
-    with open(data_file, 'r') as f:
-        campaign_data = json.load(f)
+    if "campaign_id" not in campaign_data:
+        raise ValueError("Campaign data must contain 'campaign_id' field.")
+    if "info" not in campaign_data:
+        raise ValueError("Campaign data must contain 'info' field.")
+    if "data" not in campaign_data:
+        raise ValueError("Campaign data must contain 'data' field.")
 
     with open(f"{ROOT}/data/progress.json", "r") as f:
         progress_data = json.load(f)
 
-    if campaign_data['campaign_id'] in progress_data and not overwrite:
+    if campaign_data["campaign_id"] in progress_data and not overwrite:
         raise ValueError(
             f"Campaign {campaign_data['campaign_id']} already exists.\n"
             "Use -o to overwrite."
         )
 
-    if "info" not in campaign_data:
-        raise ValueError("Campaign data must contain 'info' field.")
-    if "data" not in campaign_data:
-        raise ValueError("Campaign data must contain 'data' field.")
     if "assignment" not in campaign_data["info"]:
         raise ValueError("Campaign 'info' must contain 'assignment' field.")
-    
+
     # Template defaults to "basic" if not specified
     assignment = campaign_data["info"]["assignment"]
     # use random words for identifying users
@@ -225,11 +251,11 @@ def _add_single_campaign(data_file, overwrite, server):
     if assignment == "task-based":
         tasks = campaign_data["data"]
         if not isinstance(tasks, list):
-            raise ValueError(
-                "Task-based campaign 'data' must be a list of tasks.")
+            raise ValueError("Task-based campaign 'data' must be a list of tasks.")
         if not all(isinstance(task, list) for task in tasks):
             raise ValueError(
-                "Each task in task-based campaign 'data' must be a list of items.")
+                "Each task in task-based campaign 'data' must be a list of items."
+            )
         # Validate item structure for each task
         for task_i, task in enumerate(tasks):
             for doc_i, doc in enumerate(task):
@@ -241,11 +267,9 @@ def _add_single_campaign(data_file, overwrite, server):
     elif assignment == "single-stream":
         tasks = campaign_data["data"]
         if users_spec is None:
-            raise ValueError(
-                "Single-stream campaigns must specify 'users' in info.")
+            raise ValueError("Single-stream campaigns must specify 'users' in info.")
         if not isinstance(campaign_data["data"], list):
-            raise ValueError(
-                "Single-stream campaign 'data' must be a list of items.")
+            raise ValueError("Single-stream campaign 'data' must be a list of items.")
         # Validate item structure for single-stream
         for doc_i, doc in enumerate(tasks):
             try:
@@ -259,8 +283,50 @@ def _add_single_campaign(data_file, overwrite, server):
         else:
             raise ValueError("'users' must be an integer or a list.")
     elif assignment == "dynamic":
-        raise NotImplementedError(
-            "Dynamic campaign assignment is not yet implemented.")
+        tasks = campaign_data["data"]
+        if users_spec is None:
+            raise ValueError("Dynamic campaigns must specify 'users' in info.")
+        if not isinstance(campaign_data["data"], list):
+            raise ValueError("Dynamic campaign 'data' must be a list of items.")
+        # Validate item structure for dynamic
+        for doc_i, doc in enumerate(tasks):
+            try:
+                _validate_item_structure(doc)
+            except ValueError as e:
+                raise ValueError(f"Document {doc_i}: {e}")
+        if isinstance(users_spec, int):
+            num_users = users_spec
+        elif isinstance(users_spec, list):
+            num_users = len(users_spec)
+        else:
+            raise ValueError("'users' must be an integer or a list.")
+        # Validate dynamic-specific parameters
+        if "dynamic_top" not in campaign_data["info"]:
+            campaign_data["info"]["dynamic_top"] = 2
+        if "dynamic_first" not in campaign_data["info"]:
+            campaign_data["info"]["dynamic_first"] = 5
+        if "dynamic_contrastive_models" not in campaign_data["info"]:
+            campaign_data["info"]["dynamic_contrastive_models"] = 1
+        # Validate that dynamic_first is at least 1
+        assert (
+            campaign_data["info"]["dynamic_first"] >= 1
+        ), "dynamic_first must be at least 1"
+        # Validate that dynamic_contrastive_models is at most dynamic_top
+        assert (
+            campaign_data["info"]["dynamic_contrastive_models"]
+            <= campaign_data["info"]["dynamic_top"]
+        ), "dynamic_contrastive_models must be at most dynamic_top"
+        # Validate that all items have the same models
+        all_models = set()
+        for item in campaign_data["data"]:
+            if item and len(item) > 0:
+                all_models.update(item[0]["tgt"].keys())
+        for item in campaign_data["data"]:
+            if item and len(item) > 0:
+                item_models = set(item[0]["tgt"].keys())
+                assert (
+                    item_models == all_models
+                ), "All items must have the same model outputs"
     else:
         raise ValueError(f"Unknown campaign assignment type: {assignment}")
 
@@ -272,14 +338,12 @@ def _add_single_campaign(data_file, overwrite, server):
             new_id = f"{rword.random_words(amount=1, include_parts_of_speech=['adjective'])[0]}-{rword.random_words(amount=1, include_parts_of_speech=['noun'])[0]}"
             if new_id not in user_ids:
                 user_ids.append(new_id)
-        user_ids = [
-            f"{user_id}-{rng.randint(0, 999):03d}"
-            for user_id in user_ids
-        ]
+        user_ids = [f"{user_id}-{rng.randint(0, 999):03d}" for user_id in user_ids]
     elif isinstance(users_spec, list):
         if len(users_spec) != num_users:
             raise ValueError(
-                f"Number of users ({len(users_spec)}) must match expected count ({num_users}).")
+                f"Number of users ({len(users_spec)}) must match expected count ({num_users})."
+            )
         if all(isinstance(u, str) for u in users_spec):
             # List of string IDs
             user_ids = users_spec
@@ -298,32 +362,47 @@ def _add_single_campaign(data_file, overwrite, server):
             raise ValueError("'users' list must contain all strings or all dicts.")
     else:
         raise ValueError("'users' must be an integer or a list.")
-    
+
     if "protocol" not in campaign_data["info"]:
         campaign_data["info"]["protocol"] = "ESA"
-        print("Warning: 'protocol' not specified in campaign info. Defaulting to 'ESA'.")
+        print(
+            "Warning: 'protocol' not specified in campaign info. Defaulting to 'ESA'."
+        )
+
+    # Validate sliders structure if present
+    if "sliders" in campaign_data["info"]:
+        if not all(
+            isinstance(s, dict)
+            and all(k in s for k in ("name", "min", "max", "step"))
+            and isinstance(s.get("min"), (int, float))
+            and isinstance(s.get("max"), (int, float))
+            and isinstance(s.get("step"), (int, float))
+            and s["min"] <= s["max"]
+            and s["step"] > 0
+            for s in campaign_data["info"]["sliders"]
+        ):
+            raise ValueError(
+                "Each slider must be a dict with 'name', 'min', 'max', and 'step' keys, where min/max/step are numeric, min <= max, and step > 0"
+            )
 
     # Remove output file when overwriting (after all validations pass)
-    if overwrite and campaign_data['campaign_id'] in progress_data:
+    if overwrite and campaign_data["campaign_id"] in progress_data:
         output_file = f"{ROOT}/data/outputs/{campaign_data['campaign_id']}.jsonl"
         if os.path.exists(output_file):
             os.remove(output_file)
 
     # For task-based, data is a dict mapping user_id -> tasks
-    # For single-stream, data is a flat list (shared among all users)
+    # For single-stream and dynamic, data is a flat list (shared among all users)
     if assignment == "task-based":
         campaign_data["data"] = {
-            user_id: task
-            for user_id, task in zip(user_ids, tasks)
+            user_id: task for user_id, task in zip(user_ids, tasks)
         }
-    elif assignment == "single-stream":
+    elif assignment in ["single-stream", "dynamic"]:
         campaign_data["data"] = tasks
 
     # generate a token for dashboard access if not present
     if "token" not in campaign_data:
-        campaign_data["token"] = (
-            hashlib.sha256(random.randbytes(16)).hexdigest()[:10]
-        )
+        campaign_data["token"] = hashlib.sha256(random.randbytes(16)).hexdigest()[:10]
 
     def get_token(user_id, token_type):
         """Get user token or generate a random one."""
@@ -336,9 +415,17 @@ def _add_single_campaign(data_file, overwrite, server):
         user_id: {
             # TODO: progress tracking could be based on the assignment type
             "progress": (
-                [False]*len(campaign_data["data"][user_id]) if assignment == "task-based"
-                else [False]*len(campaign_data["data"]) if assignment == "single-stream"
-                else []
+                [False] * len(campaign_data["data"][user_id])
+                if assignment == "task-based"
+                else (
+                    [False] * len(campaign_data["data"])
+                    if assignment == "single-stream"
+                    else (
+                        [list() for _ in range(len(campaign_data["data"]))]
+                        if assignment == "dynamic"
+                        else []
+                    )
+                )
             ),
             "time_start": None,
             "time_end": None,
@@ -357,26 +444,34 @@ def _add_single_campaign(data_file, overwrite, server):
     # Handle assets symlink if specified
     if "assets" in campaign_data["info"]:
         assets_config = campaign_data["info"]["assets"]
-        
+
         # assets must be a dictionary with source and destination keys
         if not isinstance(assets_config, dict):
-            raise ValueError("Assets must be a dictionary with 'source' and 'destination' keys.")
+            raise ValueError(
+                "Assets must be a dictionary with 'source' and 'destination' keys."
+            )
         if "source" not in assets_config or "destination" not in assets_config:
-            raise ValueError("Assets config must contain 'source' and 'destination' keys.")
-        
+            raise ValueError(
+                "Assets config must contain 'source' and 'destination' keys."
+            )
+
         assets_source = assets_config["source"]
         assets_destination = assets_config["destination"]
-        
+
         # Validate destination starts with 'assets/'
         if not assets_destination.startswith("assets/"):
-            raise ValueError(f"Assets destination '{assets_destination}' must start with 'assets/'.")
-        
+            raise ValueError(
+                f"Assets destination '{assets_destination}' must start with 'assets/'."
+            )
+
         # Resolve relative paths from the caller's current working directory
         assets_real_path = os.path.abspath(assets_source)
 
         if not os.path.isdir(assets_real_path):
-            raise ValueError(f"Assets source path '{assets_real_path}' must be an existing directory.")
-        
+            raise ValueError(
+                f"Assets source path '{assets_real_path}' must be an existing directory."
+            )
+
         # Symlink path is based on the destination, stripping the 'assets/' prefix
         # User assets are now stored under data/assets/ instead of static/assets/
         symlink_path = f"{ROOT}/data/{assets_destination}".rstrip("/")
@@ -384,7 +479,7 @@ def _add_single_campaign(data_file, overwrite, server):
         # Remove existing symlink if present and we are overriding the same campaign
         if os.path.lexists(symlink_path):
             # Check if any other campaign is using this destination
-            current_campaign_id = campaign_data['campaign_id']
+            current_campaign_id = campaign_data["campaign_id"]
 
             for other_campaign_id in progress_data.keys():
                 if other_campaign_id == current_campaign_id:
@@ -401,8 +496,10 @@ def _add_single_campaign(data_file, overwrite, server):
             if overwrite:
                 os.remove(symlink_path)
             else:
-                raise ValueError(f"Assets destination '{assets_destination}' is already taken.")
-        
+                raise ValueError(
+                    f"Assets destination '{assets_destination}' is already taken."
+                )
+
         # Ensure the assets directory exists
         # get parent of symlink_path dir
         os.makedirs(os.path.dirname(symlink_path), exist_ok=True)
@@ -410,7 +507,6 @@ def _add_single_campaign(data_file, overwrite, server):
         os.symlink(assets_real_path, symlink_path, target_is_directory=True)
         print(f"Assets symlinked: {symlink_path} -> {assets_real_path}")
 
-
     # Shuffle data if shuffle parameter is true (defaults to true)
     should_shuffle = campaign_data["info"].get("shuffle", True)
     if should_shuffle:
@@ -420,17 +516,14 @@ def _add_single_campaign(data_file, overwrite, server):
     with open(f"{ROOT}/data/tasks/{campaign_data['campaign_id']}.json", "w") as f:
         json.dump(campaign_data, f, indent=2, ensure_ascii=False)
 
-    progress_data[campaign_data['campaign_id']] = user_progress
-
-    with open(f"{ROOT}/data/progress.json", "w") as f:
-        json.dump(progress_data, f, indent=2, ensure_ascii=False)
-
+    progress_data[campaign_data["campaign_id"]] = user_progress
+    save_progress_data(progress_data)
 
     print(
         "🎛️ ",
         f"{server}/dashboard.html"
         f"?campaign_id={urllib.parse.quote_plus(campaign_data['campaign_id'])}"
-        f"&token={campaign_data['token']}"
+        f"&token={campaign_data['token']}",
     )
     for user_id, user_val in user_progress.items():
         # point to the protocol URL
@@ -444,22 +537,28 @@ def _add_campaign(args_unknown):
     """
     args = argparse.ArgumentParser()
     args.add_argument(
-        'data_files', type=str, nargs='+',
-        help='One or more paths to campaign data files'
+        "data_files",
+        type=str,
+        nargs="+",
+        help="One or more paths to campaign data files",
     )
     args.add_argument(
-        "-o", "--overwrite", action="store_true",
-        help="Overwrite existing campaign if it exists"
+        "-o",
+        "--overwrite",
+        action="store_true",
+        help="Overwrite existing campaign if it exists",
     )
     args.add_argument(
-        "--server", default="http://localhost:8001",
-        help="Prefix server URL for protocol links"
+        "--server",
+        default="http://localhost:8001",
+        help="Prefix server URL for protocol links",
     )
     args = args.parse_args(args_unknown)
 
     for data_file in args.data_files:
         try:
-            _add_single_campaign(data_file, args.overwrite, args.server)
+            with open(data_file, "r") as f:
+                _add_single_campaign(json.load(f), args.overwrite, args.server)
         except Exception as e:
             print(f"Error processing {data_file}: {e}")
             exit(1)
@@ -470,7 +569,13 @@ def main():
     Main entry point for the CLI.
     """
     args = argparse.ArgumentParser()
-    args.add_argument('command', type=str, choices=['run', 'add', 'purge'])
+    args.add_argument(
+        "command",
+        type=str,
+        choices=["run", "add", "purge"],
+        default="run",
+        nargs="?",
+    )
     args, args_unknown = args.parse_known_args()
 
     # enforce that only one pearmut process is running
@@ -480,11 +585,11 @@ def main():
             print(p)
             exit(1)
 
-    if args.command == 'run':
+    if args.command == "run":
         _run(args_unknown)
-    elif args.command == 'add':
+    elif args.command == "add":
         _add_campaign(args_unknown)
-    elif args.command == 'purge':
+    elif args.command == "purge":
         import shutil
 
         def _unlink_assets(campaign_id):
@@ -494,7 +599,9 @@ def main():
                 return
             with open(task_file, "r") as f:
                 campaign_data = json.load(f)
-            destination = campaign_data.get("info", {}).get("assets", {}).get("destination")
+            destination = (
+                campaign_data.get("info", {}).get("assets", {}).get("destination")
+            )
             if destination:
                 symlink_path = f"{ROOT}/data/{destination}".rstrip("/")
                 if os.path.islink(symlink_path):
@@ -504,8 +611,11 @@ def main():
         # Parse optional campaign name
         purge_args = argparse.ArgumentParser()
         purge_args.add_argument(
-            'campaign', type=str, nargs='?', default=None,
-            help='Optional campaign name to purge (purges all if not specified)'
+            "campaign",
+            type=str,
+            nargs="?",
+            default=None,
+            help="Optional campaign name to purge (purges all if not specified)",
         )
         purge_args = purge_args.parse_args(args_unknown)
         progress_data = load_progress_data()
@@ -519,7 +629,7 @@ def main():
             confirm = input(
                 f"Are you sure you want to purge campaign '{campaign_id}'? This action cannot be undone. [y/n] "
             )
-            if confirm.lower() == 'y':
+            if confirm.lower() == "y":
                 # Unlink assets before removing task file
                 _unlink_assets(campaign_id)
                 # Remove task file
@@ -543,7 +653,7 @@ def main():
             confirm = input(
                 "Are you sure you want to purge all campaign data? This action cannot be undone. [y/n] "
             )
-            if confirm.lower() == 'y':
+            if confirm.lower() == "y":
                 # Unlink all assets first
                 for campaign_id in progress_data.keys():
                     _unlink_assets(campaign_id)