| """Merge completed quality annotations into the annotated Parquet dataset.""" |
|
|
| import json |
| import os |
| import random |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
| from pathlib import Path |
|
|
| import polars as polars |
| from tqdm import tqdm |
|
|
| from build_quality_annotation_dataset import ( |
| MAX_WORKERS, |
| ROWS_PER_WINDOW, |
| SOURCE_SHARDS, |
| window_jobs_for, |
| ) |
|
|
| CATEGORIES = { |
| "Society", |
| "Arts", |
| "Business", |
| "Science", |
| "Sports", |
| "Lifestyle", |
| "Health", |
| "Games", |
| "News", |
| } |
| ANNOTATION_COLUMNS = [ |
| "custom_id", |
| "batch_id", |
| "justification", |
| "educational_score", |
| "category", |
| ] |
|
|
|
|
| def result_files_from(manifest_file: Path) -> list[tuple[str, Path]]: |
| """Return batch IDs and their downloaded result paths.""" |
| manifest = json.loads(manifest_file.read_text(encoding="utf-8")) |
| return [ |
| (batch["id"], Path("batch_results") / f"{batch['id']}.jsonl") |
| for batch in manifest["batches"] |
| ] |
|
|
|
|
| def parsed_annotations( |
| input_file: Path, |
| manifest_file: Path, |
| ) -> polars.DataFrame: |
| """Parse and validate OpenRouter responses, then match them to source IDs.""" |
| records = [] |
| for batch_id, result_file in result_files_from(manifest_file=manifest_file): |
| if not result_file.exists(): |
| raise FileNotFoundError(f"Missing batch result: {result_file}") |
| with result_file.open(encoding="utf-8") as file: |
| for line in file: |
| result = json.loads(line) |
| if result.get("error") is not None: |
| raise RuntimeError(f"Failed result {result.get('custom_id')}: {result['error']}") |
| response = result["response"] |
| if response["status_code"] != 200: |
| raise RuntimeError( |
| f"Result {result['custom_id']} returned {response['status_code']}" |
| ) |
| content = response["body"]["choices"][0]["message"]["content"] |
| annotation = json.loads(content) |
| score = annotation.get("educational_score") |
| category = annotation.get("category") |
| if not isinstance(score, int) or score not in range(6): |
| raise ValueError(f"Invalid score for {result['custom_id']}: {score}") |
| if category not in CATEGORIES: |
| raise ValueError( |
| f"Invalid category for {result['custom_id']}: {category}" |
| ) |
| records.append( |
| { |
| "custom_id": result["custom_id"], |
| "batch_id": batch_id, |
| "justification": annotation["justification"], |
| "educational_score": score, |
| "category": category, |
| } |
| ) |
|
|
| annotations = polars.DataFrame(data=records) |
| inputs = polars.read_ndjson(source=input_file).select("custom_id", "id") |
| if annotations.get_column("custom_id").n_unique() != annotations.height: |
| raise ValueError("Batch results contain duplicate custom IDs.") |
| if annotations.height != inputs.height: |
| raise ValueError( |
| f"Expected {inputs.height:,} results, received {annotations.height:,}." |
| ) |
| matched = inputs.join( |
| other=annotations, |
| on="custom_id", |
| how="inner", |
| validate="1:1", |
| ) |
| if matched.height != inputs.height: |
| raise ValueError("Some input rows have no matching batch result.") |
| return matched.select("id", *ANNOTATION_COLUMNS) |
|
|
|
|
| def fetch_full_window( |
| url: str, |
| seed: int, |
| storage_options: dict[str, str] | None, |
| ) -> polars.DataFrame: |
| """Re-fetch one deterministic candidate window with every source column.""" |
| scan = polars.scan_parquet(source=url, storage_options=storage_options) |
| rows = scan.select(polars.len()).collect().item() |
| offset = random.Random(x=seed).randint( |
| a=0, |
| b=max(rows - ROWS_PER_WINDOW, 0), |
| ) |
| return scan.slice(offset=offset, length=ROWS_PER_WINDOW).collect() |
|
|
|
|
| def source_rows_for( |
| source: str, |
| target_ids: polars.DataFrame, |
| storage_options: dict[str, str] | None, |
| ) -> polars.DataFrame: |
| """Re-fetch the full source rows selected for annotation.""" |
| jobs = window_jobs_for(source=source) |
| windows: list[polars.DataFrame | None] = [None] * len(jobs) |
| with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor: |
| futures = { |
| executor.submit( |
| fetch_full_window, |
| url=url, |
| seed=seed, |
| storage_options=storage_options, |
| ): index |
| for index, (url, seed) in enumerate(jobs) |
| } |
| for future in tqdm( |
| as_completed(futures), |
| total=len(futures), |
| desc=f"Re-fetching {source}", |
| ): |
| windows[futures[future]] = future.result() |
| candidates = polars.concat( |
| items=[window for window in windows if window is not None] |
| ).unique(subset="id", keep="first", maintain_order=True) |
| return candidates.join( |
| other=target_ids, |
| on="id", |
| how="semi", |
| ) |
|
|
|
|
| def main( |
| input_file: str = "to_annotate_quality.jsonl", |
| manifest_file: str = "to_annotate_quality.batches.json", |
| existing_data: str = "data/annotated.parquet", |
| output_file: str = "data/annotated.parquet", |
| ) -> None: |
| """Write the existing and newly annotated rows with one shared schema.""" |
| input_path = Path(input_file) |
| annotations = parsed_annotations( |
| input_file=input_path, |
| manifest_file=Path(manifest_file), |
| ) |
| inputs = polars.read_ndjson(source=input_path).select("id", "source") |
| token = os.getenv("HF_TOKEN") |
| storage_options = {"token": token} if token else None |
| full_rows = polars.concat( |
| items=[ |
| source_rows_for( |
| source=source, |
| target_ids=inputs.filter(polars.col("source") == source).select("id"), |
| storage_options=storage_options, |
| ) |
| for source in SOURCE_SHARDS |
| ] |
| ) |
| if full_rows.height != inputs.height: |
| raise ValueError( |
| f"Recovered {full_rows.height:,} of {inputs.height:,} source rows." |
| ) |
|
|
| existing = polars.read_parquet(source=existing_data) |
| new_rows = full_rows.join( |
| other=annotations, |
| on="id", |
| how="inner", |
| validate="1:1", |
| ).select(existing.columns) |
| combined = polars.concat(items=[existing, new_rows]) |
| if combined.get_column("id").n_unique() != combined.height: |
| raise ValueError("Combined dataset contains duplicate source IDs.") |
|
|
| output_path = Path(output_file) |
| temporary_path = output_path.with_suffix(".tmp.parquet") |
| combined.write_parquet(file=temporary_path) |
| temporary_path.replace(output_path) |
| print( |
| combined.group_by("source", "educational_score") |
| .len() |
| .sort("source", "educational_score") |
| ) |
| print(f"Wrote {combined.height:,} rows to {output_path}") |
|
|
|
|
| if __name__ == "__main__": |
| import fire |
|
|
| fire.Fire(component=main) |
|
|
