Datasets:
Formats:
parquet
Size:
100K - 1M
Tags:
population-genetics
demographic-inference
effective-population-size
coalescent
msprime
simulation
License:
| from __future__ import annotations | |
| import dataclasses | |
| import hashlib | |
| import json | |
| from collections.abc import Mapping | |
| from pathlib import Path | |
| from typing import Any | |
| FINGERPRINT_VERSION = 1 | |
| # The on-disk contract: what arrays a shard holds, what each one means, and | |
| # what the label is. A reader checks it before anything else and refuses a | |
| # dataset it does not recognise, because two schemas cannot be pooled -- the | |
| # labels come from different mixtures and the arrays have different dtypes. | |
| # | |
| # Bump it whenever identical Config values would produce meaningfully different | |
| # samples or shard semantics, and say here what changed. | |
| SAMPLE_GENERATOR_SCHEMA_VERSION = 1 | |
| DONE_CONFIG_STATE_KEY = "sample_generation_config" | |
| RUNTIME_CONFIG_FIELDS = frozenset( | |
| { | |
| "dataset_name", | |
| "compute_chunk_size", | |
| "force", | |
| "out_dir", | |
| "workers", | |
| } | |
| ) | |
| class DatasetConfigMismatchError(RuntimeError): | |
| """Raised when an existing dataset cannot safely be reused.""" | |
| def _as_mapping(config: Any) -> dict[str, Any]: | |
| if dataclasses.is_dataclass(config) and not isinstance(config, type): | |
| return dataclasses.asdict(config) | |
| if isinstance(config, Mapping): | |
| return dict(config) | |
| raise TypeError("config must be a dataclass instance or mapping") | |
| def _json_compatible(value: Any) -> Any: | |
| """Config values, for the fingerprint that decides whether a run resumes. | |
| ``map_cache`` has a function of the same name and a different contract: it | |
| encodes cache keys, so it sorts and rejects non-finite floats. This one | |
| keeps insertion order, which is part of what it hashes, and accepts | |
| dataclasses, because a Config is one. Merging them would move every | |
| fingerprint. | |
| """ | |
| if dataclasses.is_dataclass(value) and not isinstance(value, type): | |
| return _json_compatible(dataclasses.asdict(value)) | |
| if isinstance(value, Mapping): | |
| return {str(key): _json_compatible(item) for key, item in value.items()} | |
| if isinstance(value, (list, tuple)): | |
| return [_json_compatible(item) for item in value] | |
| if isinstance(value, Path): | |
| return str(value) | |
| if value is None or isinstance(value, (bool, int, float, str)): | |
| return value | |
| raise TypeError(f"config value of type {type(value).__name__} is not JSON-compatible") | |
| def sample_generation_config(config: Any) -> dict[str, Any]: | |
| """Return the config fields that determine generated sample data or its format.""" | |
| raw = _as_mapping(config) | |
| return { | |
| key: _json_compatible(value) | |
| for key, value in raw.items() | |
| if key not in RUNTIME_CONFIG_FIELDS | |
| } | |
| def sample_generation_fingerprint(config: Any) -> str: | |
| relevant = sample_generation_config(config) | |
| canonical = json.dumps( | |
| relevant, | |
| ensure_ascii=False, | |
| allow_nan=False, | |
| sort_keys=True, | |
| separators=(",", ":"), | |
| ) | |
| return hashlib.sha256(canonical.encode("utf-8")).hexdigest() | |
| def generation_config_state(config: Any) -> dict[str, Any]: | |
| relevant = sample_generation_config(config) | |
| return { | |
| "version": FINGERPRINT_VERSION, | |
| "generator_schema_version": SAMPLE_GENERATOR_SCHEMA_VERSION, | |
| "algorithm": "sha256", | |
| "sha256": sample_generation_fingerprint(relevant), | |
| "ignored_fields": sorted(RUNTIME_CONFIG_FIELDS), | |
| "config": relevant, | |
| } | |
| def stamp_done_manifest(manifest: Mapping[str, Any], config: Any) -> dict[str, Any]: | |
| stamped = dict(manifest) | |
| stamped[DONE_CONFIG_STATE_KEY] = generation_config_state(config) | |
| return stamped | |
| def _mismatch_details(stored: Any, current: Any) -> str: | |
| if not isinstance(stored, Mapping) or not isinstance(current, Mapping): | |
| return "" | |
| keys = sorted(set(stored) | set(current)) | |
| changed = [key for key in keys if stored.get(key) != current.get(key)] | |
| if not changed: | |
| return "" | |
| preview = ", ".join(changed[:8]) | |
| if len(changed) > 8: | |
| preview += f", ... (+{len(changed) - 8} more)" | |
| return f" Differing sample-generation fields: {preview}." | |
| def _reuse_error(message: str) -> DatasetConfigMismatchError: | |
| return DatasetConfigMismatchError( | |
| f"{message} Refusing to reuse the existing shards; rerun with --force to regenerate them." | |
| ) | |
| def validate_done_for_reuse( | |
| done_manifest: Mapping[str, Any], | |
| current_config: Any, | |
| ) -> dict[str, Any]: | |
| """ | |
| Validate that DONE belongs to the requested sample-generation configuration. | |
| Returns the canonical state for a fingerprinted DONE. Legacy completion | |
| files are deliberately rejected because a mutable config.json cannot prove | |
| which configuration generated their shards. | |
| """ | |
| current_state = generation_config_state(current_config) | |
| stored_state = done_manifest.get(DONE_CONFIG_STATE_KEY) | |
| if stored_state is None: | |
| raise _reuse_error( | |
| "DONE.json predates trustworthy configuration fingerprints; legacy " | |
| "config.json cannot prove which settings generated the existing shards." | |
| ) | |
| if not isinstance(stored_state, Mapping): | |
| raise _reuse_error(f"{DONE_CONFIG_STATE_KEY!r} in DONE.json is malformed.") | |
| if stored_state.get("version") != FINGERPRINT_VERSION: | |
| raise _reuse_error( | |
| "DONE.json uses an unsupported sample-generation fingerprint version " | |
| f"({stored_state.get('version')!r})." | |
| ) | |
| if stored_state.get("generator_schema_version") != SAMPLE_GENERATOR_SCHEMA_VERSION: | |
| raise _reuse_error( | |
| "DONE.json was produced by an unsupported sample-generator schema " | |
| f"({stored_state.get('generator_schema_version')!r})." | |
| ) | |
| if stored_state.get("algorithm") != "sha256": | |
| raise _reuse_error( | |
| "DONE.json uses an unsupported sample-generation fingerprint algorithm " | |
| f"({stored_state.get('algorithm')!r})." | |
| ) | |
| stored_sha256 = stored_state.get("sha256") | |
| if not isinstance(stored_sha256, str) or len(stored_sha256) != 64: | |
| raise _reuse_error("DONE.json contains a malformed sample-generation fingerprint.") | |
| stored_config = stored_state.get("config") | |
| if stored_config is not None: | |
| if not isinstance(stored_config, Mapping): | |
| raise _reuse_error("DONE.json contains a malformed sample-generation config snapshot.") | |
| if sample_generation_fingerprint(stored_config) != stored_sha256: | |
| raise _reuse_error( | |
| "The sample-generation config snapshot in DONE.json does not match its fingerprint." | |
| ) | |
| if stored_sha256 != current_state["sha256"]: | |
| details = _mismatch_details(stored_config, current_state["config"]) | |
| raise _reuse_error( | |
| "The requested configuration does not match the configuration that generated DONE.json." | |
| + details | |
| ) | |
| return current_state | |