Refactor: Extract shared problem sync logic into libkernelbot

- Create problem_sync.py module with shared logic for downloading repos,
  parsing competition YAMLs, and creating/updating leaderboards
- Simplify API endpoint to use shared sync_problems() function
- Reduces code duplication between API and Discord cog

Author: Mark Saroufim

src/kernelbot/api/main.py

@@ -3,14 +3,10 @@
 import datetime
 import json
 import os
-import subprocess
-import tempfile
 import time
 from dataclasses import asdict
-from pathlib import Path
 from typing import Annotated, Any, Optional
 
-import yaml
 from fastapi import Depends, FastAPI, Header, HTTPException, Request, UploadFile
 from fastapi.responses import JSONResponse, StreamingResponse
 
@@ -20,6 +16,7 @@
 from libkernelbot.consts import SubmissionMode
 from libkernelbot.db_types import IdentityType
 from libkernelbot.leaderboard_db import LeaderboardDB, LeaderboardRankedEntry
+from libkernelbot.problem_sync import sync_problems
 from libkernelbot.submission import (
     ProcessedSubmissionRequest,
     SubmissionRequest,
@@ -28,7 +25,6 @@
 from libkernelbot.task import make_task_definition
 from libkernelbot.utils import (
     KernelBotError,
-    parse_deadline,
     resolve_problem_directory,
     setup_logging,
 )
@@ -610,7 +606,7 @@ async def admin_get_submission(
 
 
 @app.post("/admin/update-problems")
-async def admin_update_problems(  # noqa: C901
+async def admin_update_problems(
     payload: dict,
     _: Annotated[None, Depends(require_admin)],
     db_context=Depends(get_db),
@@ -621,179 +617,32 @@ async def admin_update_problems(  # noqa: C901
     Downloads the repository, parses competition YAML files, and creates/updates leaderboards.
     """
     repository = payload.get("repository", "gpu-mode/reference-kernels")
-    problem_set = payload.get("problem_set")  # Optional - if None, process all
+    problem_set = payload.get("problem_set")
     branch = payload.get("branch", "main")
     force = payload.get("force", False)
 
-    if "/" in branch:
-        raise HTTPException(status_code=400, detail="Branch names with slashes are not supported")
-
-    url = f"https://github.com/{repository}/archive/{branch}.zip"
-    folder_name = repository.split("/")[-1] + "-" + branch
-
-    created = []
-    updated = []
-    skipped = []
-    errors = []
-
-    with tempfile.TemporaryDirectory() as temp_dir:
-        # Download the repository
-        try:
-            subprocess.check_call(
-                ["wget", "-q", "-O", temp_dir + "/problems.zip", url],
-                encoding="utf-8",
-                timeout=60,
-            )
-        except subprocess.CalledProcessError as e:
-            raise HTTPException(
-                status_code=400,
-                detail=f"Could not download repository from {url}: {e}"
-            ) from e
-        except subprocess.TimeoutExpired as e:
-            raise HTTPException(
-                status_code=408,
-                detail="Timeout downloading repository"
-            ) from e
-
-        # Unzip
-        try:
-            subprocess.check_call(
-                ["unzip", "-q", temp_dir + "/problems.zip", "-d", temp_dir],
-                encoding="utf-8",
-                timeout=30,
-            )
-        except subprocess.CalledProcessError as e:
-            raise HTTPException(
-                status_code=400,
-                detail=f"Could not unzip repository: {e}"
-            ) from e
-
-        problem_dir = Path(temp_dir) / folder_name / "problems"
-        if not problem_dir.exists():
-            raise HTTPException(
-                status_code=400,
-                detail="No 'problems' directory found in repository"
-            )
-
-        # Find competition YAML files
-        if problem_set is None:
-            yaml_files = list(problem_dir.glob("*.yaml"))
-        else:
-            yaml_file = problem_dir / f"{problem_set}.yaml"
-            if not yaml_file.exists():
-                available = [f.stem for f in problem_dir.glob("*.yaml")]
-                raise HTTPException(
-                    status_code=400,
-                    detail=f"Problem set '{problem_set}' not found. Available: {available}"
-                )
-            yaml_files = [yaml_file]
-
-        # Get existing leaderboards
-        with db_context as db:
-            existing_leaderboards = {lb["name"]: lb for lb in db.get_leaderboards()}
-
-        # Process each competition YAML
-        for yaml_file in yaml_files:
-            try:
-                with open(yaml_file) as f:
-                    competition = yaml.safe_load(f)
-
-                for problem in competition.get("problems", []):
-                    problem_name = problem.get("name")
-                    directory = problem.get("directory")
-                    deadline_str = problem.get("deadline")
-                    gpus = problem.get("gpus", [])
-
-                    if not problem_name or not directory:
-                        errors.append({"name": problem_name or "unknown", "error": "Missing name or directory"})
-                        continue
-
-                    source_path = problem_dir / directory
-                    if not source_path.exists():
-                        errors.append({"name": problem_name, "error": f"Directory {directory} not found"})
-                        continue
-
-                    try:
-                        definition = make_task_definition(source_path)
-                    except Exception as e:
-                        errors.append({"name": problem_name, "error": f"Failed to parse task.yml: {e}"})
-                        continue
-
-                    deadline = parse_deadline(deadline_str) if deadline_str else None
-                    if deadline is None:
-                        deadline = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(days=365)
-
-                    # Check if leaderboard exists
-                    if problem_name in existing_leaderboards:
-                        old_lb = existing_leaderboards[problem_name]
-                        # Check if update is needed
-                        old_deadline = old_lb["deadline"]
-                        if hasattr(old_deadline, "tzinfo") and old_deadline.tzinfo is None:
-                            old_deadline = old_deadline.replace(tzinfo=datetime.timezone.utc)
-
-                        deadline_changed = old_deadline != deadline
-                        task_changed = old_lb["task"] != definition.task
-
-                        if not deadline_changed and not task_changed:
-                            skipped.append({"name": problem_name, "reason": "no changes"})
-                            continue
-
-                        if task_changed and not force:
-                            # Check if only safe changes (description/templates)
-                            old_task = old_lb["task"]
-                            new_task = definition.task
-                            if (old_task.files != new_task.files or
-                                old_task.config != new_task.config or
-                                old_task.lang != new_task.lang or
-                                old_task.benchmarks != new_task.benchmarks):
-                                skipped.append({
-                                    "name": problem_name,
-                                    "reason": "significant task changes require --force"
-                                })
-                                continue
-
-                        # Update the leaderboard
-                        try:
-                            with db_context as db:
-                                db.update_leaderboard(problem_name, deadline, definition)
-                            updated.append(problem_name)
-                        except Exception as e:
-                            errors.append({"name": problem_name, "error": f"Update failed: {e}"})
-                    else:
-                        # Create new leaderboard
-                        if not gpus:
-                            gpus = definition.gpus if definition.gpus else []
-                        if not gpus:
-                            errors.append({"name": problem_name, "error": "No GPUs specified in task.yml or YAML"})
-                            continue
-
-                        try:
-                            with db_context as db:
-                                db.create_leaderboard(
-                                    name=problem_name,
-                                    deadline=deadline,
-                                    definition=definition,
-                                    creator_id=0,  # API-created
-                                    forum_id=-1,   # No Discord forum
-                                    gpu_types=gpus,
-                                )
-                            created.append(problem_name)
-                        except Exception as e:
-                            errors.append({"name": problem_name, "error": f"Create failed: {e}"})
-
-            except yaml.YAMLError as e:
-                errors.append({"name": yaml_file.stem, "error": f"Invalid YAML: {e}"})
-            except Exception as e:
-                errors.append({"name": yaml_file.stem, "error": str(e)})
+    try:
+        result = sync_problems(
+            db_context=db_context,
+            repository=repository,
+            problem_set=problem_set,
+            branch=branch,
+            force=force,
+            creator_id=0,  # API-created
+            forum_id=-1,   # No Discord forum
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e)) from e
 
     return {
         "status": "ok",
-        "created": created,
-        "updated": updated,
-        "skipped": skipped,
-        "errors": errors,
+        "created": result.created,
+        "updated": result.updated,
+        "skipped": result.skipped,
+        "errors": result.errors,
     }
 
+
 @app.get("/leaderboards")
 async def get_leaderboards(db_context=Depends(get_db)):
     """An endpoint that returns all leaderboards.