| """Resolve per-scene license information for RING trajectory data. |
| |
| Reads scene asset lists and annotation excerpts from a bulk-download directory:: |
| |
| <download_dir>/<task_config>/metadata/ |
| annotations_used.json.gz |
| train_assets.jsonl.gz |
| val_assets.jsonl.gz |
| |
| Objaverse assets (present in annotations_used) are resolved from their |
| ``license_info``. All other assets are treated as THOR / in-house Ai2 assets. |
| |
| Usage:: |
| |
| python license_info.py <download_dir> --split train --house-index 0 |
| python license_info.py <download_dir> --split train --list-all |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import gzip |
| import json |
| import sys |
| from pathlib import Path |
| from typing import Any |
|
|
| DEFAULT_TASK = "ObjectNavType" |
| SPLITS = ("train", "val") |
|
|
| METADATA_FILES = ( |
| "annotations_used.json.gz", |
| "train_assets.jsonl.gz", |
| "val_assets.jsonl.gz", |
| ) |
|
|
| DEFAULT_LICENSE = { |
| "license": "CC-BY-4.0", |
| "license_url": "https://creativecommons.org/licenses/by/4.0/", |
| "creator_name": "Allen Institute for AI (Ai2)", |
| "source": "In-house", |
| } |
|
|
| ATTRIBUTION_TEMPLATE = ( |
| "{assets}" |
| f" by the {DEFAULT_LICENSE['creator_name']}," |
| f" licensed under {DEFAULT_LICENSE['license'].replace('-', ' ')}." |
| ) |
|
|
| ANNOTATION_FIELDS = ( |
| "uid", |
| "size_annotated_by", |
| "synset_labeled_by", |
| "scale_annotated_by", |
| "wn_version", |
| "license_info", |
| ) |
|
|
|
|
| class MetadataStore: |
| """Lazy loader for metadata under <download_dir>/<task_config>/metadata/.""" |
|
|
| def __init__(self, download_dir: Path, task_config: str): |
| self.metadata_dir = download_dir / task_config / "metadata" |
| self._annotations: dict[str, dict[str, Any]] | None = None |
|
|
| missing = [ |
| name for name in METADATA_FILES if not (self.metadata_dir / name).is_file() |
| ] |
| if missing: |
| raise FileNotFoundError( |
| f"Missing metadata file(s) in {self.metadata_dir}: {', '.join(missing)}" |
| ) |
|
|
| @property |
| def annotations(self) -> dict[str, dict[str, Any]]: |
| if self._annotations is None: |
| with gzip.open( |
| self.metadata_dir / "annotations_used.json.gz", "rt", encoding="utf-8" |
| ) as f: |
| self._annotations = json.load(f) |
| return self._annotations |
|
|
| def scene_asset_ids(self, split: str, house_index: int) -> list[str] | None: |
| if split not in SPLITS: |
| raise ValueError(f"split must be one of {SPLITS}, got {split!r}") |
|
|
| path = self.metadata_dir / f"{split}_assets.jsonl.gz" |
| with gzip.open(path, "rt", encoding="utf-8") as f: |
| for line_no, line in enumerate(f): |
| if line_no == house_index: |
| return json.loads(line) |
| raise IndexError( |
| f"house_index {house_index} out of range for {split} " |
| f"(file has {line_no + 1} lines)" |
| ) |
|
|
| def iter_valid_house_indices(self, split: str) -> list[int]: |
| path = self.metadata_dir / f"{split}_assets.jsonl.gz" |
| indices: list[int] = [] |
| with gzip.open(path, "rt", encoding="utf-8") as f: |
| for line_no, line in enumerate(f): |
| if json.loads(line) is not None: |
| indices.append(line_no) |
| return indices |
|
|
| def scene_count(self, split: str) -> int: |
| path = self.metadata_dir / f"{split}_assets.jsonl.gz" |
| with gzip.open(path, "rt", encoding="utf-8") as f: |
| return sum(1 for _ in f) |
|
|
|
|
| def _annotation_excerpt(annotation: dict[str, Any]) -> dict[str, Any]: |
| return {key: annotation.get(key) for key in ANNOTATION_FIELDS} |
|
|
|
|
| def resolve_objaverse_license( |
| asset_id: str, annotation: dict[str, Any] |
| ) -> dict[str, Any]: |
| lic = annotation["license_info"] |
| creator_profile_url = lic.get("creator_profile_url", "") |
| if "sketchfab" not in creator_profile_url: |
| raise ValueError( |
| f"Only sketchfab assets expected for {asset_id=}, " |
| f"got {creator_profile_url=}" |
| ) |
|
|
| cur_license: dict[str, Any] = { |
| "data_type": "objects", |
| "data_source": "objaverse", |
| "asset_id": asset_id, |
| "creator_username": lic["creator_username"], |
| "creator_display_name": lic["creator_display_name"], |
| "creator_profile_url": lic["creator_profile_url"], |
| "source": "Sketchfab", |
| "uri": lic["uri"], |
| "downloaded": "2021-2022", |
| "license_determination": ( |
| "License inferred from Sketchfab designation at time of download " |
| "(circa 2021/2022)." |
| ), |
| "modifications": ( |
| "The model has been significantly modified to reduce memory and " |
| "processing requirements, including mesh decimation, convex collider " |
| "extraction, and baking of visual effects via Blender scripts. " |
| "The provided quality may not reflect the original model." |
| ), |
| "dataset_license": "This subset of Objaverse is licensed under ODC-BY 1.0.", |
| "annotation": _annotation_excerpt(annotation), |
| } |
|
|
| license_code = lic["license"] |
| if license_code == "by": |
| cur_license["license"] = "CC-BY-4.0" |
| cur_license["license_url"] = "https://creativecommons.org/licenses/by/4.0/" |
| cur_license["derivative_notice"] = ( |
| "This work is a derivative of the original model." |
| ) |
| cur_license["attribution"] = ( |
| f"Model by {lic['creator_display_name']} ({lic['creator_username']}), " |
| "licensed under CC BY 4.0." |
| ) |
| elif license_code == "by-sa": |
| cur_license["license"] = "CC-BY-SA-4.0" |
| cur_license["license_url"] = "https://creativecommons.org/licenses/by-sa/4.0/" |
| cur_license["derivative_license"] = ( |
| "This derivative work is licensed under CC BY-SA 4.0." |
| ) |
| cur_license["attribution"] = ( |
| f"Model by {lic['creator_display_name']} ({lic['creator_username']}), " |
| "licensed under CC BY-SA 4.0." |
| ) |
| elif license_code == "cc0": |
| cur_license["license"] = "CC0-1.0" |
| cur_license["license_url"] = ( |
| "https://creativecommons.org/publicdomain/zero/1.0/" |
| ) |
| cur_license["derivative_notice"] = ( |
| "This work is a derivative of the original asset, which was released " |
| "under CC0." |
| ) |
| cur_license["attribution"] = ( |
| f"Model by {lic['creator_display_name']} ({lic['creator_username']}), " |
| "licensed under CC0-1.0." |
| ) |
| elif license_code == "by-nc": |
| cur_license["license"] = "CC-BY-NC-4.0" |
| cur_license["license_url"] = "https://creativecommons.org/licenses/by-nc/4.0/" |
| cur_license["commercial_use"] = False |
| cur_license["derivative_notice"] = ( |
| "This work is a derivative of the original asset and may not be used " |
| "for commercial purposes." |
| ) |
| cur_license["attribution"] = ( |
| f"Model by {lic['creator_display_name']} ({lic['creator_username']}), " |
| "licensed under CC BY-NC 4.0. Non-commercial use only." |
| ) |
| elif license_code == "by-nc-sa": |
| cur_license["license"] = "CC-BY-NC-SA-4.0" |
| cur_license["license_url"] = ( |
| "https://creativecommons.org/licenses/by-nc-sa/4.0/" |
| ) |
| cur_license["commercial_use"] = False |
| cur_license["derivative_license"] = ( |
| "This derivative work is licensed under CC BY-NC-SA 4.0." |
| ) |
| cur_license["derivative_notice"] = ( |
| "This work is a derivative of the original asset and may not be used " |
| "for commercial purposes." |
| ) |
| cur_license["attribution"] = ( |
| f"Model by {lic['creator_display_name']} ({lic['creator_username']}), " |
| "licensed under CC BY-NC-SA 4.0. Non-commercial use only." |
| ) |
| else: |
| raise NotImplementedError(f"Unsupported Sketchfab license {license_code!r}") |
|
|
| return cur_license |
|
|
|
|
| def resolve_thor_license(asset_id: str) -> dict[str, Any]: |
| return { |
| "data_type": "objects", |
| "data_source": "thor", |
| "asset_id": asset_id, |
| **DEFAULT_LICENSE, |
| "attribution": ATTRIBUTION_TEMPLATE.format(assets="Model(s)"), |
| } |
|
|
|
|
| def resolve_object_license( |
| asset_id: str, annotations: dict[str, dict[str, Any]] |
| ) -> dict[str, Any]: |
| annotation = annotations.get(asset_id) |
| if annotation is not None: |
| return resolve_objaverse_license(asset_id, annotation) |
| return resolve_thor_license(asset_id) |
|
|
|
|
| def resolve_scene_license( |
| store: MetadataStore, |
| *, |
| split: str, |
| house_index: int, |
| task_config: str, |
| ) -> dict[str, Any]: |
| asset_ids = store.scene_asset_ids(split, house_index) |
| if asset_ids is None: |
| raise ValueError( |
| f"No house at {split} house_index={house_index} (scene is null)" |
| ) |
|
|
| annotations = store.annotations |
| includes = [ |
| resolve_object_license(asset_id, annotations) for asset_id in sorted(asset_ids) |
| ] |
|
|
| scene_license: dict[str, Any] = { |
| "data_type": "scenes", |
| "data_source": task_config, |
| "split": split, |
| "house_index": house_index, |
| **DEFAULT_LICENSE, |
| "attribution": ATTRIBUTION_TEMPLATE.format(assets="Scene"), |
| "scope": ( |
| "Scene composition, layout, non-object-specific textures, and metadata." |
| ), |
| "relationship_to_assets": "collection", |
| "asset_licenses": ( |
| "Assets are independently licensed; see assets info below for details." |
| ), |
| "license_determination": ( |
| "Scenes are collections referencing independently licensed assets; " |
| f"{DEFAULT_LICENSE['license']} applies only to scene composition, " |
| "layout, and metadata." |
| ), |
| } |
| if includes: |
| scene_license["assets"] = includes |
| return scene_license |
|
|
|
|
| def print_license_info( |
| download_dir: str | Path, |
| *, |
| split: str, |
| house_index: int | str, |
| task_config: str = DEFAULT_TASK, |
| ) -> None: |
| store = MetadataStore(Path(download_dir).resolve(), task_config) |
|
|
| if house_index == "--list_all": |
| for sp in SPLITS: |
| valid = store.iter_valid_house_indices(sp) |
| print(f"{sp}: {len(valid)} valid houses (of {store.scene_count(sp)} lines)") |
| return |
|
|
| license_info = resolve_scene_license( |
| store, |
| split=split, |
| house_index=int(house_index), |
| task_config=task_config, |
| ) |
| print(json.dumps(license_info, indent=2)) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser( |
| description="License information for RING scene houses.", |
| formatter_class=argparse.RawDescriptionHelpFormatter, |
| epilog=( |
| "Examples:\n" |
| " python license_info.py ./ring_download --split train --house-index 0\n" |
| " python license_info.py ./ring_download --split val --list-all\n" |
| ), |
| ) |
| parser.add_argument( |
| "download_dir", |
| type=Path, |
| help="Root directory passed to bulk_download.py.", |
| ) |
| parser.add_argument( |
| "--config", |
| default=DEFAULT_TASK, |
| help=f"Task config subdirectory (default: {DEFAULT_TASK}).", |
| ) |
| parser.add_argument( |
| "--split", |
| choices=SPLITS, |
| default="train", |
| help="Scene split (default: train).", |
| ) |
| group = parser.add_mutually_exclusive_group(required=True) |
| group.add_argument( |
| "--house-index", |
| type=int, |
| help="0-based house index within the split asset list.", |
| ) |
| group.add_argument( |
| "--list-all", |
| action="store_true", |
| help="List valid house counts per split.", |
| ) |
| args = parser.parse_args() |
|
|
| try: |
| if args.list_all: |
| print_license_info( |
| args.download_dir, |
| split=args.split, |
| house_index="--list_all", |
| task_config=args.config, |
| ) |
| else: |
| print_license_info( |
| args.download_dir, |
| split=args.split, |
| house_index=args.house_index, |
| task_config=args.config, |
| ) |
| except (FileNotFoundError, IndexError, ValueError, NotImplementedError) as exc: |
| print(exc, file=sys.stderr) |
| raise SystemExit(1) from exc |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
