Progress reporting

# Register recipe stages
from adaptive_harmony import recipe_main, RecipeContext


@recipe_main
async def main(ctx: RecipeContext):

    batch_inference_stage, eval_stage = ["Generating completions", "Evaluating completions"]
    ctx.job.register_stages(stages)

# for training progress report
stage = "Generating grades"
total = 1000
current = 50
ctx.job.report_progress(stage, total, current)

from adaptive_harmony.common import GRPO
stage_notifier = ctx.job.stage_notifier(stage="GRPO Training")

trainer = GRPO(
    ...,
    stage_notifier=stage_notifier,
    ...
)

from adaptive_harmony.runtime import SimpleProgressNotifier

async with SimpleProgressNotifier(ctx.job.stage_notifier("Spawning judge model")):
    judge = await ctx.client.model("model_registry://llama-3.3-70b").spawn_inference("judge")
    

@recipe_main
async def recipe(config: EvalConfig, ctx: RecipeContext):
    # load dataset...
    # spawn models...

    # Register recipe stages
    inference_stage, eval_stage = "Generating completions", "Evaluating completions"

    stages = [inference_stage, eval_stage]
    ctx.job.register_stages(stages)

    batch_size=20

    # batch method not implemented here
    inference_batches = batch(dataset, batch_size=batch_size)
    completions = []
    for i, batch in inference_batches:
        completions.extend([model.generate(thread) for thread in batch])
        ctx.job.report_inference_progress(inference_stage, len(dataset), i * batch_size + len(batch))

    eval_batches = batch(completions, batch_size=batch_size):
    grades = []
    for i, batch in eval_batches:
        grades.extend(grades.extend([grader.grade(thread) for thread in batch]))
        ctx.job.report_progress(
            eval_stage,
            len(completions),
            i * batch_size + len(batch)
        )
    
    print("Recipe finished")