diff --git a/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/__init__.py b/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/__init__.py new file mode 100644 index 000000000..0c51f93ec --- /dev/null +++ b/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/__init__.py @@ -0,0 +1,4 @@ +"""Connectors for datasets built from the Lichess open database. + +Keep this regular package so pkgutil.walk_packages can discover its connector children. +""" diff --git a/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/__init__.py b/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/__init__.py new file mode 100644 index 000000000..936b8a41f --- /dev/null +++ b/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/__init__.py @@ -0,0 +1,6 @@ +"""Lichess Clock-Blunder: clocks and engine evaluation of real games, and whether a blunder follows.""" + +from timenet_connectors.datasets.lichess.clock_blunder.connector import ( + CONNECTOR as CONNECTOR, + ClockBlunderConnector as ClockBlunderConnector, +) diff --git a/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/connector.py b/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/connector.py new file mode 100644 index 000000000..62efe8f15 --- /dev/null +++ b/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/connector.py @@ -0,0 +1,411 @@ +"""The Lichess Clock-Blunder connector: real games as clock and evaluation series, and a blunder question. + +The Lichess open database ships every rated game as PGN. Since 2017 each move carries the mover's clock +(``[%clk 0:04:59]``), and analysed games also carry the Stockfish evaluation after the move +(``[%eval 0.27]`` in pawns, or ``[%eval #-3]`` for a forced mate). This connector reads a fixed byte range +at the start of the April 2017 dump, keeps the complete games that have both on every ply, and turns each +game into a few windows. A window holds the last plies before one player's move, and its task asks +whether that player blunders within their next three moves. + +A blunder follows Lichess's own rule: the move drops the mover's winning chances by at least 0.3, where +winning chances are ``2 / (1 + exp(-0.00368208 * centipawns)) - 1`` and a forced mate counts as +1 or -1. +""" + +from collections.abc import Iterator +from dataclasses import dataclass +import hashlib +import io +import math +from pathlib import Path +import re +from typing import Self + +import numpy as np + +from timenet.connectors import BaseConnector +from timenet.dataset import Record, Signal, Source, TimeFDataset +from timenet.dataset.axis import OrdinalAxis +from timenet.errors import TimeNetConnectorError +from timenet.types import Annotation, ClassificationTask, Label, LabelSet, Split, TimeSeriesSpec, ureg +from timenet_connectors.download import Artifact, download_files + + +DUMP_URL = "https://database.lichess.org/standard/lichess_db_standard_rated_2017-04.pgn.zst" +PREFIX_BYTES = 64 * 1024 * 1024 +"""Only this many bytes at the start of the 3.5 GB dump are read, so every build sees the same games.""" +PREFIX_SHA256 = "d53e00e3cf7098057f136c2937d97f0cdd45963c52362565cbd2008814c99d1b" + +WINDOW_PLIES = 40 +"""A window holds at most this many plies before the decision point.""" +MIN_DECISION_PLY = 12 +"""No window ends inside the first six moves of each side: the opening is mostly preparation.""" +HORIZON_MOVES = 3 +"""The task asks about the mover's next three moves, so their plies p, p + 2 and p + 4.""" +WINDOWS_PER_GAME = 4 +TRAIN_BUCKETS = 8 +"""Of the ten buckets a game id hashes into, the first eight are train, then one validation, one test.""" +BLUNDER_DROP = 0.3 +"""Lichess's blunder threshold on the -1 to +1 winning-chances scale.""" +MATE_PAWNS = 100.0 +"""A forced mate, stored in pawns. Its winning chances round to exactly +1 or -1.""" +EVAL_CLIP_PAWNS = 10.0 +"""The stored evaluation is clipped here, so one mate does not dwarf the rest of the window.""" + +BLUNDER = LabelSet( + [ + Label(name="no", description="None of the player's next three moves is a blunder."), + Label(name="yes", description="At least one of the player's next three moves is a blunder."), + ], + annotations=[Annotation("name", value="blunder_within_three_moves")], +) +CLOCK = TimeSeriesSpec(spec_type="chess_clock", name="Chess clock", unit_value=ureg.second, dtype="float64") +EVALUATION = TimeSeriesSpec( + spec_type="engine_evaluation", name="Engine evaluation", unit_value=ureg.dimensionless, dtype="float64" +) +PER_PLY = OrdinalAxis() + +_HEADER = re.compile(r'^\[(\w+) "(.*)"\]$', re.MULTILINE) +_COMMENT = re.compile(r"\{([^}]*)\}") +_EVAL = re.compile(r"\[%eval (#?-?[\d.]+)\]") +_CLOCK = re.compile(r"\[%clk (\d+):(\d\d):(\d\d)\]") +_RESULT = re.compile(r"(1-0|0-1|1/2-1/2)\s*$") +_TIME_CONTROL = re.compile(r"^(\d+)\+(\d+)$") + + +def winning_chances(pawns: float) -> float: + """Return Lichess's winning chances for White, from -1 to +1. + + Args: + pawns: The evaluation in pawns from White's view. A mate is ``±MATE_PAWNS``. + + Returns: + The winning chances, -1 for a lost position and +1 for a won one. + """ + if abs(pawns) >= MATE_PAWNS: + return math.copysign(1.0, pawns) + return 2.0 / (1.0 + math.exp(-0.00368208 * pawns * 100.0)) - 1.0 + + +def parse_eval(text: str) -> float: + """Parse a PGN ``%eval`` value into pawns from White's view, a mate becoming ``±MATE_PAWNS``. + + Returns: + The evaluation in pawns. + + Raises: + TimeNetConnectorError: If the value is not a number or a mate. + """ + try: + if text.startswith("#"): + # "#-3" is a mate for Black. "#0" never appears after a move, but treat it as decided. + return -MATE_PAWNS if text[1:].startswith("-") else MATE_PAWNS + return float(text) + except ValueError as exc: + raise TimeNetConnectorError(f"evaluation {text!r} is not a number or a mate") from exc + + +@dataclass(frozen=True) +class Game: + """One complete game: its tags and, for every ply, the mover's clock and the evaluation after it.""" + + game_id: str + time_control: str + white_elo: int + black_elo: int + result: str + clocks: np.ndarray + """The mover's clock in seconds after each ply. Even plies are White's moves.""" + evals: np.ndarray + """The evaluation in pawns from White's view after each ply.""" + + @property + def n_plies(self) -> int: + """The number of plies.""" + return len(self.clocks) + + @classmethod + def from_pgn(cls, text: str) -> Self | None: + """Parse one PGN game, or return ``None`` when it lacks something the dataset needs. + + A kept game is rated with a ``base+increment`` time control, finished with a result, and has + exactly one clock and one evaluation on every ply. + + Returns: + The game, or ``None``. + """ + tags = dict(_HEADER.findall(text)) + site, control = tags.get("Site", ""), tags.get("TimeControl", "") + if not site.startswith("https://lichess.org/") or not _TIME_CONTROL.match(control): + return None + movetext = text.partition("\n\n")[2] # the tag pairs end at the first blank line + if not _RESULT.search(movetext): + return None # a game cut by the end of the byte range has no result token + comments = _COMMENT.findall(movetext) + evals = [found for c in comments if (found := _EVAL.search(c))] + clocks = [found for c in comments if (found := _CLOCK.search(c))] + if not comments or len(evals) != len(comments) or len(clocks) != len(comments): + return None + # One comment per ply: count the move tokens outside the comments to be sure none is missing. + bare = _COMMENT.sub(" ", movetext) + n_moves = len([t for t in bare.split() if not t.endswith(".") and not _RESULT.match(t)]) + if n_moves != len(comments): + return None + try: + white_elo, black_elo = int(tags["WhiteElo"]), int(tags["BlackElo"]) + except (KeyError, ValueError): + return None + return cls( + game_id=site.rsplit("/", 1)[-1], + time_control=control, + white_elo=white_elo, + black_elo=black_elo, + result=tags.get("Result", ""), + clocks=np.array([int(h) * 3600 + int(m) * 60 + int(s) for h, m, s in (c.groups() for c in clocks)], float), + evals=np.array([parse_eval(e.group(1)) for e in evals], float), + ) + + def blunders(self) -> np.ndarray: + """Return, for each ply, whether that move is a blunder by the player who made it. + + The position before the first move counts as level. + + Returns: + One boolean per ply. + """ + chances = np.array([winning_chances(e) for e in self.evals]) + before = np.concatenate(([0.0], chances[:-1])) + mover_sign = np.where(np.arange(self.n_plies) % 2 == 0, 1.0, -1.0) + return mover_sign * (before - chances) >= BLUNDER_DROP + + def series_until(self, ply: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + """Return both clocks and the evaluation for the plies before ``ply``, at most ``WINDOW_PLIES``. + + A clock only changes on its owner's moves, so between them it keeps its last value. Before a + player's first move, their clock is their first recorded reading. That is not always the base + time of the control: a player who berserks in a Lichess tournament starts with half of it. + + Returns: + White's clock, Black's clock and the clipped evaluation, one value per ply of the window. + """ + white, black = np.empty(ply), np.empty(ply) + last_white, last_black = float(self.clocks[0]), float(self.clocks[1]) + for index in range(ply): + if index % 2 == 0: + last_white = self.clocks[index] + else: + last_black = self.clocks[index] + white[index], black[index] = last_white, last_black + start = max(0, ply - WINDOW_PLIES) + evals = np.clip(self.evals[start:ply], -EVAL_CLIP_PAWNS, EVAL_CLIP_PAWNS) + return white[start:], black[start:], evals + + def decision_plies(self) -> list[int]: + """Pick up to ``WINDOWS_PER_GAME`` decision plies, seeded by the game id. + + A decision ply leaves room for the mover's next three moves, so every answer is known. + + Returns: + The chosen plies, in increasing order. + """ + last = self.n_plies - 2 * (HORIZON_MOVES - 1) + candidates = list(range(MIN_DECISION_PLY, last)) + if not candidates: + return [] + seed = int.from_bytes(hashlib.sha256(self.game_id.encode()).digest()[:8], "big") + rng = np.random.default_rng(seed) + count = min(WINDOWS_PER_GAME, len(candidates)) + return sorted(int(p) for p in rng.choice(candidates, size=count, replace=False)) + + @property + def split(self) -> Split: + """The split of every window of this game: 80% train, 10% validation, 10% test, by game id.""" + bucket = hashlib.sha256(self.game_id.encode()).digest()[-1] % 10 + return Split.TRAIN if bucket < TRAIN_BUCKETS else Split.VALIDATION if bucket == TRAIN_BUCKETS else Split.TEST + + +def _clock_text(seconds: float) -> str: + minutes, rest = divmod(round(seconds), 60) + return f"{minutes}:{rest:02d}" + + +def rationale(game: Game, ply: int, answer: bool) -> str: + """Write the template rationale of a window from its own numbers and its known answer. + + It is generated supervision: it states what the series show, then the answer. It never claims the + clock caused the outcome. + + Returns: + The rationale text, ending with ``Answer: yes`` or ``Answer: no``. + """ + side = "White" if ply % 2 == 0 else "Black" + own = game.clocks[ply % 2 : ply : 2] + other = game.clocks[1 - ply % 2 : ply : 2] + increment = int(game.time_control.split("+")[1]) + # The time a move took is the clock before it, plus the increment, minus the clock after it. + spent = -np.diff(own) + increment + recent = spent[-5:] + eval_now = float(np.clip(game.evals[ply - 1], -EVAL_CLIP_PAWNS, EVAL_CLIP_PAWNS)) + mover_eval = eval_now if side == "White" else -eval_now + swing = float(np.ptp(np.clip(game.evals[max(0, ply - 10) : ply], -EVAL_CLIP_PAWNS, EVAL_CLIP_PAWNS))) + own_left, other_left = float(own[-1]), float(other[-1]) + moves_left_at_pace = own_left / max(float(np.mean(recent)), 1.0) + parts = [ + f"{side} is to move with {_clock_text(own_left)} left against {_clock_text(other_left)}.", + f"Over the last {len(recent)} moves {side} spent {np.mean(recent):.1f} seconds per move on average," + f" enough for about {moves_left_at_pace:.0f} more moves at that pace.", + f"The evaluation is {mover_eval:+.1f} pawns from {side}'s side, and it swung {swing:.1f} pawns over" + " the last ten plies.", + ] + if answer: + parts.append(f"{side} does blunder within the next three moves.") + else: + parts.append(f"None of {side}'s next three moves is a blunder.") + return " ".join(parts) + f" Answer: {'yes' if answer else 'no'}" + + +def prompt(game: Game, ply: int) -> str: + """Write the question of a window. + + Returns: + The prompt text. + """ + side = "White" if ply % 2 == 0 else "Black" + return ( + f"Rated Lichess game, time control {game.time_control} (seconds + increment), White rated " + f"{game.white_elo}, Black rated {game.black_elo}. The series give White's clock and Black's clock in " + "seconds and the engine evaluation in pawns from White's view, one value per ply, for the plies " + f"before move {ply // 2 + 1}. {side} is to move. Will {side} blunder within their next three moves, " + "that is, make a move that loses at least 0.3 winning chances on Lichess's -1 to +1 scale? " + "Answer yes or no." + ) + + +@dataclass(frozen=True) +class DumpPrefix: + """The downloaded byte range at the start of the compressed dump.""" + + path: Path + + def iter_games(self) -> Iterator[Game]: + """Decompress the prefix and yield every game the dataset keeps, in dump order. + + The byte range ends inside a zstd frame, so decoding stops at the cut, with or without an error. + Everything decoded before it is kept, and the last, cut game has no result token, so it is dropped. + + Yields: + Each kept game. + + Raises: + ImportError: If ``zstandard``, declared in this connector's requirements, is not installed. + """ + try: + import zstandard # ruff: ignore[import-outside-top-level] + except ImportError as exc: + raise ImportError( + "reading the Lichess dump needs zstandard, declared in this connector's " + "requirements.txt. Run the build without --no-isolation, or install it yourself" + ) from exc + + decoded = io.BytesIO() + with self.path.open("rb") as raw, zstandard.ZstdDecompressor().stream_reader(raw) as reader: + try: + while chunk := reader.read(1 << 20): + decoded.write(chunk) + except zstandard.ZstdError: + pass # the cut at the end of the byte range + text = decoded.getvalue().decode("utf-8", errors="replace") + for block in re.split(r"\n\n(?=\[Event )", text): + if (game := Game.from_pgn(block.strip())) is not None: + yield game + + +def create_window(game: Game, ply: int) -> tuple[Record, ClassificationTask]: + """Create the Record and the task of one window. + + Returns: + The Record and the task, not yet added to a dataset. + """ + white, black, evals = game.series_until(ply) + record = Record( + sources=[ + Source( + name="Clocks", + signals=[ + Signal.from_values(white, spec=CLOCK, name="white_clock", time_axis=PER_PLY), + Signal.from_values(black, spec=CLOCK, name="black_clock", time_axis=PER_PLY), + ], + ), + Source( + name="Engine", + signals=[Signal.from_values(evals, spec=EVALUATION, name="evaluation_pawns", time_axis=PER_PLY)], + ), + ], + annotations=[ + Annotation("time_control", value=game.time_control), + Annotation("white_elo", value=game.white_elo), + Annotation("black_elo", value=game.black_elo), + Annotation("side_to_move", value="white" if ply % 2 == 0 else "black"), + Annotation("ply", value=ply), + ], + metadata={"lichess_game_id": game.game_id}, + ) + answer = bool(game.blunders()[ply : ply + 2 * HORIZON_MOVES : 2].any()) + task = ClassificationTask( + inputs=[record], + targets="yes" if answer else "no", + label_set=BLUNDER, + prompt=prompt(game, ply), + rationale=rationale(game, ply, answer), + split=game.split, + ) + return record, task + + +class ClockBlunderConnector(BaseConnector[list[DumpPrefix]]): + """Connector for windows of real Lichess games with clocks and evaluations.""" + + async def download_async(self, cache_dir: Path) -> list[DumpPrefix]: # ruff: ignore[no-self-use] + """Download the fixed byte range at the start of the April 2017 dump once. + + Args: + cache_dir: The directory that holds the byte range. + + Returns: + The one byte range. + """ + artifact = Artifact( + DUMP_URL, + cache_dir / "lichess_db_standard_rated_2017-04.prefix.pgn.zst", + headers={"Range": f"bytes=0-{PREFIX_BYTES - 1}"}, + sha256=PREFIX_SHA256, + ) + (path,) = await download_files([artifact]) + return [DumpPrefix(path)] + + def convert(self, prefixes: list[DumpPrefix]) -> TimeFDataset: + """Create one Record and one ClassificationTask for each window of each kept game. + + Args: + prefixes: The byte range from :meth:`download_async`. + + Returns: + The populated dataset. + + Raises: + TimeNetConnectorError: If the byte range holds no usable game. + """ + dataset = TimeFDataset(metadata=self.metadata()) + windows = 0 + for prefix in prefixes: + for game in prefix.iter_games(): + for ply in game.decision_plies(): + record, task = create_window(game, ply) + dataset.add_record(record) + dataset.add_task(task) + windows += 1 + if windows == 0: + raise TimeNetConnectorError("the dump prefix held no complete game with clocks and evaluations") + return dataset + + +CONNECTOR = ClockBlunderConnector diff --git a/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/dataset.yaml b/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/dataset.yaml new file mode 100644 index 000000000..f35e61371 --- /dev/null +++ b/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/dataset.yaml @@ -0,0 +1,35 @@ +# yaml-language-server: $schema=https://docs.timenet.ai/schemas/dataset-card-v1.schema.json +yaml_schema_version: 1 +dataset_id: lichess/clock-blunder +dataset_version: 1.0.0 +name: Lichess Clock-Blunder +description: >- + 60,358 windows from 15,205 real rated Lichess games (48,055 train, 6,136 validation, 6,167 + test), each holding three per-ply series: White's clock and Black's clock in seconds, and the + Stockfish evaluation in pawns from White's view, as recorded by Lichess in the game's PGN. Each + window ends just before one player's move, and the task asks whether that player blunders within + their next three moves. A blunder uses Lichess's own rule: a move that drops the player's + winning chances by 0.3 or more on the -1 to +1 scale, with winning chances 2 / (1 + + exp(-0.00368208 * centipawns)) - 1 and a forced mate counted as +1 or -1. The answer is computed + from the recorded evaluations, not read from the ?? marks of the PGN, which do not always agree + with it. The answer is yes in 13,761 windows (22.8%). The games are the complete games with an + evaluation and a clock on every ply among the first 64 MiB of the April 2017 standard rated dump + (a fixed byte range, so every build sees the same games). Lichess records no evaluation for a + checkmating move, so no kept game ends in checkmate, and 7,273 of the kept games end on time. Up + to four windows are drawn from each game at a seeded random ply, so the share of yes answers + matches real play. The split is by game, so no game appears in two splits. The rationale of each + task is written from a template that reads the window's own numbers and the answer; it is + generated supervision, not expert commentary. Player names are not kept. +license: CC0-1.0 +source_url: https://database.lichess.org/ +domains: + - general +tags: + - chess + - games + - human-behavior + - lichess + - clock + - classification + - cot + - generated-supervision diff --git a/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/requirements.txt b/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/requirements.txt new file mode 100644 index 000000000..ec9524ae3 --- /dev/null +++ b/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/requirements.txt @@ -0,0 +1,2 @@ +# zstandard decompresses the Lichess dump, which ships as .pgn.zst. +zstandard>=0.22 diff --git a/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/tests/test_connector.py b/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/tests/test_connector.py new file mode 100644 index 000000000..9ac5e6763 --- /dev/null +++ b/packages/timenet-connectors/src/timenet_connectors/datasets/lichess/clock_blunder/tests/test_connector.py @@ -0,0 +1,405 @@ +from pathlib import Path + +import numpy as np +import pytest +import zstandard + +from timenet.dataset import TimeFDataset +from timenet.errors import TimeNetConnectorError +from timenet.reader import TimeFReader +from timenet.registry import open_local_version +from timenet.testing import assert_datasets_equal +from timenet.types import ClassificationTask, Split +from timenet.types.text import read_value +from timenet_connectors.datasets.lichess.clock_blunder.connector import ( + BLUNDER, + DUMP_URL, + MIN_DECISION_PLY, + PREFIX_BYTES, + PREFIX_SHA256, + WINDOW_PLIES, + WINDOWS_PER_GAME, + ClockBlunderConnector, + DumpPrefix, + Game, + create_window, + parse_eval, + prompt, + winning_chances, +) + + +_MOVES = ("Nf3", "Nf6", "Ng1", "Ng8") +"""Both knights go out and back, so the moves are legal chess at any length.""" + + +def _pgn( # ruff: ignore[too-many-arguments] + game_id: str, + evals: list[str | None], + clocks: list[int], + *, + time_control: str = "300+0", + result: str = "1-0", + white_elo: str = "1500", + site: str = "https://lichess.org/", +) -> str: + # Synthetic games in the shape of the Lichess dump: tag pairs, a blank line, then one comment + # with the evaluation and the clock after each move. + tags = { + "Event": "Rated Blitz game", + "Site": site + game_id, + "White": "Manvith", + "Black": "Twisha", + "Result": result, + "WhiteElo": white_elo, + "BlackElo": "1480", + "TimeControl": time_control, + "Termination": "Normal", + } + moves = [] + for ply, (evaluation, clock) in enumerate(zip(evals, clocks, strict=True)): + number = f"{ply // 2 + 1}{'.' if ply % 2 == 0 else '...'}" + notes = ([] if evaluation is None else [f"[%eval {evaluation}]"]) + [ + f"[%clk {clock // 3600}:{clock % 3600 // 60:02d}:{clock % 60:02d}]" + ] + moves.append(f"{number} {_MOVES[ply % 4]} {{ {' '.join(notes)} }}") + header = "\n".join(f'[{key} "{value}"]' for key, value in tags.items()) + return f"{header}\n\n{' '.join([*moves, result])}\n" + + +def _clocks(n_plies: int, *, start: int = 300, white_step: int = 4, black_step: int = 2) -> list[int]: + # White spends white_step seconds on each move after the first, Black black_step. + return [start - (white_step if ply % 2 == 0 else black_step) * (ply // 2) for ply in range(n_plies)] + + +# 26 plies with an increment. White walks into a forced mate on ply 18 and Black lets it go on ply 21. +# Those are the only two blunders: 0.3 pawns is 0.055 winning chances, a mate for Black is -1. +_MATE_EVALS: list[str | None] = [*["0.3"] * 18, "#-3", "#-2", "#-2", *["0.0"] * 5] +_MATE_PGN = _pgn("mateGame", _MATE_EVALS, _clocks(26), time_control="300+3", result="1/2-1/2") +# The same game until Black's move on ply 21, where Black now keeps the mate. +_MATE_KEPT_PGN = _pgn("mateGame", [*_MATE_EVALS[:21], *["#-2"] * 5], _clocks(26), time_control="300+3", result="0-1") +# 20 quiet plies. Both players berserked: half the base time on the clock from the first move. +_BERSERK_PGN = _pgn("berserk2", ["0.2"] * 20, _clocks(20, start=150, white_step=3, black_step=4)) +_LONG_PGN = _pgn("longGame", ["0.2"] * 60, _clocks(60, white_step=1, black_step=1), time_control="600+0") +# 16 plies: no ply at or after MIN_DECISION_PLY leaves the mover three more moves. +_SHORT_PGN = _pgn("shortGam", ["0.2"] * 16, _clocks(16)) +_NO_EVALS_PGN = _pgn("noEvals1", [None] * 20, _clocks(20)) +# The byte range of the real dump ends inside a game: no result token, and half a comment. +_CUT_OFF_PGN = _pgn("cutOff01", ["0.2"] * 20, _clocks(20))[: -len("0:04:42] } 1-0\n")] + +_GAMES_IN_THE_DUMP = (_MATE_PGN, _NO_EVALS_PGN, _BERSERK_PGN, _SHORT_PGN, _LONG_PGN, _CUT_OFF_PGN) + + +def _game(pgn: str) -> Game: + game = Game.from_pgn(pgn.strip()) + assert game is not None + return game + + +def _write_dump(directory: Path, *pgns: str) -> DumpPrefix: + # The dump puts one blank line after each game. + path = directory / "dump.pgn.zst" + path.write_bytes(zstandard.ZstdCompressor().compress("".join(pgn + "\n" for pgn in pgns).encode())) + return DumpPrefix(path) + + +def _convert(directory: Path) -> TimeFDataset: + return ClockBlunderConnector().convert([_write_dump(directory, *_GAMES_IN_THE_DUMP)]) + + +def _tasks_of_game(dataset: TimeFDataset, game_id: str) -> list[ClassificationTask]: + return [ + task for task in dataset.tasks_of(ClassificationTask) if task.inputs[0].metadata["lichess_game_id"] == game_id + ] + + +def _texts(task: ClassificationTask) -> tuple[str, str, str]: + # The prompt, the rationale and the answer. Every window has all three. + assert task.prompt is not None + assert task.rationale is not None + assert task.targets is not None + return str(read_value(task.prompt)), str(read_value(task.rationale)), str(read_value(task.targets[0])) + + +def test_metadata(): + metadata = ClockBlunderConnector().metadata() + assert metadata.dataset_id == "lichess/clock-blunder" + assert str(metadata.license) == "CC0-1.0" + assert str(metadata.dataset_version) == "1.0.0" + + +def test_source_is_pinned(): + # Literal pins, so moving to another dump or byte range is a deliberate test edit. + assert DUMP_URL == "https://database.lichess.org/standard/lichess_db_standard_rated_2017-04.pgn.zst" + assert PREFIX_BYTES == 67_108_864 + assert PREFIX_SHA256 == "d53e00e3cf7098057f136c2937d97f0cdd45963c52362565cbd2008814c99d1b" + + +@pytest.mark.parametrize( + ("pawns", "chances"), + # 2 / (1 + exp(-0.00368208 * centipawns)) - 1, worked out by hand as tanh(0.00184104 * centipawns). + [(0.0, 0.0), (1.0, 0.182052), (-3.0, -0.502251), (10.0, 0.950895), (100.0, 1.0), (-100.0, -1.0)], +) +def test_winning_chances_follow_the_lichess_formula(pawns, chances): + assert winning_chances(pawns) == pytest.approx(chances, abs=1e-6) + + +@pytest.mark.parametrize(("text", "pawns"), [("0.27", 0.27), ("-1.5", -1.5), ("#4", 100.0), ("#-3", -100.0)]) +def test_an_evaluation_is_pawns_and_a_mate_is_a_hundred_of_them(text, pawns): + assert parse_eval(text) == pytest.approx(pawns) + + +def test_an_evaluation_that_is_not_a_number_raises(): + with pytest.raises(TimeNetConnectorError, match=r"evaluation '1\.2\.3' is not a number or a mate"): + parse_eval("1.2.3") + + +def test_a_blunder_is_a_drop_of_0_3_winning_chances_for_the_mover(): + # Winning chances for White: 1.7 pawns is 0.3031, 1.6 pawns is 0.2863, 0.1 pawns is 0.0184, + # 9 pawns is 0.9296. + evals: list[str | None] = ["0.0", "1.7", "0.1", "0.0", "-1.6", "-1.6", "#-3", "#-1", "#-1", "-9.0"] + expected = [ + False, # White, level to level + True, # Black gives White 0.3031 + False, # White drops 0.3031 - 0.0184 = 0.2847 + False, # Black gains 0.0184 + False, # White drops 0.2863, just short + False, # Black, no change + True, # White walks into a mate: 1 - 0.2863 = 0.7137 + False, # Black keeps the mate + False, # White is mated anyway + False, # Black loses the mate but only 1 - 0.9296 = 0.0704 + ] + assert _game(_pgn("edgeGame", evals, _clocks(10))).blunders().tolist() == expected + + +def test_a_game_keeps_its_tags_and_one_clock_and_evaluation_per_ply(): + game = _game(_MATE_PGN) + assert (game.game_id, game.time_control, game.white_elo, game.black_elo) == ("mateGame", "300+3", 1500, 1480) + assert game.result == "1/2-1/2" + assert game.n_plies == 26 + np.testing.assert_array_equal(game.clocks, np.array(_clocks(26), dtype=np.float64)) + np.testing.assert_array_equal(game.evals, [*[0.3] * 18, -100.0, -100.0, -100.0, *[0.0] * 5]) + assert np.flatnonzero(game.blunders()).tolist() == [18, 21] + + +@pytest.mark.parametrize( + "pgn", + [ + _NO_EVALS_PGN, + _pgn("oneNoEvl", [*["0.2"] * 19, None], _clocks(20)), + _CUT_OFF_PGN, + _pgn("cutOff02", ["0.2"] * 20, _clocks(20))[: -len(" 1-0\n")], + _pgn("unfinish", ["0.2"] * 20, _clocks(20), result="*"), + _pgn("corresp1", ["0.2"] * 20, _clocks(20), time_control="-"), + _pgn("unrated1", ["0.2"] * 20, _clocks(20), white_elo="?"), + _BERSERK_PGN.replace(" 3. Nf3 { [%eval 0.2] [%clk 0:02:24] }", " 3. Nf3"), + _pgn("otherSit", ["0.2"] * 20, _clocks(20), site="https://example.org/"), + ], + ids=[ + "no evaluations", + "one ply without an evaluation", + "cut off inside a comment", + "cut off between the last move and the result", + "not finished", + "no clock in the time control", + "an unknown rating", + "a move without a comment", + "not a Lichess game", + ], +) +def test_a_game_the_dataset_cannot_use_is_skipped(pgn): + assert Game.from_pgn(pgn.strip()) is None + + +def test_each_clock_keeps_its_last_value_between_its_owner_moves(): + white, black, evals = _game(_MATE_PGN).series_until(5) + # White moved on plies 0, 2 and 4, Black on plies 1 and 3. Black's clock on ply 0 is its first reading. + np.testing.assert_array_equal(white, [300, 300, 296, 296, 292]) + np.testing.assert_array_equal(black, [300, 300, 300, 298, 298]) + np.testing.assert_array_equal(evals, [0.3] * 5) + + +def test_a_berserked_clock_starts_at_its_first_reading_not_at_the_base_time(): + white, black, _ = _game(_BERSERK_PGN).series_until(4) + np.testing.assert_array_equal(white, [150, 150, 147, 147]) + np.testing.assert_array_equal(black, [150, 150, 150, 146]) + + +def test_a_window_holds_the_last_plies_before_the_decision_and_a_clipped_evaluation(): + game = _game(_LONG_PGN) + white, black, evals = game.series_until(51) + assert len(white) == len(black) == len(evals) == WINDOW_PLIES + # Plies 11 to 50. White's last move was ply 50, its 26th; Black's was ply 49, its 25th. + assert (white[0], white[-1]) == (300 - 5, 300 - 25) + assert (black[0], black[-1]) == (300 - 5, 300 - 24) + # A mate is stored as the clip, not as the 100 pawns the label uses. + _, _, mate_evals = _game(_MATE_PGN).series_until(21) + np.testing.assert_array_equal(mate_evals, [*[0.3] * 18, -10.0, -10.0, -10.0]) + + +def test_decision_plies_are_seeded_by_the_game_and_leave_room_for_three_moves(): + for pgn in (_MATE_PGN, _BERSERK_PGN, _LONG_PGN): + game = _game(pgn) + plies = game.decision_plies() + assert plies == _game(pgn).decision_plies() + assert plies == sorted(set(plies)) + assert len(plies) == WINDOWS_PER_GAME + # The mover's third move is ply + 4, and the last ply of the game is n_plies - 1. + assert all(MIN_DECISION_PLY <= ply <= game.n_plies - 5 for ply in plies) + # 20 plies leave exactly plies 12 to 15, so all four are chosen whatever the seed. + assert _game(_BERSERK_PGN).decision_plies() == [12, 13, 14, 15] + # A literal pin: another choice here moves every window of a published dataset version. + assert _game(_MATE_PGN).decision_plies() == [13, 14, 15, 18] + assert _game(_LONG_PGN).decision_plies() == [19, 21, 34, 48] + + +@pytest.mark.parametrize(("n_plies", "expected"), [(16, []), (17, [12]), (18, [12, 13])]) +def test_a_game_too_short_for_three_more_moves_gives_fewer_windows(n_plies, expected): + assert _game(_pgn("shortGam", ["0.2"] * n_plies, _clocks(n_plies))).decision_plies() == expected + + +def test_the_answer_counts_the_movers_next_three_moves_only(): + game = _game(_MATE_PGN) + answers = {ply: _texts(create_window(game, ply)[1])[2] for ply in range(12, 22)} + assert answers == { + 12: "no", # White: plies 12, 14, 16. The blunder on ply 18 is White's fourth move. + 13: "no", # Black: plies 13, 15, 17. + 14: "yes", # White: ply 18 is the third move. + 15: "no", # Black: plies 15, 17, 19. White's blunder on ply 18 is not Black's. + 16: "yes", + 17: "yes", # Black: ply 21 is the third move, and the last ply with room is 21. + 18: "yes", # White blunders on the move itself. + 19: "yes", + 20: "no", # White: plies 20, 22, 24. Black's blunder on ply 21 is not White's. + 21: "yes", # Black: plies 21, 23 and 25, the last ply of the game. + } + + +def test_the_split_depends_only_on_the_game_id(): + # Literal pins: a change here moves games of a published dataset version between splits. + assert _game(_LONG_PGN).split == Split.TRAIN + assert _game(_BERSERK_PGN).split == Split.VALIDATION + assert _game(_MATE_PGN).split == Split.TEST + assert _game(_MATE_KEPT_PGN).split == Split.TEST + + +def test_iter_games_reads_the_compressed_dump_and_keeps_the_complete_games(tmp_path): + games = list(_write_dump(tmp_path, *_GAMES_IN_THE_DUMP).iter_games()) + # The short game is a complete game. It only gives no window. + assert [game.game_id for game in games] == ["mateGame", "berserk2", "shortGam", "longGame"] + + +def test_iter_games_stops_quietly_where_the_byte_range_cuts_the_stream(tmp_path): + # Enough games for several zstd blocks, so a cut loses the last block and not the whole stream. + pgns = [_pgn(f"game{index:04d}", ["0.2"] * 20, _clocks(20)) for index in range(600)] + path = _write_dump(tmp_path, *pgns).path + path.write_bytes(path.read_bytes()[:-8]) + games = [game.game_id for game in DumpPrefix(path).iter_games()] + assert 0 < len(games) < len(pgns) + assert games == [f"game{index:04d}" for index in range(len(games))] + + +def test_each_window_becomes_a_record_and_a_classification_task(tmp_path): + dataset = _convert(tmp_path) + tasks = dataset.tasks_of(ClassificationTask) + # Four windows from each of the three games that are long enough, in dump order. + assert [task.inputs[0].metadata["lichess_game_id"] for task in tasks] == ( + ["mateGame"] * 4 + ["berserk2"] * 4 + ["longGame"] * 4 + ) + assert len(dataset.records) == len(tasks) + for game_id, split in (("mateGame", Split.TEST), ("berserk2", Split.VALIDATION), ("longGame", Split.TRAIN)): + assert {task.split for task in _tasks_of_game(dataset, game_id)} == {split} + + # The last window of the first game: White is to move on ply 18, and walks into the mate. + task = _tasks_of_game(dataset, "mateGame")[-1] + (record,) = task.inputs + signals = {signal.name: signal.to_numpy() for signal in record.signals} + assert set(signals) == {"white_clock", "black_clock", "evaluation_pawns"} + assert {values.dtype for values in signals.values()} == {np.dtype(np.float64)} + np.testing.assert_array_equal(signals["white_clock"], [300 - 4 * (ply // 2) for ply in range(18)]) + np.testing.assert_array_equal(signals["black_clock"], [300, *[300 - 2 * ((ply - 1) // 2) for ply in range(1, 18)]]) + np.testing.assert_array_equal(signals["evaluation_pawns"], [0.3] * 18) + assert {annotation.key: read_value(annotation.value) for annotation in record.annotations} == { + "time_control": "300+3", + "white_elo": 1500, + "black_elo": 1480, + "side_to_move": "white", + "ply": 18, + } + assert task.label_set == BLUNDER + assert task.annotations == () + prompt_text, rationale_text, answer = _texts(task) + assert answer == "yes" + # The texts of one window in full: a model is trained on these words. + assert prompt_text == ( + "Rated Lichess game, time control 300+3 (seconds + increment), White rated 1500, Black rated 1480. " + "The series give White's clock and Black's clock in seconds and the engine evaluation in pawns from " + "White's view, one value per ply, for the plies before move 10. White is to move. Will White blunder " + "within their next three moves, that is, make a move that loses at least 0.3 winning chances on " + "Lichess's -1 to +1 scale? Answer yes or no." + ) + # White has 300 - 4 * 8 = 268 seconds and spent 4 + 3 seconds on each move, so 268 / 7 = 38 moves. + assert rationale_text == ( + "White is to move with 4:28 left against 4:44. Over the last 5 moves White spent 7.0 seconds per " + "move on average, enough for about 38 more moves at that pace. The evaluation is +0.3 pawns from " + "White's side, and it swung 0.0 pawns over the last ten plies. White does blunder within the next " + "three moves. Answer: yes" + ) + + +def test_the_names_of_the_players_are_not_kept(tmp_path): + for task in _convert(tmp_path).tasks_of(ClassificationTask): + (record,) = task.inputs + texts = [*_texts(task), *map(str, record.metadata.values())] + texts += [str(read_value(annotation.value)) for annotation in record.annotations] + assert not any(name in text for text in texts for name in ("Manvith", "Twisha")) + + +def test_the_prompt_and_the_series_never_contain_the_answer(): + # Two games that are the same until the decision on ply 21 and differ only after it. + blunders, keeps_the_mate = _game(_MATE_PGN), _game(_MATE_KEPT_PGN) + for ply in (17, 19, 21): + (record, task), (other_record, other_task) = create_window(blunders, ply), create_window(keeps_the_mate, ply) + assert (_texts(task)[2], _texts(other_task)[2]) == ("yes", "no") + assert _texts(task)[0] == _texts(other_task)[0] == prompt(blunders, ply) + assert "Answer:" not in _texts(task)[0] + for signal, other_signal in zip(record.signals, other_record.signals, strict=True): + np.testing.assert_array_equal(signal.to_numpy(), other_signal.to_numpy()) + assert record.annotations == other_record.annotations + + +def test_the_rationale_ends_with_the_answer(tmp_path): + tasks = _convert(tmp_path).tasks_of(ClassificationTask) + assert {_texts(task)[2] for task in tasks} == {"yes", "no"} + for task in tasks: + _, rationale_text, answer = _texts(task) + assert rationale_text.endswith(f" Answer: {answer}") + + +def test_the_rationale_reads_the_evaluation_from_the_side_of_the_mover(): + # Black to move on ply 21 with a forced mate, stored as the clip of 10 pawns. Black has + # 300 - 2 * 9 = 282 seconds and spent 2 + 3 seconds on each move, so 282 / 5 = 56 moves. + _, task = create_window(_game(_MATE_KEPT_PGN), 21) + assert _texts(task)[1] == ( + "Black is to move with 4:42 left against 4:20. Over the last 5 moves Black spent 5.0 seconds per " + "move on average, enough for about 56 more moves at that pace. The evaluation is +10.0 pawns from " + "Black's side, and it swung 10.3 pawns over the last ten plies. None of Black's next three moves is " + "a blunder. Answer: no" + ) + + +def test_a_dump_without_a_usable_game_raises(tmp_path): + prefix = _write_dump(tmp_path, _NO_EVALS_PGN, _SHORT_PGN, _CUT_OFF_PGN) + with pytest.raises(TimeNetConnectorError, match="held no complete game with clocks and evaluations"): + ClockBlunderConnector().convert([prefix]) + + +def test_the_dataset_round_trips_through_storage(tmp_path): + source = tmp_path / "source" + source.mkdir() + dataset = _convert(source) + version_dir = dataset.write(path=tmp_path / "registry") + with TimeFReader(open_local_version(version_dir)) as reader: + reader.verify() + assert_datasets_equal(dataset, reader.read()) diff --git a/pyproject.toml b/pyproject.toml index 1b9ddbfe8..a3b8ca685 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -20,6 +20,7 @@ dev = [ "edfio>=0.4.14", "wfdb>=4.1", "xlrd>=2.0", + "zstandard>=0.22", ] docs = [ "zensical", diff --git a/uv.lock b/uv.lock index 3d9b91921..cf2021c6e 100644 --- a/uv.lock +++ b/uv.lock @@ -37,6 +37,7 @@ dev = [ { name = "ty", specifier = ">=0.0.92" }, { name = "wfdb", specifier = ">=4.1" }, { name = "xlrd", specifier = ">=2.0" }, + { name = "zstandard", specifier = ">=0.22" }, ] docs = [ { name = "beautifulsoup4" }, @@ -4229,13 +4230,82 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/48/21/02db3e1fb3904016bfac310037c95b9f1eaaf0ffe7b4a84f14263a7d95df/zensical-0.0.51-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:134d776afa526098e05e34713e2f577c075e57a232e01b97842bb0206716afce", size = 12791154, upload-time = "2026-07-17T18:07:20.748Z" }, { url = "https://files.pythonhosted.org/packages/a2/35/b0d96f58253514cb3d08f5779020ab01ee5472334fb984b92e3fc9e9c9ac/zensical-0.0.51-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:e97ab39668ae3b452c550634e921a0336443743aae5e1fe031c7bb57d049e535", size = 12692190, upload-time = "2026-07-17T18:07:24.553Z" }, { url = "https://files.pythonhosted.org/packages/2e/90/7a60e126a10c37c6b789938ff17e73fe76bba707fa029cb40ac659aeaa82/zensical-0.0.51-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c9579809f88608e7aa2cff516fff9d267d74a843cf6088a5f4227de2f092bb5", size = 13139337, upload-time = "2026-07-17T18:07:27.885Z" }, - { url = "https://files.pythonhosted.org/packages/ae/c3/9101c97b90d4713ef2816db03366a45ae4762efebffd296737a2dd2df325/zensical-0.0.51-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:296dc7a14aa28b81a58eb57df2d5c9c9a4b0de7e90c11d99c943354287952925", size = 13069851, upload-time = "2026-07-17T18:07:31.814Z" }, - { url = "https://files.pythonhosted.org/packages/d2/79/0474df9e15a2c18f6281a786e10177c1b6e16feac1c568e7f36ad39b339c/zensical-0.0.51-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f779d2d87b4bf228cf2e279bc0ae6bcf3b36a9335ff283a317d01f7c15ae46b2", size = 13451083, upload-time = "2026-07-17T18:07:35.543Z" }, { url = "https://files.pythonhosted.org/packages/fe/6f/91bbf78f704d5fd4c0c9be27d6bce3b6e4c2c339e4dcd6e7cf19ecda643c/zensical-0.0.51-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67f813a1514a90890ca86248a8d54b81b2164bcbff11a6bcf11b01e1c01a1454", size = 13110446, upload-time = "2026-07-17T18:07:38.783Z" }, { url = "https://files.pythonhosted.org/packages/d9/89/aa9a95f81771614c37bdc52b8ab21fcdef4c8de7c9cedf34e9bf62674281/zensical-0.0.51-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:186ef37e0eee0e969e2cfae47b1b97775e3164e2cba95c71faa4dd6ef47ed009", size = 13315871, upload-time = "2026-07-17T18:07:42.43Z" }, - { url = "https://files.pythonhosted.org/packages/08/11/1bf6e9ded29d376f8c12644cc4de04676b010fee8caa17f682606b1f16d5/zensical-0.0.51-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:f5d91ce246ed930224603083cef02ae8947132fc7c52901d72015ea03526fa58", size = 13344382, upload-time = "2026-07-17T18:07:46.066Z" }, - { url = "https://files.pythonhosted.org/packages/d6/ec/663f16ff82d08b212e7c3236a88bd332f73331f94ddac1c91aaf882bbd1e/zensical-0.0.51-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:b1108eae82c6e8ffc33026f60b485c1512647a5333be4f547166b7c8877b98af", size = 13499628, upload-time = "2026-07-17T18:07:49.196Z" }, { url = "https://files.pythonhosted.org/packages/60/b4/7f1b6c3cf06d9f6ff5216523168a5d6ccc693444d5ceeb911eca97b30d98/zensical-0.0.51-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6fa0ecaf14f56841bfc595fa141396350c72aafbec73a016ebe3c824ed21ac72", size = 13451420, upload-time = "2026-07-17T18:07:52.563Z" }, - { url = "https://files.pythonhosted.org/packages/0a/44/be4bc09ec8f69e7be1b07b875887961c4e0e478b03a10d2cc624ef28fbe6/zensical-0.0.51-cp310-abi3-win32.whl", hash = "sha256:fb7ff4946b72168759c6af0a29cf5de4c38aebe633a83292e8cd4145b5213cc2", size = 12375639, upload-time = "2026-07-17T18:07:56.081Z" }, { url = "https://files.pythonhosted.org/packages/1f/85/aa827c244ed4f404e99a91c3ecf5e5adb62eca806a9e9c8e3333bbad8660/zensical-0.0.51-cp310-abi3-win_amd64.whl", hash = "sha256:12529d3d3991b63820952111dc1d1edc29b2c9b3a3abb16c243bcb649631ebf2", size = 12628965, upload-time = "2026-07-17T18:07:59.741Z" }, ] + +[[package]] +name = "zstandard" +version = "0.25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/aa/3e0508d5a5dd96529cdc5a97011299056e14c6505b678fd58938792794b1/zstandard-0.25.0.tar.gz", hash = "sha256:7713e1179d162cf5c7906da876ec2ccb9c3a9dcbdffef0cc7f70c3667a205f0b", size = 711513, upload-time = "2025-09-14T22:15:54.002Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/83/c3ca27c363d104980f1c9cee1101cc8ba724ac8c28a033ede6aab89585b1/zstandard-0.25.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:933b65d7680ea337180733cf9e87293cc5500cc0eb3fc8769f4d3c88d724ec5c", size = 795254, upload-time = "2025-09-14T22:16:26.137Z" }, + { url = "https://files.pythonhosted.org/packages/ac/4d/e66465c5411a7cf4866aeadc7d108081d8ceba9bc7abe6b14aa21c671ec3/zstandard-0.25.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3f79487c687b1fc69f19e487cd949bf3aae653d181dfb5fde3bf6d18894706f", size = 640559, upload-time = "2025-09-14T22:16:27.973Z" }, + { url = "https://files.pythonhosted.org/packages/12/56/354fe655905f290d3b147b33fe946b0f27e791e4b50a5f004c802cb3eb7b/zstandard-0.25.0-cp311-cp311-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:0bbc9a0c65ce0eea3c34a691e3c4b6889f5f3909ba4822ab385fab9057099431", size = 5348020, upload-time = "2025-09-14T22:16:29.523Z" }, + { url = "https://files.pythonhosted.org/packages/3b/13/2b7ed68bd85e69a2069bcc72141d378f22cae5a0f3b353a2c8f50ef30c1b/zstandard-0.25.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:01582723b3ccd6939ab7b3a78622c573799d5d8737b534b86d0e06ac18dbde4a", size = 5058126, upload-time = "2025-09-14T22:16:31.811Z" }, + { url = "https://files.pythonhosted.org/packages/c9/dd/fdaf0674f4b10d92cb120ccff58bbb6626bf8368f00ebfd2a41ba4a0dc99/zstandard-0.25.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5f1ad7bf88535edcf30038f6919abe087f606f62c00a87d7e33e7fc57cb69fcc", size = 5405390, upload-time = "2025-09-14T22:16:33.486Z" }, + { url = "https://files.pythonhosted.org/packages/0f/67/354d1555575bc2490435f90d67ca4dd65238ff2f119f30f72d5cde09c2ad/zstandard-0.25.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:06acb75eebeedb77b69048031282737717a63e71e4ae3f77cc0c3b9508320df6", size = 5452914, upload-time = "2025-09-14T22:16:35.277Z" }, + { url = "https://files.pythonhosted.org/packages/bb/1f/e9cfd801a3f9190bf3e759c422bbfd2247db9d7f3d54a56ecde70137791a/zstandard-0.25.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9300d02ea7c6506f00e627e287e0492a5eb0371ec1670ae852fefffa6164b072", size = 5559635, upload-time = "2025-09-14T22:16:37.141Z" }, + { url = "https://files.pythonhosted.org/packages/21/88/5ba550f797ca953a52d708c8e4f380959e7e3280af029e38fbf47b55916e/zstandard-0.25.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bfd06b1c5584b657a2892a6014c2f4c20e0db0208c159148fa78c65f7e0b0277", size = 5048277, upload-time = "2025-09-14T22:16:38.807Z" }, + { url = "https://files.pythonhosted.org/packages/46/c0/ca3e533b4fa03112facbe7fbe7779cb1ebec215688e5df576fe5429172e0/zstandard-0.25.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f373da2c1757bb7f1acaf09369cdc1d51d84131e50d5fa9863982fd626466313", size = 5574377, upload-time = "2025-09-14T22:16:40.523Z" }, + { url = "https://files.pythonhosted.org/packages/12/9b/3fb626390113f272abd0799fd677ea33d5fc3ec185e62e6be534493c4b60/zstandard-0.25.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6c0e5a65158a7946e7a7affa6418878ef97ab66636f13353b8502d7ea03c8097", size = 4961493, upload-time = "2025-09-14T22:16:43.3Z" }, + { url = "https://files.pythonhosted.org/packages/cb/d3/23094a6b6a4b1343b27ae68249daa17ae0651fcfec9ed4de09d14b940285/zstandard-0.25.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c8e167d5adf59476fa3e37bee730890e389410c354771a62e3c076c86f9f7778", size = 5269018, upload-time = "2025-09-14T22:16:45.292Z" }, + { url = "https://files.pythonhosted.org/packages/8c/a7/bb5a0c1c0f3f4b5e9d5b55198e39de91e04ba7c205cc46fcb0f95f0383c1/zstandard-0.25.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:98750a309eb2f020da61e727de7d7ba3c57c97cf6213f6f6277bb7fb42a8e065", size = 5443672, upload-time = "2025-09-14T22:16:47.076Z" }, + { url = "https://files.pythonhosted.org/packages/27/22/503347aa08d073993f25109c36c8d9f029c7d5949198050962cb568dfa5e/zstandard-0.25.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:22a086cff1b6ceca18a8dd6096ec631e430e93a8e70a9ca5efa7561a00f826fa", size = 5822753, upload-time = "2025-09-14T22:16:49.316Z" }, + { url = "https://files.pythonhosted.org/packages/e2/be/94267dc6ee64f0f8ba2b2ae7c7a2df934a816baaa7291db9e1aa77394c3c/zstandard-0.25.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:72d35d7aa0bba323965da807a462b0966c91608ef3a48ba761678cb20ce5d8b7", size = 5366047, upload-time = "2025-09-14T22:16:51.328Z" }, + { url = "https://files.pythonhosted.org/packages/7b/a3/732893eab0a3a7aecff8b99052fecf9f605cf0fb5fb6d0290e36beee47a4/zstandard-0.25.0-cp311-cp311-win32.whl", hash = "sha256:f5aeea11ded7320a84dcdd62a3d95b5186834224a9e55b92ccae35d21a8b63d4", size = 436484, upload-time = "2025-09-14T22:16:55.005Z" }, + { url = "https://files.pythonhosted.org/packages/43/a3/c6155f5c1cce691cb80dfd38627046e50af3ee9ddc5d0b45b9b063bfb8c9/zstandard-0.25.0-cp311-cp311-win_amd64.whl", hash = "sha256:daab68faadb847063d0c56f361a289c4f268706b598afbf9ad113cbe5c38b6b2", size = 506183, upload-time = "2025-09-14T22:16:52.753Z" }, + { url = "https://files.pythonhosted.org/packages/8c/3e/8945ab86a0820cc0e0cdbf38086a92868a9172020fdab8a03ac19662b0e5/zstandard-0.25.0-cp311-cp311-win_arm64.whl", hash = "sha256:22a06c5df3751bb7dc67406f5374734ccee8ed37fc5981bf1ad7041831fa1137", size = 462533, upload-time = "2025-09-14T22:16:53.878Z" }, + { url = "https://files.pythonhosted.org/packages/82/fc/f26eb6ef91ae723a03e16eddb198abcfce2bc5a42e224d44cc8b6765e57e/zstandard-0.25.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7b3c3a3ab9daa3eed242d6ecceead93aebbb8f5f84318d82cee643e019c4b73b", size = 795738, upload-time = "2025-09-14T22:16:56.237Z" }, + { url = "https://files.pythonhosted.org/packages/aa/1c/d920d64b22f8dd028a8b90e2d756e431a5d86194caa78e3819c7bf53b4b3/zstandard-0.25.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:913cbd31a400febff93b564a23e17c3ed2d56c064006f54efec210d586171c00", size = 640436, upload-time = "2025-09-14T22:16:57.774Z" }, + { url = "https://files.pythonhosted.org/packages/53/6c/288c3f0bd9fcfe9ca41e2c2fbfd17b2097f6af57b62a81161941f09afa76/zstandard-0.25.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:011d388c76b11a0c165374ce660ce2c8efa8e5d87f34996aa80f9c0816698b64", size = 5343019, upload-time = "2025-09-14T22:16:59.302Z" }, + { url = "https://files.pythonhosted.org/packages/1e/15/efef5a2f204a64bdb5571e6161d49f7ef0fffdbca953a615efbec045f60f/zstandard-0.25.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dffecc361d079bb48d7caef5d673c88c8988d3d33fb74ab95b7ee6da42652ea", size = 5063012, upload-time = "2025-09-14T22:17:01.156Z" }, + { url = "https://files.pythonhosted.org/packages/b7/37/a6ce629ffdb43959e92e87ebdaeebb5ac81c944b6a75c9c47e300f85abdf/zstandard-0.25.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:7149623bba7fdf7e7f24312953bcf73cae103db8cae49f8154dd1eadc8a29ecb", size = 5394148, upload-time = "2025-09-14T22:17:03.091Z" }, + { url = "https://files.pythonhosted.org/packages/e3/79/2bf870b3abeb5c070fe2d670a5a8d1057a8270f125ef7676d29ea900f496/zstandard-0.25.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6a573a35693e03cf1d67799fd01b50ff578515a8aeadd4595d2a7fa9f3ec002a", size = 5451652, upload-time = "2025-09-14T22:17:04.979Z" }, + { url = "https://files.pythonhosted.org/packages/53/60/7be26e610767316c028a2cbedb9a3beabdbe33e2182c373f71a1c0b88f36/zstandard-0.25.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5a56ba0db2d244117ed744dfa8f6f5b366e14148e00de44723413b2f3938a902", size = 5546993, upload-time = "2025-09-14T22:17:06.781Z" }, + { url = "https://files.pythonhosted.org/packages/85/c7/3483ad9ff0662623f3648479b0380d2de5510abf00990468c286c6b04017/zstandard-0.25.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:10ef2a79ab8e2974e2075fb984e5b9806c64134810fac21576f0668e7ea19f8f", size = 5046806, upload-time = "2025-09-14T22:17:08.415Z" }, + { url = "https://files.pythonhosted.org/packages/08/b3/206883dd25b8d1591a1caa44b54c2aad84badccf2f1de9e2d60a446f9a25/zstandard-0.25.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:aaf21ba8fb76d102b696781bddaa0954b782536446083ae3fdaa6f16b25a1c4b", size = 5576659, upload-time = "2025-09-14T22:17:10.164Z" }, + { url = "https://files.pythonhosted.org/packages/9d/31/76c0779101453e6c117b0ff22565865c54f48f8bd807df2b00c2c404b8e0/zstandard-0.25.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1869da9571d5e94a85a5e8d57e4e8807b175c9e4a6294e3b66fa4efb074d90f6", size = 4953933, upload-time = "2025-09-14T22:17:11.857Z" }, + { url = "https://files.pythonhosted.org/packages/18/e1/97680c664a1bf9a247a280a053d98e251424af51f1b196c6d52f117c9720/zstandard-0.25.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:809c5bcb2c67cd0ed81e9229d227d4ca28f82d0f778fc5fea624a9def3963f91", size = 5268008, upload-time = "2025-09-14T22:17:13.627Z" }, + { url = "https://files.pythonhosted.org/packages/1e/73/316e4010de585ac798e154e88fd81bb16afc5c5cb1a72eeb16dd37e8024a/zstandard-0.25.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f27662e4f7dbf9f9c12391cb37b4c4c3cb90ffbd3b1fb9284dadbbb8935fa708", size = 5433517, upload-time = "2025-09-14T22:17:16.103Z" }, + { url = "https://files.pythonhosted.org/packages/5b/60/dd0f8cfa8129c5a0ce3ea6b7f70be5b33d2618013a161e1ff26c2b39787c/zstandard-0.25.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:99c0c846e6e61718715a3c9437ccc625de26593fea60189567f0118dc9db7512", size = 5814292, upload-time = "2025-09-14T22:17:17.827Z" }, + { url = "https://files.pythonhosted.org/packages/fc/5f/75aafd4b9d11b5407b641b8e41a57864097663699f23e9ad4dbb91dc6bfe/zstandard-0.25.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:474d2596a2dbc241a556e965fb76002c1ce655445e4e3bf38e5477d413165ffa", size = 5360237, upload-time = "2025-09-14T22:17:19.954Z" }, + { url = "https://files.pythonhosted.org/packages/ff/8d/0309daffea4fcac7981021dbf21cdb2e3427a9e76bafbcdbdf5392ff99a4/zstandard-0.25.0-cp312-cp312-win32.whl", hash = "sha256:23ebc8f17a03133b4426bcc04aabd68f8236eb78c3760f12783385171b0fd8bd", size = 436922, upload-time = "2025-09-14T22:17:24.398Z" }, + { url = "https://files.pythonhosted.org/packages/79/3b/fa54d9015f945330510cb5d0b0501e8253c127cca7ebe8ba46a965df18c5/zstandard-0.25.0-cp312-cp312-win_amd64.whl", hash = "sha256:ffef5a74088f1e09947aecf91011136665152e0b4b359c42be3373897fb39b01", size = 506276, upload-time = "2025-09-14T22:17:21.429Z" }, + { url = "https://files.pythonhosted.org/packages/ea/6b/8b51697e5319b1f9ac71087b0af9a40d8a6288ff8025c36486e0c12abcc4/zstandard-0.25.0-cp312-cp312-win_arm64.whl", hash = "sha256:181eb40e0b6a29b3cd2849f825e0fa34397f649170673d385f3598ae17cca2e9", size = 462679, upload-time = "2025-09-14T22:17:23.147Z" }, + { url = "https://files.pythonhosted.org/packages/35/0b/8df9c4ad06af91d39e94fa96cc010a24ac4ef1378d3efab9223cc8593d40/zstandard-0.25.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec996f12524f88e151c339688c3897194821d7f03081ab35d31d1e12ec975e94", size = 795735, upload-time = "2025-09-14T22:17:26.042Z" }, + { url = "https://files.pythonhosted.org/packages/3f/06/9ae96a3e5dcfd119377ba33d4c42a7d89da1efabd5cb3e366b156c45ff4d/zstandard-0.25.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a1a4ae2dec3993a32247995bdfe367fc3266da832d82f8438c8570f989753de1", size = 640440, upload-time = "2025-09-14T22:17:27.366Z" }, + { url = "https://files.pythonhosted.org/packages/d9/14/933d27204c2bd404229c69f445862454dcc101cd69ef8c6068f15aaec12c/zstandard-0.25.0-cp313-cp313-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:e96594a5537722fdfb79951672a2a63aec5ebfb823e7560586f7484819f2a08f", size = 5343070, upload-time = "2025-09-14T22:17:28.896Z" }, + { url = "https://files.pythonhosted.org/packages/6d/db/ddb11011826ed7db9d0e485d13df79b58586bfdec56e5c84a928a9a78c1c/zstandard-0.25.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bfc4e20784722098822e3eee42b8e576b379ed72cca4a7cb856ae733e62192ea", size = 5063001, upload-time = "2025-09-14T22:17:31.044Z" }, + { url = "https://files.pythonhosted.org/packages/db/00/87466ea3f99599d02a5238498b87bf84a6348290c19571051839ca943777/zstandard-0.25.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:457ed498fc58cdc12fc48f7950e02740d4f7ae9493dd4ab2168a47c93c31298e", size = 5394120, upload-time = "2025-09-14T22:17:32.711Z" }, + { url = "https://files.pythonhosted.org/packages/2b/95/fc5531d9c618a679a20ff6c29e2b3ef1d1f4ad66c5e161ae6ff847d102a9/zstandard-0.25.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:fd7a5004eb1980d3cefe26b2685bcb0b17989901a70a1040d1ac86f1d898c551", size = 5451230, upload-time = "2025-09-14T22:17:34.41Z" }, + { url = "https://files.pythonhosted.org/packages/63/4b/e3678b4e776db00f9f7b2fe58e547e8928ef32727d7a1ff01dea010f3f13/zstandard-0.25.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e735494da3db08694d26480f1493ad2cf86e99bdd53e8e9771b2752a5c0246a", size = 5547173, upload-time = "2025-09-14T22:17:36.084Z" }, + { url = "https://files.pythonhosted.org/packages/4e/d5/ba05ed95c6b8ec30bd468dfeab20589f2cf709b5c940483e31d991f2ca58/zstandard-0.25.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3a39c94ad7866160a4a46d772e43311a743c316942037671beb264e395bdd611", size = 5046736, upload-time = "2025-09-14T22:17:37.891Z" }, + { url = "https://files.pythonhosted.org/packages/50/d5/870aa06b3a76c73eced65c044b92286a3c4e00554005ff51962deef28e28/zstandard-0.25.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:172de1f06947577d3a3005416977cce6168f2261284c02080e7ad0185faeced3", size = 5576368, upload-time = "2025-09-14T22:17:40.206Z" }, + { url = "https://files.pythonhosted.org/packages/5d/35/398dc2ffc89d304d59bc12f0fdd931b4ce455bddf7038a0a67733a25f550/zstandard-0.25.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3c83b0188c852a47cd13ef3bf9209fb0a77fa5374958b8c53aaa699398c6bd7b", size = 4954022, upload-time = "2025-09-14T22:17:41.879Z" }, + { url = "https://files.pythonhosted.org/packages/9a/5c/36ba1e5507d56d2213202ec2b05e8541734af5f2ce378c5d1ceaf4d88dc4/zstandard-0.25.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1673b7199bbe763365b81a4f3252b8e80f44c9e323fc42940dc8843bfeaf9851", size = 5267889, upload-time = "2025-09-14T22:17:43.577Z" }, + { url = "https://files.pythonhosted.org/packages/70/e8/2ec6b6fb7358b2ec0113ae202647ca7c0e9d15b61c005ae5225ad0995df5/zstandard-0.25.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:0be7622c37c183406f3dbf0cba104118eb16a4ea7359eeb5752f0794882fc250", size = 5433952, upload-time = "2025-09-14T22:17:45.271Z" }, + { url = "https://files.pythonhosted.org/packages/7b/01/b5f4d4dbc59ef193e870495c6f1275f5b2928e01ff5a81fecb22a06e22fb/zstandard-0.25.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:5f5e4c2a23ca271c218ac025bd7d635597048b366d6f31f420aaeb715239fc98", size = 5814054, upload-time = "2025-09-14T22:17:47.08Z" }, + { url = "https://files.pythonhosted.org/packages/b2/e5/fbd822d5c6f427cf158316d012c5a12f233473c2f9c5fe5ab1ae5d21f3d8/zstandard-0.25.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f187a0bb61b35119d1926aee039524d1f93aaf38a9916b8c4b78ac8514a0aaf", size = 5360113, upload-time = "2025-09-14T22:17:48.893Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e0/69a553d2047f9a2c7347caa225bb3a63b6d7704ad74610cb7823baa08ed7/zstandard-0.25.0-cp313-cp313-win32.whl", hash = "sha256:7030defa83eef3e51ff26f0b7bfb229f0204b66fe18e04359ce3474ac33cbc09", size = 436936, upload-time = "2025-09-14T22:17:52.658Z" }, + { url = "https://files.pythonhosted.org/packages/d9/82/b9c06c870f3bd8767c201f1edbdf9e8dc34be5b0fbc5682c4f80fe948475/zstandard-0.25.0-cp313-cp313-win_amd64.whl", hash = "sha256:1f830a0dac88719af0ae43b8b2d6aef487d437036468ef3c2ea59c51f9d55fd5", size = 506232, upload-time = "2025-09-14T22:17:50.402Z" }, + { url = "https://files.pythonhosted.org/packages/d4/57/60c3c01243bb81d381c9916e2a6d9e149ab8627c0c7d7abb2d73384b3c0c/zstandard-0.25.0-cp313-cp313-win_arm64.whl", hash = "sha256:85304a43f4d513f5464ceb938aa02c1e78c2943b29f44a750b48b25ac999a049", size = 462671, upload-time = "2025-09-14T22:17:51.533Z" }, + { url = "https://files.pythonhosted.org/packages/3d/5c/f8923b595b55fe49e30612987ad8bf053aef555c14f05bb659dd5dbe3e8a/zstandard-0.25.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e29f0cf06974c899b2c188ef7f783607dbef36da4c242eb6c82dcd8b512855e3", size = 795887, upload-time = "2025-09-14T22:17:54.198Z" }, + { url = "https://files.pythonhosted.org/packages/8d/09/d0a2a14fc3439c5f874042dca72a79c70a532090b7ba0003be73fee37ae2/zstandard-0.25.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:05df5136bc5a011f33cd25bc9f506e7426c0c9b3f9954f056831ce68f3b6689f", size = 640658, upload-time = "2025-09-14T22:17:55.423Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7c/8b6b71b1ddd517f68ffb55e10834388d4f793c49c6b83effaaa05785b0b4/zstandard-0.25.0-cp314-cp314-manylinux2010_i686.manylinux_2_12_i686.manylinux_2_28_i686.whl", hash = "sha256:f604efd28f239cc21b3adb53eb061e2a205dc164be408e553b41ba2ffe0ca15c", size = 5379849, upload-time = "2025-09-14T22:17:57.372Z" }, + { url = "https://files.pythonhosted.org/packages/a4/86/a48e56320d0a17189ab7a42645387334fba2200e904ee47fc5a26c1fd8ca/zstandard-0.25.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223415140608d0f0da010499eaa8ccdb9af210a543fac54bce15babbcfc78439", size = 5058095, upload-time = "2025-09-14T22:17:59.498Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ad/eb659984ee2c0a779f9d06dbfe45e2dc39d99ff40a319895df2d3d9a48e5/zstandard-0.25.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e54296a283f3ab5a26fc9b8b5d4978ea0532f37b231644f367aa588930aa043", size = 5551751, upload-time = "2025-09-14T22:18:01.618Z" }, + { url = "https://files.pythonhosted.org/packages/61/b3/b637faea43677eb7bd42ab204dfb7053bd5c4582bfe6b1baefa80ac0c47b/zstandard-0.25.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ca54090275939dc8ec5dea2d2afb400e0f83444b2fc24e07df7fdef677110859", size = 6364818, upload-time = "2025-09-14T22:18:03.769Z" }, + { url = "https://files.pythonhosted.org/packages/31/dc/cc50210e11e465c975462439a492516a73300ab8caa8f5e0902544fd748b/zstandard-0.25.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e09bb6252b6476d8d56100e8147b803befa9a12cea144bbe629dd508800d1ad0", size = 5560402, upload-time = "2025-09-14T22:18:05.954Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ae/56523ae9c142f0c08efd5e868a6da613ae76614eca1305259c3bf6a0ed43/zstandard-0.25.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a9ec8c642d1ec73287ae3e726792dd86c96f5681eb8df274a757bf62b750eae7", size = 4955108, upload-time = "2025-09-14T22:18:07.68Z" }, + { url = "https://files.pythonhosted.org/packages/98/cf/c899f2d6df0840d5e384cf4c4121458c72802e8bda19691f3b16619f51e9/zstandard-0.25.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a4089a10e598eae6393756b036e0f419e8c1d60f44a831520f9af41c14216cf2", size = 5269248, upload-time = "2025-09-14T22:18:09.753Z" }, + { url = "https://files.pythonhosted.org/packages/1b/c0/59e912a531d91e1c192d3085fc0f6fb2852753c301a812d856d857ea03c6/zstandard-0.25.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f67e8f1a324a900e75b5e28ffb152bcac9fbed1cc7b43f99cd90f395c4375344", size = 5430330, upload-time = "2025-09-14T22:18:11.966Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/7e31db1240de2df22a58e2ea9a93fc6e38cc29353e660c0272b6735d6669/zstandard-0.25.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9654dbc012d8b06fc3d19cc825af3f7bf8ae242226df5f83936cb39f5fdc846c", size = 5811123, upload-time = "2025-09-14T22:18:13.907Z" }, + { url = "https://files.pythonhosted.org/packages/f6/49/fac46df5ad353d50535e118d6983069df68ca5908d4d65b8c466150a4ff1/zstandard-0.25.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4203ce3b31aec23012d3a4cf4a2ed64d12fea5269c49aed5e4c3611b938e4088", size = 5359591, upload-time = "2025-09-14T22:18:16.465Z" }, + { url = "https://files.pythonhosted.org/packages/c2/38/f249a2050ad1eea0bb364046153942e34abba95dd5520af199aed86fbb49/zstandard-0.25.0-cp314-cp314-win32.whl", hash = "sha256:da469dc041701583e34de852d8634703550348d5822e66a0c827d39b05365b12", size = 444513, upload-time = "2025-09-14T22:18:20.61Z" }, + { url = "https://files.pythonhosted.org/packages/3a/43/241f9615bcf8ba8903b3f0432da069e857fc4fd1783bd26183db53c4804b/zstandard-0.25.0-cp314-cp314-win_amd64.whl", hash = "sha256:c19bcdd826e95671065f8692b5a4aa95c52dc7a02a4c5a0cac46deb879a017a2", size = 516118, upload-time = "2025-09-14T22:18:17.849Z" }, + { url = "https://files.pythonhosted.org/packages/f0/ef/da163ce2450ed4febf6467d77ccb4cd52c4c30ab45624bad26ca0a27260c/zstandard-0.25.0-cp314-cp314-win_arm64.whl", hash = "sha256:d7541afd73985c630bafcd6338d2518ae96060075f9463d7dc14cfb33514383d", size = 476940, upload-time = "2025-09-14T22:18:19.088Z" }, +]