| import zlib |
| from collections import defaultdict |
| from dataclasses import dataclass |
| from pathlib import Path |
|
|
| import pyarrow as pa |
| import pyarrow.compute as pc |
| import pyarrow.parquet as pq |
|
|
|
|
| def shard_of(value: str, n: int) -> int: |
| return zlib.crc32(value.encode()) % n |
|
|
|
|
| def shard_name(config: str, s: int, n: int) -> str: |
| return f"{config}-{s:05d}-of-{n:05d}.parquet" |
|
|
|
|
| def read_shard(directory: Path, config: str, s: int, n: int) -> pa.Table | None: |
| path = Path(directory) / shard_name(config, s, n) |
| return pq.read_table(path) if path.exists() else None |
|
|
|
|
| def write_shard(table: pa.Table, directory: Path, config: str, s: int, n: int) -> Path: |
| directory = Path(directory) |
| directory.mkdir(parents=True, exist_ok=True) |
| path = directory / shard_name(config, s, n) |
| pq.write_table(table, path, compression="zstd") |
| return path |
|
|
|
|
| def read_index(raw_dir: Path, key_col: str, mod_col: str) -> dict[str, str]: |
| out: dict[str, str] = {} |
| for f in sorted(Path(raw_dir).glob("*.parquet")): |
| t = pq.read_table(f, columns=[key_col, mod_col]) |
| out.update(zip(t.column(key_col).to_pylist(), t.column(mod_col).to_pylist())) |
| return out |
|
|
|
|
| @dataclass |
| class Diff: |
| fetch: list[str] |
| removed: set[str] |
| added: int |
| changed: int |
| unchanged: int |
|
|
|
|
| def diff(current: dict[str, str], previous: dict[str, str]) -> Diff: |
| added = [k for k in current if k not in previous] |
| changed = [k for k in current if k in previous and previous[k] != current[k]] |
| return Diff( |
| fetch=added + changed, |
| removed=set(previous) - set(current), |
| added=len(added), |
| changed=len(changed), |
| unchanged=len(current) - len(added) - len(changed), |
| ) |
|
|
|
|
| class Staging: |
| """Buffers fetched rows to per-shard Parquet files so a shard is read back without scanning the rest.""" |
|
|
| def __init__(self, directory: Path, schema: pa.Schema, shard_col: str, n_shards: int, flush_rows: int = 100): |
| self.dir = Path(directory) |
| self.dir.mkdir(parents=True, exist_ok=True) |
| self.schema = schema |
| self.shard_col = shard_col |
| self.n = n_shards |
| self.flush_rows = flush_rows |
| self.buffers: dict[int, list[dict]] = defaultdict(list) |
| self.seq = 0 |
|
|
| def add(self, row: dict) -> None: |
| s = shard_of(row[self.shard_col], self.n) |
| self.buffers[s].append(row) |
| if len(self.buffers[s]) >= self.flush_rows: |
| self._flush_shard(s) |
|
|
| def flush(self) -> None: |
| for s in list(self.buffers): |
| self._flush_shard(s) |
|
|
| def _flush_shard(self, s: int) -> None: |
| rows = self.buffers.pop(s, []) |
| if not rows: |
| return |
| self.seq += 1 |
| pq.write_table(pa.Table.from_pylist(rows, schema=self.schema), self.dir / f"{s:05d}-{self.seq:07d}.parquet") |
|
|
| def read_shard(self, s: int) -> pa.Table: |
| files = sorted(self.dir.glob(f"{s:05d}-*.parquet")) |
| if not files: |
| return self.schema.empty_table() |
| return pa.concat_tables(pq.read_table(f).cast(self.schema) for f in files) |
|
|
|
|
| def merge_shard( |
| previous: pa.Table | None, fetched: pa.Table, removed: set[str], key_col: str, schema: pa.Schema |
| ) -> pa.Table: |
| parts = [] |
| if previous is not None and previous.num_rows: |
| drop = pa.array(sorted(set(removed) | set(fetched.column(key_col).to_pylist())), pa.string()) |
| keep = pc.invert(pc.is_in(previous.column(key_col), value_set=drop)) |
| parts.append(previous.filter(keep).select(schema.names).cast(schema)) |
| parts.append(fetched.select(schema.names).cast(schema)) |
| return pa.concat_tables(parts).sort_by(key_col) |
|
|
