| |
| """Apply verified source URLs and source-video clip intervals.""" |
| from __future__ import annotations |
|
|
| import argparse |
| from collections import Counter |
| import csv |
| from datetime import datetime, timezone |
| import hashlib |
| import json |
| from pathlib import Path |
| import shutil |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
|
|
| def write_csv(path, rows, fields): |
| with path.open('w', encoding='utf-8-sig', newline='') as stream: |
| writer = csv.DictWriter(stream, fieldnames=fields) |
| writer.writeheader() |
| for row in rows: |
| writer.writerow({k: json.dumps(v, ensure_ascii=False, sort_keys=True) |
| if isinstance(v, (list, dict)) else v for k, v in row.items()}) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--release-root', type=Path, required=True) |
| args = parser.parse_args() |
| root = args.release_root.resolve() |
| public = root / 'huggingface' |
| sources = json.loads((public / 'reference_sources.json').read_text()) |
| stamp = datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ') |
| backup = root / 'private/reference_source_recovery' / ('before_apply_' + stamp) |
| plans = [] |
| changed_ids = set() |
| for split in ('all', 'train'): |
| for task in ('i2v', 'v2v'): |
| folder = public / split / task |
| path = folder / ('data-00000-of-00001.parquet' if split == 'all' |
| else 'train-00000-of-00001.parquet') |
| table = pq.read_table(path) |
| before = table.to_pylist() |
| after = [dict(row) for row in before] |
| for old, new in zip(before, after): |
| source = sources.get(new['task_id']) |
| if not source: |
| continue |
| url = source['reference_url'] |
| if old['reference_url'] and old['reference_url'] != url: |
| raise ValueError('Conflicting existing locator: ' + new['task_id']) |
| new['reference_url'] = url |
| updated_fields = {'reference_url'} |
| if 'keyclip_start_s' in source or 'keyclip_end_s' in source: |
| if new['task'] != 'v2v': |
| raise ValueError('Clip timestamps are only valid for V2V: ' + new['task_id']) |
| start = source.get('keyclip_start_s') |
| end = source.get('keyclip_end_s') |
| if start is None or end is None or float(start) < 0 or float(start) >= float(end): |
| raise ValueError('Invalid source clip interval: ' + new['task_id']) |
| new['keyclip_start_s'] = float(start) |
| new['keyclip_end_s'] = float(end) |
| updated_fields.update({'keyclip_start_s', 'keyclip_end_s'}) |
| assert {k: v for k, v in old.items() if k not in updated_fields} == { |
| k: v for k, v in new.items() if k not in updated_fields} |
| changed_ids.add(new['task_id']) |
| assert len(before) == len(after) == 693 |
| assert table.schema.names[-1] == 'qa' |
| for row in after: |
| for field in ('video_categories', 'subtypes', 'subjects', 'motion_types', 'events', 'qa'): |
| assert isinstance(row[field], list), (row['task_id'], field) |
| plans.append((path, table.schema, after)) |
| assert changed_ids == set(sources) |
| for task in ('i2v', 'v2v'): |
| assert next(p[2] for p in plans if p[0].parent == public / 'all' / task) == next( |
| p[2] for p in plans if p[0].parent == public / 'train' / task) |
| issues_path = public / 'data_issues.csv' |
| with issues_path.open(encoding='utf-8-sig', newline='') as stream: |
| reader = csv.DictReader(stream) |
| issue_fields = reader.fieldnames |
| issues = [row for row in reader if not ( |
| row['issue'] == 'missing_reference_url' and row['task_id'] in sources)] |
| for path, schema, rows in plans: |
| for file in (path, path.parent / 'records.jsonl', path.parent / 'records.csv'): |
| dest = backup / file.relative_to(public) |
| dest.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copy2(file, dest) |
| temp = path.with_suffix('.parquet.tmp') |
| pq.write_table(pa.Table.from_pylist(rows, schema=schema), temp, compression='zstd') |
| assert pq.read_table(temp).to_pylist() == rows |
| temp.replace(path) |
| (path.parent / 'records.jsonl').write_text(''.join( |
| json.dumps(row, ensure_ascii=False, sort_keys=True) + '\n' for row in rows)) |
| write_csv(path.parent / 'records.csv', rows, schema.names) |
| for name in ('data_issues.csv', 'manifest.json'): |
| shutil.copy2(public / name, backup / name) |
| write_csv(issues_path, issues, issue_fields) |
| manifest_path = public / 'manifest.json' |
| manifest = json.loads(manifest_path.read_text()) |
| manifest['warnings'] = dict(Counter(row['issue'] for row in issues)) |
| manifest['rows_with_warnings'] = len({row['task_id'] for row in issues}) |
| manifest['reference_sources_updated_at'] = datetime.now(timezone.utc).isoformat() |
| for name in list(manifest['files']) + ['reference_sources.json', 'data_issues.csv']: |
| file = public / name |
| if file.is_file(): |
| data = file.read_bytes() |
| manifest['files'][name] = {'bytes': len(data), 'sha256': hashlib.sha256(data).hexdigest()} |
| manifest_path.write_text(json.dumps(manifest, indent=2) + '\n') |
| report = {'source_locators_recovered': len(changed_ids), 'source_intervals_updated': sum( |
| 'keyclip_start_s' in sources[task_id] for task_id in changed_ids), |
| 'remaining_issues': len(issues), 'all_train_identical': True, |
| 'non_reference_fields_unchanged': True, |
| 'backup': str(backup), 'changed_task_ids': sorted(changed_ids)} |
| (backup.parent / ('apply_report_' + stamp + '.json')).write_text(json.dumps(report, indent=2) + '\n') |
| print(json.dumps({k: v for k, v in report.items() if k != 'changed_task_ids'}), flush=True) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
