From b679e13cd13741107a5739b4eb3f65db3d2cf174 Mon Sep 17 00:00:00 2001 From: Daniel Young Date: Fri, 2 Oct 2026 17:49:53 -0400 Subject: [PATCH 01/10] [cli] Add versioned JSON command output Give automation stable status, history, lint and drift documents. Keep diagnostics off stdout and distinguish drift from read failures. Resolve applied ancestors and preserve explicit waiver reasons. Ported from the held 1.0 line onto 0.7.0 for 0.8 (DRY-1542 kept --json; plan is not part of it). The only conflict was status's black-wrapped render_status call. uv.lock is re-locked from 0.7.0's lock plus jsonschema rather than taken from the 1.0 line. Solves: DRY-1244 Tests: 704 unit tests on Python 3.13 (686 on 0.7.0 plus 18 JSON) (cherry picked from commit 37aa615483ad4c321ffa10e1fc73d059b4a3dc42) --- CHANGELOG.md | 1 + README.md | 47 +++- ch_migrate/cli.py | 78 +++++- ch_migrate/json_output.py | 152 +++++++++++ ch_migrate/lint.py | 13 +- docs/schemas/diff.schema.json | 102 ++++++++ docs/schemas/history.schema.json | 87 +++++++ docs/schemas/lint.schema.json | 124 +++++++++ docs/schemas/status.schema.json | 72 ++++++ pyproject.toml | 2 + tests/integration/test_json_commands.py | 105 ++++++++ tests/test_json_output.py | 198 +++++++++++++++ uv.lock | 325 +++++++++++++++++++++++- 13 files changed, 1285 insertions(+), 21 deletions(-) create mode 100644 ch_migrate/json_output.py create mode 100644 docs/schemas/diff.schema.json create mode 100644 docs/schemas/history.schema.json create mode 100644 docs/schemas/lint.schema.json create mode 100644 docs/schemas/status.schema.json create mode 100644 tests/integration/test_json_commands.py create mode 100644 tests/test_json_output.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 5d55207..82bbf36 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -59,6 +59,7 @@ To stay on 0.5.x until then, pin `ch-migrate-cli==0.5.1`. ### Added +- Versioned `--json` output and published JSON Schemas for status, history, lint, and diff, with machine-readable errors, graph-resolved applied revisions, explicit waiver reasons, and CI-friendly exit codes. - Reviewed idempotency corpus covering DDL, mutations, inserts, and partition operations. - Required-reason `ch-migrate: allow-non-idempotent` statement waivers, reported as INFO. - Gate findings say how to make the flagged statement safe to run twice, using its own names: the exact `IF NOT EXISTS` or `IF EXISTS` rewrite, or what a retry would do and the usual fix, such as `TRUNCATE` before a backfill or `REPLACE PARTITION` instead of `ATTACH PARTITION ... FROM`. diff --git a/README.md b/README.md index 3c9f2f7..9bb7db9 100644 --- a/README.md +++ b/README.md @@ -479,6 +479,8 @@ Every command accepts `--help`. Top-level `ch-migrate --version` reports the ins Output lines start with `→` for a step, `✓` for a result, `!` for a warning and `✗` for an error; warnings and errors go to stderr. Colour is dropped when output is not a terminal or `NO_COLOR` is set, and lines are never wrapped, so paths and SQL can be copied or grepped. +`status`, `history`, `lint`, and `diff` accept `--json`. JSON mode writes one document to stdout; diagnostics go to stderr. Every document includes `"schema_version": 1` and `"command"`. From 1.0 this is a public interface: breaking changes require a major version. Errors include an `error` string rather than inventing a successful empty result. The schemas linked below use JSON Schema draft 2020-12. + ### `init` `ch-migrate init [PATH] [-n NAME]` initializes the current directory by default. `-n/--name` sets the project name; otherwise it uses the directory name. @@ -511,22 +513,53 @@ Example: `ch-migrate down dev --revision base` ### `status` -`ch-migrate status ENV` shows connection information, applied/pending counts, and head status, and names the `up` command when migrations are pending. No command-specific options. Status is a report: it exits 0 when the database is unreachable (with a warning) or migrations are pending, and exits 1 only when the configuration or `migrations/versions/` is missing, so CI can run it as a non-blocking check. +`ch-migrate status ENV [--json]` shows connection information, applied/pending counts, and head status, and names the `up` command when migrations are pending. Status is a report: human output exits 0 when the database is unreachable (with a warning) or migrations are pending, and exits 1 only when the configuration or `migrations/versions/` is missing, so CI can run it as a non-blocking check. JSON mode uses nonzero exits for unreachable or pending state. Example: `ch-migrate status dev` +With `--json`, [the status schema](docs/schemas/status.schema.json) includes +`database`, `current_heads`, `script_heads`, `pending`, `applied`, and `at_head`. +`applied` includes ancestors resolved through the revision graph, not just stored +heads. JSON exits 0 when the head sets match exactly, 1 when pending or diverged, +and 2 when configuration or database state cannot be read. Human-mode exits are +unchanged. + +```bash +ch-migrate status dev --json | jq -e .current_heads +# Check the actual head set, not the last element of applied: +ch-migrate status dev --json | jq -e '.current_heads == ["PINNED_REVISION"]' +``` + +Replace `PINNED_REVISION` with the required revision. In a shell pipeline, enable +`set -o pipefail` if the caller must also preserve ch-migrate's exit code. + ### `history` -`ch-migrate history ENV` displays the revision graph and applied state. No command-specific options. +`ch-migrate history ENV [--json]` displays the revision graph and applied state. Example: `ch-migrate history dev` +`ch-migrate history dev --json` follows [the history schema](docs/schemas/history.schema.json). +Each entry in `revisions` includes its revision, all `down_revisions` (including +merge parents), description, create date, path, applied status, and irreversible +reason. A reversible revision has `irreversible: null`. If database state is +unavailable, `applied` is null, the document includes `error`, and JSON exits 2. +An unknown database head also makes applied status unknown instead of claiming +that every local revision is unapplied. + ### `lint` -`ch-migrate lint [ENV]` analyzes upgrade statements, not downgrade SQL. Without `ENV`, it checks revisions after the gate baseline statically without credentials or a connection. With an environment, it checks only pending revisions in that scope and adds live size and dependency checks. If it cannot determine the pending set, it fails rather than silently checking a different scope. No command-specific options. Errors exit nonzero; warnings and waiver INFO lines alone do not. +`ch-migrate lint [ENV] [--json]` analyzes upgrade statements, not downgrade SQL. Without `ENV`, it checks revisions after the gate baseline statically without credentials or a connection. With an environment, it checks only pending revisions in that scope and adds live size and dependency checks. If it cannot determine the pending set, it fails rather than silently checking a different scope. Errors exit nonzero; warnings and waiver INFO lines alone do not. Example: `ch-migrate lint` +`ch-migrate lint --json` follows [the lint schema](docs/schemas/lint.schema.json). +`findings` include rule, severity, source file/line, message, `blocking`, and +`waived`. `blocking` means the finding currently blocks `up`; a waived finding +has its written reason and does not block. `counts` reports total, error, warning, +info, blocking, and waived findings. JSON and human output use the same exit +codes: 1 for lint/configuration errors, otherwise 0. + Findings name the project-relative SQL file and statement line. Inline Python SQL points to its `op.execute` call. Extraction reads `run_sql`/`read_sql` file references and literal or f-string `op.execute` arguments without importing @@ -543,10 +576,16 @@ Example: `ch-migrate deps dev --validate migrations/sql/history/tables/logs/chan ### `diff` -`ch-migrate diff ENV [-s PATH]` compares the live schema with the latest snapshot. `-s/--snapshot-dir PATH` chooses another snapshot. Exit code 0 means no drift; 1 means drift or an execution error. +`ch-migrate diff ENV [-s PATH] [--json]` compares the live schema with the latest snapshot. `-s/--snapshot-dir PATH` chooses another snapshot. Exit code 0 means no drift; 1 means drift. JSON errors exit 2; human-mode execution errors retain exit 1. Example: `ch-migrate diff dev --snapshot-dir migrations/sql/snapshots/20261002_120000` +`ch-migrate diff dev --json` follows [the diff schema](docs/schemas/diff.schema.json). +`objects` identifies each object's type, name, status, and structural `details` +(field, local value, remote value, and message). `in_sync` is true only when every +object matches. Use the exit code as the drift gate; an error document does not +contain a fabricated `in_sync: true`. + ### `snapshot` `ch-migrate snapshot ENV [-e GLOB] [-f GLOB]` writes CREATE statements to a timestamped snapshot directory. `-e/--exclude` and `-f/--filter` accept repeated glob patterns for excluded and included objects. diff --git a/ch_migrate/cli.py b/ch_migrate/cli.py index 48ef4ef..d806605 100644 --- a/ch_migrate/cli.py +++ b/ch_migrate/cli.py @@ -19,6 +19,15 @@ from ch_migrate import __version__, ui from ch_migrate.authoring import NewOptions from ch_migrate.config import get_env_config +from ch_migrate.json_output import ( + JsonCommand, + command_failure, + diff_document, + emit_json, + history_document, + lint_document, + status_document, +) from ch_migrate.runner import alembic_failure, run_alembic, run_migrations if TYPE_CHECKING: @@ -303,9 +312,10 @@ def down( sys.exit(run_migrations(environment, [*named, "downgrade", revision], verbose=verbose)) -@main.command() +@main.command(cls=JsonCommand) @click.argument("environment") -def status(environment: str) -> None: +@click.option("--json", "json_output", is_flag=True, help="Emit a versioned JSON document") +def status(environment: str, json_output: bool) -> None: """Show migration status. Displays environment info, applied/pending counts, and head status. @@ -316,6 +326,12 @@ def status(environment: str) -> None: from ch_migrate.display import render_status state = _load_migration_state(environment) + if json_output: + if state.db_error is not None: + command_failure(state.db_error) + document = status_document(state.graph, state.heads, state.env_config["database"]) + emit_json("status", document) + sys.exit(0 if document["at_head"] else 1) render_status( environment, state.env_config, state.graph, state.applied, db_error=state.db_error ) @@ -328,9 +344,10 @@ def status(environment: str) -> None: ui.hint(f"Run `ch-migrate up {environment}` to apply {pending} pending {noun}.") -@main.command() +@main.command(cls=JsonCommand) @click.argument("environment") -def history(environment: str) -> None: +@click.option("--json", "json_output", is_flag=True, help="Emit a versioned JSON document") +def history(environment: str, json_output: bool) -> None: """Show migration history. Displays a tree of all migrations, color-coded by applied status. @@ -339,6 +356,14 @@ def history(environment: str) -> None: from ch_migrate.display import render_history state = _load_migration_state(environment) + if json_output: + document = history_document( + state.graph, None if state.heads - set(state.graph.migrations) else state.applied + ) + if state.db_error is not None: + document["error"] = state.db_error + emit_json("history", document) + sys.exit(2 if state.db_error is not None else 0) render_history(state.graph, state.applied, db_error=state.db_error) @@ -348,6 +373,7 @@ class _MigrationState: graph: RevisionGraph applied: set[str] | None # None when the database could not be read db_error: str | None + heads: set[str] def _load_migration_state(environment: str) -> _MigrationState: @@ -363,7 +389,7 @@ def _load_migration_state(environment: str) -> _MigrationState: if warning := state.version_table.warning(): ui.warn(warning) except Exception as e: - return _MigrationState(env_config, graph, None, str(e)) + return _MigrationState(env_config, graph, None, str(e), set()) applied: set[str] = set() unknown = [head for head in heads if head not in graph.migrations] for head in heads: @@ -373,19 +399,23 @@ def _load_migration_state(environment: str) -> _MigrationState: ui.warn(f"The database is at {head[:12]}, which is not in your local migration files.") if unknown: ui.warn("Applied status may be incomplete; pull the missing revisions.") - return _MigrationState(env_config, graph, applied, None) + return _MigrationState(env_config, graph, applied, None, heads) def _env_config_or_fail(environment: str) -> dict[str, Any]: try: return get_env_config(environment, Path.cwd() / "config.yaml") except Exception as e: + if click.get_current_context().params.get("json_output"): + command_failure(f"Error loading config: {e}") ui.fail(f"Could not load config: {e}") def _versions_dir_or_fail() -> Path: versions_dir = Path.cwd() / "migrations" / "versions" if not versions_dir.exists(): + if click.get_current_context().params.get("json_output"): + command_failure("Error: migrations/versions/ not found") ui.fail("migrations/versions/ not found.", "Run `ch-migrate init` to create a project.") return versions_dir @@ -757,9 +787,10 @@ def skill(target: str) -> None: ui.success(f"Installed the skill to {skill_dst}") -@main.command() +@main.command(cls=JsonCommand) @click.argument("environment", required=False, default=None) -def lint(environment: str | None) -> None: +@click.option("--json", "json_output", is_flag=True, help="Emit a versioned JSON document") +def lint(environment: str | None, json_output: bool) -> None: """Lint upgrade statements with their source file and line. Without an environment, checks revisions after the gate baseline statically, @@ -806,6 +837,8 @@ def lint(environment: str | None) -> None: ) client = get_client(env_config) except Exception as e: + if json_output: + command_failure(f"Could not work out the pending revisions for {environment}: {e}") ui.fail(f"Could not work out the pending revisions for {environment}: {e}") try: @@ -817,12 +850,17 @@ def lint(environment: str | None) -> None: revisions=revisions, ) except (OSError, SyntaxError, ValueError) as e: + if json_output: + command_failure(str(e)) ui.fail(str(e)) finally: if client is not None: client.close() - render_lint_report(report, runtime=environment is not None) + if json_output: + emit_json("lint", lint_document(report)) + else: + render_lint_report(report, runtime=environment is not None) sys.exit(1 if report.has_errors else 0) @@ -880,15 +918,16 @@ def deps(environment: str, validate_sql: str | None) -> None: ui.success(f"Validation passed: {validate_sql} keeps every dependency intact.") -@main.command(name="diff") +@main.command(name="diff", cls=JsonCommand) @click.argument("environment") +@click.option("--json", "json_output", is_flag=True, help="Emit a versioned JSON document") @click.option( "--snapshot-dir", "-s", type=click.Path(exists=True), help="Path to a snapshot directory to compare against. Defaults to latest snapshot.", ) -def diff_cmd(environment: str, snapshot_dir: str | None) -> None: +def diff_cmd(environment: str, snapshot_dir: str | None, json_output: bool) -> None: """Detect schema drift between local snapshot and live database. Compares the most recent snapshot (or a specified one) against the live @@ -919,10 +958,13 @@ def diff_cmd(environment: str, snapshot_dir: str | None) -> None: snapshots_base = Path.cwd() / "migrations" / "sql" / "snapshots" dirs = sorted(snapshots_base.iterdir()) if snapshots_base.exists() else [] if not dirs: + if json_output: + command_failure(f"No snapshots found. Run `ch-migrate snapshot {environment}` first.") ui.fail("No snapshots found.", f"Run `ch-migrate snapshot {environment}` first.") snap_path = dirs[-1] - ui.step(f"Comparing snapshot {snap_path.name} with {environment} ({database})") + if not json_output: + ui.step(f"Comparing snapshot {snap_path.name} with {environment} ({database})") # Load local schema from snapshot files local_schema = Schema(database=database) @@ -971,13 +1013,21 @@ def diff_cmd(environment: str, snapshot_dir: str | None) -> None: # Get live schema try: client = get_client(env_config) - live_schema = get_live_schema(client, database) + try: + live_schema = get_live_schema(client, database) + finally: + client.close() except Exception as e: + if json_output: + command_failure(f"Error connecting to {environment}: {e}") ui.fail(f"Could not read the live schema from {environment}: {e}") # Compare diffs = compare_schemas(local_schema, live_schema) - render_diff_report(diffs) + if json_output: + emit_json("diff", diff_document(diffs)) + else: + render_diff_report(diffs) if any(d.status != DiffStatus.IN_SYNC for d in diffs): ui.hint( diff --git a/ch_migrate/json_output.py b/ch_migrate/json_output.py new file mode 100644 index 0000000..801c7db --- /dev/null +++ b/ch_migrate/json_output.py @@ -0,0 +1,152 @@ +"""Versioned CLI documents; stdout contains only JSON in machine-readable mode.""" + +from __future__ import annotations + +import json +import sys +from contextlib import redirect_stdout +from typing import Any, NoReturn + +import click + +from ch_migrate.diff import DiffStatus, SchemaDiff +from ch_migrate.downgrade import irreversible_reason +from ch_migrate.lint import GATE_RULES, LintReport, Severity +from ch_migrate.rebase import RevisionGraph + + +class JsonCommand(click.Command): + """Keep diagnostics off stdout and return a document for command errors.""" + + def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]: + json_requested = "--json" in args + try: + return super().parse_args(ctx, args) + except click.ClickException as error: + if not json_requested: + raise + emit_json(self.name or "", {"error": error.format_message()}) + raise click.exceptions.Exit(2) from error + + def invoke(self, ctx: click.Context) -> Any: + if not ctx.params.get("json_output"): + return super().invoke(ctx) + ctx.meta["json_stdout"] = sys.stdout + with redirect_stdout(sys.stderr): + try: + return super().invoke(ctx) + except click.exceptions.Exit: + raise + except Exception as error: + message = ( + error.format_message() + if isinstance(error, click.ClickException) + else str(error) + ) + emit_json(self.name or "", {"error": message}) + raise click.exceptions.Exit(_error_exit(self.name)) from error + + +def emit_json(command: str, payload: dict[str, Any]) -> None: + """Write one schema-versioned document to the caller's original stdout.""" + ctx = click.get_current_context(silent=True) + stream = ctx.meta.get("json_stdout") if ctx else None + document = {"schema_version": 1, "command": command, **payload} + click.echo(json.dumps(document, ensure_ascii=False, allow_nan=False), file=stream) + + +def command_failure(message: str) -> NoReturn: + """Preserve human failure behavior while giving JSON callers a real error.""" + ctx = click.get_current_context() + if ctx.params.get("json_output"): + emit_json(ctx.command.name or "", {"error": message}) + raise click.exceptions.Exit(_error_exit(ctx.command.name)) + click.echo(message, err=True) + raise click.exceptions.Exit(1) + + +def status_document(graph: RevisionGraph, heads: set[str], database: str) -> dict[str, Any]: + applied = set() + for head in heads: + if head in graph.migrations: + applied.update(graph.walk_to_root(head)) + applied.intersection_update(graph.migrations) + script_heads = set(graph.heads()) + return { + "database": database, + "current_heads": sorted(heads), + "script_heads": sorted(script_heads), + "pending": sorted(set(graph.migrations) - applied), + "applied": sorted(applied), + "at_head": heads == script_heads, + } + + +def history_document(graph: RevisionGraph, applied: set[str] | None) -> dict[str, Any]: + return { + "revisions": [ + { + "revision": migration.revision, + "down_revisions": list(migration.down_revisions), + "description": migration.description, + "create_date": migration.create_date, + "path": str(migration.path), + "applied": migration.revision in applied if applied is not None else None, + "irreversible": irreversible_reason(graph, migration.revision), + } + for migration in graph.migrations.values() + ] + } + + +def lint_document(report: LintReport) -> dict[str, Any]: + findings = [ + { + "rule": result.rule, + "severity": result.severity.value, + "blocking": result.rule in GATE_RULES and result.severity == Severity.ERROR, + "file": result.file, + "line": result.line, + "message": result.message, + "waived": result.waived, + } + for result in report.results + ] + return { + "findings": findings, + "counts": { + "total": len(findings), + "error": report.error_count, + "warning": report.warning_count, + "info": report.info_count, + "blocking": sum(finding["blocking"] for finding in findings), + "waived": sum(finding["waived"] is not None for finding in findings), + }, + } + + +def diff_document(diffs: list[SchemaDiff]) -> dict[str, Any]: + return { + "objects": [ + { + "type": item.obj_type, + "name": item.name, + "status": item.status.value, + "details": [ + { + "field": detail.field_name, + "local": detail.local_value, + "remote": detail.remote_value, + "message": detail.message, + } + for detail in item.field_diffs + ], + } + for item in diffs + ], + "in_sync": all(item.status == DiffStatus.IN_SYNC for item in diffs), + } + + +def _error_exit(command: str | None) -> int: + return 1 if command == "lint" else 2 diff --git a/ch_migrate/lint.py b/ch_migrate/lint.py index a0efddb..b2b9f13 100644 --- a/ch_migrate/lint.py +++ b/ch_migrate/lint.py @@ -39,6 +39,7 @@ class LintResult: file: str | None = None line: int | None = None statement: str | None = None + waived: str | None = None @dataclass @@ -392,7 +393,17 @@ def check(self, sql: str, **kwargs: Any) -> list[LintResult]: "ch-migrate: allow-non-idempotent waiver" ) first_line = sql.strip().splitlines()[0] if sql.strip() else "" - return [LintResult(self.name, message, severity, kwargs.get("file_path"), 1, first_line)] + return [ + LintResult( + self.name, + message, + severity, + kwargs.get("file_path"), + 1, + first_line, + waived=reason or None, + ) + ] class StandaloneSetRule(LintRule): diff --git a/docs/schemas/diff.schema.json b/docs/schemas/diff.schema.json new file mode 100644 index 0000000..19d79f1 --- /dev/null +++ b/docs/schemas/diff.schema.json @@ -0,0 +1,102 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "diff.schema.json", + "title": "ch-migrate diff schema version 1", + "type": "object", + "required": [ + "schema_version", + "command" + ], + "properties": { + "schema_version": { + "const": 1 + }, + "command": { + "const": "diff" + }, + "error": { + "type": "string" + }, + "objects": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type": { + "enum": [ + "table", + "view", + "materialized_view", + "dictionary" + ] + }, + "name": { + "type": "string" + }, + "status": { + "enum": [ + "in_sync", + "modified", + "local_only", + "remote_only" + ] + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "field": { + "type": "string" + }, + "local": { + "type": [ + "string", + "null" + ] + }, + "remote": { + "type": [ + "string", + "null" + ] + }, + "message": { + "type": "string" + } + }, + "required": [ + "field", + "local", + "remote", + "message" + ] + } + } + }, + "required": [ + "type", + "name", + "status", + "details" + ] + } + }, + "in_sync": { + "type": "boolean" + } + }, + "anyOf": [ + { + "required": [ + "error" + ] + }, + { + "required": [ + "objects", + "in_sync" + ] + } + ] +} diff --git a/docs/schemas/history.schema.json b/docs/schemas/history.schema.json new file mode 100644 index 0000000..75db349 --- /dev/null +++ b/docs/schemas/history.schema.json @@ -0,0 +1,87 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "history.schema.json", + "title": "ch-migrate history schema version 1", + "type": "object", + "required": [ + "schema_version", + "command" + ], + "properties": { + "schema_version": { + "const": 1 + }, + "command": { + "const": "history" + }, + "error": { + "type": "string" + }, + "revisions": { + "type": "array", + "items": { + "type": "object", + "properties": { + "revision": { + "type": "string" + }, + "down_revisions": { + "type": "array", + "items": { + "type": "string" + }, + "uniqueItems": true + }, + "description": { + "type": [ + "string", + "null" + ] + }, + "create_date": { + "type": [ + "string", + "null" + ] + }, + "path": { + "type": "string" + }, + "applied": { + "type": [ + "boolean", + "null" + ] + }, + "irreversible": { + "type": [ + "string", + "null" + ] + } + }, + "required": [ + "revision", + "down_revisions", + "description", + "create_date", + "path", + "applied", + "irreversible" + ] + } + } + }, + "anyOf": [ + { + "required": [ + "error" + ] + }, + { + "required": [ + "revisions" + ] + } + ] +} diff --git a/docs/schemas/lint.schema.json b/docs/schemas/lint.schema.json new file mode 100644 index 0000000..8bea30c --- /dev/null +++ b/docs/schemas/lint.schema.json @@ -0,0 +1,124 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "lint.schema.json", + "title": "ch-migrate lint schema version 1", + "type": "object", + "required": [ + "schema_version", + "command" + ], + "properties": { + "schema_version": { + "const": 1 + }, + "command": { + "const": "lint" + }, + "error": { + "type": "string" + }, + "findings": { + "type": "array", + "items": { + "type": "object", + "properties": { + "rule": { + "type": "string" + }, + "severity": { + "enum": [ + "error", + "warn", + "info", + "off" + ] + }, + "blocking": { + "type": "boolean" + }, + "file": { + "type": [ + "string", + "null" + ] + }, + "line": { + "type": [ + "integer", + "null" + ], + "minimum": 1 + }, + "message": { + "type": "string" + }, + "waived": { + "type": [ + "string", + "null" + ] + } + }, + "required": [ + "rule", + "severity", + "blocking", + "file", + "line", + "message", + "waived" + ] + } + }, + "counts": { + "type": "object", + "properties": { + "total": { + "type": "integer", + "minimum": 0 + }, + "error": { + "type": "integer", + "minimum": 0 + }, + "warning": { + "type": "integer", + "minimum": 0 + }, + "info": { + "type": "integer", + "minimum": 0 + }, + "blocking": { + "type": "integer", + "minimum": 0 + }, + "waived": { + "type": "integer", + "minimum": 0 + } + }, + "required": [ + "total", + "error", + "warning", + "info", + "blocking", + "waived" + ] + } + }, + "anyOf": [ + { + "required": [ + "error" + ] + }, + { + "required": [ + "findings", + "counts" + ] + } + ] +} diff --git a/docs/schemas/status.schema.json b/docs/schemas/status.schema.json new file mode 100644 index 0000000..5e5d6c8 --- /dev/null +++ b/docs/schemas/status.schema.json @@ -0,0 +1,72 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "status.schema.json", + "title": "ch-migrate status schema version 1", + "type": "object", + "required": [ + "schema_version", + "command" + ], + "properties": { + "schema_version": { + "const": 1 + }, + "command": { + "const": "status" + }, + "error": { + "type": "string" + }, + "database": { + "type": "string" + }, + "current_heads": { + "type": "array", + "items": { + "type": "string" + }, + "uniqueItems": true + }, + "script_heads": { + "type": "array", + "items": { + "type": "string" + }, + "uniqueItems": true + }, + "pending": { + "type": "array", + "items": { + "type": "string" + }, + "uniqueItems": true + }, + "applied": { + "type": "array", + "items": { + "type": "string" + }, + "uniqueItems": true + }, + "at_head": { + "type": "boolean" + } + }, + "anyOf": [ + { + "required": [ + "error" + ] + }, + { + "required": [ + "database", + "current_heads", + "script_heads", + "pending", + "applied", + "at_head" + ] + } + ] +} diff --git a/pyproject.toml b/pyproject.toml index 389d5ee..609dff9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -50,6 +50,7 @@ dev = [ "isort>=5.12.0", "mypy>=1.5.0", "types-PyYAML", + "jsonschema>=4.18", ] [build-system] @@ -74,6 +75,7 @@ dev = [ "isort>=5.12.0", "mypy>=1.5.0", "types-PyYAML", + "jsonschema>=4.18", ] [tool.black] diff --git a/tests/integration/test_json_commands.py b/tests/integration/test_json_commands.py new file mode 100644 index 0000000..7219955 --- /dev/null +++ b/tests/integration/test_json_commands.py @@ -0,0 +1,105 @@ +"""Versioned documents from actual commands against the owned ClickHouse fixture.""" + +import json +import subprocess +import sys +from pathlib import Path + +import pytest +from jsonschema import Draft202012Validator + +pytestmark = pytest.mark.integration +SCHEMAS = Path(__file__).parents[2] / "docs" / "schemas" + + +def test_json_commands_follow_live_migration_and_drift_state(project): + # One project deliberately follows pending -> applied -> drift transitions. + project.write_revision( + "aaaa", + { + "upgrade": 'op.execute(f"CREATE TABLE IF NOT EXISTS {db}.events (id UInt64) ENGINE = MergeTree ORDER BY id")' + }, + ) + project.write_revision( + "bbbb", + {"upgrade": 'op.execute(f"ALTER TABLE {db}.events ADD COLUMN IF NOT EXISTS extra String")'}, + "aaaa", + ) + result, pending = _document(project, "status") + assert result.exit_code == 1 and pending["pending"] == ["aaaa", "bbbb"] + result, lint = _document(project, "lint") + assert result.exit_code == 0 and lint["counts"]["blocking"] == 0 + upgraded = project.run("up", "it") + assert upgraded.exit_code == 0, upgraded.output + result, status = _document(project, "status") + assert result.exit_code == 0 and status["at_head"] + assert status["current_heads"] == ["bbbb"] + assert status["applied"] == ["aaaa", "bbbb"] + result, history = _document(project, "history") + assert result.exit_code == 0 + assert {item["revision"] for item in history["revisions"] if item["applied"]} == { + "aaaa", + "bbbb", + } + snapshot = project.run("snapshot", "it") + assert snapshot.exit_code == 0, snapshot.output + result, before = _document(project, "diff") + assert result.exit_code == 0 and before["in_sync"], result.output + project.client.command( + f"ALTER TABLE {project.database}.events ADD COLUMN outside_migrations UInt32" + ) + result, after = _document(project, "diff") + assert result.exit_code == 1 and not after["in_sync"] + event = next(item for item in after["objects"] if item["name"] == "events") + assert event["status"] == "modified" + assert any("outside_migrations" in detail["field"] for detail in event["details"]) + _jq_status(project) + + +def test_json_live_lint_exposes_waiver_and_blocking_statement(project): + project.write_revision( + "aaaa", + { + "upgrade": """ + # ch-migrate: allow-non-idempotent Operator reconciles this one-time insert + op.execute(f"INSERT INTO {db}.events SELECT 1") + op.execute(f"CREATE TABLE {db}.events (id UInt64) ENGINE = Memory") + """ + }, + ) + result, document = _document(project, "lint") + assert result.exit_code == 1 + findings = [item for item in document["findings"] if item["rule"] == "idempotency"] + assert any( + item["waived"] == "Operator reconciles this one-time insert" and not item["blocking"] + for item in findings + ) + assert any(item["blocking"] and item["waived"] is None for item in findings) + + +def _document(project, command): + result = project.run(command, "it", "--json") + document = json.loads(result.stdout) + schema = json.loads((SCHEMAS / f"{command}.schema.json").read_text()) + Draft202012Validator(schema).validate(document) + return result, document + + +def _jq_status(project): + result = subprocess.run( + [ + "bash", + "-o", + "pipefail", + "-c", + '"$1" -m ch_migrate.cli status it --json | jq -e .current_heads', + "json-smoke", + sys.executable, + ], + cwd=project.root, + capture_output=True, + text=True, + timeout=30, + ) + assert result.returncode == 0, result.stderr + assert json.loads(result.stdout) == ["bbbb"] diff --git a/tests/test_json_output.py b/tests/test_json_output.py new file mode 100644 index 0000000..c4b972d --- /dev/null +++ b/tests/test_json_output.py @@ -0,0 +1,198 @@ +"""CLI JSON contracts: graph meaning, error exits, waivers, and structural drift.""" + +import json +from pathlib import Path +from unittest.mock import MagicMock + +import pytest +from click.testing import CliRunner +from jsonschema import Draft202012Validator + +from ch_migrate.cli import main +from ch_migrate.connection import MigrationState +from ch_migrate.introspect import Schema, parse_create_statement +from ch_migrate.version_table import VersionTableState + +SCHEMAS = Path(__file__).parents[1] / "docs" / "schemas" + + +@pytest.fixture +def json_project(tmp_path, monkeypatch): + runner = CliRunner() + assert runner.invoke(main, ["init", str(tmp_path)]).exit_code == 0 + monkeypatch.chdir(tmp_path) + monkeypatch.setattr( + "ch_migrate.cli.get_env_config", lambda *args: {"database": "example"} + ) + state = {"heads": set(), "error": None} + + def read_state(config): + if state["error"]: + raise OSError(state["error"]) + return MigrationState(state["heads"], VersionTableState("example", "Atomic")) + + monkeypatch.setattr("ch_migrate.connection.get_migration_state", read_state) + return tmp_path, state + + +@pytest.fixture +def revision_project(json_project): + root, state = json_project + versions = root / "migrations" / "versions" + _revision(versions / "root.py", None, 'irreversible = "Removed historical rows"') + _revision(versions / "left.py", "root") + _revision(versions / "right.py", "root") + _revision(versions / "merged.py", ("left", "right")) + return root, state + + +@pytest.mark.parametrize( + "heads,applied,pending,exit_code", + [ + (set(), [], ["left", "merged", "right", "root"], 1), + ({"merged"}, ["left", "merged", "right", "root"], [], 0), + ({"right"}, ["right", "root"], ["left", "merged"], 1), + ({"foreign"}, [], ["left", "merged", "right", "root"], 1), + ({"root", "merged"}, ["left", "merged", "right", "root"], [], 1), + ], +) +def test_status_json_resolves_graph(revision_project, heads, applied, pending, exit_code): + # Pytest's parameterization is the public test contract, not a runtime API. + revision_project[1]["heads"] = heads + result, document = _run("status", "dev", "--json") + assert result.exit_code == exit_code, result.output + assert document["current_heads"] == sorted(heads) + assert document["script_heads"] == ["merged"] + assert document["applied"] == applied + assert document["pending"] == pending + assert document["at_head"] is (exit_code == 0) + assert document["database"] == "example" + + +def test_history_json_preserves_merge_and_irreversibility(revision_project): + revision_project[1]["heads"] = {"merged"} + result, document = _run("history", "dev", "--json") + assert result.exit_code == 0 + revisions = {item["revision"]: item for item in document["revisions"]} + assert revisions["merged"]["down_revisions"] == ["left", "right"] + assert revisions["root"]["irreversible"] == "Removed historical rows" + assert revisions["left"]["irreversible"] is None + assert all(item["applied"] is True for item in revisions.values()) + assert revisions["root"]["description"] == "Migration root" + assert revisions["root"]["create_date"] == "2026-10-02 12:00:00" + assert Path(revisions["root"]["path"]).name == "root.py" + + +@pytest.mark.parametrize("command", ["status", "history"]) +def test_revision_json_database_error_is_not_empty_success(revision_project, command): + revision_project[1]["error"] = "database unavailable" + result, document = _run(command, "dev", "--json") + assert result.exit_code == 2 + assert "database unavailable" in document["error"] + if command == "history": + assert all(item["applied"] is None for item in document["revisions"]) + else: + assert "at_head" not in document + human = CliRunner().invoke(main, [command, "dev"]) + assert human.exit_code == 0 + + +def test_history_json_unknown_head_does_not_claim_unapplied(revision_project): + revision_project[1]["heads"] = {"foreign"} + result, document = _run("history", "dev", "--json") + assert result.exit_code == 0 + assert all(item["applied"] is None for item in document["revisions"]) + assert "foreign" in result.stderr + + +@pytest.mark.parametrize("command", ["status", "history", "lint", "diff"]) +def test_json_config_errors_are_documents(json_project, monkeypatch, command): + def fail_config(*args): + raise ValueError("environment is not configured") + + monkeypatch.setattr("ch_migrate.cli.get_env_config", fail_config) + result, document = _run(command, "missing", "--json") + assert result.exit_code == (1 if command == "lint" else 2) + assert "environment is not configured" in document["error"] + + +def test_lint_json_reports_gate_and_waiver_reason(json_project): + root, _ = json_project + sql = root / "migrations" / "sql" / "sample.up.sql" + sql.write_text( + "CREATE TABLE unsafe (id UInt64) ENGINE = MergeTree ORDER BY id;\n" + "-- ch-migrate: allow-non-idempotent Copy is manually reconciled before retry\n" + "INSERT INTO unsafe SELECT 1;\n" + ) + _revision( + root / "migrations" / "versions" / "sample.py", + None, + "from ch_migrate import run_sql\ndef upgrade():\n run_sql('sample.up.sql')\n", + ) + result, document = _run("lint", "--json") + assert result.exit_code == 1 + gate = [item for item in document["findings"] if item["rule"] == "idempotency"] + assert [(item["blocking"], item["waived"]) for item in gate] == [ + (True, None), + (False, "Copy is manually reconciled before retry"), + ] + assert [item["line"] for item in gate] == [1, 3] + assert all(item["file"].endswith("sample.up.sql") for item in gate) + assert document["counts"]["blocking"] == 1 + assert document["counts"]["waived"] == 1 + assert document["counts"]["error"] == 1 + assert CliRunner().invoke(main, ["lint"]).exit_code == result.exit_code + + +@pytest.mark.parametrize("drift", [False, True]) +def test_diff_json_reports_structural_changes(json_project, monkeypatch, drift): + root, _ = json_project + snapshot = root / "snapshot" / "tables" + snapshot.mkdir(parents=True) + before = "CREATE TABLE example.events (id UInt64) ENGINE = MergeTree ORDER BY id" + (snapshot / "events.sql").write_text(before) + live = Schema(database="example") + after = before.replace("id UInt64", "id UInt64, extra String") if drift else before + live.tables["events"] = parse_create_statement(after) + client = MagicMock() + monkeypatch.setattr("ch_migrate.connection.get_client", lambda config: client) + monkeypatch.setattr("ch_migrate.introspect.get_live_schema", lambda *args: live) + result, document = _run("diff", "dev", "--json", "--snapshot-dir", str(snapshot.parent)) + assert result.exit_code == int(drift), result.output + assert document["in_sync"] is (not drift) + item = document["objects"][0] + assert item["name"] == "events" and item["type"] == "table" + assert item["status"] == ("modified" if drift else "in_sync") + if drift: + assert any("extra" in detail["field"] for detail in item["details"]) + else: + assert item["details"] == [] + + +def test_diff_json_no_snapshot_returns_error(json_project): + result, document = _run("diff", "dev", "--json") + assert result.exit_code == 2 + assert "snapshot" in document["error"].lower() + assert "in_sync" not in document + + +def test_json_invalid_option_value_is_parseable(json_project): + result, document = _run("diff", "dev", "--json", "--snapshot-dir", "missing") + assert result.exit_code == 2 + assert "missing" in document["error"] + + +def _revision(path, parents, body=""): + path.write_text( + f'"""Migration {path.stem}\n\nCreate Date: 2026-10-02 12:00:00\n"""\n' + f"revision = {path.stem!r}\ndown_revision = {parents!r}\n{body}\n" + ) + + +def _run(*args): + result = CliRunner().invoke(main, list(args)) + document = json.loads(result.stdout) + schema = json.loads((SCHEMAS / f"{args[0]}.schema.json").read_text()) + Draft202012Validator.check_schema(schema) + Draft202012Validator(schema).validate(document) + return result, document diff --git a/uv.lock b/uv.lock index c88a6a1..3672c60 100644 --- a/uv.lock +++ b/uv.lock @@ -1,9 +1,10 @@ version = 1 -revision = 3 +revision = 5 requires-python = ">=3.10" resolution-markers = [ "python_full_version >= '3.14'", - "python_full_version < '3.14'", + "python_full_version >= '3.11' and python_full_version < '3.14'", + "python_full_version < '3.11'", ] [[package]] @@ -21,6 +22,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/3f/27/78a89b55b0904d222183164e079b4ca56208e94eff1d35ad1f1ad5be9b06/alembic-1.20.0-py3-none-any.whl", hash = "sha256:77eb101048d95f982c0353e9233404889dcd7a6fc244c107836c0e2fc9cf7d9d", size = 268719, upload-time = "2026-09-11T19:09:12.88Z" }, ] +[[package]] +name = "attrs" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, +] + [[package]] name = "backports-zstd" version = "1.7.0" @@ -204,6 +214,7 @@ dependencies = [ dev = [ { name = "black" }, { name = "isort" }, + { name = "jsonschema" }, { name = "mypy" }, { name = "pytest" }, { name = "pytest-cov" }, @@ -217,6 +228,7 @@ postgres = [ dev = [ { name = "black" }, { name = "isort" }, + { name = "jsonschema" }, { name = "mypy" }, { name = "pytest" }, { name = "pytest-cov" }, @@ -231,6 +243,7 @@ requires-dist = [ { name = "click", specifier = ">=8.1.0" }, { name = "clickhouse-connect", extras = ["alembic"], specifier = ">=1.9" }, { name = "isort", marker = "extra == 'dev'", specifier = ">=5.12.0" }, + { name = "jsonschema", marker = "extra == 'dev'", specifier = ">=4.18" }, { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.5.0" }, { name = "psycopg2-binary", marker = "extra == 'postgres'", specifier = ">=2.9.0" }, { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.4.0" }, @@ -247,6 +260,7 @@ provides-extras = ["dev", "postgres"] dev = [ { name = "black", specifier = ">=23.0.0" }, { name = "isort", specifier = ">=5.12.0" }, + { name = "jsonschema", specifier = ">=4.18" }, { name = "mypy", specifier = ">=1.5.0" }, { name = "pytest", specifier = ">=7.4.0" }, { name = "pytest-cov", specifier = ">=4.1.0" }, @@ -553,6 +567,34 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256, upload-time = "2022-06-17T18:00:10.251Z" }, ] +[[package]] +name = "jsonschema" +version = "4.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py", version = "0.30.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "rpds-py", version = "2026.9.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + [[package]] name = "lz4" version = "4.4.5" @@ -1026,6 +1068,21 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, ] +[[package]] +name = "referencing" +version = "0.37.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py", version = "0.30.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "rpds-py", version = "2026.9.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, +] + [[package]] name = "rich" version = "15.0.0" @@ -1039,6 +1096,270 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" }, ] +[[package]] +name = "rpds-py" +version = "0.30.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/06/0c/0c411a0ec64ccb6d104dcabe0e713e05e153a9a2c3c2bd2b32ce412166fe/rpds_py-0.30.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:679ae98e00c0e8d68a7fda324e16b90fd5260945b45d3b824c892cec9eea3288", size = 370490, upload-time = "2025-11-30T20:21:33.256Z" }, + { url = "https://files.pythonhosted.org/packages/19/6a/4ba3d0fb7297ebae71171822554abe48d7cab29c28b8f9f2c04b79988c05/rpds_py-0.30.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4cc2206b76b4f576934f0ed374b10d7ca5f457858b157ca52064bdfc26b9fc00", size = 359751, upload-time = "2025-11-30T20:21:34.591Z" }, + { url = "https://files.pythonhosted.org/packages/cd/7c/e4933565ef7f7a0818985d87c15d9d273f1a649afa6a52ea35ad011195ea/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:389a2d49eded1896c3d48b0136ead37c48e221b391c052fba3f4055c367f60a6", size = 389696, upload-time = "2025-11-30T20:21:36.122Z" }, + { url = "https://files.pythonhosted.org/packages/5e/01/6271a2511ad0815f00f7ed4390cf2567bec1d4b1da39e2c27a41e6e3b4de/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:32c8528634e1bf7121f3de08fa85b138f4e0dc47657866630611b03967f041d7", size = 403136, upload-time = "2025-11-30T20:21:37.728Z" }, + { url = "https://files.pythonhosted.org/packages/55/64/c857eb7cd7541e9b4eee9d49c196e833128a55b89a9850a9c9ac33ccf897/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f207f69853edd6f6700b86efb84999651baf3789e78a466431df1331608e5324", size = 524699, upload-time = "2025-11-30T20:21:38.92Z" }, + { url = "https://files.pythonhosted.org/packages/9c/ed/94816543404078af9ab26159c44f9e98e20fe47e2126d5d32c9d9948d10a/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:67b02ec25ba7a9e8fa74c63b6ca44cf5707f2fbfadae3ee8e7494297d56aa9df", size = 412022, upload-time = "2025-11-30T20:21:40.407Z" }, + { url = "https://files.pythonhosted.org/packages/61/b5/707f6cf0066a6412aacc11d17920ea2e19e5b2f04081c64526eb35b5c6e7/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0e95f6819a19965ff420f65578bacb0b00f251fefe2c8b23347c37174271f3", size = 390522, upload-time = "2025-11-30T20:21:42.17Z" }, + { url = "https://files.pythonhosted.org/packages/13/4e/57a85fda37a229ff4226f8cbcf09f2a455d1ed20e802ce5b2b4a7f5ed053/rpds_py-0.30.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:a452763cc5198f2f98898eb98f7569649fe5da666c2dc6b5ddb10fde5a574221", size = 404579, upload-time = "2025-11-30T20:21:43.769Z" }, + { url = "https://files.pythonhosted.org/packages/f9/da/c9339293513ec680a721e0e16bf2bac3db6e5d7e922488de471308349bba/rpds_py-0.30.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e0b65193a413ccc930671c55153a03ee57cecb49e6227204b04fae512eb657a7", size = 421305, upload-time = "2025-11-30T20:21:44.994Z" }, + { url = "https://files.pythonhosted.org/packages/f9/be/522cb84751114f4ad9d822ff5a1aa3c98006341895d5f084779b99596e5c/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:858738e9c32147f78b3ac24dc0edb6610000e56dc0f700fd5f651d0a0f0eb9ff", size = 572503, upload-time = "2025-11-30T20:21:46.91Z" }, + { url = "https://files.pythonhosted.org/packages/a2/9b/de879f7e7ceddc973ea6e4629e9b380213a6938a249e94b0cdbcc325bb66/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:da279aa314f00acbb803da1e76fa18666778e8a8f83484fba94526da5de2cba7", size = 598322, upload-time = "2025-11-30T20:21:48.709Z" }, + { url = "https://files.pythonhosted.org/packages/48/ac/f01fc22efec3f37d8a914fc1b2fb9bcafd56a299edbe96406f3053edea5a/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7c64d38fb49b6cdeda16ab49e35fe0da2e1e9b34bc38bd78386530f218b37139", size = 560792, upload-time = "2025-11-30T20:21:50.024Z" }, + { url = "https://files.pythonhosted.org/packages/e2/da/4e2b19d0f131f35b6146425f846563d0ce036763e38913d917187307a671/rpds_py-0.30.0-cp310-cp310-win32.whl", hash = "sha256:6de2a32a1665b93233cde140ff8b3467bdb9e2af2b91079f0333a0974d12d464", size = 221901, upload-time = "2025-11-30T20:21:51.32Z" }, + { url = "https://files.pythonhosted.org/packages/96/cb/156d7a5cf4f78a7cc571465d8aec7a3c447c94f6749c5123f08438bcf7bc/rpds_py-0.30.0-cp310-cp310-win_amd64.whl", hash = "sha256:1726859cd0de969f88dc8673bdd954185b9104e05806be64bcd87badbe313169", size = 235823, upload-time = "2025-11-30T20:21:52.505Z" }, + { url = "https://files.pythonhosted.org/packages/4d/6e/f964e88b3d2abee2a82c1ac8366da848fce1c6d834dc2132c3fda3970290/rpds_py-0.30.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a2bffea6a4ca9f01b3f8e548302470306689684e61602aa3d141e34da06cf425", size = 370157, upload-time = "2025-11-30T20:21:53.789Z" }, + { url = "https://files.pythonhosted.org/packages/94/ba/24e5ebb7c1c82e74c4e4f33b2112a5573ddc703915b13a073737b59b86e0/rpds_py-0.30.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc4f992dfe1e2bc3ebc7444f6c7051b4bc13cd8e33e43511e8ffd13bf407010d", size = 359676, upload-time = "2025-11-30T20:21:55.475Z" }, + { url = "https://files.pythonhosted.org/packages/84/86/04dbba1b087227747d64d80c3b74df946b986c57af0a9f0c98726d4d7a3b/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:422c3cb9856d80b09d30d2eb255d0754b23e090034e1deb4083f8004bd0761e4", size = 389938, upload-time = "2025-11-30T20:21:57.079Z" }, + { url = "https://files.pythonhosted.org/packages/42/bb/1463f0b1722b7f45431bdd468301991d1328b16cffe0b1c2918eba2c4eee/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07ae8a593e1c3c6b82ca3292efbe73c30b61332fd612e05abee07c79359f292f", size = 402932, upload-time = "2025-11-30T20:21:58.47Z" }, + { url = "https://files.pythonhosted.org/packages/99/ee/2520700a5c1f2d76631f948b0736cdf9b0acb25abd0ca8e889b5c62ac2e3/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12f90dd7557b6bd57f40abe7747e81e0c0b119bef015ea7726e69fe550e394a4", size = 525830, upload-time = "2025-11-30T20:21:59.699Z" }, + { url = "https://files.pythonhosted.org/packages/e0/ad/bd0331f740f5705cc555a5e17fdf334671262160270962e69a2bdef3bf76/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:99b47d6ad9a6da00bec6aabe5a6279ecd3c06a329d4aa4771034a21e335c3a97", size = 412033, upload-time = "2025-11-30T20:22:00.991Z" }, + { url = "https://files.pythonhosted.org/packages/f8/1e/372195d326549bb51f0ba0f2ecb9874579906b97e08880e7a65c3bef1a99/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33f559f3104504506a44bb666b93a33f5d33133765b0c216a5bf2f1e1503af89", size = 390828, upload-time = "2025-11-30T20:22:02.723Z" }, + { url = "https://files.pythonhosted.org/packages/ab/2b/d88bb33294e3e0c76bc8f351a3721212713629ffca1700fa94979cb3eae8/rpds_py-0.30.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:946fe926af6e44f3697abbc305ea168c2c31d3e3ef1058cf68f379bf0335a78d", size = 404683, upload-time = "2025-11-30T20:22:04.367Z" }, + { url = "https://files.pythonhosted.org/packages/50/32/c759a8d42bcb5289c1fac697cd92f6fe01a018dd937e62ae77e0e7f15702/rpds_py-0.30.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:495aeca4b93d465efde585977365187149e75383ad2684f81519f504f5c13038", size = 421583, upload-time = "2025-11-30T20:22:05.814Z" }, + { url = "https://files.pythonhosted.org/packages/2b/81/e729761dbd55ddf5d84ec4ff1f47857f4374b0f19bdabfcf929164da3e24/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9a0ca5da0386dee0655b4ccdf46119df60e0f10da268d04fe7cc87886872ba7", size = 572496, upload-time = "2025-11-30T20:22:07.713Z" }, + { url = "https://files.pythonhosted.org/packages/14/f6/69066a924c3557c9c30baa6ec3a0aa07526305684c6f86c696b08860726c/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8d6d1cc13664ec13c1b84241204ff3b12f9bb82464b8ad6e7a5d3486975c2eed", size = 598669, upload-time = "2025-11-30T20:22:09.312Z" }, + { url = "https://files.pythonhosted.org/packages/5f/48/905896b1eb8a05630d20333d1d8ffd162394127b74ce0b0784ae04498d32/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3896fa1be39912cf0757753826bc8bdc8ca331a28a7c4ae46b7a21280b06bb85", size = 561011, upload-time = "2025-11-30T20:22:11.309Z" }, + { url = "https://files.pythonhosted.org/packages/22/16/cd3027c7e279d22e5eb431dd3c0fbc677bed58797fe7581e148f3f68818b/rpds_py-0.30.0-cp311-cp311-win32.whl", hash = "sha256:55f66022632205940f1827effeff17c4fa7ae1953d2b74a8581baaefb7d16f8c", size = 221406, upload-time = "2025-11-30T20:22:13.101Z" }, + { url = "https://files.pythonhosted.org/packages/fa/5b/e7b7aa136f28462b344e652ee010d4de26ee9fd16f1bfd5811f5153ccf89/rpds_py-0.30.0-cp311-cp311-win_amd64.whl", hash = "sha256:a51033ff701fca756439d641c0ad09a41d9242fa69121c7d8769604a0a629825", size = 236024, upload-time = "2025-11-30T20:22:14.853Z" }, + { url = "https://files.pythonhosted.org/packages/14/a6/364bba985e4c13658edb156640608f2c9e1d3ea3c81b27aa9d889fff0e31/rpds_py-0.30.0-cp311-cp311-win_arm64.whl", hash = "sha256:47b0ef6231c58f506ef0b74d44e330405caa8428e770fec25329ed2cb971a229", size = 229069, upload-time = "2025-11-30T20:22:16.577Z" }, + { url = "https://files.pythonhosted.org/packages/03/e7/98a2f4ac921d82f33e03f3835f5bf3a4a40aa1bfdc57975e74a97b2b4bdd/rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad", size = 375086, upload-time = "2025-11-30T20:22:17.93Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a1/bca7fd3d452b272e13335db8d6b0b3ecde0f90ad6f16f3328c6fb150c889/rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05", size = 359053, upload-time = "2025-11-30T20:22:19.297Z" }, + { url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28", size = 390763, upload-time = "2025-11-30T20:22:21.661Z" }, + { url = "https://files.pythonhosted.org/packages/d4/36/eb2eb8515e2ad24c0bd43c3ee9cd74c33f7ca6430755ccdb240fd3144c44/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd", size = 408951, upload-time = "2025-11-30T20:22:23.408Z" }, + { url = "https://files.pythonhosted.org/packages/d6/65/ad8dc1784a331fabbd740ef6f71ce2198c7ed0890dab595adb9ea2d775a1/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f", size = 514622, upload-time = "2025-11-30T20:22:25.16Z" }, + { url = "https://files.pythonhosted.org/packages/63/8e/0cfa7ae158e15e143fe03993b5bcd743a59f541f5952e1546b1ac1b5fd45/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1", size = 414492, upload-time = "2025-11-30T20:22:26.505Z" }, + { url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23", size = 394080, upload-time = "2025-11-30T20:22:27.934Z" }, + { url = "https://files.pythonhosted.org/packages/6d/d5/a266341051a7a3ca2f4b750a3aa4abc986378431fc2da508c5034d081b70/rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6", size = 408680, upload-time = "2025-11-30T20:22:29.341Z" }, + { url = "https://files.pythonhosted.org/packages/10/3b/71b725851df9ab7a7a4e33cf36d241933da66040d195a84781f49c50490c/rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51", size = 423589, upload-time = "2025-11-30T20:22:31.469Z" }, + { url = "https://files.pythonhosted.org/packages/00/2b/e59e58c544dc9bd8bd8384ecdb8ea91f6727f0e37a7131baeff8d6f51661/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5", size = 573289, upload-time = "2025-11-30T20:22:32.997Z" }, + { url = "https://files.pythonhosted.org/packages/da/3e/a18e6f5b460893172a7d6a680e86d3b6bc87a54c1f0b03446a3c8c7b588f/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e", size = 599737, upload-time = "2025-11-30T20:22:34.419Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e2/714694e4b87b85a18e2c243614974413c60aa107fd815b8cbc42b873d1d7/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394", size = 563120, upload-time = "2025-11-30T20:22:35.903Z" }, + { url = "https://files.pythonhosted.org/packages/6f/ab/d5d5e3bcedb0a77f4f613706b750e50a5a3ba1c15ccd3665ecc636c968fd/rpds_py-0.30.0-cp312-cp312-win32.whl", hash = "sha256:1ab5b83dbcf55acc8b08fc62b796ef672c457b17dbd7820a11d6c52c06839bdf", size = 223782, upload-time = "2025-11-30T20:22:37.271Z" }, + { url = "https://files.pythonhosted.org/packages/39/3b/f786af9957306fdc38a74cef405b7b93180f481fb48453a114bb6465744a/rpds_py-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:a090322ca841abd453d43456ac34db46e8b05fd9b3b4ac0c78bcde8b089f959b", size = 240463, upload-time = "2025-11-30T20:22:39.021Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d2/b91dc748126c1559042cfe41990deb92c4ee3e2b415f6b5234969ffaf0cc/rpds_py-0.30.0-cp312-cp312-win_arm64.whl", hash = "sha256:669b1805bd639dd2989b281be2cfd951c6121b65e729d9b843e9639ef1fd555e", size = 230868, upload-time = "2025-11-30T20:22:40.493Z" }, + { url = "https://files.pythonhosted.org/packages/ed/dc/d61221eb88ff410de3c49143407f6f3147acf2538c86f2ab7ce65ae7d5f9/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2", size = 374887, upload-time = "2025-11-30T20:22:41.812Z" }, + { url = "https://files.pythonhosted.org/packages/fd/32/55fb50ae104061dbc564ef15cc43c013dc4a9f4527a1f4d99baddf56fe5f/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8", size = 358904, upload-time = "2025-11-30T20:22:43.479Z" }, + { url = "https://files.pythonhosted.org/packages/58/70/faed8186300e3b9bdd138d0273109784eea2396c68458ed580f885dfe7ad/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4", size = 389945, upload-time = "2025-11-30T20:22:44.819Z" }, + { url = "https://files.pythonhosted.org/packages/bd/a8/073cac3ed2c6387df38f71296d002ab43496a96b92c823e76f46b8af0543/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136", size = 407783, upload-time = "2025-11-30T20:22:46.103Z" }, + { url = "https://files.pythonhosted.org/packages/77/57/5999eb8c58671f1c11eba084115e77a8899d6e694d2a18f69f0ba471ec8b/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7", size = 515021, upload-time = "2025-11-30T20:22:47.458Z" }, + { url = "https://files.pythonhosted.org/packages/e0/af/5ab4833eadc36c0a8ed2bc5c0de0493c04f6c06de223170bd0798ff98ced/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2", size = 414589, upload-time = "2025-11-30T20:22:48.872Z" }, + { url = "https://files.pythonhosted.org/packages/b7/de/f7192e12b21b9e9a68a6d0f249b4af3fdcdff8418be0767a627564afa1f1/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6", size = 394025, upload-time = "2025-11-30T20:22:50.196Z" }, + { url = "https://files.pythonhosted.org/packages/91/c4/fc70cd0249496493500e7cc2de87504f5aa6509de1e88623431fec76d4b6/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e", size = 408895, upload-time = "2025-11-30T20:22:51.87Z" }, + { url = "https://files.pythonhosted.org/packages/58/95/d9275b05ab96556fefff73a385813eb66032e4c99f411d0795372d9abcea/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d", size = 422799, upload-time = "2025-11-30T20:22:53.341Z" }, + { url = "https://files.pythonhosted.org/packages/06/c1/3088fc04b6624eb12a57eb814f0d4997a44b0d208d6cace713033ff1a6ba/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7", size = 572731, upload-time = "2025-11-30T20:22:54.778Z" }, + { url = "https://files.pythonhosted.org/packages/d8/42/c612a833183b39774e8ac8fecae81263a68b9583ee343db33ab571a7ce55/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31", size = 599027, upload-time = "2025-11-30T20:22:56.212Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/525a50f45b01d70005403ae0e25f43c0384369ad24ffe46e8d9068b50086/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95", size = 563020, upload-time = "2025-11-30T20:22:58.2Z" }, + { url = "https://files.pythonhosted.org/packages/0b/5d/47c4655e9bcd5ca907148535c10e7d489044243cc9941c16ed7cd53be91d/rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d", size = 223139, upload-time = "2025-11-30T20:23:00.209Z" }, + { url = "https://files.pythonhosted.org/packages/f2/e1/485132437d20aa4d3e1d8b3fb5a5e65aa8139f1e097080c2a8443201742c/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15", size = 240224, upload-time = "2025-11-30T20:23:02.008Z" }, + { url = "https://files.pythonhosted.org/packages/24/95/ffd128ed1146a153d928617b0ef673960130be0009c77d8fbf0abe306713/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1", size = 230645, upload-time = "2025-11-30T20:23:03.43Z" }, + { url = "https://files.pythonhosted.org/packages/ff/1b/b10de890a0def2a319a2626334a7f0ae388215eb60914dbac8a3bae54435/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a", size = 364443, upload-time = "2025-11-30T20:23:04.878Z" }, + { url = "https://files.pythonhosted.org/packages/0d/bf/27e39f5971dc4f305a4fb9c672ca06f290f7c4e261c568f3dea16a410d47/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e", size = 353375, upload-time = "2025-11-30T20:23:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/40/58/442ada3bba6e8e6615fc00483135c14a7538d2ffac30e2d933ccf6852232/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000", size = 383850, upload-time = "2025-11-30T20:23:07.825Z" }, + { url = "https://files.pythonhosted.org/packages/14/14/f59b0127409a33c6ef6f5c1ebd5ad8e32d7861c9c7adfa9a624fc3889f6c/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db", size = 392812, upload-time = "2025-11-30T20:23:09.228Z" }, + { url = "https://files.pythonhosted.org/packages/b3/66/e0be3e162ac299b3a22527e8913767d869e6cc75c46bd844aa43fb81ab62/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2", size = 517841, upload-time = "2025-11-30T20:23:11.186Z" }, + { url = "https://files.pythonhosted.org/packages/3d/55/fa3b9cf31d0c963ecf1ba777f7cf4b2a2c976795ac430d24a1f43d25a6ba/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa", size = 408149, upload-time = "2025-11-30T20:23:12.864Z" }, + { url = "https://files.pythonhosted.org/packages/60/ca/780cf3b1a32b18c0f05c441958d3758f02544f1d613abf9488cd78876378/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083", size = 383843, upload-time = "2025-11-30T20:23:14.638Z" }, + { url = "https://files.pythonhosted.org/packages/82/86/d5f2e04f2aa6247c613da0c1dd87fcd08fa17107e858193566048a1e2f0a/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9", size = 396507, upload-time = "2025-11-30T20:23:16.105Z" }, + { url = "https://files.pythonhosted.org/packages/4b/9a/453255d2f769fe44e07ea9785c8347edaf867f7026872e76c1ad9f7bed92/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0", size = 414949, upload-time = "2025-11-30T20:23:17.539Z" }, + { url = "https://files.pythonhosted.org/packages/a3/31/622a86cdc0c45d6df0e9ccb6becdba5074735e7033c20e401a6d9d0e2ca0/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94", size = 565790, upload-time = "2025-11-30T20:23:19.029Z" }, + { url = "https://files.pythonhosted.org/packages/1c/5d/15bbf0fb4a3f58a3b1c67855ec1efcc4ceaef4e86644665fff03e1b66d8d/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08", size = 590217, upload-time = "2025-11-30T20:23:20.885Z" }, + { url = "https://files.pythonhosted.org/packages/6d/61/21b8c41f68e60c8cc3b2e25644f0e3681926020f11d06ab0b78e3c6bbff1/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27", size = 555806, upload-time = "2025-11-30T20:23:22.488Z" }, + { url = "https://files.pythonhosted.org/packages/f9/39/7e067bb06c31de48de3eb200f9fc7c58982a4d3db44b07e73963e10d3be9/rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6", size = 211341, upload-time = "2025-11-30T20:23:24.449Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4d/222ef0b46443cf4cf46764d9c630f3fe4abaa7245be9417e56e9f52b8f65/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d", size = 225768, upload-time = "2025-11-30T20:23:25.908Z" }, + { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0", size = 362099, upload-time = "2025-11-30T20:23:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be", size = 353192, upload-time = "2025-11-30T20:23:29.151Z" }, + { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f", size = 384080, upload-time = "2025-11-30T20:23:30.785Z" }, + { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f", size = 394841, upload-time = "2025-11-30T20:23:32.209Z" }, + { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87", size = 516670, upload-time = "2025-11-30T20:23:33.742Z" }, + { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18", size = 408005, upload-time = "2025-11-30T20:23:35.253Z" }, + { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad", size = 382112, upload-time = "2025-11-30T20:23:36.842Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07", size = 399049, upload-time = "2025-11-30T20:23:38.343Z" }, + { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f", size = 415661, upload-time = "2025-11-30T20:23:40.263Z" }, + { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65", size = 565606, upload-time = "2025-11-30T20:23:42.186Z" }, + { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f", size = 591126, upload-time = "2025-11-30T20:23:44.086Z" }, + { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53", size = 553371, upload-time = "2025-11-30T20:23:46.004Z" }, + { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed", size = 215298, upload-time = "2025-11-30T20:23:47.696Z" }, + { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950", size = 228604, upload-time = "2025-11-30T20:23:49.501Z" }, + { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6", size = 222391, upload-time = "2025-11-30T20:23:50.96Z" }, + { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb", size = 364868, upload-time = "2025-11-30T20:23:52.494Z" }, + { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8", size = 353747, upload-time = "2025-11-30T20:23:54.036Z" }, + { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7", size = 383795, upload-time = "2025-11-30T20:23:55.556Z" }, + { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898", size = 393330, upload-time = "2025-11-30T20:23:57.033Z" }, + { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e", size = 518194, upload-time = "2025-11-30T20:23:58.637Z" }, + { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419", size = 408340, upload-time = "2025-11-30T20:24:00.2Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551", size = 383765, upload-time = "2025-11-30T20:24:01.759Z" }, + { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8", size = 396834, upload-time = "2025-11-30T20:24:03.687Z" }, + { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5", size = 415470, upload-time = "2025-11-30T20:24:05.232Z" }, + { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404", size = 565630, upload-time = "2025-11-30T20:24:06.878Z" }, + { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856", size = 591148, upload-time = "2025-11-30T20:24:08.445Z" }, + { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" }, + { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" }, + { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" }, + { url = "https://files.pythonhosted.org/packages/69/71/3f34339ee70521864411f8b6992e7ab13ac30d8e4e3309e07c7361767d91/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c2262bdba0ad4fc6fb5545660673925c2d2a5d9e2e0fb603aad545427be0fc58", size = 372292, upload-time = "2025-11-30T20:24:16.537Z" }, + { url = "https://files.pythonhosted.org/packages/57/09/f183df9b8f2d66720d2ef71075c59f7e1b336bec7ee4c48f0a2b06857653/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ee6af14263f25eedc3bb918a3c04245106a42dfd4f5c2285ea6f997b1fc3f89a", size = 362128, upload-time = "2025-11-30T20:24:18.086Z" }, + { url = "https://files.pythonhosted.org/packages/7a/68/5c2594e937253457342e078f0cc1ded3dd7b2ad59afdbf2d354869110a02/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3adbb8179ce342d235c31ab8ec511e66c73faa27a47e076ccc92421add53e2bb", size = 391542, upload-time = "2025-11-30T20:24:20.092Z" }, + { url = "https://files.pythonhosted.org/packages/49/5c/31ef1afd70b4b4fbdb2800249f34c57c64beb687495b10aec0365f53dfc4/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:250fa00e9543ac9b97ac258bd37367ff5256666122c2d0f2bc97577c60a1818c", size = 404004, upload-time = "2025-11-30T20:24:22.231Z" }, + { url = "https://files.pythonhosted.org/packages/e3/63/0cfbea38d05756f3440ce6534d51a491d26176ac045e2707adc99bb6e60a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9854cf4f488b3d57b9aaeb105f06d78e5529d3145b1e4a41750167e8c213c6d3", size = 527063, upload-time = "2025-11-30T20:24:24.302Z" }, + { url = "https://files.pythonhosted.org/packages/42/e6/01e1f72a2456678b0f618fc9a1a13f882061690893c192fcad9f2926553a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:993914b8e560023bc0a8bf742c5f303551992dcb85e247b1e5c7f4a7d145bda5", size = 413099, upload-time = "2025-11-30T20:24:25.916Z" }, + { url = "https://files.pythonhosted.org/packages/b8/25/8df56677f209003dcbb180765520c544525e3ef21ea72279c98b9aa7c7fb/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58edca431fb9b29950807e301826586e5bbf24163677732429770a697ffe6738", size = 392177, upload-time = "2025-11-30T20:24:27.834Z" }, + { url = "https://files.pythonhosted.org/packages/4a/b4/0a771378c5f16f8115f796d1f437950158679bcd2a7c68cf251cfb00ed5b/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:dea5b552272a944763b34394d04577cf0f9bd013207bc32323b5a89a53cf9c2f", size = 406015, upload-time = "2025-11-30T20:24:29.457Z" }, + { url = "https://files.pythonhosted.org/packages/36/d8/456dbba0af75049dc6f63ff295a2f92766b9d521fa00de67a2bd6427d57a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ba3af48635eb83d03f6c9735dfb21785303e73d22ad03d489e88adae6eab8877", size = 423736, upload-time = "2025-11-30T20:24:31.22Z" }, + { url = "https://files.pythonhosted.org/packages/13/64/b4d76f227d5c45a7e0b796c674fd81b0a6c4fbd48dc29271857d8219571c/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:dff13836529b921e22f15cb099751209a60009731a68519630a24d61f0b1b30a", size = 573981, upload-time = "2025-11-30T20:24:32.934Z" }, + { url = "https://files.pythonhosted.org/packages/20/91/092bacadeda3edf92bf743cc96a7be133e13a39cdbfd7b5082e7ab638406/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:1b151685b23929ab7beec71080a8889d4d6d9fa9a983d213f07121205d48e2c4", size = 599782, upload-time = "2025-11-30T20:24:35.169Z" }, + { url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e", size = 562191, upload-time = "2025-11-30T20:24:36.853Z" }, +] + +[[package]] +name = "rpds-py" +version = "2026.9.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.14'", + "python_full_version >= '3.11' and python_full_version < '3.14'", +] +sdist = { url = "https://files.pythonhosted.org/packages/42/68/3bd46b8a5e01d3c2ebdf9c5e9497912e3fe0cde02bac21a7130ca866e403/rpds_py-2026.9.1.tar.gz", hash = "sha256:4793ef7f78268b124b73fa933440f01d258bbae01de9fa53e9080c9ab0425a12", size = 63948, upload-time = "2026-10-04T16:32:36.469Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f5/6d/ddb8dfcf41892ba9c672d27988592c038d30db61708230313831b6780a1b/rpds_py-2026.9.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:2711d29b653b3bce48a63d18b9c6b53274669e6d6c4094dddeb4d9a0e45128b2", size = 344947, upload-time = "2026-10-04T16:28:55.207Z" }, + { url = "https://files.pythonhosted.org/packages/9e/b2/632c3d034961149eff606e3e357547620a9ab37b849ae5815f67838753fd/rpds_py-2026.9.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3231c4c0e521dafa5be0c9f114ee2c2ad46650836f2d72caa86801950c3e7044", size = 346770, upload-time = "2026-10-04T16:28:56.884Z" }, + { url = "https://files.pythonhosted.org/packages/6d/45/4df346410bb873d03ec60c3b891d1fceb8cabde1971d29844bbb625cc296/rpds_py-2026.9.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e01b3c878c8641913e688edd1b3f08658c6783d29cf6b826bd3c0d1ae7a1ffaa", size = 377795, upload-time = "2026-10-04T16:28:58.193Z" }, + { url = "https://files.pythonhosted.org/packages/ba/b8/a70f302207e4f29f873c01a986fcac5def49b9c8224328cef1ad7da6b7a9/rpds_py-2026.9.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3e524c7874ac72884d28e16dd5b8d839fd09e0fe76b020d3fbca23212a7b8c52", size = 383137, upload-time = "2026-10-04T16:28:59.411Z" }, + { url = "https://files.pythonhosted.org/packages/13/e3/3aa28a48a01169d0e20728bf0e5ebbea3ae2774285b40853ae49b3ef332a/rpds_py-2026.9.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:761fdae6728ceb99ab182fad2f0cc1e262f610834dc891aea1d1a2a2e634776f", size = 496789, upload-time = "2026-10-04T16:29:01.011Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a7/414e8d088602d66ad6f47c65bf07fe5090992a8574cdd4571c1a83b647ed/rpds_py-2026.9.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6b723eb406dec5bc9ec516c73ab9c3239a3284e017f7eb89ee2b3258bd504fb7", size = 395929, upload-time = "2026-10-04T16:29:02.465Z" }, + { url = "https://files.pythonhosted.org/packages/2d/5c/aac3b960fd55d37b49f77c0eebbe043eaf36762ebd48e7b46951e59c1c05/rpds_py-2026.9.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:136a1c3fe4402b7008bc81cb62ee538481795b61a7e83df88dff3b3f02b726ff", size = 375426, upload-time = "2026-10-04T16:29:03.944Z" }, + { url = "https://files.pythonhosted.org/packages/d3/80/77987a41c40be7202a78d9aed4a650bfb05792237cfd3b9e22638d990fe5/rpds_py-2026.9.1-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:839dde845559254f34885267c6878f60d61d5205180226d976fe488d45fa128e", size = 381497, upload-time = "2026-10-04T16:29:05.308Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d0/640b02eb1ecd71a913c1178b6235287b31006266bca9a26862e80e497b54/rpds_py-2026.9.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:56cd8b3f77d7b6812f533b662186a1f28316931166ddc00fb893b1b0db7e9888", size = 405740, upload-time = "2026-10-04T16:29:06.578Z" }, + { url = "https://files.pythonhosted.org/packages/3e/8c/d034195d45d215625a23f2ae85dbbdb86a49a93a51272061c97c80b9d316/rpds_py-2026.9.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:074a4d198bc34d9a8ea425114fc3ded6d11ec01f6a314a8db67454a5152d8834", size = 555850, upload-time = "2026-10-04T16:29:08.115Z" }, + { url = "https://files.pythonhosted.org/packages/de/f8/532f1addfc86207bc3cf23749638bb0d457bce891595012ed8a08d0543b8/rpds_py-2026.9.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:6beb738155fe8ab8091afdfa5a3226b21c2b1593f1e50ebb90eb25b44dbc0391", size = 618661, upload-time = "2026-10-04T16:29:09.554Z" }, + { url = "https://files.pythonhosted.org/packages/50/5b/b0f2c9833a36a5b1f6ac5cb0e635fabacf713266f46ceefba2102da0bf51/rpds_py-2026.9.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:57492a550a1d88d29d003247e5f78dd8cf04a701fac0e4c8db8745a6d2504e0a", size = 583530, upload-time = "2026-10-04T16:29:11.072Z" }, + { url = "https://files.pythonhosted.org/packages/bf/20/464ed4b98d3c8c6a334f3b5e24d3886de04b05658a95fc40a37e0e6e4775/rpds_py-2026.9.1-cp311-cp311-win32.whl", hash = "sha256:d95a354e02393eada6d7351184671aced9d4cce109dabf927cb7aa99624352a1", size = 208125, upload-time = "2026-10-04T16:29:12.408Z" }, + { url = "https://files.pythonhosted.org/packages/df/c9/384a9b62f8cd89c8e3e609b8c9052c140e8c01d807261e0517c904b8bf29/rpds_py-2026.9.1-cp311-cp311-win_amd64.whl", hash = "sha256:ce4d4f52e2a4324396caddbd45a97d8d7be5f42edd25d2355282a9c34f9b2f7f", size = 226045, upload-time = "2026-10-04T16:29:13.751Z" }, + { url = "https://files.pythonhosted.org/packages/4f/3b/0a691f0dcb2301fa9c736346da2d0d4991778373283301c5c12b8f952f3d/rpds_py-2026.9.1-cp311-cp311-win_arm64.whl", hash = "sha256:fdcd198979b4ecffcc1beba366a7fbcf4eb41243691a82fe52ceb0b902f09c12", size = 222636, upload-time = "2026-10-04T16:29:14.989Z" }, + { url = "https://files.pythonhosted.org/packages/5d/34/a828586ea3329fbb50895b50e9cf98ca3d924a9f41a0b26d443bff1b3794/rpds_py-2026.9.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:50906f5aea24b5a865cbd0a589698288631d9f3a54c3a937c83aefa95a0d14af", size = 346822, upload-time = "2026-10-04T16:29:16.258Z" }, + { url = "https://files.pythonhosted.org/packages/90/81/ac6a0d064982251856ce009c9e1dd51a34110b3c055aa7d1aad18b4899a3/rpds_py-2026.9.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e21c1429e205828ea886a2293a4a2c8e01f4c25d9893ca330e97a6cf73f52e7b", size = 341380, upload-time = "2026-10-04T16:29:17.706Z" }, + { url = "https://files.pythonhosted.org/packages/42/ff/bf7d54f362748fd6a49277b9d6531c394074110fedf50ad791ec59133fbb/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2693b2728bbcc48d09a981a356954b0c47c53ff25b545856f28a889ea619f69a", size = 373053, upload-time = "2026-10-04T16:29:19.063Z" }, + { url = "https://files.pythonhosted.org/packages/60/de/74b0ccdbbd28687b9b5fdb34c1cabed88352182facaced9d6f5486b8b9ed/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8601470267d938bcb7f3ab1a336100af51a4fd5b6ed030ef52461bb3ef5e7e07", size = 377742, upload-time = "2026-10-04T16:29:20.543Z" }, + { url = "https://files.pythonhosted.org/packages/c2/6d/b979775a3057b2a5c26d75ecbff60a20a24ef081db6dd76836fca3f20247/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3890a6aa36e6baa53d5258a2a25d3ef8b37ad165a6ab27a892d7c3e3a432cd69", size = 487289, upload-time = "2026-10-04T16:29:21.958Z" }, + { url = "https://files.pythonhosted.org/packages/1d/5d/7c34734ce3ece943d9d6ee0122a74a21bbc75b47acb5b7053c83f6efb1ed/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6b5b393eda5ea42cca1c1a6665f2a4882b4fd5d1777e41ce0545a107fb008c9d", size = 390710, upload-time = "2026-10-04T16:29:23.378Z" }, + { url = "https://files.pythonhosted.org/packages/1d/6d/b26eb1e75395925b3a142ed351cbed2ec8212f5c9d937aee3df32c701baa/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:addeda51556dac7c1a2f14cda62db8b621cd12afba3091d03a96c72932387eab", size = 371261, upload-time = "2026-10-04T16:29:25.1Z" }, + { url = "https://files.pythonhosted.org/packages/7c/98/b2fdfe10301a9e27af21e634337fbba7baac0bc17fe44619a17c26bba2cb/rpds_py-2026.9.1-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:d9edf30457d74eebfd76b045535e36f1cd89062566a128a0db2145ca042d787e", size = 376075, upload-time = "2026-10-04T16:29:26.748Z" }, + { url = "https://files.pythonhosted.org/packages/c5/b1/c4b8d954e49c3c69cf8063c0c9e0919c99f3d2cecc46311606a1cbe835dc/rpds_py-2026.9.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:815d26356930846a40c7bc1366e7b1b0320ab8a063e66c11298a208bed0fd237", size = 399358, upload-time = "2026-10-04T16:29:28.282Z" }, + { url = "https://files.pythonhosted.org/packages/b3/59/9559a7293c97dff0cbb293efffbd36644103883ecc27741af8ef90c84ca8/rpds_py-2026.9.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3b5a6f40f0a1486b4b36c888123afc67acdbd9f33235927acf5ff295429a0ba3", size = 550267, upload-time = "2026-10-04T16:29:29.851Z" }, + { url = "https://files.pythonhosted.org/packages/6c/9d/6dc60e49511de4c8b00e74f9c1d43aed4d27f712cdb1ade92f2c199cbf64/rpds_py-2026.9.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b5b8b0753718d258fd454283fbd57e14545d3b40583fa672e27cb4f987626bcc", size = 614018, upload-time = "2026-10-04T16:29:31.54Z" }, + { url = "https://files.pythonhosted.org/packages/fb/bc/92a4ecf27301b886232a413360f6b348a81d55ffef654f2ebda5970ebc3d/rpds_py-2026.9.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:46d80bc76b51a6c24f9944368c28d38b8bcbcea1da4f2f8d3ebc31a67e8c6ec6", size = 578509, upload-time = "2026-10-04T16:29:33.01Z" }, + { url = "https://files.pythonhosted.org/packages/08/53/efb97f2e6589b7ab8394385a73870e0b2ab2a195281c117b21fd6d7d4855/rpds_py-2026.9.1-cp312-cp312-win32.whl", hash = "sha256:befc2d6a953e563f8a7bfd87a42c22ebf8a3e980dcb7b6a4d17b70b0e914e8a3", size = 205401, upload-time = "2026-10-04T16:29:34.451Z" }, + { url = "https://files.pythonhosted.org/packages/1c/84/1700cc748d0eaa747486e4e82882d2575224e6e9a3148df583058850c629/rpds_py-2026.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:5ce8943f79c2210f7abcc28e86367b03b28d95027fd01c46d2472373ae70c86f", size = 222923, upload-time = "2026-10-04T16:29:35.709Z" }, + { url = "https://files.pythonhosted.org/packages/c3/89/0302215373c2f8b4408b0fdfee955368cc378a98ff59508d47a7e0dc2dbf/rpds_py-2026.9.1-cp312-cp312-win_arm64.whl", hash = "sha256:501909f2e4a1e2dee528ef766fe3c469060ebc17e54a8383d404ba07a81a6f02", size = 218415, upload-time = "2026-10-04T16:29:37.263Z" }, + { url = "https://files.pythonhosted.org/packages/83/ea/ee88fd9e756ff93fb6b1182a47ec09504a242620e33ce1d20679efefe841/rpds_py-2026.9.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:a36b70596407634ca82d4b989a3729074a008537a0522e4c8046a67c729103e9", size = 346229, upload-time = "2026-10-04T16:29:38.82Z" }, + { url = "https://files.pythonhosted.org/packages/57/71/a097d6552f837500fc36e6b23d09cfb9890c3cc47531f9ca64e149799615/rpds_py-2026.9.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eba5d173f7d5708b22a93815017a4611873ed54db9f268077c0dd1ed99cfc858", size = 340514, upload-time = "2026-10-04T16:29:40.405Z" }, + { url = "https://files.pythonhosted.org/packages/bd/b7/497e85768bf4e0d8ddbaa096a4cac31d1509251dee2728a8490aa367e0b5/rpds_py-2026.9.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:457866b85daf5034296666168b84a69e0b2e89dc4f1af102b46f6448a60b9063", size = 372611, upload-time = "2026-10-04T16:29:41.778Z" }, + { url = "https://files.pythonhosted.org/packages/52/4b/74ab4108916250b6e198e0d3af05bc6835eb046315f22f7a0ceb49667c5a/rpds_py-2026.9.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a3a52a3ba86436ab3aef510fbe21512abc2ddd1993005dfe50514bd2284ef025", size = 377712, upload-time = "2026-10-04T16:29:43.242Z" }, + { url = "https://files.pythonhosted.org/packages/0c/8e/067e77d9d7b3cc793c9d909b7e97e7aadbbb1fb094093b6876902cc96d38/rpds_py-2026.9.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d7841166b7fa64c9c56404617ae4341448847482d45933b13135d26c130519e5", size = 488106, upload-time = "2026-10-04T16:29:44.692Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b4/c5aae6c2dde269bf955f6b7d35065c655a57e47750d9668052ad67e74dda/rpds_py-2026.9.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:926bdd3e3b5998ddf70cc64bc8cf57209571f9044542913afb673799fec77dd0", size = 390795, upload-time = "2026-10-04T16:29:46.129Z" }, + { url = "https://files.pythonhosted.org/packages/a0/36/76fab39973ee11e7f9f357c55138197bb01c86f6502cb76487e3b4f42db0/rpds_py-2026.9.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7868b85224291c6cb6759f9b5adb9745f486d226f62b16a614dd5a2a5ab2b35b", size = 370794, upload-time = "2026-10-04T16:29:47.603Z" }, + { url = "https://files.pythonhosted.org/packages/3d/fe/cd2a80e6d7b871937a60e935c5d507aa390d143f4ff3636f640b9733d5df/rpds_py-2026.9.1-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:3cd182d7291d29b92c521a0069d9c01ba6193628a9a105531d11b40a6d731a33", size = 375673, upload-time = "2026-10-04T16:29:49.223Z" }, + { url = "https://files.pythonhosted.org/packages/6c/18/7464a9953724e55a3b3206062fa0ffdeaa519584c6aabf65d3956d94f131/rpds_py-2026.9.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e6ea1cda8d8c688278430e4268a42f5e5da3bdd74578dfadc0820c3f1766ce83", size = 398758, upload-time = "2026-10-04T16:29:50.601Z" }, + { url = "https://files.pythonhosted.org/packages/c0/86/1534b436700fd49ff411063b7c4d7e938adfabf90895b6cf1622d5a7d1f6/rpds_py-2026.9.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5943980471829f6de242a20b109de3111ba6b77e3af0ffc587028ac854b05e6c", size = 550370, upload-time = "2026-10-04T16:29:52.002Z" }, + { url = "https://files.pythonhosted.org/packages/57/1c/e1fa82a8a01e3c5820f3ba98a8b2673f642128eb368fa88871b01dd2c909/rpds_py-2026.9.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:76d3af9732d2dab69f28179b40ba2d87e2f1d5824b4a694780aa787d685e8f36", size = 613106, upload-time = "2026-10-04T16:29:53.655Z" }, + { url = "https://files.pythonhosted.org/packages/29/55/b20b8c4c3dde8755bfcd5b08492a02d0cd2e26929aedf6199ca2a377d42a/rpds_py-2026.9.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:78326f4cb4427a56ba4996c0762b63be45f06b85f086526420d2b3a66e40f84d", size = 578235, upload-time = "2026-10-04T16:29:55.157Z" }, + { url = "https://files.pythonhosted.org/packages/55/42/df3f7bbc3f7ab37a8a9db8d6c2ff2c985422899f1f7926afbf7ec3c0b8b4/rpds_py-2026.9.1-cp313-cp313-win32.whl", hash = "sha256:172e47169583f46ce118cbec68e6795d0da0f4606b488b6434f8276bca0a058c", size = 205293, upload-time = "2026-10-04T16:29:56.669Z" }, + { url = "https://files.pythonhosted.org/packages/31/9c/ba5a9569d719bfdd6ce863df4133ac6a1658cf1b07cc3534c31db729fbbc/rpds_py-2026.9.1-cp313-cp313-win_amd64.whl", hash = "sha256:3e93b2cd69a9830be33e03945cd7cda940a0a8bfcfbff41d6144f0cb0d3d8bd9", size = 222409, upload-time = "2026-10-04T16:29:58.049Z" }, + { url = "https://files.pythonhosted.org/packages/35/72/f28ca566f6c23c35bbf7445f65eb0364577b25a026305995e24f78b83d94/rpds_py-2026.9.1-cp313-cp313-win_arm64.whl", hash = "sha256:d151e148117294133bf8af7eeace085e7e87432db15ab6adf640330298a47f6f", size = 217681, upload-time = "2026-10-04T16:29:59.449Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f2/67b94be1532767803415c1c5a1fd88ea487643d74a673cec1ba140af77bb/rpds_py-2026.9.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:c9d1aca01f49170fdcf5c92761b1fafe97f554b721ca4570c5949fff778f0d4b", size = 347178, upload-time = "2026-10-04T16:30:00.865Z" }, + { url = "https://files.pythonhosted.org/packages/04/37/b751de2b59b0197a1d92a5dd491de88e8a5e928c2e6562581974f1e85263/rpds_py-2026.9.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3f0e9ac28fc067d4d34b88ae43c48e9489455c97fee9633d851f7eeed5a05d35", size = 341878, upload-time = "2026-10-04T16:30:02.564Z" }, + { url = "https://files.pythonhosted.org/packages/72/e2/5873bc4643c250db9e05d48dc0c93763d4aa68bc3b81164cb1af3b45b284/rpds_py-2026.9.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:07deecbfce94c78473018bc7d10b337cc651d12df87a1eb2cb3e4024bc9c33d0", size = 373963, upload-time = "2026-10-04T16:30:04.026Z" }, + { url = "https://files.pythonhosted.org/packages/51/03/5acf7632158247f3f6386ff0af3a1ee48167d575037e8d0920594b76d92b/rpds_py-2026.9.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:821b2755db9194409254012f429c56643416fb96ef9be090be82ec8826b7f477", size = 377975, upload-time = "2026-10-04T16:30:05.555Z" }, + { url = "https://files.pythonhosted.org/packages/e6/00/63fda451b8bffa5808fc8bb311ee7c073b340974b09f273c7b2a145d3d62/rpds_py-2026.9.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3c91c210ae7645626c608400e3519b4a642f837cce09ca830db3beb2e9f274d4", size = 490347, upload-time = "2026-10-04T16:30:07.156Z" }, + { url = "https://files.pythonhosted.org/packages/a1/ae/c093ffd070ba0fb02f76c565d06fecc65ad6e4afdbae78f7031076d3cdac/rpds_py-2026.9.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:54ac2158a6f96cfbabff0b2eedaf94b90c5ec7ca8317fcadc61e1c2b2e0ff6ef", size = 392962, upload-time = "2026-10-04T16:30:08.77Z" }, + { url = "https://files.pythonhosted.org/packages/22/9d/d08a1128ab199b2f0cf25bfeb0639bd05119fff4b7c47bec24ef9a8ec23f/rpds_py-2026.9.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eac2f5dbafd585dfe31f86a23ebf0d3ba480a9d49ebc87947267b5608d4ea0cd", size = 371623, upload-time = "2026-10-04T16:30:10.501Z" }, + { url = "https://files.pythonhosted.org/packages/53/c7/4758ddcbb75609414bbccfcb11d612436f9b3ee821bd2f33f0f1604ee648/rpds_py-2026.9.1-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:8aa5dda18d39b6143eb24809d158f9252c88f402749b6f1b62a506cc7d96cc35", size = 376997, upload-time = "2026-10-04T16:30:12.124Z" }, + { url = "https://files.pythonhosted.org/packages/87/e4/947bd7f608ff60faf46dc9d389c3dffd0e3d767d78a0be19978448ef0ce7/rpds_py-2026.9.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5c90e7fa02e8f5de0d10c17595c568ada48c5302e749462c0ea1a4c362111a86", size = 400169, upload-time = "2026-10-04T16:30:13.804Z" }, + { url = "https://files.pythonhosted.org/packages/4b/35/fe93e020a0543b5670472c18d7e6af3197c08da571240ce1965c84f85c0f/rpds_py-2026.9.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e6d198bad4e49dd6732fbd636e2fc5c082f45c8cad0b4acb756b00c82c76072e", size = 551615, upload-time = "2026-10-04T16:30:15.332Z" }, + { url = "https://files.pythonhosted.org/packages/0d/4f/5d2a0136bb03b2a56a39dc6ff92d58a6e3e53a2e17079238b86228882f16/rpds_py-2026.9.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:96beca19ec79de272e8668585380ff9092c47077c1d7a1e098e00bbd921f4785", size = 614655, upload-time = "2026-10-04T16:30:16.92Z" }, + { url = "https://files.pythonhosted.org/packages/09/1c/3f1025aaf70d9bf7272cc41f8b64ee76b48bf01726248138430e16f23b38/rpds_py-2026.9.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5cf77eb04f20b720be95265a3e00eb2a14814074255cc27069c551b2db53118", size = 579602, upload-time = "2026-10-04T16:30:18.555Z" }, + { url = "https://files.pythonhosted.org/packages/53/0d/5c72e6204f76610608706da32b6b7e11ef7e10317558a7bb15a122e008dc/rpds_py-2026.9.1-cp314-cp314-win32.whl", hash = "sha256:a03d57b86d2a51d0a66c92177e2be154ad015f357791d306e714569999cdb4cc", size = 206315, upload-time = "2026-10-04T16:30:20.05Z" }, + { url = "https://files.pythonhosted.org/packages/a4/0b/489d48abbcc7d70cf3fbf662d9d22abf1f4650761c0a9ae05260800800d3/rpds_py-2026.9.1-cp314-cp314-win_amd64.whl", hash = "sha256:837c6b305e26fe0f75b15c92cf3b2ba29e0ae19dc40b1c557b026cb426347d0c", size = 222852, upload-time = "2026-10-04T16:30:21.604Z" }, + { url = "https://files.pythonhosted.org/packages/91/16/bbb05a7e6a10cf79ba639be7f799d770ee15f64175cc61d081b218dd402a/rpds_py-2026.9.1-cp314-cp314-win_arm64.whl", hash = "sha256:fce4b85234a0cbad67bf8e6e1201ee815d172c9aebad75f25645bc4d834f8e31", size = 218709, upload-time = "2026-10-04T16:30:23.036Z" }, + { url = "https://files.pythonhosted.org/packages/22/ac/ac507a0a4ec478ca470440a09583db4be5259ba7670aeba0620822f1e57a/rpds_py-2026.9.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:3a72c11530d71abfb66c8d7696a2f86c43e63fca8b948f1a784ac490f4ec688e", size = 349596, upload-time = "2026-10-04T16:30:24.558Z" }, + { url = "https://files.pythonhosted.org/packages/e9/f2/817a46b658d5070f477f722c298ee9a24525b0e4017347964146ef5fdd0e/rpds_py-2026.9.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:068c37bba854ec2fe42f7365c640af11dd9895890ccbf2df5070d0c059bd7f96", size = 343114, upload-time = "2026-10-04T16:30:26.048Z" }, + { url = "https://files.pythonhosted.org/packages/6c/42/6ade976b13ac1b4cb3bf2eb603f1be2fe74df19a29988d4c2b386be59d6f/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7fca4eb6df565e2a928f1c7dad92d27db8f9df0f449e76423ed5d7e713ed445", size = 374197, upload-time = "2026-10-04T16:30:27.699Z" }, + { url = "https://files.pythonhosted.org/packages/d9/70/77cdf1d3f1a07faabe936016ae623aec7981f73108a8fe7a203ed2e21998/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c933c6678c6f116ff8af47a4c6db0868b8ace74af0343016c0ef00f00272ea69", size = 378025, upload-time = "2026-10-04T16:30:29.451Z" }, + { url = "https://files.pythonhosted.org/packages/3f/6b/18a44a3beaa9b7931acb04af7bd9539836477c630a794452d4826d6185d4/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:028ad274ea951dac64491b5d1e65712a4aeabfdbdb9fccf797b57bd899b0c495", size = 491969, upload-time = "2026-10-04T16:30:30.995Z" }, + { url = "https://files.pythonhosted.org/packages/73/27/fb39cfd6bddaf741b024f813890374578ff8ac1f1adc473659c048b03b05/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:740d0a99cf9de0b17a3943388e9294a59becf75e7c43421f387bd3c7a9901f7c", size = 393905, upload-time = "2026-10-04T16:30:32.628Z" }, + { url = "https://files.pythonhosted.org/packages/ed/71/0fa7bb77b57af0d710273964180d11b503f62b8a5c358eb2d8c3f62feff6/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0da298fb372dc192610a4b9ecbc68a0cd8b675bbbd1fc519d01b41cfd658333e", size = 374569, upload-time = "2026-10-04T16:30:34.257Z" }, + { url = "https://files.pythonhosted.org/packages/54/22/f41cfac269af3b449513ef1bc3d7f32fde52abbbd2d01c7e76b47743acd9/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:eb61be926bb81567c1f48bdc8aa22b9855048dc2efd53871f9f7e6e9a5632346", size = 377482, upload-time = "2026-10-04T16:30:35.997Z" }, + { url = "https://files.pythonhosted.org/packages/b4/fc/312b49006e7f8f9ca5f96647577b8aa6f3df30519c46bd448f5c425af0b2/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:42e75466f83cd43f6026c81eab74246efb2bdadafb307b85700632d06c68f299", size = 400040, upload-time = "2026-10-04T16:30:37.76Z" }, + { url = "https://files.pythonhosted.org/packages/cf/a6/18cca7a878dc7fa95165a83343fd4d7b65643fd22e54e47340a451121d5c/rpds_py-2026.9.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:617f59cde379b4f648a09797b7f683d04b90a46344cddab85639da5aff0f5531", size = 551849, upload-time = "2026-10-04T16:30:39.443Z" }, + { url = "https://files.pythonhosted.org/packages/e4/6d/1f5685e20f39604691bdc3c05aaa6b8bd2f954e9e996477adf2376768e33/rpds_py-2026.9.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3edae8c5ddfdb6985d49ae9d150516e5076888879022f91a26c2de9276ce0bdb", size = 614842, upload-time = "2026-10-04T16:30:41.231Z" }, + { url = "https://files.pythonhosted.org/packages/c6/25/98652109fd9f7e10268dd4571aa52b81987001b806f37ef1a18260de714a/rpds_py-2026.9.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0f045bb053c9057720d72c56dffe30dffdc05997b2897a827b9325f0ab6623fa", size = 582606, upload-time = "2026-10-04T16:30:43.345Z" }, + { url = "https://files.pythonhosted.org/packages/19/03/11ca09099bab5f53373a80a334c424ec917c13d050760a59499d2af5171e/rpds_py-2026.9.1-cp314-cp314t-win32.whl", hash = "sha256:bf35d0568abda97233239ce32896d3ad53fccc537832c104e30c94aa5fb93569", size = 203341, upload-time = "2026-10-04T16:30:44.954Z" }, + { url = "https://files.pythonhosted.org/packages/6f/8a/88909e3ffd9f47f5b58211473875d8c3c09079f0058c46fb72c55a702a26/rpds_py-2026.9.1-cp314-cp314t-win_amd64.whl", hash = "sha256:1e8d4d79d828299bf44a55db22a9388ab967b49d17132c88eab0f4360b48da8e", size = 222843, upload-time = "2026-10-04T16:30:46.486Z" }, + { url = "https://files.pythonhosted.org/packages/f6/b7/a662f367d4896dd0a10cef2fc91f10b7f08af1c10858e287e019563f338d/rpds_py-2026.9.1-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:1d77b649e6f7cdf12ca5c2a98dad0ad37f9ea9b6f960408a92f0cb12bb3d04d9", size = 347463, upload-time = "2026-10-04T16:30:48.203Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3f/ad45d03df4f84ebae5439577ee81f3999d182711e82235c8037b6528890e/rpds_py-2026.9.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:00ba2d8c7dd4ee537978ddf4b3fbd712bef2d8751603f7f3146b3f4287768e25", size = 342051, upload-time = "2026-10-04T16:30:49.872Z" }, + { url = "https://files.pythonhosted.org/packages/7e/31/3dcd68c13d4bcc59c1f7eb33ac8e80698f06f3eb0d8a1e06419836071c20/rpds_py-2026.9.1-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec450527cbf485e13c8d3602a54f428ab0432fdade0ede75efd74b735421c871", size = 374143, upload-time = "2026-10-04T16:30:51.508Z" }, + { url = "https://files.pythonhosted.org/packages/cf/0d/68c1f058a250fbd1380ebda9fc227cbf50117adf8ffe8161ef383ea79f68/rpds_py-2026.9.1-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:306ee1850d8105b5baf977e78d45fcadd12c1a54678d614c9baf217708446e91", size = 378604, upload-time = "2026-10-04T16:30:53.206Z" }, + { url = "https://files.pythonhosted.org/packages/d7/d6/2d4c59b85397cb4800594fadf692688ccf5ce556adc930e7a5bf21061a5e/rpds_py-2026.9.1-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ef6b65b03247c54692ad4fd9ee97cb772781927db72e3cb05e70b3db6d1ff14f", size = 490790, upload-time = "2026-10-04T16:30:54.925Z" }, + { url = "https://files.pythonhosted.org/packages/da/04/7e05dc3aebaf52f4e026766bd668fdd09a9d0e23f64a14686b36b3501892/rpds_py-2026.9.1-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a575404ebc9cf2e91edd32eaf570ec1430eb900d4f56724ba7dd4bc1fc9c176d", size = 393146, upload-time = "2026-10-04T16:30:56.625Z" }, + { url = "https://files.pythonhosted.org/packages/57/ca/e2e9a0a46a74ed51a0498ba1fe10f4ea6b2d9a155f372a2f91e51f18cf10/rpds_py-2026.9.1-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c16ab111bc27c646ba8aa005d0527754edc538ebb636f0b1bf8e244b48d1945", size = 372022, upload-time = "2026-10-04T16:30:58.295Z" }, + { url = "https://files.pythonhosted.org/packages/ba/cb/8f8774df5134e23424372838bcc5c7ed4127d723e1ff52f7bebd4dcb2563/rpds_py-2026.9.1-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:7664419f27db41d4f1c43a78dccda7dd6e8ef2428df3ee01d0c2a07a6b071297", size = 377092, upload-time = "2026-10-04T16:30:59.984Z" }, + { url = "https://files.pythonhosted.org/packages/90/02/8d7095d73bf9114219be40230baa5df00611e0a82ed9517779ff9c19f82b/rpds_py-2026.9.1-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4b26b03d9d2658ee2fa234f8f4f19f38a09773fe5261028025032e26d4d35af0", size = 400830, upload-time = "2026-10-04T16:31:01.721Z" }, + { url = "https://files.pythonhosted.org/packages/ec/02/8206856f8f363cd042a8315dc86b3912f5dcb6d3c66bbb24b69c2bfb0775/rpds_py-2026.9.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:be3e47e2d91aa3942ff9bf4077a505226005abfc39b6f7554a91c1b9393986b9", size = 551478, upload-time = "2026-10-04T16:31:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/41/6b/36211f1bb1f0b0313f496d92f5905b74ea107f27cb16fa3355a82f04575e/rpds_py-2026.9.1-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:6307a0da524939decb8ca4a3933b8ab62525794411d6984fca6726e732804af6", size = 615173, upload-time = "2026-10-04T16:31:05.281Z" }, + { url = "https://files.pythonhosted.org/packages/35/77/cda0c4a6f055446b692f0ed5692f73707cafd3dff82672ede31b1a9b59de/rpds_py-2026.9.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:159a7aab5c5e8b112c8830f54717ce56da1252ebdbb526f5be2df2309280b9e7", size = 579653, upload-time = "2026-10-04T16:31:07.065Z" }, + { url = "https://files.pythonhosted.org/packages/74/ec/d8385f446240aed643b9e92a5055cff3015cc04a13c61f73b2883c478ed5/rpds_py-2026.9.1-cp315-cp315-win32.whl", hash = "sha256:dbc2673f9223d420c91145599b3ba45a8a50c207d1976908e5fb5ddb0c9b9429", size = 206498, upload-time = "2026-10-04T16:31:08.989Z" }, + { url = "https://files.pythonhosted.org/packages/6d/a5/71b5cd00e0521e3b6b81828baea368c62b6b700ebdd9554cd7d41ddf12fa/rpds_py-2026.9.1-cp315-cp315-win_amd64.whl", hash = "sha256:75c38c50ab9aca840225d9a9a3810bf11d04bd5c1f186cabbb8aee56db3e9b15", size = 223121, upload-time = "2026-10-04T16:31:10.84Z" }, + { url = "https://files.pythonhosted.org/packages/33/58/dba857c3bc8221b31b62eb170a3080f4f191de79f047200389b7ed1b06a7/rpds_py-2026.9.1-cp315-cp315-win_arm64.whl", hash = "sha256:a431156bb41865fc14cd5d79bb9d7bbed83110b0159e34e62ae30951f96c0009", size = 218741, upload-time = "2026-10-04T16:31:12.592Z" }, + { url = "https://files.pythonhosted.org/packages/5b/d0/320ab28ccc1415eeb509d68682b0014fb74690cd49f1c2d29a232475af50/rpds_py-2026.9.1-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:ef0d8c843e2827d6c120ab4687e9423fb1d893db1df27b7c1506615bcb9734a0", size = 349719, upload-time = "2026-10-04T16:31:14.48Z" }, + { url = "https://files.pythonhosted.org/packages/56/88/f5b12f1358f443c08b7ce3cc8391d82d335f4872580e2e097847fd36087a/rpds_py-2026.9.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:45bc6bccf78b20fd834237d18db64965d7ee68ba7f60440a26c7ab71e7b8d51a", size = 343267, upload-time = "2026-10-04T16:31:16.827Z" }, + { url = "https://files.pythonhosted.org/packages/f7/0c/c765b0059d532acb3b9c45d781ccc22f15a96dbe443d00903f643ba9df10/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d55198263bb51f557550c6ed2e6d1cb6a6fed6eb5c9120b741c5926bef8a45d", size = 374555, upload-time = "2026-10-04T16:31:18.931Z" }, + { url = "https://files.pythonhosted.org/packages/6b/8a/cafddfda77564a10cd21184640c3bffda6a2b8d20972fb5dedd5e0166328/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a8763f20692da7df39b0afdd1ba3042b004c50a45994f76c2d9a25641f7673db", size = 378346, upload-time = "2026-10-04T16:31:20.75Z" }, + { url = "https://files.pythonhosted.org/packages/b9/01/5e626016eff72c183bf6c96539240cace15d402468647a453ec08415b2fc/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e43d4a1f673e8a1cbd8533e809e02b4bf9d4f2280269bb640436556312121250", size = 492373, upload-time = "2026-10-04T16:31:22.614Z" }, + { url = "https://files.pythonhosted.org/packages/3b/9c/15a2469e9389242f46896b3f0a01d68caea8a5a35c011fcb05ef333aae73/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea394a937f17a54c51239348bdbe2e3518124c8d4a8951ba04a311d3095bd18f", size = 394371, upload-time = "2026-10-04T16:31:24.768Z" }, + { url = "https://files.pythonhosted.org/packages/63/f5/c100ff77e1e6366e947c75969c258fdfc4b7bc5bbfe7351e62ffbf2a1228/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdeaa99ce822dca76cfb1b993e9120c5ea212f2eb66d48950ad63c349668a018", size = 375132, upload-time = "2026-10-04T16:31:26.588Z" }, + { url = "https://files.pythonhosted.org/packages/dd/f4/fe0269c9de253e99c81cabc12b8971a5feaa083debdaff1221e06264d9e3/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:b4f062343e7ad3fa94f2c66e5ae667dee47ee74dd41a9057c4fbe163236a123d", size = 377642, upload-time = "2026-10-04T16:31:28.677Z" }, + { url = "https://files.pythonhosted.org/packages/05/65/b34a7b257baccff8f4a24a722933166d4941d5ebdc9c3f4bc4ffcd5ce4f4/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:22ffd29a63d71fb1b81552c21f2c2b734949b7ac751a9be70675a939a900839b", size = 400855, upload-time = "2026-10-04T16:31:30.802Z" }, + { url = "https://files.pythonhosted.org/packages/98/32/844e54176b6071b90b38a564e6940bc6eb8f97b2890dc709c19db9dec0f4/rpds_py-2026.9.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:08dae4a4095150a7c4545a1fb40b98e1ab1744fbc2770d92c977b9dadaa49ab6", size = 552573, upload-time = "2026-10-04T16:31:32.709Z" }, + { url = "https://files.pythonhosted.org/packages/17/73/6041d20729dffbfdf155c02d65be58bc225a1c1fb548fd87c23ef306138f/rpds_py-2026.9.1-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:9a0460d43603d1fd9ef59c30278531e15d78581721ddb538fa560aa7817ea4ad", size = 615840, upload-time = "2026-10-04T16:31:34.565Z" }, + { url = "https://files.pythonhosted.org/packages/af/9e/418094adaee6b056ce199051b255448ed872829051e341b2294c80da0977/rpds_py-2026.9.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:1c2d1f6da5128eabf34e963d7163a818846075a52568250d006c4c953b40f903", size = 582764, upload-time = "2026-10-04T16:31:36.665Z" }, + { url = "https://files.pythonhosted.org/packages/3d/9b/1698ebf6b840ddfe8b472198abbed6ace35c6e398faeecd6c47dae742a4e/rpds_py-2026.9.1-cp315-cp315t-win32.whl", hash = "sha256:5c6ee90dee3e85e055ddfd502d611643d9b0fd94c818220bda84ec3dacd9b27b", size = 203795, upload-time = "2026-10-04T16:31:38.53Z" }, + { url = "https://files.pythonhosted.org/packages/8a/e2/91f70d804c61f8eac39a417e82aa1024f655ab9e8bdd7393b196242bc41b/rpds_py-2026.9.1-cp315-cp315t-win_amd64.whl", hash = "sha256:fe5ad0664ec772b02c45859041aa17655709cced7a31005817fbbbd988c25567", size = 223037, upload-time = "2026-10-04T16:31:40.468Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ad/f0eba548e297987964ef8088403db875b333963bf8189f3f563b6936b20e/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c0d2cb595a420b34d5086db0add011e26e2c09d6a024afbac4228bf8f863a30", size = 384112, upload-time = "2026-10-04T16:31:42.643Z" }, + { url = "https://files.pythonhosted.org/packages/33/89/891fa4d81f1eae7fe262ecd0aba2c51de94a116c7f3ccfb034fa75f4c537/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f3d6ed6a98cfd19155996605474982cc470d7601746a6439078f1a5a3fa8b050", size = 389662, upload-time = "2026-10-04T16:31:44.642Z" }, + { url = "https://files.pythonhosted.org/packages/4f/46/912cf623b2263f9c9c2d04e8508fc38dbe89983faeba5fb36ca4558ae550/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8171b44a054e5c67fd748ada04187f1250bf35b95f85e52ab64bcf3331a923bb", size = 504637, upload-time = "2026-10-04T16:31:46.667Z" }, + { url = "https://files.pythonhosted.org/packages/9b/5c/7f3cfa7c5f01765c9f47c8398210ed0c1eb686c0e99c223cb1c6776d3fb9/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fda1d96e542c37b6c804547dbf489c129fe7c97183a76a5ec275909ba1a063df", size = 402607, upload-time = "2026-10-04T16:31:49.068Z" }, + { url = "https://files.pythonhosted.org/packages/f0/76/2e915d4115ee453c33e6af17bc1df7e22ddc52974e178eeeb92a78c09983/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:270bdcdaac5d5b6f73c5e22e7e135c7f2a50e789f71d9e241d5be8d90026e19a", size = 382762, upload-time = "2026-10-04T16:31:51.24Z" }, + { url = "https://files.pythonhosted.org/packages/0d/e5/844382925d7b84a4074ad79fc2b9d05eb6231ea243b34f247e68e519b606/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:84a6ecc0c940169190d2c23bd969debd48c94dbc855acd60188a68d71d421608", size = 389563, upload-time = "2026-10-04T16:31:53.549Z" }, + { url = "https://files.pythonhosted.org/packages/81/82/d6e3951602dc2e24790ef9d299aa24bf5e2493df5043f2c6da00480cc447/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ab4b2fda7c2b542f7f9d886cc6a838c5079d2b76f72e6081411faba11adde2c9", size = 416842, upload-time = "2026-10-04T16:31:55.76Z" }, + { url = "https://files.pythonhosted.org/packages/ea/1c/8d248e4ea671d525ab7daa0703ad81cc2175076fa0ccd7ef088facbd2b01/rpds_py-2026.9.1-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:44b32a7c4f0da3d28af31c259e38ddcff096f855e205ed0671d02fcf44f1ea1c", size = 562434, upload-time = "2026-10-04T16:31:57.874Z" }, + { url = "https://files.pythonhosted.org/packages/ad/38/e7ac0db898120d15dea25e3661b1242a40cb3b23d1f4db86c15a01fe0ba1/rpds_py-2026.9.1-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:a3dbc5ed9514908d5046107d7b1346bde71eea61de6e0e4919c19354f97e769f", size = 627909, upload-time = "2026-10-04T16:31:59.977Z" }, + { url = "https://files.pythonhosted.org/packages/03/c8/37e555514932cb1ee36c75349187aa882a98dee5d5654c761699ed8a0d27/rpds_py-2026.9.1-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:6eae33003518fd4cb4f83a218d5371469dd3001aa3b87128c005b07762f7fe5e", size = 593658, upload-time = "2026-10-04T16:32:02.14Z" }, + { url = "https://files.pythonhosted.org/packages/12/5c/5f69a91add94a8a33acea68a2b034a464946a654ff7296af9d957ef0d6a5/rpds_py-2026.9.1-pp311-pypy311_pp80-macosx_10_12_x86_64.whl", hash = "sha256:0483515261947e4e8b8e1375bf7463e7eb6ccfb3d86e7b554d90cd5285f20f32", size = 351769, upload-time = "2026-10-04T16:32:04.675Z" }, + { url = "https://files.pythonhosted.org/packages/41/22/35ea8bf3b2682b90ab687c74e4828418ff12298a5b0b0a0c033f61c86a30/rpds_py-2026.9.1-pp311-pypy311_pp80-macosx_11_0_arm64.whl", hash = "sha256:4cfaf02209061880210819934de2f4f6aa83dc04dafe6770276acc240a56da31", size = 351719, upload-time = "2026-10-04T16:32:06.834Z" }, + { url = "https://files.pythonhosted.org/packages/a3/90/a9ba81408369d34c1aca73319c15adc91ed45c1d21e9e8ee4832ffb7fe0b/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6cdc537c8633d7fd92a82e2e0d2ab74320a3f63d5e59fb9cf08711e08fe151c4", size = 381109, upload-time = "2026-10-04T16:32:08.994Z" }, + { url = "https://files.pythonhosted.org/packages/b3/44/5192a0bed94cec86bd2a5e1cc5a1bb8f7eec3aec907eacd2deb13e87e326/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:10e208f2425d973938afcd56e28a7c4be32e27b6a60b5d381f49fb9d8acf9759", size = 388222, upload-time = "2026-10-04T16:32:11.321Z" }, + { url = "https://files.pythonhosted.org/packages/92/cd/5356549711448f18b52f7a11ffbe90f1228774996fbf3c6cd1b18d22abaf/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6c0dbbcc19735fe5f8b0a54c07659d154a9e69f47e15d0a6ab7299215daf62cb", size = 500384, upload-time = "2026-10-04T16:32:13.478Z" }, + { url = "https://files.pythonhosted.org/packages/7a/88/ddda9d28adfe33119c75b2e733d4ba7e326f41d7e1b1093951771768ca48/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:684fd492fff4fead00587544e059be2bbcb6f93454f21fa2a91b66fc7508be82", size = 401661, upload-time = "2026-10-04T16:32:15.653Z" }, + { url = "https://files.pythonhosted.org/packages/32/c3/bb59ba16a6b4a57995d15b8c04c00f28df3b938c4dcdde48fbe0f73edb0c/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d1028417bb44037eb3069c1009bd7b7277212876cda22fbe565b0bca9fab6d2c", size = 380748, upload-time = "2026-10-04T16:32:17.727Z" }, + { url = "https://files.pythonhosted.org/packages/f5/b8/0580faa1c5a32ddc160130dd7ae54d2d007272a89a40a6b5db3e50f9f585/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:492e5e428cbe126221611f47e068f01660352feec4ad18bc0f5ea9b2ae88fb14", size = 385731, upload-time = "2026-10-04T16:32:19.855Z" }, + { url = "https://files.pythonhosted.org/packages/bf/70/f73564642bbe3322c7eeef2c2f258cf040b71c41a430b532e59d04a1b838/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:88b5268892fde430d5531f95bc560b6efbbd67c929662c586afd729a96e7461c", size = 412131, upload-time = "2026-10-04T16:32:22.285Z" }, + { url = "https://files.pythonhosted.org/packages/8c/5d/17fff2e1f8f68721a2afb5cb48f7e442c751bb6b4883157c5abaf618cd08/rpds_py-2026.9.1-pp312-pypy312_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:01445c8d194aa032a08e944f16567672da1c62dbdbefd8b6d0693032e290cf68", size = 558193, upload-time = "2026-10-04T16:32:24.4Z" }, + { url = "https://files.pythonhosted.org/packages/2a/d0/869ab6fb08531f97aae4a780b4d61b4190d8aef48fe054ee28bcf7114466/rpds_py-2026.9.1-pp312-pypy312_pp73-musllinux_1_2_i686.whl", hash = "sha256:eef6a03b0b6d08d0835ccfa8ec8d1bc70525e3801387567137b50c557695e6da", size = 622448, upload-time = "2026-10-04T16:32:26.844Z" }, + { url = "https://files.pythonhosted.org/packages/ba/a5/9672e532fe02cd3b92c78cfd8743abca939d96853006c63835009a1ecb6f/rpds_py-2026.9.1-pp312-pypy312_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:6b9bf3135b4ad5981df9a73d71a35272d650a2985ae9c2746357b24d59de2448", size = 591126, upload-time = "2026-10-04T16:32:29.274Z" }, + { url = "https://files.pythonhosted.org/packages/80/ef/3a9f8e4279c7920af561deed4cb7ebebed2794a8f608cf404d5eef14a105/rpds_py-2026.9.1-pp312-pypy312_pp80-macosx_10_12_x86_64.whl", hash = "sha256:56c6952a9b15047466d0c2347c446a761d4527f89976156341e68f0ce5cc08b0", size = 357108, upload-time = "2026-10-04T16:32:31.641Z" }, + { url = "https://files.pythonhosted.org/packages/b7/55/4b2fa381a583760aea5c92841e4e928a358e1c6511b129219e9c2826a226/rpds_py-2026.9.1-pp312-pypy312_pp80-macosx_11_0_arm64.whl", hash = "sha256:b242c27c8f836305a4a72df9cdd564386ac57b807bd252a063223331c9316b37", size = 346877, upload-time = "2026-10-04T16:32:34.061Z" }, +] + [[package]] name = "ruamel-yaml" version = "0.19.1" From 552f56234857576f13b424a812cd864d5aff3935 Mon Sep 17 00:00:00 2001 From: Daniel Young Date: Fri, 2 Oct 2026 18:20:13 -0400 Subject: [PATCH 02/10] [docs] Add an executable CI drift gate Compare a committed environment snapshot without regenerating the expected schema. Preserve JSON evidence before failing the job and isolate temporary database credentials from artifacts and logs. Ported from the held 1.0 line onto 0.7.0 for 0.8. The README and CHANGELOG conflicts carried the statement-classification section from the plan work, which 0.8 does not ship; only the drift-gate parts are kept. Solves: DRY-1404 Tests: test_drift_workflow (in sync, out-of-band change, actionlint) (cherry picked from commit 4f7f2a6790a97764c67cb4a330d71c8630fd7021) --- .gitignore | 2 + CHANGELOG.md | 1 + README.md | 48 ++++++++++++ docs/examples/github-actions-drift.yml | 85 +++++++++++++++++++++ tests/integration/test_drift_workflow.py | 94 ++++++++++++++++++++++++ 5 files changed, 230 insertions(+) create mode 100644 docs/examples/github-actions-drift.yml create mode 100644 tests/integration/test_drift_workflow.py diff --git a/.gitignore b/.gitignore index 025421e..923ee9d 100644 --- a/.gitignore +++ b/.gitignore @@ -66,4 +66,6 @@ tmp/ temp/ examples/ +# Documentation examples are reviewed source, not local sample projects. +!docs/examples/ lambda-exporter/ diff --git a/CHANGELOG.md b/CHANGELOG.md index 82bbf36..c03df01 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -60,6 +60,7 @@ To stay on 0.5.x until then, pin `ch-migrate-cli==0.5.1`. ### Added - Versioned `--json` output and published JSON Schemas for status, history, lint, and diff, with machine-readable errors, graph-resolved applied revisions, explicit waiver reasons, and CI-friendly exit codes. +- A SHA-pinned GitHub Actions drift gate that preserves the JSON report on failure; its install, credential, comparison, and exit steps run against the integration fixture for both matching and out-of-band schemas. - Reviewed idempotency corpus covering DDL, mutations, inserts, and partition operations. - Required-reason `ch-migrate: allow-non-idempotent` statement waivers, reported as INFO. - Gate findings say how to make the flagged statement safe to run twice, using its own names: the exact `IF NOT EXISTS` or `IF EXISTS` rewrite, or what a retry would do and the usual fix, such as `TRUNCATE` before a backfill or `REPLACE PARTITION` instead of `ATTACH PARTITION ... FROM`. diff --git a/README.md b/README.md index 9bb7db9..b57bfe3 100644 --- a/README.md +++ b/README.md @@ -473,6 +473,54 @@ def upgrade(): create_dictionary("history/dictionaries/dict_users/001_create.sql") ``` +## Drift detection in CI + +After applying and verifying migrations in an environment, capture its expected +schema: + +```bash +ch-migrate snapshot dev +ch-migrate diff dev --snapshot-dir migrations/sql/snapshots/20261002_120000 --json +``` + +Replace the example timestamp with the directory reported by `snapshot`. Review +and commit that directory alongside the migration head. Do not regenerate the +snapshot automatically in the drift job: doing so would accept an out-of-band +change as the new expected schema. Re-snapshot after an intentional migration or +an explicitly reviewed reconciliation, not merely to turn a failed check green. + +Copy [the GitHub Actions example](docs/examples/github-actions-drift.yml) into the +consumer repository's `.github/workflows/`. It runs on a daily schedule and +same-repository pull requests; fork PRs are excluded because they have no database +secret. It does not use `pull_request_target`. All actions are pinned by commit. +The checkout must contain `config.yaml` and the committed snapshot, and the runner +must be able to reach the selected server. + +Configure these repository variables: + +| Variable | Value | +|---|---| +| `CH_MIGRATE_PACKAGE` | An approved, pinned `ch-migrate-cli` requirement that supports `diff --json`. There is no fallback to an older release. | +| `CH_MIGRATE_ENV` | An environment name in `config.yaml`, such as `dev`. | +| `CH_MIGRATE_SNAPSHOT_DIR` | That environment's committed snapshot directory. | + +Set the repository secret `DRIFT_MIGRATION_PASSWORD` to the password for that +environment's configured user. Prefer a dedicated schema-inspection account, +not an admin account. The job writes a private `.env.local` without printing the +value and removes the file even when comparison fails. + +`diff --json` exits **0** for matching schemas, **1** for drift, and **2** for a +configuration/connection error. The workflow saves `drift.json`, uploads it even +on comparison failure, then fails the job for either nonzero result. The report +names changed tables and fields. The example's install and shell steps are tested +locally against the source checkout; that does not publish the package or prove +that a previously released version contains JSON support. + +Without `--snapshot-dir`, `diff` sorts entries in `migrations/sql/snapshots/` by +name and chooses the last one. It does not select a snapshot by environment or +recorded migration revision. Use an explicit path in CI, especially when one +repository holds snapshots for several environments. + ## Command reference Every command accepts `--help`. Top-level `ch-migrate --version` reports the installed package version. `ENV` below names an entry in `config.yaml`. diff --git a/docs/examples/github-actions-drift.yml b/docs/examples/github-actions-drift.yml new file mode 100644 index 0000000..f4cd89a --- /dev/null +++ b/docs/examples/github-actions-drift.yml @@ -0,0 +1,85 @@ +name: ClickHouse schema drift + +on: + schedule: + - cron: '17 6 * * *' + pull_request: + +permissions: + contents: read + +jobs: + drift: + # Fork pull requests cannot access repository secrets. Never use + # pull_request_target to expose database credentials to untrusted code. + if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository + runs-on: ubuntu-latest + env: + # Set to an approved ch-migrate-cli requirement with --json support. + # For example, pin a released version after that feature is published. + # There is no fallback to an older release without the required command. + CH_MIGRATE_PACKAGE: ${{ vars.CH_MIGRATE_PACKAGE }} + CH_MIGRATE_PYTHON: '3.12' + # These name a config.yaml environment and its committed snapshot folder. + CH_MIGRATE_ENV: ${{ vars.CH_MIGRATE_ENV }} + CH_MIGRATE_SNAPSHOT_DIR: ${{ vars.CH_MIGRATE_SNAPSHOT_DIR }} + UV_TOOL_DIR: ${{ github.workspace }}/.ch-migrate-tools + UV_TOOL_BIN_DIR: ${{ github.workspace }}/.ch-migrate-bin + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 + with: + persist-credentials: false + - uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0 + with: + python-version: '3.12' + - name: Install ch-migrate + id: install + run: | + : "${CH_MIGRATE_PACKAGE:?Set a package requirement with JSON support}" + : "${CH_MIGRATE_ENV:?Set the config.yaml environment name}" + : "${CH_MIGRATE_SNAPSHOT_DIR:?Set the committed snapshot path}" + uv tool install --python "$CH_MIGRATE_PYTHON" "$CH_MIGRATE_PACKAGE" + - name: Write scoped database credential + id: credentials + env: + # Password for config.yaml's migration_user in CH_MIGRATE_ENV. + # Use a dedicated schema-inspection account, not an admin credential. + DRIFT_MIGRATION_PASSWORD: ${{ secrets.DRIFT_MIGRATION_PASSWORD }} + run: | + umask 077 + python - <<'PY' + import json + import os + from pathlib import Path + + password = os.environ['DRIFT_MIGRATION_PASSWORD'] + if not password: + raise SystemExit('DRIFT_MIGRATION_PASSWORD is not configured') + key = 'CH_' + os.environ['CH_MIGRATE_ENV'].upper() + '_MIGRATION_PASSWORD' + Path('.env.local').write_text(key + '=' + json.dumps(password) + '\n') + PY + - name: Compare committed schema with live schema + id: compare + continue-on-error: true + run: | + "$UV_TOOL_BIN_DIR/ch-migrate" diff "$CH_MIGRATE_ENV" \ + --snapshot-dir "$CH_MIGRATE_SNAPSHOT_DIR" --json > drift.json + - name: Preserve drift report even when comparison fails + if: always() + uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2 + with: + name: schema-drift + path: drift.json + if-no-files-found: warn + - name: Fail on drift or comparison errors + id: gate + if: always() + env: + DRIFT_OUTCOME: ${{ steps.compare.outcome }} + run: | + # compare exits 1 on drift and 2 on errors; neither is a clean result. + test "$DRIFT_OUTCOME" = success + - name: Remove the temporary credential file + id: cleanup + if: always() + run: rm -f .env.local diff --git a/tests/integration/test_drift_workflow.py b/tests/integration/test_drift_workflow.py new file mode 100644 index 0000000..8e3c41f --- /dev/null +++ b/tests/integration/test_drift_workflow.py @@ -0,0 +1,94 @@ +"""Execute the documented workflow's actual shell steps on an owned server.""" + +import json +import os +import shutil +import subprocess +import sys +from pathlib import Path + +import pytest +import yaml +from jsonschema import Draft202012Validator + +pytestmark = pytest.mark.integration +REPO = Path(__file__).parents[2] +EXAMPLE = REPO / "docs/examples/github-actions-drift.yml" + + +@pytest.mark.parametrize("drift", [False, True], ids=["in_sync", "out_of_band_change"]) +def test_drift_workflow_run_steps(project, drift): + project.client.command( + f"CREATE TABLE {project.database}.events (id UInt64) ENGINE = MergeTree ORDER BY id" + ) + captured = project.run("snapshot", "it") + assert captured.exit_code == 0, captured.output + snapshot = next((project.sql_dir / "snapshots").iterdir()) + if drift: + project.client.command( + f"ALTER TABLE {project.database}.events ADD COLUMN unexpected UInt32" + ) + outcomes = _run_steps(project, _workflow_environment(project, snapshot)) + for name in ("install", "credentials", "cleanup"): + assert outcomes[name].returncode == 0, outcomes[name].stderr + assert outcomes["compare"].returncode == int(drift), outcomes["compare"].stderr + assert outcomes["gate"].returncode == int(drift) + document = json.loads((project.root / "drift.json").read_text()) + schema = json.loads((REPO / "docs/schemas/diff.schema.json").read_text()) + Draft202012Validator(schema).validate(document) + assert document["in_sync"] is (not drift) + events = next(item for item in document["objects"] if item["name"] == "events") + assert events["status"] == ("modified" if drift else "in_sync") + assert not (project.root / ".env.local").exists() + + +def test_drift_workflow_passes_actionlint(): + validator = shutil.which("actionlint") + if validator: + command = [validator, str(EXAMPLE)] + elif shutil.which("docker"): + command = ["docker", "run", "--rm", "-i", "rhysd/actionlint:1.7.7", "-"] + else: + pytest.skip("Neither actionlint nor Docker is available to validate the workflow") + result = subprocess.run( + command, input=EXAMPLE.read_text(), capture_output=True, text=True, timeout=120 + ) + assert result.returncode == 0, result.stdout + result.stderr + + +def _workflow_environment(project, snapshot): + environment = os.environ.copy() + password = environment.pop("CH_IT_MIGRATION_PASSWORD") + environment.update( + { + "CH_MIGRATE_PACKAGE": str(REPO), + "CH_MIGRATE_PYTHON": sys.executable, + "CH_MIGRATE_ENV": "it", + "CH_MIGRATE_SNAPSHOT_DIR": str(snapshot), + "DRIFT_MIGRATION_PASSWORD": password, + "UV_TOOL_DIR": str(project.root / "tools"), + "UV_TOOL_BIN_DIR": str(project.root / "bin"), + } + ) + return environment + + +def _run_steps(project, environment): + steps = yaml.safe_load(EXAMPLE.read_text())["jobs"]["drift"]["steps"] + outcomes = {} + for step in steps: + if "run" not in step: + continue + if step["id"] == "gate": + environment["DRIFT_OUTCOME"] = ( + "success" if outcomes["compare"].returncode == 0 else "failure" + ) + outcomes[step["id"]] = subprocess.run( + ["bash", "--noprofile", "--norc", "-e", "-o", "pipefail", "-c", step["run"]], + cwd=project.root, + env=environment, + capture_output=True, + text=True, + timeout=120, + ) + return outcomes From 618d690481e6888eb8ae25635a0ddf9b6f1f776b Mon Sep 17 00:00:00 2001 From: Daniel Young Date: Tue, 10 Nov 2026 17:35:35 -0500 Subject: [PATCH 03/10] [test] Keep --json error messages as plain text 0.6 and 0.7 took 7833aaf's ui-marker output fix without its --json test, because neither had --json. Restore it now that 0.8 does: an old env.py refusal reaches a history --json caller as the plain message in the error field, with exit 2. Solves: DRY-1244 Tests: tests/test_cli_output.py (6 passed) --- tests/test_cli_output.py | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/tests/test_cli_output.py b/tests/test_cli_output.py index e6e66b9..a00ce51 100644 --- a/tests/test_cli_output.py +++ b/tests/test_cli_output.py @@ -1,5 +1,9 @@ -"""Errors and warnings from `up`, its gate and `upgrade-env` use the `ui` markers.""" +"""Errors and warnings from `up`, its gate and `upgrade-env` use the `ui` markers. +`--json` callers must still get the error message unchanged, as plain text. +""" + +import json from types import SimpleNamespace import click @@ -11,6 +15,10 @@ from ch_migrate.gate import print_gate_findings from ch_migrate.lint import LintResult, Severity +OLD_ENV_MESSAGE = ( + "This project's migrations/env.py is from ch-migrate 0.x. Run `ch-migrate upgrade-env`." +) + @pytest.fixture def project(tmp_path, monkeypatch): @@ -31,7 +39,7 @@ def broken(): assert result.stderr == "✗ It broke.\nRun ch-migrate lint.\n" -def test_failure_message_keeps_hints(): +def test_failure_message_keeps_hints_for_json(): failure = ui.Failure("It broke.", "Run `ch-migrate lint`.") assert failure.format_message() == "It broke. Run `ch-migrate lint`." @@ -46,6 +54,13 @@ def test_old_env_refusal(project): ) +def test_old_env_refusal_json_message_is_unchanged(project): + (project / "migrations" / "env.py").write_text("# ch-migrate 0.5 env.py\n") + result = CliRunner().invoke(main, ["history", "dev", "--json"]) + assert result.exit_code == 2 + assert json.loads(result.stdout)["error"] == OLD_ENV_MESSAGE + + def test_gate_findings_use_lint_markers(capsys): report = SimpleNamespace( results=[ From b9a9375f8e7483dea00f543a6b768ab91f34f392 Mon Sep 17 00:00:00 2001 From: Daniel Young Date: Tue, 10 Nov 2026 17:36:49 -0500 Subject: [PATCH 04/10] [docs] Say status does not refuse an old env.py The bundled skill listed status among the commands that refuse an old environment. Only up, down and history call the check; status is a report and keeps running, as the README already says. Solves: DRY-1542 doc follow-up (status and old env.py) Tests: none (docs) --- ch_migrate/skills/ch-migrate/SKILL.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ch_migrate/skills/ch-migrate/SKILL.md b/ch_migrate/skills/ch-migrate/SKILL.md index fee70a4..1b5099d 100644 --- a/ch_migrate/skills/ch-migrate/SKILL.md +++ b/ch_migrate/skills/ch-migrate/SKILL.md @@ -21,7 +21,8 @@ The old environment is backed up, and repeating the command preserves that backu It also records current script heads as `lint.gate_baseline`, preserving YAML comments. Review that committed boundary; it exempts those revisions and their ancestors in every environment. Repeating `upgrade-env` updates the boundary. -Old environments are refused by `up`, `down`, `status`, and `history` before connecting. +Old environments are refused by `up`, `down`, and `history` before connecting; +`status` still reports. One checked HTTP session spans the whole run: `SET` carries into subsequent revisions. Prefer statement-level `SETTINGS` for query-local changes. An expired session fails loudly. Configure idle `session_timeout` in seconds (default 1800). From 3ce23b3fd5f53e66f3201835d332732feb16acf9 Mon Sep 17 00:00:00 2001 From: Daniel Young Date: Tue, 10 Nov 2026 17:37:04 -0500 Subject: [PATCH 05/10] [docs] Teach the bundled skill the --json flag Agents that install the skill with `ch-migrate skill` read its command table, so list --json on status, history, lint and diff and give the JSON-mode exit codes there. Solves: DRY-1244 Tests: none (docs) --- ch_migrate/skills/ch-migrate/SKILL.md | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/ch_migrate/skills/ch-migrate/SKILL.md b/ch_migrate/skills/ch-migrate/SKILL.md index 1b5099d..1f74413 100644 --- a/ch_migrate/skills/ch-migrate/SKILL.md +++ b/ch_migrate/skills/ch-migrate/SKILL.md @@ -39,16 +39,23 @@ The `standalone_set` gate rule cannot be lowered through configuration. | `ch-migrate new ENV NAME [--table X] [--irreversible REASON]` | Create upgrade/downgrade SQL and their revision | | `ch-migrate up ENV [-r REV]` | Apply migrations (default: head, or to REV) | | `ch-migrate down ENV [-r REV]` | Rollback (default: last, or to REV) | -| `ch-migrate status ENV` | Show current migration state | -| `ch-migrate history ENV` | Show migration history | -| `ch-migrate lint [ENV]` | Check upgrade statements; ENV restricts to pending revisions and adds live checks | +| `ch-migrate status ENV [--json]` | Show current migration state | +| `ch-migrate history ENV [--json]` | Show migration history | +| `ch-migrate lint [ENV] [--json]` | Check upgrade statements; ENV restricts to pending revisions and adds live checks | | `ch-migrate deps ENV [--validate PATH]` | Inspect live dependencies | | `ch-migrate snapshot ENV [--exclude GLOB] [--filter GLOB]` | Capture schema | -| `ch-migrate diff ENV [--snapshot-dir PATH]` | Compare snapshot and live schema | +| `ch-migrate diff ENV [--snapshot-dir PATH] [--json]` | Compare snapshot and live schema | | `ch-migrate rebase ENV [--onto REV] [--dry-run]` | Preview/rewrite dangling revision branches | | `ch-migrate upgrade-env` | Refresh env.py, keeping env.py.bak | | `ch-migrate skill [--user\|--project]` | Install Claude skill for ch-migrate | +**`--json`:** `status`, `history`, `lint` and `diff` print one document to stdout +with `schema_version` and `command`; diagnostics go to stderr. Prefer it when a +script or agent reads the result. Exit codes in JSON mode: `status` 0 at head, +1 pending or diverged, 2 unreadable; `diff` 0 in sync, 1 drift, 2 error; `history` 2 when +the database can't be read; `lint` as without `--json`. Schemas are in the +repository's `docs/schemas/`. + **Options for `new`:** choose one of `--table NAME`, `--view NAME`, and `--dict NAME`. SQL lives under `migrations/sql/history/{tables|views|dictionaries}/NAME/`; without an object it goes under `history/other/`. Filenames are From 0d459d4cb0b2cd51e6f5069d9b626d0651b0b2d6 Mon Sep 17 00:00:00 2001 From: Daniel Young Date: Tue, 10 Nov 2026 17:40:17 -0500 Subject: [PATCH 06/10] [refactor] Split lint and diff into named steps Both commands were over the 30-line limit before --json, and the JSON branches made them longer. lint now reads as config, scope, run and report; diff as snapshot, local schema, live schema and compare. Each JSON error path is unchanged, and the idempotency rule builds its result in one line. No behaviour change. Solves: python-style length findings on lint and diff_cmd Tests: 705 unit; lint, diff, gate and JSON integration (12 passed) --- ch_migrate/cli.py | 236 ++++++++++++++++++++++++--------------------- ch_migrate/lint.py | 13 +-- 2 files changed, 130 insertions(+), 119 deletions(-) diff --git a/ch_migrate/cli.py b/ch_migrate/cli.py index d806605..9c22f96 100644 --- a/ch_migrate/cli.py +++ b/ch_migrate/cli.py @@ -31,6 +31,8 @@ from ch_migrate.runner import alembic_failure, run_alembic, run_migrations if TYPE_CHECKING: + from ch_migrate.introspect import Schema + from ch_migrate.lint import LintConfig, LintReport from ch_migrate.rebase import RevisionGraph # Load .env.local if it exists in the current directory @@ -804,65 +806,78 @@ def lint(environment: str | None, json_output: bool) -> None: ch-migrate lint # Static only (CI-friendly) ch-migrate lint dev # Static + runtime (needs DB) """ - from ch_migrate.config import load_config from ch_migrate.display import render_lint_report - from ch_migrate.lint import LintConfig, lint_migrations - from ch_migrate.rebase import build_revision_graph - from ch_migrate.statements import pending_revisions versions_dir = _versions_dir_or_fail() + lint_config = _lint_config(Path.cwd() / "config.yaml") + scope = _lint_scope(environment, versions_dir) if environment else _LintScope() + report = _run_lint(versions_dir, lint_config, scope) + if json_output: + emit_json("lint", lint_document(report)) + else: + render_lint_report(report, runtime=environment is not None) - config_path = Path.cwd() / "config.yaml" - lint_config = LintConfig() - if config_path.exists(): - try: - raw_config = load_config(config_path) - lint_config = LintConfig.from_config(raw_config) - except Exception as error: - raise ui.Failure(f"Invalid lint configuration: {error}") from error + sys.exit(1 if report.has_errors else 0) - client = None - database = None - revisions = None - if environment: - try: - env_config = get_env_config(environment, config_path) - database = env_config["database"] +@dataclass(frozen=True) +class _LintScope: + """What a runtime lint checks against; empty for a static lint.""" - from ch_migrate.connection import get_client, get_migration_state + client: Any = None + database: str | None = None + revisions: set[str] | None = None - revisions = pending_revisions( - build_revision_graph(versions_dir), get_migration_state(env_config).heads - ) - client = get_client(env_config) - except Exception as e: - if json_output: - command_failure(f"Could not work out the pending revisions for {environment}: {e}") - ui.fail(f"Could not work out the pending revisions for {environment}: {e}") + +def _lint_config(config_path: Path) -> LintConfig: + from ch_migrate.config import load_config + from ch_migrate.lint import LintConfig + + if not config_path.exists(): + return LintConfig() + try: + return LintConfig.from_config(load_config(config_path)) + except Exception as error: + raise ui.Failure(f"Invalid lint configuration: {error}") from error + + +def _lint_scope(environment: str, versions_dir: Path) -> _LintScope: + """The environment's pending revisions and a client for the live checks.""" + from ch_migrate.connection import get_client, get_migration_state + from ch_migrate.rebase import build_revision_graph + from ch_migrate.statements import pending_revisions + + try: + env_config = get_env_config(environment, Path.cwd() / "config.yaml") + revisions = pending_revisions( + build_revision_graph(versions_dir), get_migration_state(env_config).heads + ) + return _LintScope(get_client(env_config), env_config["database"], revisions) + except Exception as e: + message = f"Could not work out the pending revisions for {environment}: {e}" + if click.get_current_context().params.get("json_output"): + command_failure(message) + ui.fail(message) + + +def _run_lint(versions_dir: Path, lint_config: LintConfig, scope: _LintScope) -> LintReport: + from ch_migrate.lint import lint_migrations try: - report = lint_migrations( + return lint_migrations( versions_dir, config=lint_config, - client=client, - database=database, - revisions=revisions, + client=scope.client, + database=scope.database, + revisions=scope.revisions, ) except (OSError, SyntaxError, ValueError) as e: - if json_output: + if click.get_current_context().params.get("json_output"): command_failure(str(e)) ui.fail(str(e)) finally: - if client is not None: - client.close() - - if json_output: - emit_json("lint", lint_document(report)) - else: - render_lint_report(report, runtime=environment is not None) - - sys.exit(1 if report.has_errors else 0) + if scope.client is not None: + scope.client.close() @main.command() @@ -938,50 +953,61 @@ def diff_cmd(environment: str, snapshot_dir: str | None, json_output: bool) -> N ch-migrate diff dev ch-migrate diff dev --snapshot-dir migrations/sql/snapshots/20260305_120000 """ - from ch_migrate.connection import get_client from ch_migrate.diff import DiffStatus, compare_schemas from ch_migrate.display import render_diff_report - from ch_migrate.introspect import ( - VERSION_TABLE, - Schema, - get_live_schema, - parse_create_statement, - ) env_config = _env_config_or_fail(environment) database = env_config["database"] + snap_path = Path(snapshot_dir) if snapshot_dir else _latest_snapshot(environment) + if not json_output: + ui.step(f"Comparing snapshot {snap_path.name} with {environment} ({database})") - # Resolve snapshot directory - if snapshot_dir: - snap_path = Path(snapshot_dir) + local_schema = _snapshot_schema(snap_path, database) + diffs = compare_schemas(local_schema, _live_schema(env_config, environment)) + if json_output: + emit_json("diff", diff_document(diffs)) else: - snapshots_base = Path.cwd() / "migrations" / "sql" / "snapshots" - dirs = sorted(snapshots_base.iterdir()) if snapshots_base.exists() else [] - if not dirs: - if json_output: - command_failure(f"No snapshots found. Run `ch-migrate snapshot {environment}` first.") - ui.fail("No snapshots found.", f"Run `ch-migrate snapshot {environment}` first.") - snap_path = dirs[-1] + render_diff_report(diffs) - if not json_output: - ui.step(f"Comparing snapshot {snap_path.name} with {environment} ({database})") + if any(d.status != DiffStatus.IN_SYNC for d in diffs): + ui.hint( + f"Write a migration for it, or run `ch-migrate snapshot {environment}` " + "to accept the live schema." + ) + sys.exit(1) + + +_SNAPSHOT_TYPE_DIRS = { + "tables": "table", + "views": "view", + "materialized_views": "materialized_view", + "dictionaries": "dictionary", +} + + +def _latest_snapshot(environment: str) -> Path: + """The last snapshot directory by name; it is not matched to the environment.""" + snapshots_base = Path.cwd() / "migrations" / "sql" / "snapshots" + dirs = sorted(snapshots_base.iterdir()) if snapshots_base.exists() else [] + if not dirs: + if click.get_current_context().params.get("json_output"): + command_failure(f"No snapshots found. Run `ch-migrate snapshot {environment}` first.") + ui.fail("No snapshots found.", f"Run `ch-migrate snapshot {environment}` first.") + return dirs[-1] + + +def _snapshot_schema(snap_path: Path, database: str) -> Schema: + """Load the CREATE statements a snapshot directory holds.""" + from ch_migrate.introspect import VERSION_TABLE, Schema - # Load local schema from snapshot files local_schema = Schema(database=database) - type_dirs = { - "tables": "table", - "views": "view", - "materialized_views": "materialized_view", - "dictionaries": "dictionary", - } schema_attrs = { "table": local_schema.tables, "view": local_schema.views, "materialized_view": local_schema.materialized_views, "dictionary": local_schema.dictionaries, } - - for dir_name, obj_type in type_dirs.items(): + for dir_name, obj_type in _SNAPSHOT_TYPE_DIRS.items(): type_path = snap_path / dir_name if not type_path.exists(): continue @@ -989,53 +1015,47 @@ def diff_cmd(environment: str, snapshot_dir: str | None, json_output: bool) -> N name = sql_file.stem if name == VERSION_TABLE: continue # older snapshots captured Alembic's own table - ddl = sql_file.read_text() - parsed = parse_create_statement(ddl) - if parsed: - schema_attrs[obj_type][name] = parsed - else: - # Store minimal object with raw DDL - from ch_migrate.introspect import ( - DictDefinition, - MVDefinition, - TableDefinition, - ViewDefinition, - ) - - fallback_types = { - "table": lambda: TableDefinition(name=name, engine="", raw_ddl=ddl), - "view": lambda: ViewDefinition(name=name, select_query="", raw_ddl=ddl), - "materialized_view": lambda: MVDefinition(name=name, raw_ddl=ddl), - "dictionary": lambda: DictDefinition(name=name, raw_ddl=ddl), - } - schema_attrs[obj_type][name] = fallback_types[obj_type]() - - # Get live schema + schema_attrs[obj_type][name] = _snapshot_object(obj_type, name, sql_file.read_text()) + return local_schema + + +def _snapshot_object(obj_type: str, name: str, ddl: str) -> Any: + """Parse one object's DDL, or keep the raw DDL when it can't be parsed.""" + from ch_migrate.introspect import ( + DictDefinition, + MVDefinition, + TableDefinition, + ViewDefinition, + parse_create_statement, + ) + + parsed = parse_create_statement(ddl) + if parsed: + return parsed + fallback_types = { + "table": lambda: TableDefinition(name=name, engine="", raw_ddl=ddl), + "view": lambda: ViewDefinition(name=name, select_query="", raw_ddl=ddl), + "materialized_view": lambda: MVDefinition(name=name, raw_ddl=ddl), + "dictionary": lambda: DictDefinition(name=name, raw_ddl=ddl), + } + return fallback_types[obj_type]() + + +def _live_schema(env_config: dict[str, Any], environment: str) -> Schema: + from ch_migrate.connection import get_client + from ch_migrate.introspect import get_live_schema + try: client = get_client(env_config) try: - live_schema = get_live_schema(client, database) + return get_live_schema(client, env_config["database"]) finally: client.close() except Exception as e: - if json_output: + if click.get_current_context().params.get("json_output"): command_failure(f"Error connecting to {environment}: {e}") ui.fail(f"Could not read the live schema from {environment}: {e}") - # Compare - diffs = compare_schemas(local_schema, live_schema) - if json_output: - emit_json("diff", diff_document(diffs)) - else: - render_diff_report(diffs) - - if any(d.status != DiffStatus.IN_SYNC for d in diffs): - ui.hint( - f"Write a migration for it, or run `ch-migrate snapshot {environment}` " - "to accept the live schema." - ) - sys.exit(1) - @main.command(name="upgrade-env") def upgrade_env() -> None: diff --git a/ch_migrate/lint.py b/ch_migrate/lint.py index b2b9f13..9165e5b 100644 --- a/ch_migrate/lint.py +++ b/ch_migrate/lint.py @@ -393,17 +393,8 @@ def check(self, sql: str, **kwargs: Any) -> list[LintResult]: "ch-migrate: allow-non-idempotent waiver" ) first_line = sql.strip().splitlines()[0] if sql.strip() else "" - return [ - LintResult( - self.name, - message, - severity, - kwargs.get("file_path"), - 1, - first_line, - waived=reason or None, - ) - ] + location = (kwargs.get("file_path"), 1, first_line) + return [LintResult(self.name, message, severity, *location, waived=reason or None)] class StandaloneSetRule(LintRule): From 6cf06cd6687997c23c58a560eb9cef1574d7ed11 Mon Sep 17 00:00:00 2001 From: Daniel Young Date: Tue, 10 Nov 2026 17:40:24 -0500 Subject: [PATCH 07/10] [release] Prepare 0.8.0 0.8 is 0.7.0 plus --json on status, history, lint and diff, and the CI drift gate (DRY-1542 kept both; plan, rebuild_table and the journal waiter stay on the held 1.0 line). Without --json nothing changes and there is no upgrade-env, so the CHANGELOG leads with that. The drift gate's README and example now name 0.8.0 as the first release with diff --json. Solves: DRY-1405 (0.8 version and CHANGELOG) Tests: 705 unit on 3.13; full suites run before the tag --- CHANGELOG.md | 15 +++++++++++++-- README.md | 12 ++++++++---- ch_migrate/__init__.py | 2 +- docs/examples/github-actions-drift.yml | 6 +++--- 4 files changed, 25 insertions(+), 10 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c03df01..d13af63 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,19 @@ Changes are recorded in [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) ## [Unreleased] +## [0.8.0] + +0.8 gives CI a machine-readable view of a migration project. `status`, `history`, `lint` and `diff` take `--json` and print one versioned document to stdout, and the README has a GitHub Actions job that fails a build when the live schema drifts from a committed snapshot. Without `--json` nothing changes: output and exit codes are the same as 0.7, and there is no `upgrade-env`. + +Every document carries `"schema_version": 1`. The format can still change before 1.0. + +To stay on 0.7, pin `ch-migrate-cli==0.7.0`. + +### Added + +- Versioned `--json` output and published JSON Schemas for status, history, lint, and diff, with machine-readable errors, graph-resolved applied revisions, explicit waiver reasons, and CI-friendly exit codes. +- A SHA-pinned GitHub Actions drift gate that preserves the JSON report on failure; its install, credential, comparison, and exit steps run against the integration fixture for both matching and out-of-band schemas. + ## [0.7.0] 0.7 waits for the work a migration starts. `up` doesn't record a migration as applied until the mutations and `ON CLUSTER` DDL its statements started have finished, and it shows their progress while it waits. A normal `pip install -U` reaches it from 0.6, so read this before upgrading: @@ -59,8 +72,6 @@ To stay on 0.5.x until then, pin `ch-migrate-cli==0.5.1`. ### Added -- Versioned `--json` output and published JSON Schemas for status, history, lint, and diff, with machine-readable errors, graph-resolved applied revisions, explicit waiver reasons, and CI-friendly exit codes. -- A SHA-pinned GitHub Actions drift gate that preserves the JSON report on failure; its install, credential, comparison, and exit steps run against the integration fixture for both matching and out-of-band schemas. - Reviewed idempotency corpus covering DDL, mutations, inserts, and partition operations. - Required-reason `ch-migrate: allow-non-idempotent` statement waivers, reported as INFO. - Gate findings say how to make the flagged statement safe to run twice, using its own names: the exact `IF NOT EXISTS` or `IF EXISTS` rewrite, or what a retry would do and the usual fix, such as `TRUNCATE` before a backfill or `REPLACE PARTITION` instead of `ATTACH PARTITION ... FROM`. diff --git a/README.md b/README.md index b57bfe3..d875061 100644 --- a/README.md +++ b/README.md @@ -23,6 +23,10 @@ This README describes the source checkout, which may be ahead of PyPI. To try an ## Upgrade from 0.x +**From 0.7:** 0.8 needs no `upgrade-env`, and nothing changes unless you pass +`--json` (see [Drift detection in CI](#drift-detection-in-ci)). A loose requirement +such as `ch-migrate-cli` upgrades to 0.8; pin `ch-migrate-cli==0.7.0` to stay on 0.7. + **From 0.6:** 0.7 needs no `upgrade-env`. `up` now waits for the mutations and `ON CLUSTER` DDL its statements start (see [Migrations that wait](#migrations-that-wait)), so give CI jobs time to finish or pass `--timeout`. Where `bootstrap` couldn't grant @@ -500,7 +504,7 @@ Configure these repository variables: | Variable | Value | |---|---| -| `CH_MIGRATE_PACKAGE` | An approved, pinned `ch-migrate-cli` requirement that supports `diff --json`. There is no fallback to an older release. | +| `CH_MIGRATE_PACKAGE` | A pinned `ch-migrate-cli` requirement, such as `ch-migrate-cli==0.8.0`. 0.8.0 is the first release with `diff --json`; there is no fallback to an older one. | | `CH_MIGRATE_ENV` | An environment name in `config.yaml`, such as `dev`. | | `CH_MIGRATE_SNAPSHOT_DIR` | That environment's committed snapshot directory. | @@ -512,9 +516,9 @@ value and removes the file even when comparison fails. `diff --json` exits **0** for matching schemas, **1** for drift, and **2** for a configuration/connection error. The workflow saves `drift.json`, uploads it even on comparison failure, then fails the job for either nonzero result. The report -names changed tables and fields. The example's install and shell steps are tested -locally against the source checkout; that does not publish the package or prove -that a previously released version contains JSON support. +names changed tables and fields. ch-migrate's own test suite runs the example's +shell steps against a real ClickHouse server, installing from the source checkout, +for both a matching and a drifted schema. Without `--snapshot-dir`, `diff` sorts entries in `migrations/sql/snapshots/` by name and chooses the last one. It does not select a snapshot by environment or diff --git a/ch_migrate/__init__.py b/ch_migrate/__init__.py index e01ef59..4e1e8bd 100644 --- a/ch_migrate/__init__.py +++ b/ch_migrate/__init__.py @@ -5,7 +5,7 @@ from ch_migrate import read_sql, get_db, get_env_config, create_dictionary """ -__version__ = "0.7.0" +__version__ = "0.8.0" from typing import Any diff --git a/docs/examples/github-actions-drift.yml b/docs/examples/github-actions-drift.yml index f4cd89a..bc90571 100644 --- a/docs/examples/github-actions-drift.yml +++ b/docs/examples/github-actions-drift.yml @@ -15,9 +15,9 @@ jobs: if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository runs-on: ubuntu-latest env: - # Set to an approved ch-migrate-cli requirement with --json support. - # For example, pin a released version after that feature is published. - # There is no fallback to an older release without the required command. + # Set to a pinned ch-migrate-cli requirement with --json support, such as + # ch-migrate-cli==0.8.0 (the first release with it). There is no + # fallback to an older release without the required command. CH_MIGRATE_PACKAGE: ${{ vars.CH_MIGRATE_PACKAGE }} CH_MIGRATE_PYTHON: '3.12' # These name a config.yaml environment and its committed snapshot folder. From d0a32d86f197456bf10e73015d02811cdb79f077 Mon Sep 17 00:00:00 2001 From: Daniel Young Date: Tue, 10 Nov 2026 18:15:19 -0500 Subject: [PATCH 08/10] [docs] Don't promise a JSON freeze at 1.0 yet The ported README said --json becomes a public interface at 1.0, with breaking changes needing a major version. Whether the schemas freeze at 1.0 is still open on DRY-1542, so say what the CHANGELOG says: the format can change before 1.0, and schema_version tells a caller which one it has. Solves: DRY-1542 open question (what 1.0 promises) Tests: none (docs) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d875061..733b543 100644 --- a/README.md +++ b/README.md @@ -531,7 +531,7 @@ Every command accepts `--help`. Top-level `ch-migrate --version` reports the ins Output lines start with `→` for a step, `✓` for a result, `!` for a warning and `✗` for an error; warnings and errors go to stderr. Colour is dropped when output is not a terminal or `NO_COLOR` is set, and lines are never wrapped, so paths and SQL can be copied or grepped. -`status`, `history`, `lint`, and `diff` accept `--json`. JSON mode writes one document to stdout; diagnostics go to stderr. Every document includes `"schema_version": 1` and `"command"`. From 1.0 this is a public interface: breaking changes require a major version. Errors include an `error` string rather than inventing a successful empty result. The schemas linked below use JSON Schema draft 2020-12. +`status`, `history`, `lint`, and `diff` accept `--json`. JSON mode writes one document to stdout; diagnostics go to stderr. Every document includes `"schema_version": 1` and `"command"`. The format can still change before 1.0; `schema_version` says which one a document follows. Errors include an `error` string rather than inventing a successful empty result. The schemas linked below use JSON Schema draft 2020-12. ### `init` From 38a0996c0b46672c3745c2bb942872d5c5668cd3 Mon Sep 17 00:00:00 2001 From: Daniel Young Date: Wed, 11 Nov 2026 10:04:13 -0500 Subject: [PATCH 09/10] [docs] Give each drift snapshot a fixed folder snapshot writes a new timestamped directory every time, so a drift job pinned to the first one keeps comparing against it after a reviewed re-snapshot. Name each environment's snapshot (snapshots/dev), and replace it in place on re-snapshot, so CH_MIGRATE_SNAPSHOT_DIR never changes and review shows the schema change as a diff. Solves: DRY-1789 README drift section for 0.8.0 Tests: tests/test_readme.py --- README.md | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 733b543..964177f 100644 --- a/README.md +++ b/README.md @@ -484,14 +484,20 @@ schema: ```bash ch-migrate snapshot dev -ch-migrate diff dev --snapshot-dir migrations/sql/snapshots/20261002_120000 --json +mv migrations/sql/snapshots/20261002_120000 migrations/sql/snapshots/dev +ch-migrate diff dev --snapshot-dir migrations/sql/snapshots/dev --json ``` -Replace the example timestamp with the directory reported by `snapshot`. Review -and commit that directory alongside the migration head. Do not regenerate the -snapshot automatically in the drift job: doing so would accept an out-of-band -change as the new expected schema. Re-snapshot after an intentional migration or -an explicitly reviewed reconciliation, not merely to turn a failed check green. +`snapshot` writes a new timestamped directory every time; replace the example +timestamp with the one it reports. Give each environment's snapshot a fixed name, +such as `snapshots/dev`, so `CH_MIGRATE_SNAPSHOT_DIR` never changes and the next +snapshot shows up in review as a diff against this one. Review and commit that +directory alongside the migration head. Do not regenerate the snapshot +automatically in the drift job: doing so would accept an out-of-band change as the +new expected schema. Re-snapshot after an intentional migration or an explicitly +reviewed reconciliation, not merely to turn a failed check green. To re-snapshot, +run `snapshot` again, delete the old `snapshots/dev`, and move the new directory +into its place, so the commit also shows objects that were dropped. Copy [the GitHub Actions example](docs/examples/github-actions-drift.yml) into the consumer repository's `.github/workflows/`. It runs on a daily schedule and From 57ffb8d25527721dcb7fe18b066c76b16426e17b Mon Sep 17 00:00:00 2001 From: Daniel Young Date: Wed, 11 Nov 2026 10:37:29 -0500 Subject: [PATCH 10/10] [test] Use generic names in schema examples Rename the table, column, dictionary, user and row-policy names in the introspection, snapshot and MV-validation fixtures, the mv_validate docstring and the snapshot --filter example to generic ones. Each test checks the same parsing and validation as before. Solves: DRY-1789 fixture names before 0.8.0 Tests: unit 705 passed; sdist and wheel built and searched --- ch_migrate/cli.py | 2 +- ch_migrate/mv_validate.py | 6 ++--- tests/test_introspect.py | 50 +++++++++++++++++++-------------------- tests/test_mv_validate.py | 28 +++++++++++----------- tests/test_snapshot.py | 10 ++++---- 5 files changed, 48 insertions(+), 48 deletions(-) diff --git a/ch_migrate/cli.py b/ch_migrate/cli.py index 9c22f96..144741e 100644 --- a/ch_migrate/cli.py +++ b/ch_migrate/cli.py @@ -1132,7 +1132,7 @@ def snapshot(environment: str, exclude: tuple[str, ...], include_filter: tuple[s Examples: ch-migrate snapshot dev ch-migrate snapshot dev --exclude 'system_*' --exclude 'peerdb_*' - ch-migrate snapshot dev --filter 'geo_*' + ch-migrate snapshot dev --filter 'orders_*' """ import fnmatch diff --git a/ch_migrate/mv_validate.py b/ch_migrate/mv_validate.py index 50aaa6d..80e7a0c 100644 --- a/ch_migrate/mv_validate.py +++ b/ch_migrate/mv_validate.py @@ -11,11 +11,11 @@ "mv_name": "my_new_mv", "source_table": "logs", "target_table": "my_new_aggregate", - "inserting_users": ["intake_writer"], + "inserting_users": ["ingest_writer"], # Optional fields for additional validation: "select_users": ["readonly_user"], - "source_rls_users": ["intake_writer"], - "target_rls_policies": ["default_deny", "full_access"], + "source_rls_users": ["ingest_writer"], + "target_rls_policies": ["deny_all", "allow_all"], }] Escape hatch: diff --git a/tests/test_introspect.py b/tests/test_introspect.py index 8cd0045..f7385bc 100644 --- a/tests/test_introspect.py +++ b/tests/test_introspect.py @@ -56,21 +56,21 @@ """ SHARED_MERGETREE_DDL = """\ -CREATE TABLE mydb.geo_indicators +CREATE TABLE mydb.store_sales ( - `geo_layer` String, - `topic_key` String, - `start_year` UInt16, - `geo_id` String, - `stratification_key` String, - `region_label` String, - `time_period` String, + `store_id` String, + `product_key` String, + `fiscal_year` UInt16, + `channel` String, + `segment` String, + `label` String, + `period` String, `value` Nullable(Float64), - `moe` Nullable(Float64), - `states` Array(String) + `error_margin` Nullable(Float64), + `tags` Array(String) ) ENGINE = SharedReplacingMergeTree('/clickhouse/tables/{uuid}', '{server}') -ORDER BY (geo_layer, topic_key, start_year, geo_id, stratification_key, region_label, time_period) +ORDER BY (store_id, product_key, fiscal_year, channel, segment, label, period) SETTINGS index_granularity = 8192 """ @@ -128,26 +128,26 @@ """ DICT_TABLE_SOURCE_DDL = """\ -CREATE DICTIONARY mydb.dict_topic +CREATE DICTIONARY mydb.dict_product ( `key` String, `name` String, `units` String ) PRIMARY KEY key -SOURCE(CLICKHOUSE(TABLE 'public_attributes_attribute' DB 'mydb')) +SOURCE(CLICKHOUSE(TABLE 'products' DB 'mydb')) LAYOUT(COMPLEX_KEY_HASHED()) LIFETIME(MIN 300 MAX 600) """ DICT_QUERY_SOURCE_DDL = """\ -CREATE DICTIONARY mydb.dict_topic_category +CREATE DICTIONARY mydb.dict_product_category ( - `topic_key` String, + `product_key` String, `category_name` String ) -PRIMARY KEY topic_key -SOURCE(CLICKHOUSE(QUERY 'SELECT a.key AS topic_key, c.name AS category_name FROM mydb.attributes AS a JOIN mydb.categories AS c ON a.cat_id = c.id')) +PRIMARY KEY product_key +SOURCE(CLICKHOUSE(QUERY 'SELECT p.key AS product_key, c.name AS category_name FROM mydb.products AS p JOIN mydb.categories AS c ON p.category_id = c.id')) LAYOUT(COMPLEX_KEY_HASHED()) LIFETIME(MIN 300 MAX 600) """ @@ -223,10 +223,10 @@ def test_replacing_mergetree(self): def test_shared_mergetree(self): result = parse_create_table(SHARED_MERGETREE_DDL) assert result is not None - assert result.name == "geo_indicators" + assert result.name == "store_sales" assert "SharedReplacingMergeTree" in result.engine assert len(result.order_by) == 7 - assert result.order_by[0] == "geo_layer" + assert result.order_by[0] == "store_id" def test_materialized_and_alias_columns(self): result = parse_create_table(TABLE_WITH_MATERIALIZED_COL) @@ -334,10 +334,10 @@ class TestParseCreateDictionary: def test_table_source(self): result = parse_create_dictionary(DICT_TABLE_SOURCE_DDL) assert result is not None - assert result.name == "dict_topic" + assert result.name == "dict_product" assert result.primary_key == "key" assert result.source_type == "clickhouse" - assert result.source_table == "public_attributes_attribute" + assert result.source_table == "products" assert result.source_db == "mydb" assert result.layout == "COMPLEX_KEY_HASHED" assert result.lifetime is not None @@ -345,10 +345,10 @@ def test_table_source(self): def test_query_source(self): result = parse_create_dictionary(DICT_QUERY_SOURCE_DDL) assert result is not None - assert result.name == "dict_topic_category" + assert result.name == "dict_product_category" assert result.source_type == "clickhouse" assert result.source_query is not None - assert "attributes" in result.source_query + assert "products" in result.source_query assert result.source_table is None def test_unparseable_returns_none(self): @@ -379,7 +379,7 @@ def test_dispatches_to_mv(self): def test_dispatches_to_dictionary(self): result = parse_create_statement(DICT_TABLE_SOURCE_DDL) assert isinstance(result, DictDefinition) - assert result.name == "dict_topic" + assert result.name == "dict_product" def test_unparseable_returns_none(self): assert parse_create_statement("DROP TABLE foo") is None @@ -456,7 +456,7 @@ def test_schema_populated(self): schema.tables["users"] = parse_create_table(MERGETREE_DDL) schema.views["active_users"] = parse_create_view(VIEW_DDL) schema.materialized_views["hourly_events"] = parse_create_mv(MV_WITH_TO_DDL) - schema.dictionaries["dict_topic"] = parse_create_dictionary(DICT_TABLE_SOURCE_DDL) + schema.dictionaries["dict_product"] = parse_create_dictionary(DICT_TABLE_SOURCE_DDL) assert len(schema.tables) == 1 assert len(schema.views) == 1 diff --git a/tests/test_mv_validate.py b/tests/test_mv_validate.py index ba97eba..aadcde1 100644 --- a/tests/test_mv_validate.py +++ b/tests/test_mv_validate.py @@ -210,11 +210,11 @@ def test_finds_or_replace(self): class TestPermissiveRowPolicyDetection: def test_finds_permissive_policy(self): policies = _find_permissive_row_policies( - "CREATE ROW POLICY my_policy ON {db}.logs USING 1 TO intake_writer;" + "CREATE ROW POLICY my_policy ON {db}.logs USING 1 TO ingest_writer;" ) assert len(policies) == 1 assert policies[0][0] == "logs" - assert "intake_writer" in policies[0][1] + assert "ingest_writer" in policies[0][1] def test_finds_multi_user(self): policies = _find_permissive_row_policies( @@ -288,9 +288,9 @@ def test_present_declarations_with_grants_passes(self, tmp_path: Path): "create_mv", sql=( "CREATE MATERIALIZED VIEW {db}.my_mv TO {db}.dest AS SELECT 1 FROM {db}.src;\n" - "GRANT INSERT ON {db}.dest TO intake_writer" + "GRANT INSERT ON {db}.dest TO ingest_writer" ), - mv_declarations='[{"mv_name": "my_mv", "source_table": "src", "target_table": "dest", "inserting_users": ["intake_writer"]}]', + mv_declarations='[{"mv_name": "my_mv", "source_table": "src", "target_table": "dest", "inserting_users": ["ingest_writer"]}]', ) errors = validate_mv_migrations(versions) assert errors == [] @@ -411,13 +411,13 @@ def test_missing_grant_insert_errors(self, tmp_path: Path): versions, "create_mv", sql="CREATE MATERIALIZED VIEW {db}.my_mv TO {db}.dest AS SELECT 1 FROM {db}.src", - mv_declarations='[{"mv_name": "my_mv", "source_table": "src", "target_table": "dest", "inserting_users": ["intake_writer"]}]', + mv_declarations='[{"mv_name": "my_mv", "source_table": "src", "target_table": "dest", "inserting_users": ["ingest_writer"]}]', ) errors = validate_mv_migrations(versions) assert len(errors) == 1 assert "GRANT INSERT" in errors[0].message assert "dest" in errors[0].message - assert "intake_writer" in errors[0].message + assert "ingest_writer" in errors[0].message def test_grant_in_same_migration_passes(self, tmp_path: Path): versions = tmp_path / "versions" @@ -426,9 +426,9 @@ def test_grant_in_same_migration_passes(self, tmp_path: Path): "create_mv", sql=( "CREATE MATERIALIZED VIEW {db}.my_mv TO {db}.dest AS SELECT 1 FROM {db}.src;\n" - "GRANT INSERT ON {db}.dest TO intake_writer" + "GRANT INSERT ON {db}.dest TO ingest_writer" ), - mv_declarations='[{"mv_name": "my_mv", "source_table": "src", "target_table": "dest", "inserting_users": ["intake_writer"]}]', + mv_declarations='[{"mv_name": "my_mv", "source_table": "src", "target_table": "dest", "inserting_users": ["ingest_writer"]}]', ) errors = validate_mv_migrations(versions) assert errors == [] @@ -439,13 +439,13 @@ def test_grant_in_companion_migration_passes(self, tmp_path: Path): versions, "create_mv", sql="CREATE MATERIALIZED VIEW {db}.my_mv TO {db}.dest AS SELECT 1 FROM {db}.src", - mv_declarations='[{"mv_name": "my_mv", "source_table": "src", "target_table": "dest", "inserting_users": ["intake_writer"]}]', + mv_declarations='[{"mv_name": "my_mv", "source_table": "src", "target_table": "dest", "inserting_users": ["ingest_writer"]}]', revision="aaa000000001", ) _write_migration( versions, "grant_mv", - sql="GRANT INSERT ON {db}.dest TO intake_writer", + sql="GRANT INSERT ON {db}.dest TO ingest_writer", revision="bbb000000002", down_revision="aaa000000001", ) @@ -648,12 +648,12 @@ def test_missing_target_rls_errors(self, tmp_path: Path): ), mv_declarations=( '[{"mv_name": "mv", "source_table": "src", "target_table": "dest",' - ' "inserting_users": ["writer"], "target_rls_policies": ["default_deny"]}]' + ' "inserting_users": ["writer"], "target_rls_policies": ["deny_all"]}]' ), ) errors = validate_mv_migrations(versions) assert len(errors) == 1 - assert "default_deny" in errors[0].message + assert "deny_all" in errors[0].message def test_target_rls_present_passes(self, tmp_path: Path): versions = tmp_path / "versions" @@ -663,11 +663,11 @@ def test_target_rls_present_passes(self, tmp_path: Path): sql=( "CREATE MATERIALIZED VIEW {db}.mv TO {db}.dest AS SELECT 1 FROM {db}.src;\n" "GRANT INSERT ON {db}.dest TO writer;\n" - "CREATE ROW POLICY dest_default_deny ON {db}.dest USING 0 TO ALL;" + "CREATE ROW POLICY dest_deny_all ON {db}.dest USING 0 TO ALL;" ), mv_declarations=( '[{"mv_name": "mv", "source_table": "src", "target_table": "dest",' - ' "inserting_users": ["writer"], "target_rls_policies": ["default_deny"]}]' + ' "inserting_users": ["writer"], "target_rls_policies": ["deny_all"]}]' ), ) errors = validate_mv_migrations(versions) diff --git a/tests/test_snapshot.py b/tests/test_snapshot.py index 8665254..0c28089 100644 --- a/tests/test_snapshot.py +++ b/tests/test_snapshot.py @@ -46,9 +46,9 @@ def _make_schema() -> Schema: name="hourly_events", raw_ddl="CREATE MATERIALIZED VIEW testdb.hourly_events TO testdb.hourly_dest AS SELECT count() FROM events", ) - schema.dictionaries["dict_topic"] = DictDefinition( - name="dict_topic", - raw_ddl="CREATE DICTIONARY testdb.dict_topic (key String) PRIMARY KEY key SOURCE(CLICKHOUSE(TABLE 'topics' DB 'testdb')) LAYOUT(HASHED()) LIFETIME(300)", + schema.dictionaries["dict_product"] = DictDefinition( + name="dict_product", + raw_ddl="CREATE DICTIONARY testdb.dict_product (key String) PRIMARY KEY key SOURCE(CLICKHOUSE(TABLE 'products' DB 'testdb')) LAYOUT(HASHED()) LIFETIME(300)", ) return schema @@ -95,7 +95,7 @@ def test_captures_all_objects(self, mock_schema, mock_client, runner, tmp_path): assert (snap / "tables" / "peerdb_staging.sql").exists() assert (snap / "views" / "active_users.sql").exists() assert (snap / "materialized_views" / "hourly_events.sql").exists() - assert (snap / "dictionaries" / "dict_topic.sql").exists() + assert (snap / "dictionaries" / "dict_product.sql").exists() @patch("ch_migrate.connection.get_client") @patch("ch_migrate.introspect.get_live_schema") @@ -157,7 +157,7 @@ def test_include_filter(self, mock_schema, mock_client, runner, tmp_path): assert (snap / "tables" / "users.sql").exists() assert (snap / "views" / "active_users.sql").exists() - assert (snap / "dictionaries" / "dict_topic.sql").exists() + assert (snap / "dictionaries" / "dict_product.sql").exists() assert not (snap / "tables" / "events.sql").exists() @patch("ch_migrate.connection.get_client")