Datasets:
Formats:
parquet
Size:
100K - 1M
Tags:
population-genetics
demographic-inference
effective-population-size
coalescent
msprime
simulation
License:
| """Durable file operations, in one place. | |
| Every module here that writes a receipt, a plan or a completion marker needs | |
| the same three things: a write that either lands whole or not at all, a hash | |
| that identifies a file's contents, and a canonical encoding for the values that | |
| get hashed. Three modules grew their own, and the copies drifted -- which is | |
| the failure mode that makes duplication worth removing here rather than merely | |
| untidy. | |
| ``replacement.py``'s atomic write fsynced the file and then renamed it without | |
| fsyncing the directory, so a crash between the rename and the next flush could | |
| lose the rename itself and leave the old file in place. That is precisely the | |
| loss the module exists to prevent. ``shards.py``'s directory fsync opened the | |
| directory with no ``O_DIRECTORY`` and no ``except OSError``, where | |
| ``map_cache.py``'s tolerated both -- two fixes applied to two copies of the | |
| same function, neither aware of the other. | |
| One implementation now, with the strongest guarantee any caller needed. | |
| """ | |
| from __future__ import annotations | |
| import hashlib | |
| import json | |
| import os | |
| from collections.abc import Mapping | |
| from pathlib import Path | |
| from typing import Any | |
| # Read in whole-megabyte chunks: large enough that the syscall overhead | |
| # disappears against a multi-megabyte shard, small enough not to hold the file | |
| # in memory. | |
| _HASH_CHUNK_BYTES = 8 * 1024 * 1024 | |
| def file_sha256(path: Path) -> str: | |
| """Hash a file's contents without reading it all into memory.""" | |
| digest = hashlib.sha256() | |
| with Path(path).open("rb") as handle: | |
| for chunk in iter(lambda: handle.read(_HASH_CHUNK_BYTES), b""): | |
| digest.update(chunk) | |
| return digest.hexdigest() | |
| def canonical_bytes(value: object) -> bytes: | |
| """Encode a value so equal values encode identically. | |
| Sorted keys and no incidental whitespace, because the result is hashed: | |
| two dictionaries that differ only in insertion order have to produce one | |
| digest, or a receipt stops identifying what it was meant to identify. | |
| ``allow_nan`` is off because NaN has no JSON spelling and the encoders that | |
| invent one do not agree with each other. | |
| """ | |
| return json.dumps( | |
| value, | |
| ensure_ascii=False, | |
| allow_nan=False, | |
| sort_keys=True, | |
| separators=(",", ":"), | |
| ).encode("utf-8") | |
| def canonical_sha256(value: object) -> str: | |
| """The digest of a value's canonical encoding.""" | |
| return hashlib.sha256(canonical_bytes(value)).hexdigest() | |
| def fsync_directory(path: Path) -> None: | |
| """Flush a directory entry, so a rename into it survives a crash. | |
| Renaming is atomic but not durable: the new name can still be in the | |
| kernel's cache when the machine stops. Opening a directory is not portable | |
| -- Windows refuses it outright -- so a failure here is a platform that | |
| cannot offer the guarantee rather than an error to propagate. | |
| """ | |
| flags = os.O_RDONLY | |
| if hasattr(os, "O_DIRECTORY"): | |
| flags |= os.O_DIRECTORY | |
| try: | |
| descriptor = os.open(path, flags) | |
| except OSError: | |
| return | |
| try: | |
| os.fsync(descriptor) | |
| finally: | |
| os.close(descriptor) | |
| def write_json_atomic( | |
| path: Path, | |
| value: Mapping[str, Any], | |
| *, | |
| canonical: bool = False, | |
| ) -> None: | |
| """Write JSON so a reader sees the old file or the new one, never a partial. | |
| Write to a temporary name in the same directory, flush it to disk, rename | |
| it over the target, then flush the directory. Every step is needed: a | |
| rename across filesystems is not atomic, an unflushed file can be renamed | |
| into place empty, and an unflushed directory can lose the rename. | |
| ``canonical`` selects the encoding used for values that get hashed -- | |
| sorted and compact -- rather than the indented form meant to be read. | |
| """ | |
| path = Path(path) | |
| path.parent.mkdir(parents=True, exist_ok=True) | |
| # The pid and clock keep two processes writing the same target from | |
| # colliding on the temporary name. | |
| temporary = path.with_name(f".{path.name}.{os.getpid()}.{os.urandom(4).hex()}.tmp") | |
| try: | |
| payload = ( | |
| canonical_bytes(value) | |
| if canonical | |
| else json.dumps( | |
| value, indent=2, ensure_ascii=False, allow_nan=False | |
| ).encode("utf-8") | |
| ) | |
| with temporary.open("wb") as handle: | |
| handle.write(payload) | |
| handle.write(b"\n") | |
| handle.flush() | |
| os.fsync(handle.fileno()) | |
| temporary.replace(path) | |
| fsync_directory(path.parent) | |
| finally: | |
| temporary.unlink(missing_ok=True) | |
| def read_json(path: Path, description: str, error: type[Exception]) -> dict[str, Any]: | |
| """Read a JSON object, raising ``error`` with the path in the message. | |
| The caller supplies the exception type because the two replacement modules | |
| have their own, and which one is raised is part of their contract. | |
| """ | |
| try: | |
| value = json.loads(Path(path).read_text(encoding="utf-8")) | |
| except (OSError, UnicodeError, json.JSONDecodeError) as exc: | |
| raise error(f"{description} at {path} is unreadable: {exc}") from exc | |
| if not isinstance(value, dict): | |
| raise error(f"{description} at {path} is not a JSON object") | |
| return value | |