From f449033e15f989aeaf35c776245cb4286e1f0ed5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=81=D0=BB=D0=BE=D0=B2?= Date: Sun, 15 Nov 2026 20:16:06 +0300 Subject: [PATCH 01/12] feat(storage): add private object storage and bounded image uploads --- .dockerignore | 13 + .env.example | 6 + .gitignore | 5 + .python-version | 1 + Dockerfile | 22 + Makefile | 18 + compose.yaml | 152 ++++ infra/haproxy.cfg | 36 + infra/s3-bootstrap.sh | 14 + infra/s3-entrypoint.sh | 6 + infra/s3-policy.json | 15 + infra/s3.Dockerfile | 37 + migrations/001_core.sql | 36 + migrations/002_idempotency.sql | 10 + migrations/003_attachments.sql | 32 + pyproject.toml | 37 + scripts/bootstrap.py | 51 ++ scripts/cluster.py | 83 ++ scripts/restart.sh | 4 + scripts/rolling-update.sh | 3 + scripts/stand.py | 137 ++++ scripts/stop-one.sh | 3 + scripts/verify_clean.py | 215 +++++ scripts/verify_cluster.py | 342 ++++++++ src/__init__.py | 0 src/__main__.py | 44 ++ src/api.py | 424 ++++++++++ src/attachments.py | 116 +++ src/cache.py | 66 ++ src/cursor.py | 64 ++ src/database.py | 69 ++ src/domain.py | 45 ++ src/errors.py | 16 + src/images.py | 77 ++ src/logging_config.py | 17 + src/migrate.py | 51 ++ src/object_store.py | 84 ++ src/password.py | 36 + src/reconcile.py | 200 +++++ src/repository.py | 287 +++++++ src/schemas.py | 65 ++ src/service.py | 179 +++++ src/settings.py | 37 + student-tests/conftest.py | 115 +++ student-tests/test_api.py | 412 ++++++++++ student-tests/test_attachments.py | 181 +++++ student-tests/test_contract_edges.py | 26 + student-tests/test_history_acl.py | 23 + student-tests/test_idempotency.py | 75 ++ student-tests/test_sessions.py | 114 +++ uv.lock | 1095 ++++++++++++++++++++++++++ 51 files changed, 5196 insertions(+) create mode 100644 .python-version create mode 100644 Dockerfile create mode 100644 compose.yaml create mode 100644 infra/haproxy.cfg create mode 100644 infra/s3-bootstrap.sh create mode 100644 infra/s3-entrypoint.sh create mode 100644 infra/s3-policy.json create mode 100644 infra/s3.Dockerfile create mode 100644 migrations/001_core.sql create mode 100644 migrations/002_idempotency.sql create mode 100644 migrations/003_attachments.sql create mode 100644 pyproject.toml create mode 100644 scripts/bootstrap.py create mode 100644 scripts/cluster.py create mode 100755 scripts/restart.sh create mode 100755 scripts/rolling-update.sh create mode 100644 scripts/stand.py create mode 100755 scripts/stop-one.sh create mode 100644 scripts/verify_clean.py create mode 100644 scripts/verify_cluster.py create mode 100644 src/__init__.py create mode 100644 src/__main__.py create mode 100644 src/api.py create mode 100644 src/attachments.py create mode 100644 src/cache.py create mode 100644 src/cursor.py create mode 100644 src/database.py create mode 100644 src/domain.py create mode 100644 src/errors.py create mode 100644 src/images.py create mode 100644 src/logging_config.py create mode 100644 src/migrate.py create mode 100644 src/object_store.py create mode 100644 src/password.py create mode 100644 src/reconcile.py create mode 100644 src/repository.py create mode 100644 src/schemas.py create mode 100644 src/service.py create mode 100644 src/settings.py create mode 100644 student-tests/conftest.py create mode 100644 student-tests/test_api.py create mode 100644 student-tests/test_attachments.py create mode 100644 student-tests/test_contract_edges.py create mode 100644 student-tests/test_history_acl.py create mode 100644 student-tests/test_idempotency.py create mode 100644 student-tests/test_sessions.py create mode 100644 uv.lock diff --git a/.dockerignore b/.dockerignore index bc16e556..163b0987 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,16 @@ __pycache__ node_modules evidence .DS_Store +**/__pycache__ +**/*.py[cod] +.work +.pytest_cache +.ruff_cache +tests +student-tests +research +scripts +contracts +*.md +Makefile +compose.yaml diff --git a/.env.example b/.env.example index d99d26a2..fdf0138f 100644 --- a/.env.example +++ b/.env.example @@ -18,3 +18,9 @@ S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key MAX_UPLOAD_BYTES=10485760 MAX_IMAGE_PIXELS=40000000 + +PUBLIC_PORT=8084 +API_CPUS=0.5 +API_MEMORY=768m +DB_POOL_SIZE=10 +RECONCILE_GRACE_SECONDS=300 diff --git a/.gitignore b/.gitignore index b5a71896..5e1bf8b9 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,8 @@ coverage/ .vscode/ # Keep small, sanitized evidence summaries in evidence/ under version control. # Inspect git diff --cached: ignore rules are not a secret scanner. + +.work/ +.work-*.txt +.pytest_cache/ +.ruff_cache/ diff --git a/.python-version b/.python-version new file mode 100644 index 00000000..a128d5c0 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.14.7 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..15856ef7 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,22 @@ +FROM ghcr.io/astral-sh/uv:0.13.7@sha256:96f40d3904aad8d0bd010539001d36c8e2188b981e1334471a90c4a1d93bb490 AS uv +FROM python:3.14.7-slim-trixie@sha256:51dafde81dbdb6ebde285137a295cf18a47ca95234fe388a343719cb97305b3d AS builder +COPY --from=uv /uv /usr/local/bin/uv +WORKDIR /app +ENV UV_PYTHON_DOWNLOADS=never UV_LINK_MODE=copy +COPY pyproject.toml uv.lock ./ +RUN --mount=type=cache,target=/root/.cache/uv uv sync --locked --no-dev --no-install-project + +FROM python:3.14.7-slim-trixie@sha256:51dafde81dbdb6ebde285137a295cf18a47ca95234fe388a343719cb97305b3d AS runtime +ARG VCS_REF=unknown +LABEL org.opencontainers.image.revision=$VCS_REF +WORKDIR /app +ENV PATH="/app/.venv/bin:$PATH" PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 APP_HOST=0.0.0.0 APP_PORT=8080 +RUN groupadd --gid 10001 app && useradd --uid 10001 --gid app --no-create-home app +COPY --from=builder /app/.venv /app/.venv +COPY src /app/src +COPY migrations /app/migrations +USER 10001:10001 +EXPOSE 8080 +HEALTHCHECK --interval=10s --timeout=2s --start-period=10s --start-interval=1s --retries=3 CMD ["python", "-c", "import os,urllib.request; urllib.request.urlopen('http://127.0.0.1:'+os.getenv('APP_PORT','8080')+'/health/ready',timeout=1).read()"] +STOPSIGNAL SIGTERM +CMD ["python", "-m", "src"] diff --git a/Makefile b/Makefile index 5d86d171..d06fd361 100644 --- a/Makefile +++ b/Makefile @@ -28,3 +28,21 @@ test-persistence: test-failover: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2) $(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +UV ?= uv +BASE_URL = http://127.0.0.1:8084 +VERIFY_OUTPUT ?= evidence/storage-repeat.json +.PHONY: bootstrap up down lint test-student verify +bootstrap: + $(PYTHON) scripts/bootstrap.py +up: bootstrap + VCS_REF=$$(git rev-parse HEAD) docker compose up -d --build --wait +down: + docker compose down +lint: + $(UV) run --locked ruff format src student-tests scripts/bootstrap.py scripts/stand.py scripts/cluster.py $(wildcard scripts/verify_*.py) + $(UV) run --locked ruff check src student-tests scripts/bootstrap.py scripts/stand.py scripts/cluster.py $(wildcard scripts/verify_*.py) +test-student: + BASE_URL="$(BASE_URL)" $(UV) run --locked pytest student-tests +verify: + $(UV) run --locked python -m scripts.verify_storage --output "$(VERIFY_OUTPUT)" diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..82cb6a10 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,152 @@ +name: mtusi-lab4-maslov +services: + postgres: + image: postgres:18.3@sha256:7e32e9833a6fb1c92c32552794cb6ed569d51b445a54907d35fc112ef39684db + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + PGDATA: /var/lib/postgresql/data/pgdata + secrets: [postgres_password] + volumes: + - postgres_data:/var/lib/postgresql + healthcheck: + test: [CMD-SHELL, 'pg_isready -U messenger -d messenger'] + interval: 2s + timeout: 2s + retries: 20 + cpus: 1 + mem_limit: 512m + memswap_limit: 512m + cache: + image: valkey/valkey:8.1.3@sha256:fea8b3e67b15729d4bb70589eb03367bab9ad1ee89c876f54327fc7c6e618571 + command: [valkey-server, /run/secrets/valkey.conf] + secrets: + - cache_password + - source: valkey_config + target: valkey.conf + healthcheck: + test: [CMD-SHELL, 'REDISCLI_AUTH="$$(cat /run/secrets/cache_password)" valkey-cli ping'] + interval: 2s + timeout: 2s + retries: 20 + cpus: 0.25 + mem_limit: 128m + memswap_limit: 128m + migrate: + image: ${API_IMAGE:-mtusi-messenger:lab4} + pull_policy: never + command: [python, -m, src.migrate] + environment: + DATABASE_URL_FILE: /run/secrets/database_url + secrets: [database_url] + depends_on: + postgres: {condition: service_healthy} + cpus: 0.5 + mem_limit: 256m + read_only: true + api: + image: ${API_IMAGE:-mtusi-messenger:lab4} + build: + context: . + args: + VCS_REF: ${VCS_REF:-unknown} + scale: ${API_REPLICAS:-2} + environment: + APP_HOST: 0.0.0.0 + APP_PORT: 8080 + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + S3_ACCESS_KEY_FILE: /run/secrets/s3_access_key + S3_SECRET_KEY_FILE: /run/secrets/s3_secret_key + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DB_POOL_SIZE: ${DB_POOL_SIZE:-10} + secrets: [database_url, cache_url, s3_access_key, s3_secret_key] + depends_on: + migrate: {condition: service_completed_successfully} + cache: {condition: service_healthy} + s3-bootstrap: {condition: service_completed_successfully} + cpus: ${API_CPUS:-0.5} + mem_limit: ${API_MEMORY:-384m} + memswap_limit: ${API_MEMORY:-384m} + pids_limit: 128 + read_only: true + tmpfs: ["/tmp:rw,noexec,nosuid,size=128m"] + cap_drop: [ALL] + security_opt: [no-new-privileges:true] + stop_grace_period: 10s + s3: + image: ${S3_IMAGE:-mtusi-storage:minio-20251015} + build: {context: ., dockerfile: infra/s3.Dockerfile, target: server} + secrets: [s3_root_user, s3_root_password] + volumes: [s3_data:/data] + cpus: 1 + mem_limit: 1024m + memswap_limit: 1024m + read_only: true + tmpfs: ["/tmp:rw,nosuid,size=32m"] + environment: + HOME: /tmp + security_opt: [no-new-privileges:true] + s3-bootstrap: + image: ${MC_IMAGE:-mtusi-storage:mc-20250813} + build: {context: ., dockerfile: infra/s3.Dockerfile, target: bootstrap} + secrets: [s3_root_user, s3_root_password, s3_access_key, s3_secret_key] + depends_on: + s3: {condition: service_healthy} + cpus: 0.25 + mem_limit: 128m + read_only: true + tmpfs: ["/tmp:rw,nosuid,size=16m"] + reconciler: + image: ${API_IMAGE:-mtusi-messenger:lab4} + pull_policy: never + command: [python, -m, src.reconcile, --apply, --loop] + environment: + DATABASE_URL_FILE: /run/secrets/database_url + S3_ACCESS_KEY_FILE: /run/secrets/s3_access_key + S3_SECRET_KEY_FILE: /run/secrets/s3_secret_key + RECONCILE_GRACE_SECONDS: ${RECONCILE_GRACE_SECONDS:-300} + secrets: [database_url, s3_access_key, s3_secret_key] + depends_on: + migrate: {condition: service_completed_successfully} + s3-bootstrap: {condition: service_completed_successfully} + cpus: 0.25 + mem_limit: 256m + memswap_limit: 256m + read_only: true + healthcheck: {disable: true} + lb: + image: haproxy:3.2.1-alpine@sha256:ac79fe145f2bb6626ff26b584a2d0a34e791906c01015f2ae037aa3137b683d9 + ports: + - "127.0.0.1:${PUBLIC_PORT:-8084}:8080" + volumes: + - ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + depends_on: + api: {condition: service_healthy} + cpus: 0.5 + mem_limit: 128m + memswap_limit: 128m + read_only: true + tmpfs: ["/tmp:rw,nosuid,size=4m"] + security_opt: [no-new-privileges:true] + stop_grace_period: 10s +secrets: + s3_root_user: {file: ./secrets/s3_root_user} + s3_root_password: {file: ./secrets/s3_root_password} + s3_access_key: {file: ./secrets/s3_access_key} + s3_secret_key: {file: ./secrets/s3_secret_key} + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + cache_password: + file: ./secrets/cache_password + cache_url: + file: ./secrets/cache_url + valkey_config: + file: ./secrets/valkey.conf + name: valkey.conf +volumes: + s3_data: + postgres_data: diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg new file mode 100644 index 00000000..7528702e --- /dev/null +++ b/infra/haproxy.cfg @@ -0,0 +1,36 @@ +global + log stdout format raw local0 + maxconn 512 + stats socket /tmp/admin.sock mode 600 level admin + +defaults + mode http + log global + option httplog + timeout connect 1s + timeout client 15s + timeout server 8s + timeout http-request 10s + timeout http-keep-alive 5s + retries 0 + +resolvers docker + nameserver dns 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 1s + hold obsolete 1s + hold nx 1s + +frontend public + bind :8080 + default_backend messenger + +backend messenger + balance roundrobin + option httpchk + http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host api + http-check expect status 200 + default-server check inter 1s fastinter 250ms fall 2 rise 1 resolvers docker init-addr libc,none resolve-prefer ipv4 + server-template api 1-8 api:8080 diff --git a/infra/s3-bootstrap.sh b/infra/s3-bootstrap.sh new file mode 100644 index 00000000..5732c258 --- /dev/null +++ b/infra/s3-bootstrap.sh @@ -0,0 +1,14 @@ +#!/bin/sh +set -eu +root_user=$(cat /run/secrets/s3_root_user) +root_password=$(cat /run/secrets/s3_root_password) +api_key=$(cat /run/secrets/s3_access_key) +api_secret=$(cat /run/secrets/s3_secret_key) +# Credentials are passed only inside this isolated bootstrap container. +mc alias set local http://s3:9000 "$root_user" "$root_password" >/dev/null 2>&1 +mc mb --ignore-existing local/messenger >/dev/null 2>&1 +mc anonymous set none local/messenger >/dev/null 2>&1 +mc admin user add local "$api_key" "$api_secret" >/dev/null 2>&1 +mc admin policy create local messenger-api /policy.json >/dev/null 2>&1 +mc admin policy attach local messenger-api --user "$api_key" >/dev/null 2>&1 +printf '%s\n' 'Private bucket and scoped application policy ready' diff --git a/infra/s3-entrypoint.sh b/infra/s3-entrypoint.sh new file mode 100644 index 00000000..ea521ab9 --- /dev/null +++ b/infra/s3-entrypoint.sh @@ -0,0 +1,6 @@ +#!/bin/sh +set -eu +export MINIO_ROOT_USER="$(cat /run/secrets/s3_root_user)" +export MINIO_ROOT_PASSWORD="$(cat /run/secrets/s3_root_password)" +export MINIO_BROWSER_REDIRECT_URL=http://127.0.0.1:9001 +exec minio server /data --address :9000 --console-address 127.0.0.1:9001 diff --git a/infra/s3-policy.json b/infra/s3-policy.json new file mode 100644 index 00000000..f7ec8fb5 --- /dev/null +++ b/infra/s3-policy.json @@ -0,0 +1,15 @@ +{ + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Action": ["s3:GetBucketLocation", "s3:ListBucket"], + "Resource": ["arn:aws:s3:::messenger"] + }, + { + "Effect": "Allow", + "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"], + "Resource": ["arn:aws:s3:::messenger/objects/*"] + } + ] +} diff --git a/infra/s3.Dockerfile b/infra/s3.Dockerfile new file mode 100644 index 00000000..d0f0b99c --- /dev/null +++ b/infra/s3.Dockerfile @@ -0,0 +1,37 @@ +FROM golang:1.24.8-bookworm@sha256:4ed690d6649d63c312b99a6120025ec79ce3b542968a37da53d6236c7c61a848 AS toolchain +ENV CGO_ENABLED=0 GOMAXPROCS=2 GOFLAGS=-p=2 GOTOOLCHAIN=local + +FROM toolchain AS minio-build +WORKDIR /source +RUN git init . && git remote add origin https://github.com/minio/minio.git && \ + git fetch --depth 1 origin 9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a && git checkout --detach FETCH_HEAD +RUN --mount=type=cache,target=/go/pkg/mod,sharing=locked \ + --mount=type=cache,target=/root/.cache/go-build,sharing=locked \ + go build -trimpath -ldflags='-s -w -X github.com/minio/minio/cmd.Version=2025-10-15T17:29:55Z -X github.com/minio/minio/cmd.ReleaseTag=RELEASE.2025-10-15T17-29-55Z -X github.com/minio/minio/cmd.CommitID=9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a' -o /out/minio . + +FROM toolchain AS mc-build +WORKDIR /source +RUN git init . && git remote add origin https://github.com/minio/mc.git && \ + git fetch --depth 1 origin 7394ce0dd2a80935aded936b09fa12cbb3cb8096 && git checkout --detach FETCH_HEAD +RUN --mount=type=cache,target=/go/pkg/mod,sharing=locked \ + --mount=type=cache,target=/root/.cache/go-build,sharing=locked \ + go build -trimpath -ldflags='-s -w' -o /out/mc . + +FROM python:3.14.7-slim-trixie@sha256:51dafde81dbdb6ebde285137a295cf18a47ca95234fe388a343719cb97305b3d AS server +COPY --from=minio-build /out/minio /usr/local/bin/minio +COPY --from=minio-build /source/LICENSE /licenses/minio.LICENSE +COPY --chmod=755 infra/s3-entrypoint.sh /usr/local/bin/s3-entrypoint +RUN mkdir /data && chown 10001:10001 /data +USER 10001:10001 +ENTRYPOINT ["/usr/local/bin/s3-entrypoint"] +EXPOSE 9000 +HEALTHCHECK --interval=2s --timeout=2s --start-period=10s --retries=30 CMD ["python","-c","import urllib.request; urllib.request.urlopen('http://127.0.0.1:9000/minio/health/ready',timeout=1).read()"] + +FROM python:3.14.7-slim-trixie@sha256:51dafde81dbdb6ebde285137a295cf18a47ca95234fe388a343719cb97305b3d AS bootstrap +COPY --from=mc-build /out/mc /usr/local/bin/mc +COPY --from=mc-build /source/LICENSE /licenses/mc.LICENSE +COPY --chmod=755 infra/s3-bootstrap.sh /usr/local/bin/s3-bootstrap +COPY infra/s3-policy.json /policy.json +USER 10001:10001 +ENV MC_CONFIG_DIR=/tmp/mc +ENTRYPOINT ["/usr/local/bin/s3-bootstrap"] diff --git a/migrations/001_core.sql b/migrations/001_core.sql new file mode 100644 index 00000000..f1c3acf1 --- /dev/null +++ b/migrations/001_core.sql @@ -0,0 +1,36 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100), + password_hash text NOT NULL, + created_at timestamptz NOT NULL +); +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100), + created_at timestamptz NOT NULL +); +CREATE TABLE members ( + chat_id uuid NOT NULL REFERENCES chats(id), + user_id uuid NOT NULL REFERENCES users(id), + position integer NOT NULL CHECK (position BETWEEN 0 AND 99), + PRIMARY KEY (chat_id, user_id), + UNIQUE (chat_id, position) +); +CREATE INDEX members_user_chat_idx ON members(user_id,chat_id); +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats(id), + sender_id uuid NOT NULL, + text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000), + created_at timestamptz NOT NULL, + FOREIGN KEY (chat_id, sender_id) REFERENCES members(chat_id,user_id) +); +CREATE INDEX messages_history_idx ON messages(chat_id,created_at,id); +CREATE TABLE sessions ( + token_digest bytea PRIMARY KEY CHECK (octet_length(token_digest)=32), + user_id uuid NOT NULL REFERENCES users(id), + created_at timestamptz NOT NULL, + expires_at timestamptz NOT NULL CHECK (expires_at > created_at) +); +CREATE INDEX sessions_expiry_idx ON sessions(expires_at); diff --git a/migrations/002_idempotency.sql b/migrations/002_idempotency.sql new file mode 100644 index 00000000..759451e0 --- /dev/null +++ b/migrations/002_idempotency.sql @@ -0,0 +1,10 @@ +CREATE TABLE idempotency ( + user_id uuid NOT NULL REFERENCES users(id), + chat_id uuid NOT NULL REFERENCES chats(id), + key text NOT NULL CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'), + body_hash bytea NOT NULL CHECK (octet_length(body_hash)=32), + message_id uuid NOT NULL REFERENCES messages(id), + expires_at timestamptz NOT NULL, + PRIMARY KEY(user_id, chat_id, key) +); +CREATE INDEX idempotency_expiry_idx ON idempotency(expires_at); diff --git a/migrations/003_attachments.sql b/migrations/003_attachments.sql new file mode 100644 index 00000000..f5d88aa8 --- /dev/null +++ b/migrations/003_attachments.sql @@ -0,0 +1,32 @@ +ALTER TABLE messages DROP CONSTRAINT messages_text_check; +ALTER TABLE messages ADD CHECK (char_length(text) <= 4000); +ALTER TABLE messages ADD UNIQUE(chat_id,id); +CREATE TABLE attachments ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats(id), + owner_id uuid NOT NULL, + filename text NOT NULL CHECK(char_length(filename) BETWEEN 1 AND 255), + content_type text NOT NULL CHECK(content_type IN ('image/png','image/jpeg')), + size_bytes bigint NOT NULL CHECK(size_bytes BETWEEN 1 AND 10485760), + sha256 text NOT NULL CHECK(sha256 ~ '^[a-f0-9]{64}$'), + object_key text NOT NULL UNIQUE, + state text NOT NULL CHECK(state IN ('pending','ready','failed')), + error_code text, + uploader_instance text NOT NULL, + expires_at timestamptz NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + updated_at timestamptz NOT NULL DEFAULT clock_timestamp(), + UNIQUE(chat_id,id), + FOREIGN KEY(chat_id,owner_id) REFERENCES members(chat_id,user_id) +); +CREATE INDEX attachments_state_created_idx ON attachments(state,created_at,id); +CREATE TABLE message_attachments ( + message_id uuid NOT NULL, + chat_id uuid NOT NULL, + attachment_id uuid NOT NULL, + position integer NOT NULL CHECK(position BETWEEN 0 AND 9), + PRIMARY KEY(message_id,attachment_id), + UNIQUE(message_id,position), + FOREIGN KEY(chat_id,message_id) REFERENCES messages(chat_id,id), + FOREIGN KEY(chat_id,attachment_id) REFERENCES attachments(chat_id,id) +); diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..6d8ef3e3 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,37 @@ +[project] +name = "mtusi-messenger-lab4" +version = "1.0.0" +requires-python = ">=3.14,<3.15" +dependencies = [ + "fastapi==0.143.3", + "pydantic==2.14.1", + "uvicorn==0.54.0", + "psycopg[binary,pool]==3.3.6", + "argon2-cffi>=25,<26", + "redis==8.1.0", + "minio==7.2.20", + "pillow==13.0.0", +] + +[dependency-groups] +dev = ["pytest>=8,<10", "httpx>=0.28,<1", "ruff>=0.14,<1", "openapi-spec-validator==0.7.2", "psutil>=7,<8", "matplotlib>=3.10,<4"] + +[tool.ruff] +line-length = 79 +target-version = "py314" +include = ["src/**/*.py", "student-tests/**/*.py", "research/**/*.py", "scripts/verify_*.py"] + +[tool.ruff.lint] +select = ["E", "F", "I", "B", "UP"] + +[tool.ruff.per-file-target-version] +"scripts/*.py" = "py39" + +# SQL и генерируемые Markdown-таблицы в инструментах не разрываем. +[tool.ruff.lint.per-file-ignores] +"research/*.py" = ["E501"] +"scripts/*.py" = ["E501"] + +[tool.pytest.ini_options] +testpaths = ["student-tests"] +addopts = "-ra" diff --git a/scripts/bootstrap.py b/scripts/bootstrap.py new file mode 100644 index 00000000..d6981472 --- /dev/null +++ b/scripts/bootstrap.py @@ -0,0 +1,51 @@ +"""Создаёт только отсутствующие локальные файлы; секреты не печатает.""" + +import os +import secrets +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] + + +def create(path, value): + try: + fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644) + except FileExistsError: + return + with os.fdopen(fd, "w") as stream: + stream.write(value + "\n") + + +def main(): + directory = ROOT / "secrets" + directory.mkdir(mode=0o700, exist_ok=True) + pg = directory / "postgres_password" + cache = directory / "cache_password" + create(pg, secrets.token_urlsafe(32)) + create(cache, secrets.token_urlsafe(32)) + create( + directory / "database_url", + "postgresql://messenger:" + + pg.read_text().strip() + + "@postgres:5432/messenger", + ) + create( + directory / "cache_url", + "redis://:" + cache.read_text().strip() + "@cache:6379/0", + ) + create( + directory / "valkey.conf", + "bind 0.0.0.0\nprotected-mode yes\nport 6379\nmaxmemory 64mb\n" + 'maxmemory-policy allkeys-lru\nsave ""\nappendonly no\nrequirepass ' + + cache.read_text().strip(), + ) + create(directory / "s3_root_user", secrets.token_hex(10)) + create(directory / "s3_root_password", secrets.token_urlsafe(32)) + create(directory / "s3_access_key", secrets.token_hex(10)) + create(directory / "s3_secret_key", secrets.token_urlsafe(32)) + create(ROOT / ".env", (ROOT / ".env.example").read_text().rstrip()) + print("Local configuration ready; existing files preserved") + + +if __name__ == "__main__": + main() diff --git a/scripts/cluster.py b/scripts/cluster.py new file mode 100644 index 00000000..e418d0e0 --- /dev/null +++ b/scripts/cluster.py @@ -0,0 +1,83 @@ +"""Явные операторские действия только над API текущего Compose-проекта.""" + +import json +import os +import subprocess +import sys +import time +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] + + +def command(*args): + return subprocess.check_output(args, cwd=ROOT, text=True).strip() + + +def containers(): + ids = command("docker", "compose", "ps", "-q", "api").split() + return json.loads(command("docker", "inspect", *ids)) if ids else [] + + +def alias(cid): + code = ( + "import urllib.request; r=urllib.request.urlopen(" + "'http://127.0.0.1:8080/health/live',timeout=2); " + "print(r.headers['X-Instance-Id'])" + ) + return command("docker", "exec", cid, "python", "-c", code) + + +def wait_count(count): + deadline = time.monotonic() + 60 + while time.monotonic() < deadline: + data = containers() + if len(data) == count and all( + c["State"].get("Health", {}).get("Status") == "healthy" + for c in data + ): + # DNS и проверки HAProxy должны успеть увидеть новый адрес. + time.sleep(3) + return + time.sleep(0.5) + raise TimeoutError("Replica readiness") + + +def main(): + action = sys.argv[1] + data = containers() + if action == "stop": + target = os.environ["TARGET_INSTANCE_ID"] + matches = [c for c in data if alias(c["Id"]) == target] + if len(matches) != 1 or len(data) < 2: + raise RuntimeError("Target must identify one running replica") + command("docker", "stop", "--time", "10", matches[0]["Id"]) + print("Selected API stopped") + elif action == "rolling": + count = len(data) + if count < 2: + raise RuntimeError("Need at least two replicas") + # Сначала добавляется готовая реплика, затем удаляется одна старая. + for old in data: + command( + "docker", + "compose", + "up", + "-d", + "--no-deps", + "--no-recreate", + "--scale", + f"api={count + 1}", + "api", + ) + wait_count(count + 1) + command("docker", "stop", "--time", "10", old["Id"]) + command("docker", "rm", old["Id"]) + wait_count(count) + print("Sequential replacement completed") + else: + raise ValueError("Unknown action") + + +if __name__ == "__main__": + main() diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..596a2399 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +docker compose restart api postgres cache s3 lb +docker compose up -d --no-build --no-recreate --wait diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100755 index 00000000..40ce4909 --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,3 @@ +#!/bin/sh +set -eu +exec python3 scripts/cluster.py rolling diff --git a/scripts/stand.py b/scripts/stand.py new file mode 100644 index 00000000..a56ff02a --- /dev/null +++ b/scripts/stand.py @@ -0,0 +1,137 @@ +import json +import os +import subprocess +import time +from pathlib import Path +from uuid import uuid4 + +import httpx + +ROOT = Path(__file__).resolve().parents[1] +BASE = os.environ.get("BASE_URL", "http://127.0.0.1:8084") + + +def command(args, *, input=None): + result = subprocess.run( + args, cwd=ROOT, input=input, capture_output=True, text=True + ) + if result.returncode: + raise RuntimeError( + "Command failed: " + + args[0] + + "; " + + result.stderr.replace(str(ROOT), "") + ) + return result.stdout.strip() + + +def compose(*args): + return command(["docker", "compose", *args]) + + +def sql(query, *, database="messenger"): + return compose( + "exec", + "-T", + "postgres", + "psql", + "-U", + "messenger", + "-d", + database, + "-A", + "-t", + "-v", + "ON_ERROR_STOP=1", + "-c", + query, + ) + + +def cache(command_name, *args): + script = ( + 'export REDISCLI_AUTH="$(cat /run/secrets/cache_password)"; ' + 'exec valkey-cli "$@"' + ) + return compose( + "exec", "-T", "cache", "sh", "-c", script, "sh", command_name, *args + ) + + +def ready(base=BASE, *, timeout=30): + end = time.monotonic() + timeout + with httpx.Client(base_url=base, trust_env=False, timeout=6) as client: + while time.monotonic() < end: + try: + if client.get("/health/ready").status_code == 200: + return + except httpx.HTTPError: + pass + time.sleep(0.2) + raise TimeoutError("API readiness") + + +def actor(client): + username = "verify_" + uuid4().hex[:20] + password = "Synthetic-" + uuid4().hex + ":🌍" + result = client.post( + "/api/v1/users", + json={ + "username": username, + "display_name": "Synthetic", + "password": password, + }, + ) + assert result.status_code == 201 + user = result.json() + session = client.post( + "/api/v1/auth/sessions", auth=httpx.BasicAuth(username, password) + ) + assert session.status_code == 201 + return user, password, session.json() + + +def auth(session): + return {"Authorization": "Bearer " + session["token"]} + + +def extra_api(*, ttl=3600, pool_size=1): + name = "mtusi-lab4-test-" + uuid4().hex[:10] + compose( + "run", + "-d", + "--no-deps", + "--name", + name, + "-e", + "SESSION_TTL_SECONDS=" + str(ttl), + "-e", + "DB_POOL_SIZE=" + str(pool_size), + "-p", + "127.0.0.1::8080", + "api", + ) + try: + info = json.loads(command(["docker", "inspect", name]))[0] + base = ( + "http://127.0.0.1:" + + info["NetworkSettings"]["Ports"]["8080/tcp"][0]["HostPort"] + ) + ready(base) + return name, base + except Exception: + command(["docker", "rm", "-f", name]) + raise + + +def instances(): + data = {} + for role in ["api", "postgres", "cache"]: + cid = compose("ps", "-q", role) + info = json.loads(command(["docker", "inspect", cid]))[0] + data[role] = { + "container": cid[:12], + "pid": info["State"]["Pid"], + "started_at": info["State"]["StartedAt"], + } + return data diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..a066590a --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,3 @@ +#!/bin/sh +set -eu +exec python3 scripts/cluster.py stop diff --git a/scripts/verify_clean.py b/scripts/verify_clean.py new file mode 100644 index 00000000..616bd56b --- /dev/null +++ b/scripts/verify_clean.py @@ -0,0 +1,215 @@ +import argparse +import atexit +import json +import os +import socket +import subprocess +import tempfile +from datetime import UTC, datetime +from pathlib import Path +from uuid import uuid4 + +ROOT = Path(__file__).resolve().parents[1] +PROGRESS = {} + + +def save_incomplete(): + receipt = PROGRESS.get("receipt") + if receipt and receipt.get("result") != "PASS": + target = PROGRESS["output"].with_name( + PROGRESS["output"].stem + "-failed.json" + ) + if target.exists(): + target = target.with_name( + target.stem + "-" + uuid4().hex[:8] + target.suffix + ) + target.parent.mkdir(parents=True, exist_ok=True) + target.write_text( + json.dumps( + {**receipt, "result": "INCOMPLETE"}, + ensure_ascii=False, + indent=2, + ) + + "\n" + ) + + +atexit.register(save_incomplete) + + +def run(args, *, cwd, env, expected=0): + result = subprocess.run( + args, cwd=cwd, env=env, capture_output=True, text=True + ) + + def redact(text): + return ( + text.replace(str(cwd), "") + .replace(str(ROOT), "") + .replace(str(Path.home()), "") + ) + + if result.returncode != expected: + if "receipt" in PROGRESS: + PROGRESS["receipt"]["failed_action"] = redact(" ".join(args)) + raise RuntimeError(redact(result.stdout + result.stderr)) + return redact(result.stdout.strip()) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--output", default="evidence/clean-clone.json") + args = parser.parse_args() + output = ROOT / args.output + if output.exists(): + raise SystemExit("Choose new output path") + assert not subprocess.check_output( + ["git", "status", "--porcelain"], cwd=ROOT + ) + sha = subprocess.check_output( + ["git", "rev-parse", "HEAD"], cwd=ROOT, text=True + ).strip() + identity = uuid4().hex[:10] + project = "mtusi-lab4-clean-" + identity + with socket.socket() as reservation: + reservation.bind(("127.0.0.1", 0)) + public_port = str(reservation.getsockname()[1]) + env = { + **os.environ, + "COMPOSE_PROJECT_NAME": project, + "API_IMAGE": "mtusi-messenger:lab4-clean-" + identity, + "PUBLIC_PORT": public_port, + "VCS_REF": sha, + "NO_PROXY": "localhost,127.0.0.1", + "no_proxy": "localhost,127.0.0.1", + } + receipt = { + "date": datetime.now(UTC).isoformat(), + "source_commit": sha, + "fresh_secrets_environment_and_volumes": True, + "command": "python scripts/verify_clean.py", + "fixed_host_port_for_restart": int(public_port), + } + PROGRESS.update(receipt=receipt, output=output) + with tempfile.TemporaryDirectory(prefix="mtusi-lab4-clean-") as temporary: + clone = Path(temporary) / "lab4" + run( + [ + "git", + "clone", + "--no-hardlinks", + "--branch", + "solution/bvt2301-maslov", + str(ROOT), + str(clone), + ], + cwd=ROOT, + env=env, + ) + for name in [".env", ".venv", "secrets"]: + assert not (clone / name).exists() + run(["uv", "sync", "--locked"], cwd=clone, env=env) + receipt["static_checks"] = run( + ["make", "check", "validate", "lint", "PYTHON=.venv/bin/python"], + cwd=clone, + env=env, + ) + run(["make", "bootstrap"], cwd=clone, env=env) + try: + run( + ["docker", "compose", "up", "-d", "--build", "--wait"], + cwd=clone, + env=env, + ) + env["BASE_URL"] = "http://127.0.0.1:" + public_port + receipt["smoke"] = run( + ["make", "test", "BASE_URL=" + env["BASE_URL"]], + cwd=clone, + env=env, + ) + receipt["http_tests"] = run( + [".venv/bin/pytest", "student-tests", "-q"], cwd=clone, env=env + ) + run( + [ + ".venv/bin/python", + "-m", + "scripts.verify_cluster", + "--output", + "evidence/clean-cluster.json", + ], + cwd=clone, + env=env, + ) + run( + [ + ".venv/bin/python", + "-m", + "scripts.verify_storage", + "--output", + "evidence/clean-storage.json", + ], + cwd=clone, + env=env, + ) + receipt["storage"] = json.loads( + (clone / "evidence/clean-storage.json").read_text() + ) + receipt["cluster"] = json.loads( + (clone / "evidence/clean-cluster.json").read_text() + ) + import hashlib + + expected = { + p.name: hashlib.sha256(p.read_bytes()).hexdigest() + for p in (clone / "src").glob("*.py") + } + ids = run( + ["docker", "compose", "ps", "-q", "api"], cwd=clone, env=env + ).split() + assert len(ids) == 2 + code = ( + "import hashlib,json,pathlib; print(json.dumps({p.name:" + "hashlib.sha256(p.read_bytes()).hexdigest() for p in pathlib.Path('/app/src').glob('*.py')}))" + ) + for cid in ids: + actual = json.loads( + run( + ["docker", "exec", cid, "python", "-c", code], + cwd=clone, + env=env, + ) + ) + assert actual == expected + info = json.loads( + run(["docker", "inspect", cid], cwd=clone, env=env) + )[0] + assert ( + info["Config"]["Labels"][ + "org.opencontainers.image.revision" + ] + == sha + ) + assert not info["HostConfig"]["PortBindings"] + receipt["both_replicas_runtime_hashes_and_revision_match"] = True + receipt["fsck"] = run( + ["git", "fsck", "--full"], cwd=clone, env=env + ) + receipt["checks_completed"] = True + finally: + assert project.startswith("mtusi-lab4-clean-") + run( + ["docker", "compose", "down", "--volumes", "--remove-orphans"], + cwd=clone, + env=env, + ) + receipt["result"] = "PASS" + output.parent.mkdir(parents=True, exist_ok=True) + output.write_text(json.dumps(receipt, ensure_ascii=False, indent=2) + "\n") + print( + "PASS: fresh clone, build, HTTP tests, failover, rolling, persistence and runtime hashes" + ) + + +if __name__ == "__main__": + main() diff --git a/scripts/verify_cluster.py b/scripts/verify_cluster.py new file mode 100644 index 00000000..15c08c0c --- /dev/null +++ b/scripts/verify_cluster.py @@ -0,0 +1,342 @@ +"""Проверки реальных процессов, failover, rolling и общей идемпотентности.""" + +import argparse +import json +import os +import subprocess +import threading +import time +from concurrent.futures import ThreadPoolExecutor +from datetime import datetime, timezone +from pathlib import Path +from uuid import uuid4 + +import httpx + +from scripts import cluster +from scripts.stand import BASE, ROOT, actor, auth, command, compose, ready, sql + + +def snapshot(): + ids = compose("ps", "-q").split() + result = [] + for c in json.loads(command(["docker", "inspect", *ids])): + role = c["Config"]["Labels"]["com.docker.compose.service"] + entry = { + "role": role, + "container": c["Id"][:12], + "pid": c["State"]["Pid"], + "started_at": c["State"]["StartedAt"], + "ports": c["HostConfig"]["PortBindings"], + "cpu_nano": c["HostConfig"]["NanoCpus"], + "memory_limit": c["HostConfig"]["Memory"], + } + if role == "api": + entry["instance"] = cluster.alias(c["Id"]) + assert not entry["ports"] + result.append(entry) + return result + + +def exercise(client, session, chat, action, *, seconds=15): + path = f"/api/v1/chats/{chat['id']}/messages" + observations, confirmed, errors, reads = [], {}, 0, 0 + started = time.monotonic() + finished = threading.Event() + action_result = {} + + def operate(): + time.sleep(0.5) + try: + action() + except BaseException as exc: + action_result["error"] = type(exc).__name__ + finally: + action_result["finished"] = round(time.monotonic() - started, 3) + finished.set() + + thread = threading.Thread(target=operate) + thread.start() + key = uuid4().hex + try: + while time.monotonic() - started < seconds or not finished.is_set(): + h = {**auth(session), "Idempotency-Key": key} + try: + r = client.post(path, headers=h, json={"text": key}) + if r.status_code != 201: + errors += 1 + continue + m = r.json() + confirmed[m["id"]] = m + observations.append( + { + "at": round(time.monotonic() - started, 3), + "instance": r.headers["x-instance-id"], + } + ) + key = uuid4().hex + read = client.get( + path, headers=auth(session), params={"limit": 100} + ) + reads += read.status_code == 200 + errors += read.status_code != 200 + except httpx.HTTPError: + errors += 1 + time.sleep(0.04) + finally: + thread.join(timeout=90) + assert not action_result.get("error"), action_result + found, cursor = [], None + while True: + r = client.get( + path, + headers=auth(session), + params={"limit": 100, **({"cursor": cursor} if cursor else {})}, + ) + assert r.status_code == 200 + page = r.json() + found.extend(page["items"]) + cursor = page["next_cursor"] + if not cursor: + break + by_id = {m["id"]: m for m in found} + assert all(by_id.get(k) == v for k, v in confirmed.items()) + texts = [m["text"] for m in found] + assert len(texts) == len(set(texts)) + recovery = next( + ( + x["at"] + for x in observations + if x["at"] >= action_result["finished"] + ), + None, + ) + assert recovery is not None and (seconds > 20 or recovery <= 10) + elapsed = time.monotonic() - started + return { + "confirmed_writes": len(confirmed), + "successful_reads": reads, + "errors": errors, + "successful_rps": round((len(confirmed) + reads) / elapsed, 2), + "first_success_after_action_seconds": recovery, + "action": action_result, + "observations": observations, + "confirmed_preserved": True, + "duplicate_texts": False, + } + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--output", default="evidence/cluster-repeat.json") + args = parser.parse_args() + report = { + "date": datetime.now(timezone.utc).isoformat(), + "source_commit": command(["git", "rev-parse", "HEAD"]), + "complete": False, + } + output = Path(args.output) + output.parent.mkdir(parents=True, exist_ok=True) + try: + ready() + initial = snapshot() + apis = [c for c in initial if c["role"] == "api"] + assert len(apis) == 2 and len({c["pid"] for c in apis}) == 2 + report["before"] = initial + with httpx.Client(base_url=BASE, trust_env=False, timeout=8) as client: + user, _, session = actor(client) + r = client.post( + "/api/v1/chats", + headers=auth(session), + json={ + "title": "Cluster verification", + "member_ids": [user["id"]], + }, + ) + assert r.status_code == 201 + chat = r.json() + path = f"/api/v1/chats/{chat['id']}/messages" + key = uuid4().hex + + def repeat(_): + with httpx.Client( + base_url=BASE, trust_env=False, timeout=8 + ) as c: + r = c.post( + path, + headers={**auth(session), "Idempotency-Key": key}, + json={"text": "Same concurrent request"}, + ) + assert r.status_code == 201 + return r.json(), r.headers["x-instance-id"] + + with ThreadPoolExecutor(max_workers=10) as pool: + repeated = list(pool.map(repeat, range(30))) + assert len({m[0]["id"] for m in repeated}) == 1 + assert len({m[1] for m in repeated}) == 2 + report["parallel_replay"] = { + "requests": 30, + "messages": 1, + "instances": sorted({m[1] for m in repeated}), + } + # Сбой второй записи транзакции не должен оставить сообщение. + fault_key = uuid4().hex + fault_text = "Atomic rollback " + fault_key + sql( + "CREATE FUNCTION student_idempo_fault() RETURNS trigger " + "LANGUAGE plpgsql AS $$ BEGIN IF NEW.key='" + + fault_key + + "' THEN RAISE EXCEPTION 'synthetic'; END IF; RETURN NEW; END $$; " + "CREATE TRIGGER student_idempo_fault BEFORE INSERT ON idempotency " + "FOR EACH ROW EXECUTE FUNCTION student_idempo_fault()" + ) + try: + failed = client.post( + path, + headers={**auth(session), "Idempotency-Key": fault_key}, + json={"text": fault_text}, + ) + assert failed.status_code == 500 + assert ( + sql( + "SELECT count(*) FROM messages WHERE text='" + + fault_text + + "'" + ) + == "0" + ) + finally: + sql( + "DROP TRIGGER student_idempo_fault ON idempotency; " + "DROP FUNCTION student_idempo_fault()" + ) + retried = client.post( + path, + headers={**auth(session), "Idempotency-Key": fault_key}, + json={"text": fault_text}, + ) + assert retried.status_code == 201 + report["atomic_rollback_and_5xx_retry"] = True + sql( + "UPDATE idempotency SET expires_at=clock_timestamp()-interval '1 second' " + "WHERE key='" + fault_key + "'" + ) + expired = client.post( + path, + headers={**auth(session), "Idempotency-Key": fault_key}, + json={"text": "New retention window"}, + ) + assert expired.status_code == 201 + assert expired.json()["id"] != retried.json()["id"] + report["expired_key_can_be_reused"] = True + # Отдельный чат каждой серии: проверки дубликатов не смешивают тексты. + report["failovers"] = [] + for api in apis: + + def stop(target=api["instance"]): + env = {**os.environ, "TARGET_INSTANCE_ID": target} + subprocess.run( + ["scripts/stop-one.sh"], + cwd=ROOT, + env=env, + check=True, + capture_output=True, + text=True, + ) + + r = client.post( + "/api/v1/chats", + headers=auth(session), + json={"title": "Failover", "member_ids": [user["id"]]}, + ) + result = exercise(client, session, r.json(), stop) + assert api["instance"] not in [ + o["instance"] for o in result["observations"][-5:] + ] + assert ( + command( + [ + "docker", + "inspect", + "-f", + "{{.State.Running}}", + api["container"], + ] + ) + == "false" + ) + result["stopped"] = api + report["failovers"].append(result) + compose("up", "-d", "--no-build", "--wait") + ready() + r = client.post( + "/api/v1/chats", + headers=auth(session), + json={"title": "Rolling", "member_ids": [user["id"]]}, + ) + before_roll = snapshot() + report["rolling"] = exercise( + client, + session, + r.json(), + lambda: command(["scripts/rolling-update.sh"]), + seconds=45, + ) + after_roll = snapshot() + assert not ( + {c["container"] for c in before_roll if c["role"] == "api"} + & {c["container"] for c in after_roll if c["role"] == "api"} + ) + report["rolling"]["before"] = before_roll + report["rolling"]["after"] = after_roll + replay = repeat(0)[0] + assert replay == repeated[0][0] + report["replay_after_replacement"] = True + before = snapshot() + env = { + **os.environ, + "NO_PROXY": "localhost,127.0.0.1", + "no_proxy": "localhost,127.0.0.1", + } + for mode, hook in [ + ("failover", "scripts/stop-one.sh"), + ("persistence", "scripts/restart.sh"), + ]: + if mode == "persistence": + compose("up", "-d", "--no-build", "--wait") + ready() + before = snapshot() + run = subprocess.run( + [ + ".venv/bin/python", + "tests/resilience.py", + "--mode", + mode, + "--action-script", + hook, + "--base-url", + BASE, + ], + cwd=ROOT, + env=env, + capture_output=True, + text=True, + ) + assert run.returncode == 0, run.stdout + run.stderr + report["public_" + mode] = run.stdout.strip() + after = snapshot() + for role in ["postgres", "cache", "s3", "lb"]: + old = next(c for c in before if c["role"] == role) + new = next(c for c in after if c["role"] == role) + assert old["started_at"] != new["started_at"] + report["after_persistence"] = after + report["complete"] = True + finally: + output.write_text( + json.dumps(report, ensure_ascii=False, indent=2) + "\n" + ) + print("PASS: process failover, rolling, replay and full persistence") + + +if __name__ == "__main__": + main() diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/__main__.py b/src/__main__.py new file mode 100644 index 00000000..20228f97 --- /dev/null +++ b/src/__main__.py @@ -0,0 +1,44 @@ +import json +import logging +import os +import signal +import sys + + +def early_stop(signum, _frame): + print( + json.dumps({"event": "stopped_before_startup", "signal": signum}), + flush=True, + ) + sys.exit(0) + + +signal.signal(signal.SIGTERM, early_stop) +signal.signal(signal.SIGINT, early_stop) + +import uvicorn # noqa: E402 + +from src.logging_config import JsonFormatter # noqa: E402 + + +def main() -> None: + host = os.environ.get("APP_HOST", "127.0.0.1") + port = int(os.environ.get("APP_PORT", "8080")) + if not 1 <= port <= 65535: + raise ValueError("APP_PORT must be between 1 and 65535") + handler = logging.StreamHandler(sys.stdout) + handler.setFormatter(JsonFormatter()) + logging.basicConfig(level=logging.INFO, handlers=[handler], force=True) + uvicorn.run( + "src.api:app", + host=host, + port=port, + workers=1, + access_log=False, + timeout_graceful_shutdown=5, + log_config=None, + ) + + +if __name__ == "__main__": + main() diff --git a/src/api.py b/src/api.py new file mode 100644 index 00000000..8265a57f --- /dev/null +++ b/src/api.py @@ -0,0 +1,424 @@ +import hashlib +import json +import logging +import tempfile +import time +from collections.abc import AsyncIterator +from contextlib import asynccontextmanager +from datetime import datetime +from functools import partial +from urllib.parse import quote +from uuid import UUID, uuid4 + +from anyio import Semaphore, fail_after, to_thread +from fastapi import FastAPI, Request +from fastapi.encoders import jsonable_encoder +from pydantic import ValidationError +from starlette.exceptions import HTTPException +from starlette.requests import ClientDisconnect +from starlette.responses import JSONResponse, Response, StreamingResponse + +from src import images +from src.attachments import Attachments +from src.cache import UserCache +from src.cursor import parse_uuid +from src.database import Database +from src.domain import timestamp +from src.errors import DomainError, invalid +from src.object_store import ObjectStore +from src.password import Passwords +from src.repository import PostgresRepository +from src.schemas import CreateChat, CreateMessage, CreateUser, Input +from src.service import MessengerService +from src.settings import Settings + +logger = logging.getLogger("messenger") +INSTANCE_ID = uuid4().hex + + +def response(data: object, *, status: int = 200) -> JSONResponse: + return JSONResponse( + jsonable_encoder( + data, custom_encoder={datetime: timestamp, UUID: str} + ), + status_code=status, + ) + + +async def body(request: Request, model: type[Input]) -> Input: + try: + data = await request.body() + return model.model_validate( + json.loads( + data.decode("utf-8"), + parse_constant=lambda _: (_ for _ in ()).throw(ValueError()), + ) + ) + except ValueError, ValidationError, UnicodeError, RecursionError: + raise invalid() from None + + +def pagination(request: Request) -> tuple[int, str | None]: + limits = request.query_params.getlist("limit") + cursors = request.query_params.getlist("cursor") + if len(limits) > 1 or len(cursors) > 1: + raise invalid() + raw = limits[0] if limits else "50" + if not raw.isascii() or not raw.isdecimal(): + raise invalid() + raw = raw.lstrip("0") or "0" + if len(raw) > 3: + raise invalid() + limit = int(raw) + if not 1 <= limit <= 100: + raise invalid() + return limit, cursors[0] if cursors else None + + +def service(request: Request) -> MessengerService: + return request.app.state.service + + +async def run_io(function, **kwargs): + return await to_thread.run_sync(partial(function, **kwargs)) + + +async def actor(request: Request): + return await run_io( + service(request).identify, value=request.headers.get("authorization") + ) + + +@asynccontextmanager +async def lifespan(app: FastAPI) -> AsyncIterator[None]: + settings = Settings.load() + database = Database(url=settings.database_url, size=settings.pool_size) + cache = UserCache(url=settings.cache_url) + store = ObjectStore() + try: + await run_io(database.open) + passwords = await run_io(Passwords) + app.state.database = database + app.state.store = store + app.state.upload_slots = Semaphore(2) + app.state.attachments = Attachments( + database=database, store=store, instance=INSTANCE_ID + ) + app.state.service = MessengerService( + repository=PostgresRepository(database=database, cache=cache), + passwords=passwords, + session_ttl=settings.session_ttl, + ) + app.state.ready = True + yield + finally: + app.state.ready = False + await run_io(store.close) + await run_io(cache.close) + await run_io(database.close) + + +app = FastAPI( + lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None +) + + +@app.middleware("http") +async def request_context(request: Request, call_next): + request_id = str(uuid4()) + request.state.request_id = request_id + started = time.perf_counter() + try: + result = await call_next(request) + except Exception: + logger.error( + json.dumps({"event": "internal_error", "request_id": request_id}) + ) + result = response( + { + "error": { + "code": "internal_error", + "message": "Internal error", + "request_id": request_id, + } + }, + status=500, + ) + result.headers["X-Request-Id"] = request_id + result.headers["X-Instance-Id"] = INSTANCE_ID + route = request.scope.get("route") + logger.info( + json.dumps( + { + "event": "request", + "request_id": request_id, + "method": request.method, + "route": getattr(route, "path", "unmatched"), + "status": result.status_code, + "elapsed_ms": round((time.perf_counter() - started) * 1000, 3), + } + ) + ) + return result + + +@app.exception_handler(DomainError) +async def domain_error(request: Request, error: DomainError): + result = response( + { + "error": { + "code": error.code, + "message": error.message, + "request_id": request.state.request_id, + } + }, + status=error.status, + ) + result.headers.update(error.headers) + return result + + +@app.exception_handler(HTTPException) +async def http_error(request: Request, error: HTTPException): + code = "not_found" if error.status_code == 404 else "invalid_request" + return response( + { + "error": { + "code": code, + "message": "Resource not found" + if error.status_code == 404 + else "Invalid request", + "request_id": request.state.request_id, + } + }, + status=error.status_code, + ) + + +@app.get("/health/live") +async def live(): + return response({"status": "ok"}) + + +@app.get("/health/ready") +async def ready(): + if not getattr(app.state, "ready", False): + raise DomainError(503, "unavailable", "Not ready") + await run_io(app.state.database.ping) + await run_io(app.state.store.ping) + return response({"status": "ok"}) + + +@app.post("/api/v1/users") +async def register(request: Request): + data = await body(request, CreateUser) + return response( + await run_io(service(request).register, **data.model_dump()), + status=201, + ) + + +@app.get("/api/v1/users/me") +async def current(request: Request): + return response(await actor(request)) + + +@app.post("/api/v1/chats") +async def create_chat(request: Request): + user = await actor(request) + data = await body(request, CreateChat) + return response( + await run_io( + service(request).create_chat, actor_id=user.id, **data.model_dump() + ), + status=201, + ) + + +@app.get("/api/v1/chats") +async def list_chats(request: Request): + user = await actor(request) + limit, cursor = pagination(request) + return response( + await run_io( + service(request).chats, + actor_id=user.id, + limit=limit, + cursor=cursor, + ) + ) + + +@app.get("/api/v1/chats/{chat_id}") +async def get_chat(request: Request, chat_id: str): + user = await actor(request) + return response( + await run_io( + service(request).get_chat, + actor_id=user.id, + chat_id=parse_uuid(chat_id), + ) + ) + + +@app.post("/api/v1/chats/{chat_id}/messages") +async def send(request: Request, chat_id: str): + user = await actor(request) + cid = parse_uuid(chat_id) + await run_io(service(request).get_chat, actor_id=user.id, chat_id=cid) + data = await body(request, CreateMessage) + return response( + await run_io( + service(request).send, + actor_id=user.id, + chat_id=cid, + idempotency_key=request.headers.get("idempotency-key"), + **data.model_dump(), + ), + status=201, + ) + + +@app.get("/api/v1/chats/{chat_id}/messages") +async def history(request: Request, chat_id: str): + user = await actor(request) + cid = parse_uuid(chat_id) + chat = await run_io( + service(request).get_chat, actor_id=user.id, chat_id=cid + ) + limit, cursor = pagination(request) + return response( + await run_io( + service(request).history, + actor_id=user.id, + chat=chat, + limit=limit, + cursor=cursor, + ) + ) + + +@app.post("/api/v1/auth/sessions") +async def login(request: Request): + return response( + await run_io( + service(request).login, + authorization=request.headers.get("authorization"), + ), + status=201, + ) + + +@app.delete("/api/v1/auth/sessions/current") +async def logout(request: Request): + await run_io( + service(request).logout, + authorization=request.headers.get("authorization"), + ) + return Response(status_code=204) + + +@app.post("/api/v1/chats/{chat_id}/attachments") +async def upload(request: Request, chat_id: str): + user = await actor(request) + cid = parse_uuid(chat_id) + await run_io(service(request).get_chat, actor_id=user.id, chat_id=cid) + names = request.query_params.getlist("filename") + if len(names) != 1: + raise invalid() + name = images.filename(names[0]) + declared = ( + request.headers.get("content-type", "") + .partition(";")[0] + .strip() + .lower() + ) + if declared not in {"image/png", "image/jpeg"}: + raise DomainError( + 415, "unsupported_media_type", "PNG or JPEG required" + ) + length = request.headers.get("content-length") + if length and (not length.isdecimal() or len(length) > 12): + raise invalid() + if length and int(length) > images.MAX_BYTES: + raise DomainError(413, "payload_too_large", "Byte limit exceeded") + try: + with fail_after(20): + async with app.state.upload_slots: + with tempfile.SpooledTemporaryFile( + max_size=1024 * 1024, mode="w+b" + ) as stream: + size = 0 + digest = hashlib.sha256() + async for chunk in request.stream(): + size += len(chunk) + if size > images.MAX_BYTES: + raise DomainError( + 413, "payload_too_large", "Byte limit exceeded" + ) + digest.update(chunk) + stream.write(chunk) + await run_io( + images.verify, stream=stream, declared=declared + ) + result = await run_io( + app.state.attachments.upload, + chat_id=cid, + owner_id=user.id, + filename=name, + content_type=declared, + size=size, + sha256=digest.hexdigest(), + stream=stream, + ) + return response(result, status=201) + except ClientDisconnect: + raise invalid() from None + except TimeoutError: + raise DomainError( + 503, "unavailable", "Upload deadline exceeded" + ) from None + + +@app.get("/api/v1/attachments/{attachment_id}") +async def attachment_metadata(request: Request, attachment_id: str): + user = await actor(request) + return response( + await run_io( + app.state.attachments.metadata, + identity=parse_uuid(attachment_id), + actor_id=user.id, + ) + ) + + +@app.get("/api/v1/attachments/{attachment_id}/content") +async def attachment_content(request: Request, attachment_id: str): + user = await actor(request) + variants = request.query_params.getlist("variant") + if len(variants) > 1: + raise invalid() + row, upstream = await run_io( + app.state.attachments.content, + identity=parse_uuid(attachment_id), + actor_id=user.id, + variant=variants[0] if variants else "original", + ) + + def chunks(): + try: + while data := upstream.read(65536): + yield data + finally: + upstream.close() + upstream.release_conn() + + return StreamingResponse( + chunks(), + media_type=row["content_type"], + headers={ + "Content-Length": str(row["size_bytes"]), + "Content-Disposition": "inline; filename*=UTF-8''" + + quote(row["filename"], safe=""), + }, + ) diff --git a/src/attachments.py b/src/attachments.py new file mode 100644 index 00000000..be170108 --- /dev/null +++ b/src/attachments.py @@ -0,0 +1,116 @@ +from uuid import uuid4 + +from src.errors import DomainError, not_found + + +def dto(row): + if row["state"] != "ready": + raise DomainError(409, "conflict", "Attachment is not ready") + return { + k: row[k] + for k in [ + "id", + "chat_id", + "owner_id", + "filename", + "content_type", + "size_bytes", + "sha256", + "created_at", + "updated_at", + ] + } | { + "status": "ready", + "variants": [], + "error_code": None, + } + + +class Attachments: + def __init__(self, *, database, store, instance): + self.database = database + self.store = store + self.instance = instance + + def upload( + self, + *, + chat_id, + owner_id, + filename, + content_type, + size, + sha256, + stream, + ): + identity = uuid4() + key = f"objects/{identity}/original" + # Durable intent precedes bytes; expired writers cannot confirm. + with self.database.connection() as conn: + conn.execute( + "INSERT INTO attachments(id,chat_id,owner_id,filename," + "content_type," + "size_bytes,sha256,object_key,state,uploader_instance," + "expires_at) " + "VALUES(%s,%s,%s,%s,%s,%s,%s,%s,'pending',%s," + "clock_timestamp()+interval '120 seconds')", + ( + identity, + chat_id, + owner_id, + filename, + content_type, + size, + sha256, + key, + self.instance, + ), + ) + self.store.put( + key=key, + stream=stream, + size=size, + content_type=content_type, + sha256=sha256, + ) + with self.database.connection() as conn: + row = conn.execute( + "UPDATE attachments SET state='ready'," + "updated_at=clock_timestamp() " + "WHERE id=%s AND state='pending' " + "AND expires_at>clock_timestamp() " + "RETURNING *", + (identity,), + ).fetchone() + if row is None: + row = conn.execute( + "SELECT * FROM attachments WHERE id=%s", (identity,) + ).fetchone() + if row["state"] != "ready": + raise DomainError( + 503, "unavailable", "Upload reservation expired" + ) + return dto(row) + + def row(self, *, identity, actor_id): + with self.database.connection() as conn: + row = conn.execute( + "SELECT a.* FROM attachments a JOIN members m " + "ON m.chat_id=a.chat_id AND m.user_id=%s WHERE a.id=%s", + (actor_id, identity), + ).fetchone() + if row is None: + raise not_found() + return row + + def metadata(self, *, identity, actor_id): + return dto(self.row(identity=identity, actor_id=actor_id)) + + def content(self, *, identity, actor_id, variant): + row = self.row(identity=identity, actor_id=actor_id) + dto(row) + if variant != "original": + raise not_found() + if self.store.head(key=row["object_key"]) is None: + raise DomainError(503, "unavailable", "Original unavailable") + return row, self.store.get(key=row["object_key"]) diff --git a/src/cache.py b/src/cache.py new file mode 100644 index 00000000..adbea82b --- /dev/null +++ b/src/cache.py @@ -0,0 +1,66 @@ +import json +import threading +import time +from datetime import datetime +from uuid import UUID + +import redis +from redis.backoff import NoBackoff +from redis.retry import Retry + +from src.domain import User, timestamp + + +class UserCache: + def __init__(self, *, url: str): + self.client = redis.Redis.from_url( + url, + socket_connect_timeout=0.15, + socket_timeout=0.15, + max_connections=16, + retry=Retry(NoBackoff(), 0), + decode_responses=True, + ) + self.disabled_until = 0.0 + self.lock = threading.Lock() + + def close(self): + self.client.close() + + def _command(self, function, *args, **kwargs): + if time.monotonic() < self.disabled_until: + return None + try: + return function(*args, **kwargs) + except redis.RedisError, OSError: + with self.lock: + self.disabled_until = time.monotonic() + 5 + return None + + def get(self, *, user_id: UUID) -> User | None: + raw = self._command(self.client.get, "user:" + str(user_id)) + if raw is None: + return None + try: + row = json.loads(raw) + if UUID(row["id"]) != user_id: + return None + return User( + user_id, + row["username"], + row["display_name"], + datetime.fromisoformat(row["created_at"]), + ) + except ValueError, TypeError, KeyError: + return None + + def put(self, *, user: User): + raw = json.dumps( + { + "id": str(user.id), + "username": user.username, + "display_name": user.display_name, + "created_at": timestamp(user.created_at), + } + ) + self._command(self.client.set, "user:" + str(user.id), raw, ex=30) diff --git a/src/cursor.py b/src/cursor.py new file mode 100644 index 00000000..9d9c3c9c --- /dev/null +++ b/src/cursor.py @@ -0,0 +1,64 @@ +import base64 +import binascii +import json +import re +from datetime import datetime +from uuid import UUID + +from src.domain import Key, timestamp +from src.errors import invalid + + +def parse_uuid(value: str) -> UUID: + if not isinstance(value, str) or not re.fullmatch( + r"[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}", value + ): + raise invalid() + return UUID(value) + + +def encode_cursor(*, scope: str, key: Key) -> str: + payload = { + "v": 1, + "scope": scope, + "at": timestamp(key[0]), + "id": str(key[1]), + } + return ( + base64.urlsafe_b64encode( + json.dumps(payload, separators=(",", ":")).encode() + ) + .decode() + .rstrip("=") + ) + + +def decode_cursor(*, value: str | None, scope: str) -> Key | None: + if value is None: + return None + try: + if ( + not value + or len(value) > 2048 + or not re.fullmatch(r"[A-Za-z0-9_-]+", value) + ): + raise ValueError + data = json.loads( + base64.b64decode( + value + "=" * (-len(value) % 4), altchars=b"-_", validate=True + ) + ) + if ( + not isinstance(data, dict) + or type(data.get("v")) is not int + or data["v"] != 1 + or data.get("scope") != scope + or not isinstance(data.get("at"), str) + ): + raise ValueError + at = datetime.fromisoformat(data["at"]) + if at.tzinfo is None or timestamp(at) != data["at"]: + raise ValueError + return at, parse_uuid(data["id"]) + except ValueError, TypeError, KeyError, binascii.Error, RecursionError: + raise invalid() from None diff --git a/src/database.py b/src/database.py new file mode 100644 index 00000000..130b5238 --- /dev/null +++ b/src/database.py @@ -0,0 +1,69 @@ +import time +from contextlib import contextmanager + +import psycopg +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool, PoolTimeout + +from src.errors import DomainError + + +class DeadlineConnection(psycopg.Connection): + """Клиентский срок действует и при замороженном PostgreSQL.""" + + def wait(self, gen, interval=0.1, timeout=None): + deadline = getattr(self, "request_deadline", None) + remaining = ( + max(0.001, deadline - time.monotonic()) if deadline else 3.0 + ) + bound = min(remaining, timeout) if timeout is not None else remaining + try: + return super().wait(gen, interval=interval, timeout=bound) + except psycopg.OperationalError: + self.close() + raise + + +class Database: + def __init__(self, *, url: str, size: int): + self.pool = ConnectionPool( + url, + connection_class=DeadlineConnection, + kwargs={ + "autocommit": True, + "row_factory": dict_row, + "connect_timeout": 2, + "options": ( + "-c statement_timeout=2500 -c lock_timeout=1000 " + "-c idle_in_transaction_session_timeout=6000" + ), + }, + min_size=1, + max_size=size, + timeout=1, + open=False, + ) + + def open(self): + self.pool.open(wait=True, timeout=10) + + def close(self): + self.pool.close(timeout=2) + + @contextmanager + def connection(self): + try: + with self.pool.connection(timeout=1) as conn: + conn.request_deadline = time.monotonic() + 4 + try: + yield conn + finally: + conn.request_deadline = None + except psycopg.OperationalError, psycopg.InterfaceError, PoolTimeout: + raise DomainError( + 503, "unavailable", "Database unavailable" + ) from None + + def ping(self): + with self.connection() as conn: + conn.execute("SELECT 1").fetchone() diff --git a/src/domain.py b/src/domain.py new file mode 100644 index 00000000..e595a2e6 --- /dev/null +++ b/src/domain.py @@ -0,0 +1,45 @@ +from dataclasses import dataclass +from datetime import UTC, datetime +from uuid import UUID + + +def utcnow() -> datetime: + return datetime.now(UTC) + + +def timestamp(value: datetime) -> str: + return value.isoformat(timespec="microseconds").replace("+00:00", "Z") + + +@dataclass(frozen=True, slots=True) +class User: + id: UUID + username: str + display_name: str + created_at: datetime + + +@dataclass(frozen=True, slots=True) +class Chat: + id: UUID + title: str + member_ids: tuple[UUID, ...] + created_at: datetime + + +@dataclass(frozen=True, slots=True) +class Message: + id: UUID + chat_id: UUID + sender_id: UUID + text: str + created_at: datetime + attachment_ids: tuple[UUID, ...] = () + + +type Record = User | Chat | Message +type Key = tuple[datetime, UUID] + + +def order_key(record: Record) -> Key: + return record.created_at, record.id diff --git a/src/errors.py b/src/errors.py new file mode 100644 index 00000000..693b2ccf --- /dev/null +++ b/src/errors.py @@ -0,0 +1,16 @@ +class DomainError(Exception): + def __init__( + self, status: int, code: str, message: str, headers=None + ) -> None: + self.status = status + self.code = code + self.message = message + self.headers = headers or {} + + +def invalid() -> DomainError: + return DomainError(400, "invalid_request", "Invalid request") + + +def not_found() -> DomainError: + return DomainError(404, "not_found", "Resource not found") diff --git a/src/images.py b/src/images.py new file mode 100644 index 00000000..bf7f57bb --- /dev/null +++ b/src/images.py @@ -0,0 +1,77 @@ +import struct +import threading +import unicodedata +import zlib + +from PIL import Image, UnidentifiedImageError + +from src.errors import DomainError, invalid + +MAX_BYTES = 10 * 1024 * 1024 +MAX_PIXELS = 40_000_000 +Image.MAX_IMAGE_PIXELS = MAX_PIXELS +DECODE_SLOT = threading.BoundedSemaphore(1) + + +def filename(value): + if ( + not value + or not 1 <= len(value) <= 255 + or not value.strip() + or any( + c in "/\\" or unicodedata.category(c) in {"Cc", "Cs"} + for c in value + ) + ): + raise invalid() + return value + + +def verify(stream, *, declared): + if declared not in {"image/png", "image/jpeg"}: + raise DomainError( + 415, "unsupported_media_type", "PNG or JPEG required" + ) + with DECODE_SLOT: + try: + stream.seek(0) + with Image.open(stream) as image: + actual = {"PNG": "image/png", "JPEG": "image/jpeg"}.get( + image.format + ) + if actual != declared: + raise DomainError( + 415, "unsupported_media_type", "Image type mismatch" + ) + if image.width * image.height > MAX_PIXELS: + raise DomainError( + 413, "payload_too_large", "Pixel limit exceeded" + ) + image.verify() + # JPEG verify alone does not decode entropy data. + stream.seek(0) + with Image.open(stream) as image: + image.load() + except Image.DecompressionBombError: + raise DomainError( + 413, "payload_too_large", "Pixel limit exceeded" + ) from None + except ( + UnidentifiedImageError, + OSError, + ValueError, + SyntaxError, + struct.error, + zlib.error, + EOFError, + ): + raise DomainError( + 415, "unsupported_media_type", "Invalid image" + ) from None + except MemoryError: + raise DomainError( + 503, "unavailable", "Image memory budget exceeded" + ) from None + finally: + stream.seek(0) + return declared diff --git a/src/logging_config.py b/src/logging_config.py new file mode 100644 index 00000000..e89db63a --- /dev/null +++ b/src/logging_config.py @@ -0,0 +1,17 @@ +import json +import logging +from datetime import UTC, datetime + + +class JsonFormatter(logging.Formatter): + def format(self, record: logging.LogRecord) -> str: + message = record.getMessage() + try: + event = json.loads(message) + if not isinstance(event, dict): + event = {"event": message} + except ValueError: + event = {"event": message} + event["timestamp"] = datetime.now(UTC).isoformat() + event["level"] = record.levelname.lower() + return json.dumps(event, ensure_ascii=False) diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..30363ba6 --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,51 @@ +import hashlib +import json +from pathlib import Path + +import psycopg + +from src.settings import secret + + +def main(): + with psycopg.connect( + secret("DATABASE_URL"), autocommit=True, connect_timeout=3 + ) as conn: + conn.execute("SELECT pg_advisory_lock(2301002)") + try: + conn.execute( + "CREATE TABLE IF NOT EXISTS schema_migrations " + "(name text PRIMARY KEY, checksum text NOT NULL, " + "applied_at timestamptz NOT NULL DEFAULT now())" + ) + for path in sorted(Path("migrations").glob("*.sql")): + content = path.read_bytes() + checksum = hashlib.sha256(content).hexdigest() + row = conn.execute( + "SELECT checksum FROM schema_migrations WHERE name=%s", + (path.name,), + ).fetchone() + if row: + if row[0] != checksum: + raise RuntimeError( + "Applied migration checksum mismatch" + ) + continue + with conn.transaction(): + conn.execute(content.decode()) + conn.execute( + "INSERT INTO schema_migrations(name,checksum) " + "VALUES(%s,%s)", + (path.name, checksum), + ) + print( + json.dumps( + {"event": "migration_applied", "name": path.name} + ) + ) + finally: + conn.execute("SELECT pg_advisory_unlock(2301002)") + + +if __name__ == "__main__": + main() diff --git a/src/object_store.py b/src/object_store.py new file mode 100644 index 00000000..998a7467 --- /dev/null +++ b/src/object_store.py @@ -0,0 +1,84 @@ +from contextlib import contextmanager + +import urllib3 +from minio import Minio +from minio.error import S3Error + +from src.errors import DomainError +from src.settings import secret + +BUCKET = "messenger" + + +class ObjectStore: + def __init__(self): + self.http = urllib3.PoolManager( + maxsize=32, + block=True, + timeout=urllib3.Timeout(connect=1, read=3), + retries=urllib3.Retry(total=0), + ) + self.client = Minio( + "s3:9000", + access_key=secret("S3_ACCESS_KEY"), + secret_key=secret("S3_SECRET_KEY"), + secure=False, + region="us-east-1", + http_client=self.http, + ) + + @contextmanager + def operation(self): + try: + yield + except S3Error, urllib3.exceptions.HTTPError, OSError: + raise DomainError( + 503, "unavailable", "Object store unavailable" + ) from None + + def ping(self): + with self.operation(): + if not self.client.bucket_exists(BUCKET): + raise DomainError( + 503, "unavailable", "Object store unavailable" + ) + + def put(self, *, key, stream, size, content_type, sha256): + stream.seek(0) + with self.operation(): + self.client.put_object( + BUCKET, + key, + stream, + length=size, + content_type=content_type, + metadata={"sha256": sha256}, + part_size=10 * 1024 * 1024, + num_parallel_uploads=1, + ) + + def head(self, *, key): + with self.operation(): + try: + return self.client.stat_object(BUCKET, key) + except S3Error as exc: + if exc.code in {"NoSuchKey", "NoSuchObject"}: + return None + raise + + def get(self, *, key): + with self.operation(): + return self.client.get_object(BUCKET, key) + + def delete(self, *, key): + with self.operation(): + self.client.remove_object(BUCKET, key) + + def objects(self): + with self.operation(): + yield from self.client.list_objects( + BUCKET, prefix="objects/", recursive=True + ) + + def close(self): + self.http.clear() diff --git a/src/password.py b/src/password.py new file mode 100644 index 00000000..bce8bd29 --- /dev/null +++ b/src/password.py @@ -0,0 +1,36 @@ +import threading + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError +from argon2.low_level import Type + +from src.errors import DomainError + + +class Passwords: + def __init__(self): + self.hasher = PasswordHasher( + time_cost=3, memory_cost=65536, parallelism=4, type=Type.ID + ) + self.slots = threading.BoundedSemaphore(2) + self.dummy = self.hasher.hash("Synthetic-dummy-password-not-for-login") + + def _run(self, function, *args): + if not self.slots.acquire(timeout=5): + raise DomainError(503, "unavailable", "Authentication busy") + try: + return function(*args) + finally: + self.slots.release() + + def hash(self, *, password: str) -> str: + return self._run(self.hasher.hash, password) + + def verify(self, *, password: str, encoded: str | None) -> bool: + try: + return ( + self._run(self.hasher.verify, encoded or self.dummy, password) + and encoded is not None + ) + except VerificationError, InvalidHashError: + return False diff --git a/src/reconcile.py b/src/reconcile.py new file mode 100644 index 00000000..e5767f65 --- /dev/null +++ b/src/reconcile.py @@ -0,0 +1,200 @@ +"""Сверка двух stores: dry-run по умолчанию, grace не менее пяти минут.""" + +import argparse +import hashlib +import json +import time +from datetime import timedelta + +from src.database import Database +from src.object_store import ObjectStore +from src.settings import integer, secret + + +def verified(store, row, counters): + counters["head_requests"] += 1 + info = store.head(key=row["object_key"]) + if info is None: + return "missing" + if info.size != row["size_bytes"]: + return "mismatch" + result = store.get(key=row["object_key"]) + digest = hashlib.sha256() + size = 0 + try: + while data := result.read(65536): + digest.update(data) + size += len(data) + counters["bytes_read"] += len(data) + if size > 10 * 1024 * 1024: + return "mismatch" + finally: + result.close() + result.release_conn() + return "valid" if digest.hexdigest() == row["sha256"] else "mismatch" + + +def reconcile(database, store, *, apply, grace): + started = time.monotonic() + result = { + "apply": apply, + "grace_seconds": grace, + "objects_scanned": 0, + "rows_scanned": 0, + "head_requests": 0, + "bytes_read": 0, + "fresh_protected": 0, + "ready_protected": 0, + "linked_protected": 0, + "actions": {}, + "applied": {}, + "details": [], + } + with database.connection() as conn: + now = conn.execute("SELECT clock_timestamp() AS at").fetchone()["at"] + rows = conn.execute("SELECT * FROM attachments ORDER BY id").fetchall() + cutoff = now - timedelta(seconds=grace) + objects = {o.object_name: o for o in store.objects()} + result["objects_scanned"] = len(objects) + result["rows_scanned"] = len(rows) + keys = {r["object_key"] for r in rows} + + def record(action, identity, *, changed=False): + result["actions"][action] = result["actions"].get(action, 0) + 1 + if changed: + result["applied"][action] = result["applied"].get(action, 0) + 1 + if len(result["details"]) < 20: + result["details"].append( + {"action": action, "identity": str(identity)} + ) + + for key, obj in objects.items(): + if obj.last_modified > cutoff: + result["fresh_protected"] += 1 + continue + if key in keys: + continue + changed = False + if apply: + with database.connection() as conn, conn.transaction(): + # Fresh intents are checked again immediately before deletion. + exists = conn.execute( + "SELECT 1 FROM attachments WHERE object_key=%s", (key,) + ).fetchone() + if exists: + continue + current = store.head(key=key) + result["head_requests"] += 1 + if current is not None and current.last_modified > cutoff: + result["fresh_protected"] += 1 + continue + store.delete(key=key) + changed = True + record("delete_orphan", key, changed=changed) + for snapshot in rows: + if snapshot["created_at"] > cutoff: + continue + with database.connection() as conn, conn.transaction(): + row = conn.execute( + "SELECT * FROM attachments WHERE id=%s FOR UPDATE", + (snapshot["id"],), + ).fetchone() + if row is None or row["created_at"] > cutoff: + continue + action = None + if row["state"] == "pending": + state = verified(store, row, result) + action = ( + "recover_pending" + if state == "valid" + else "fail_pending_" + state + ) + if apply: + conn.execute( + "UPDATE attachments SET state=%s,error_code=%s," + "updated_at=clock_timestamp() WHERE id=%s", + ( + "ready" if state == "valid" else "failed", + None if state == "valid" else "upload_" + state, + row["id"], + ), + ) + elif row["state"] == "ready": + result["head_requests"] += 1 + info = store.head(key=row["object_key"]) + if info is not None: + # A ready attachment stays even if it has no Message link. + result["ready_protected"] += 1 + continue + action = "mark_missing" + if apply: + conn.execute( + "UPDATE attachments SET state='failed'," + "error_code='original_missing'," + "updated_at=clock_timestamp() WHERE id=%s", + (row["id"],), + ) + else: + linked = conn.execute( + "SELECT 1 FROM message_attachments " + "WHERE attachment_id=%s LIMIT 1", + (row["id"],), + ).fetchone() + if linked: + result["linked_protected"] += 1 + continue + obj = objects.get(row["object_key"]) + if obj is None or obj.last_modified > cutoff: + continue + action = "delete_failed_object" + if apply: + # A timed-out uploader may finish PUT after LIST. + # Recheck freshness before removing its object. + current = store.head(key=row["object_key"]) + result["head_requests"] += 1 + if current is not None and current.last_modified > cutoff: + result["fresh_protected"] += 1 + continue + store.delete(key=row["object_key"]) + if action: + record(action, row["id"], changed=apply) + result["duration_seconds"] = round(time.monotonic() - started, 6) + result["complete"] = True + return result + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--apply", action="store_true") + parser.add_argument("--loop", action="store_true") + args = parser.parse_args() + grace = integer("RECONCILE_GRACE_SECONDS", 300, 300, 604800) + database = Database(url=secret("DATABASE_URL"), size=2) + store = ObjectStore() + try: + database.open() + while True: + try: + result = reconcile( + database, store, apply=args.apply, grace=grace + ) + print(json.dumps(result, ensure_ascii=False), flush=True) + except Exception as exc: + print( + json.dumps( + {"complete": False, "error": type(exc).__name__} + ), + flush=True, + ) + if not args.loop: + raise SystemExit(1) from None + if not args.loop: + break + time.sleep(60) + finally: + store.close() + database.close() + + +if __name__ == "__main__": + main() diff --git a/src/repository.py b/src/repository.py new file mode 100644 index 00000000..d960d7d9 --- /dev/null +++ b/src/repository.py @@ -0,0 +1,287 @@ +import hashlib +import json +from uuid import UUID + +from psycopg.errors import ForeignKeyViolation, UniqueViolation + +from src.cache import UserCache +from src.database import Database +from src.domain import Chat, Key, Message, User +from src.errors import DomainError, invalid, not_found + +MESSAGE_COLUMNS = ( + "m.*, ARRAY(SELECT attachment_id FROM message_attachments ma " + "WHERE ma.message_id=m.id ORDER BY ma.position) attachment_ids" +) + +USER_COLUMNS = "id, username, display_name, created_at" + + +def user_dto(row) -> User: + return User( + row["id"], row["username"], row["display_name"], row["created_at"] + ) + + +def chat_dto(row) -> Chat: + return Chat( + row["id"], row["title"], tuple(row["member_ids"]), row["created_at"] + ) + + +def message_dto(row) -> Message: + return Message( + row["id"], + row["chat_id"], + row["sender_id"], + row["text"], + row["created_at"], + tuple(row.get("attachment_ids", ())), + ) + + +class PostgresRepository: + def __init__(self, *, database: Database, cache: UserCache): + self.database = database + self.cache = cache + + def add_user(self, *, user: User, password_hash: str) -> User: + try: + with self.database.connection() as conn: + conn.execute( + "INSERT INTO users(id,username,display_name," + "password_hash,created_at) VALUES(%s,%s,%s,%s,%s)", + ( + user.id, + user.username, + user.display_name, + password_hash, + user.created_at, + ), + ) + except UniqueViolation: + raise DomainError( + 409, "conflict", "Username already exists" + ) from None + return user + + def get_user(self, *, user_id: UUID) -> User | None: + cached = self.cache.get(user_id=user_id) + if cached is not None: + return cached + with self.database.connection() as conn: + row = conn.execute( + "SELECT " + USER_COLUMNS + " FROM users WHERE id=%s", + (user_id,), + ).fetchone() + if row is None: + return None + user = user_dto(row) + self.cache.put(user=user) + return user + + def credentials(self, *, username: str): + with self.database.connection() as conn: + row = conn.execute( + "SELECT " + + USER_COLUMNS + + ", password_hash FROM users WHERE username=%s", + (username,), + ).fetchone() + if row is None: + return None, None + return user_dto(row), row["password_hash"] + + def add_session( + self, *, digest: bytes, user_id: UUID, created_at, expires_at + ): + with self.database.connection() as conn: + conn.execute( + "INSERT INTO sessions(token_digest,user_id,created_at," + "expires_at) VALUES(%s,%s,%s,%s)", + (digest, user_id, created_at, expires_at), + ) + + def session_user(self, *, digest: bytes) -> UUID | None: + with self.database.connection() as conn: + row = conn.execute( + "SELECT user_id FROM sessions WHERE token_digest=%s " + "AND expires_at>clock_timestamp()", + (digest,), + ).fetchone() + return row["user_id"] if row else None + + def delete_session(self, *, digest: bytes): + with self.database.connection() as conn: + conn.execute( + "DELETE FROM sessions WHERE token_digest=%s", (digest,) + ) + + def add_chat(self, *, chat: Chat, actor_id: UUID) -> Chat: + members = chat.member_ids + if actor_id not in members or len(set(members)) != len(members): + raise invalid() + try: + with self.database.connection() as conn, conn.transaction(): + conn.execute( + "INSERT INTO chats(id,title,created_at) VALUES(%s,%s,%s)", + (chat.id, chat.title, chat.created_at), + ) + with conn.cursor() as cursor: + cursor.executemany( + "INSERT INTO members(chat_id,user_id,position) " + "VALUES(%s,%s,%s)", + [ + (chat.id, user_id, position) + for position, user_id in enumerate(members) + ], + ) + except ForeignKeyViolation: + raise invalid() from None + return chat + + def get_chat(self, *, chat_id: UUID, actor_id: UUID) -> Chat: + with self.database.connection() as conn: + row = conn.execute( + "SELECT c.id,c.title,c.created_at," + "array_agg(m.user_id ORDER BY m.position) member_ids " + "FROM chats c JOIN members m ON m.chat_id=c.id " + "WHERE c.id=%s AND EXISTS(SELECT 1 FROM members own " + "WHERE own.chat_id=c.id AND own.user_id=%s) GROUP BY c.id", + (chat_id, actor_id), + ).fetchone() + if row is None: + raise not_found() + return chat_dto(row) + + def add_message( + self, *, message: Message, idempotency_key: str + ) -> Message: + # Область включает пользователя, метод и нормализованный путь чата. + scope = f"{message.sender_id}:POST:{message.chat_id}:{idempotency_key}" + lock = int.from_bytes( + hashlib.sha256(scope.encode()).digest()[:8], "big", signed=True + ) + fingerprint = hashlib.sha256( + json.dumps( + { + "text": message.text, + "attachment_ids": [str(x) for x in message.attachment_ids], + }, + ensure_ascii=False, + sort_keys=True, + separators=(",", ":"), + ).encode() + ).digest() + try: + with self.database.connection() as conn, conn.transaction(): + conn.execute("SELECT pg_advisory_xact_lock(%s)", (lock,)) + prior = conn.execute( + "SELECT i.body_hash,i.message_id," + "i.expires_at>clock_timestamp() active " + "FROM idempotency i WHERE user_id=%s AND chat_id=%s " + "AND key=%s FOR UPDATE", + (message.sender_id, message.chat_id, idempotency_key), + ).fetchone() + if prior and prior["active"]: + if bytes(prior["body_hash"]) != fingerprint: + raise DomainError(409, "conflict", "Key already used") + row = conn.execute( + "SELECT " + + MESSAGE_COLUMNS + + " FROM messages m WHERE m.id=%s", + (prior["message_id"],), + ).fetchone() + return message_dto(row) + if message.attachment_ids: + rows = conn.execute( + "SELECT id,state FROM attachments WHERE chat_id=%s " + "AND id=ANY(%s) FOR SHARE", + (message.chat_id, list(message.attachment_ids)), + ).fetchall() + if len(rows) != len(message.attachment_ids): + raise not_found() + if any(row["state"] != "ready" for row in rows): + raise DomainError( + 409, "conflict", "Attachment is not ready" + ) + conn.execute( + "INSERT INTO messages(id,chat_id,sender_id," + "text,created_at) " + "VALUES(%s,%s,%s,%s,%s)", + ( + message.id, + message.chat_id, + message.sender_id, + message.text, + message.created_at, + ), + ) + if message.attachment_ids: + with conn.cursor() as cursor: + cursor.executemany( + "INSERT INTO message_attachments(" + "message_id,chat_id," + "attachment_id,position) " + "VALUES(%s,%s,%s,%s)", + [ + (message.id, message.chat_id, aid, i) + for i, aid in enumerate(message.attachment_ids) + ], + ) + conn.execute( + "INSERT INTO idempotency(user_id,chat_id,key,body_hash," + "message_id,expires_at) VALUES(%s,%s,%s,%s,%s," + "clock_timestamp()+interval '24 hours') " + "ON CONFLICT(user_id,chat_id,key) DO UPDATE SET " + "body_hash=excluded.body_hash,message_id=excluded.message_id," + "expires_at=excluded.expires_at", + ( + message.sender_id, + message.chat_id, + idempotency_key, + fingerprint, + message.id, + ), + ) + except ForeignKeyViolation: + raise not_found() from None + return message + + def list_chats( + self, *, actor_id: UUID, after: Key | None, limit: int + ) -> list[Chat]: + condition = "AND (c.created_at,c.id)>(%s,%s)" if after else "" + parameters = ( + [actor_id, *after, limit + 1] if after else [actor_id, limit + 1] + ) + with self.database.connection() as conn: + rows = conn.execute( + "SELECT c.id,c.title,c.created_at,ARRAY(SELECT user_id " + "FROM members WHERE chat_id=c.id " + "ORDER BY position) member_ids " + "FROM chats c JOIN members own ON own.chat_id=c.id " + "WHERE own.user_id=%s " + + condition + + " ORDER BY c.created_at,c.id LIMIT %s", + parameters, + ).fetchall() + return [chat_dto(row) for row in rows] + + def list_messages( + self, *, chat_id: UUID, actor_id: UUID, after: Key | None, limit: int + ) -> list[Message]: + condition = "AND (m.created_at,m.id)>(%s,%s)" if after else "" + parameters = ( + [chat_id, *after, limit + 1] if after else [chat_id, limit + 1] + ) + with self.database.connection() as conn: + rows = conn.execute( + "SELECT " + + MESSAGE_COLUMNS + + " FROM messages m WHERE m.chat_id=%s " + + condition + + " ORDER BY m.created_at,m.id LIMIT %s", + parameters, + ).fetchall() + return [message_dto(row) for row in rows] diff --git a/src/schemas.py b/src/schemas.py new file mode 100644 index 00000000..744618c2 --- /dev/null +++ b/src/schemas.py @@ -0,0 +1,65 @@ +import re +from typing import Annotated +from uuid import UUID + +from pydantic import ( + BaseModel, + BeforeValidator, + ConfigDict, + Field, + StrictStr, + ValidationInfo, + field_validator, + model_validator, +) + +from src.cursor import parse_uuid + +UuidIn = Annotated[UUID, BeforeValidator(parse_uuid)] + + +class Input(BaseModel): + model_config = ConfigDict(extra="forbid") + + @field_validator("*", mode="after") + @classmethod + def nonblank(cls, value: object, info: ValidationInfo) -> object: + if isinstance(value, str) and ( + (not value.strip() and info.field_name != "text") + or any(0xD800 <= ord(c) <= 0xDFFF for c in value) + ): + raise ValueError("Invalid text") + return value + + +class CreateUser(Input): + username: StrictStr + display_name: StrictStr = Field(min_length=1, max_length=100) + password: StrictStr = Field(min_length=12, max_length=128) + + @field_validator("username") + @classmethod + def username_format(cls, value: str) -> str: + if not re.fullmatch(r"[a-z0-9_]{3,32}", value): + raise ValueError("Invalid username") + return value + + +class CreateChat(Input): + title: StrictStr = Field(min_length=1, max_length=100) + member_ids: list[UuidIn] = Field(min_length=1, max_length=100, strict=True) + + +class CreateMessage(Input): + text: StrictStr = Field(max_length=4000) + attachment_ids: list[UuidIn] = Field( + default_factory=list, max_length=10, strict=True + ) + + @model_validator(mode="after") + def content(self): + if len(set(self.attachment_ids)) != len(self.attachment_ids): + raise ValueError("Duplicate attachment") + if not self.text.strip() and not self.attachment_ids: + raise ValueError("Empty message") + return self diff --git a/src/service.py b/src/service.py new file mode 100644 index 00000000..373741bd --- /dev/null +++ b/src/service.py @@ -0,0 +1,179 @@ +import base64 +import hashlib +import re +import secrets +from datetime import timedelta +from uuid import UUID, uuid4 + +from src.cursor import decode_cursor, encode_cursor +from src.domain import Chat, Message, Record, User, order_key, utcnow +from src.errors import DomainError, invalid, not_found +from src.password import Passwords +from src.repository import PostgresRepository + + +def page(*, rows: list[Record], limit: int, scope: str) -> dict: + items = rows[:limit] + cursor = ( + encode_cursor(scope=scope, key=order_key(items[-1])) + if len(rows) > limit + else None + ) + return {"items": items, "next_cursor": cursor} + + +def unauthorized(*, basic=False): + challenge = ( + 'Basic realm="messenger", charset="UTF-8"' + if basic + else 'Bearer realm="messenger"' + ) + return DomainError( + 401, + "unauthorized", + "Authentication required", + {"WWW-Authenticate": challenge}, + ) + + +def bearer(value): + if not value: + raise unauthorized() + scheme, _, token = value.partition(" ") + if scheme.lower() != "bearer" or not re.fullmatch( + r"[A-Za-z0-9_-]{32,256}", token + ): + raise unauthorized() + return token + + +def token_digest(value): + return hashlib.sha256(value.encode()).digest() + + +class MessengerService: + def __init__( + self, + *, + repository: PostgresRepository, + passwords: Passwords, + session_ttl: int, + ) -> None: + self.repository = repository + self.passwords = passwords + self.session_ttl = session_ttl + + def identify(self, *, value: str | None) -> User: + token = bearer(value) + user_id = self.repository.session_user(digest=token_digest(token)) + user = self.repository.get_user(user_id=user_id) if user_id else None + if user is None: + raise unauthorized() + return user + + def register( + self, *, username: str, display_name: str, password: str + ) -> User: + encoded = self.passwords.hash(password=password) + return self.repository.add_user( + user=User(uuid4(), username, display_name, utcnow()), + password_hash=encoded, + ) + + def login(self, *, authorization: str | None): + try: + scheme, _, encoded = (authorization or "").partition(" ") + if scheme.lower() != "basic": + raise ValueError + plain = base64.b64decode(encoded, validate=True).decode("utf-8") + username, separator, password = plain.partition(":") + if ( + not separator + or not re.fullmatch(r"[a-z0-9_]{3,32}", username) + or not 12 <= len(password) <= 128 + or not password.strip() + ): + raise ValueError + except ValueError, UnicodeError: + raise unauthorized(basic=True) from None + user, password_hash = self.repository.credentials(username=username) + if not self.passwords.verify(password=password, encoded=password_hash): + raise unauthorized(basic=True) + now = utcnow() + expires = now + timedelta(seconds=self.session_ttl) + token = secrets.token_urlsafe(32) + self.repository.add_session( + digest=token_digest(token), + user_id=user.id, + created_at=now, + expires_at=expires, + ) + return { + "token": token, + "token_type": "Bearer", + "expires_at": expires, + "user": user, + } + + def logout(self, *, authorization: str | None): + self.identify(value=authorization) + self.repository.delete_session( + digest=token_digest(bearer(authorization)) + ) + + def create_chat( + self, *, actor_id: UUID, title: str, member_ids: list[UUID] + ) -> Chat: + return self.repository.add_chat( + chat=Chat(uuid4(), title, tuple(member_ids), utcnow()), + actor_id=actor_id, + ) + + def get_chat(self, *, actor_id: UUID, chat_id: UUID) -> Chat: + return self.repository.get_chat(actor_id=actor_id, chat_id=chat_id) + + def send( + self, + *, + actor_id: UUID, + chat_id: UUID, + text: str, + idempotency_key: str | None, + attachment_ids: list[UUID], + ) -> Message: + if not idempotency_key or not re.fullmatch( + r"[A-Za-z0-9._:-]{1,128}", idempotency_key + ): + raise invalid() + return self.repository.add_message( + message=Message( + uuid4(), + chat_id, + actor_id, + text, + utcnow(), + tuple(attachment_ids), + ), + idempotency_key=idempotency_key, + ) + + def chats(self, *, actor_id: UUID, limit: int, cursor: str | None) -> dict: + scope = f"chats:{actor_id}" + after = decode_cursor(value=cursor, scope=scope) + rows = self.repository.list_chats( + actor_id=actor_id, after=after, limit=limit + ) + return page(rows=rows, limit=limit, scope=scope) + + def history( + self, *, actor_id: UUID, chat: Chat, limit: int, cursor: str | None + ) -> dict: + if actor_id not in chat.member_ids: + raise not_found() + chat_id = chat.id + scope = f"messages:{chat_id}" + after = decode_cursor(value=cursor, scope=scope) + rows = self.repository.list_messages( + actor_id=actor_id, chat_id=chat_id, after=after, limit=limit + ) + return page(rows=rows, limit=limit, scope=scope) diff --git a/src/settings.py b/src/settings.py new file mode 100644 index 00000000..01ff9bfb --- /dev/null +++ b/src/settings.py @@ -0,0 +1,37 @@ +import os +from dataclasses import dataclass, field +from pathlib import Path + + +def secret(name: str) -> str: + file = os.environ.get(name + "_FILE") + if file: + return Path(file).read_text().strip() + value = os.environ.get(name) + if not value: + raise ValueError("Missing required secret setting: " + name) + return value + + +def integer(name: str, default: int, low: int, high: int) -> int: + value = int(os.environ.get(name, str(default))) + if not low <= value <= high: + raise ValueError("Invalid setting: " + name) + return value + + +@dataclass(frozen=True) +class Settings: + database_url: str = field(repr=False) + cache_url: str = field(repr=False) + session_ttl: int = 3600 + pool_size: int = 10 + + @classmethod + def load(cls): + return cls( + secret("DATABASE_URL"), + secret("CACHE_URL"), + integer("SESSION_TTL_SECONDS", 3600, 1, 86400), + integer("DB_POOL_SIZE", 10, 1, 32), + ) diff --git a/student-tests/conftest.py b/student-tests/conftest.py new file mode 100644 index 00000000..c575c2a9 --- /dev/null +++ b/student-tests/conftest.py @@ -0,0 +1,115 @@ +import json +import os +from pathlib import Path +from uuid import uuid4 + +import httpx +import pytest +from jsonschema import Draft202012Validator, FormatChecker + +CONTRACT = json.loads( + (Path(__file__).parents[1] / "contracts/openapi.json").read_text() +) +BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8084") +PASSWORD = "Synthetic-Password-🌍-123" +TOKENS = {} + + +def check(result: httpx.Response, status: int, schema: str) -> dict: + assert result.status_code == status, result.text + assert result.headers["x-request-id"] + assert result.headers["x-instance-id"] + assert result.headers["content-type"].startswith("application/json") + payload = result.json() + spec = {"$ref": f"#/components/schemas/{schema}", **CONTRACT} + Draft202012Validator(spec, format_checker=FormatChecker()).validate( + payload + ) + if schema == "Error": + assert payload["error"]["request_id"] == result.headers["x-request-id"] + assert ( + payload["error"]["code"] + == { + 400: "invalid_request", + 401: "unauthorized", + 404: "not_found", + 409: "conflict", + 500: "internal_error", + }[status] + ) + return payload + + +def register(client: httpx.Client, **overrides) -> dict: + data = { + "username": "u_" + uuid4().hex[:24], + "display_name": "Алиса 🌍", + "password": PASSWORD, + } + data.update(overrides) + user = check(client.post("/api/v1/users", json=data), 201, "User") + session = check( + client.post( + "/api/v1/auth/sessions", + auth=httpx.BasicAuth(data["username"], data["password"]), + ), + 201, + "Session", + ) + TOKENS[user["id"]] = session["token"] + return user + + +@pytest.fixture +def client(): + with httpx.Client( + base_url=BASE_URL, timeout=15, trust_env=False + ) as client: + yield client + + +@pytest.fixture +def actors(client): + return register(client), register(client), register(client) + + +@pytest.fixture +def chat(client, actors): + alice, bob, _ = actors + return check( + client.post( + "/api/v1/chats", + headers=headers(alice), + json={"title": "Учёба 🌍", "member_ids": [alice["id"], bob["id"]]}, + ), + 201, + "Chat", + ) + + +def headers(actor: dict) -> dict: + return { + "Authorization": "Bearer " + TOKENS[actor["id"]], + "Idempotency-Key": uuid4().hex, + } + + +def history(client, actor, chat_id, limit=7): + found, cursor = [], None + while True: + params = {"limit": limit} + if cursor: + params["cursor"] = cursor + page = check( + client.get( + f"/api/v1/chats/{chat_id}/messages", + headers=headers(actor), + params=params, + ), + 200, + "MessagePage", + ) + found.extend(page["items"]) + cursor = page["next_cursor"] + if cursor is None: + return found diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 00000000..964c1425 --- /dev/null +++ b/student-tests/test_api.py @@ -0,0 +1,412 @@ +import base64 +import json +import threading +from concurrent.futures import ThreadPoolExecutor +from uuid import UUID, uuid4 + +import httpx +import pytest +from conftest import BASE_URL, PASSWORD, check, headers, history, register + + +@pytest.mark.parametrize("path", ["/health/live", "/health/ready"]) +def test_health(client, path): + assert check(client.get(path), 200, "Health") == {"status": "ok"} + + +@pytest.mark.parametrize( + "value", [None, "not-a-uuid", str(uuid4()), uuid4().hex] +) +def test_identification(client, value): + check( + client.get( + "/api/v1/users/me", headers={"X-User-Id": value} if value else {} + ), + 401, + "Error", + ) + + +def test_identity(client, actors): + assert ( + check( + client.get("/api/v1/users/me", headers=headers(actors[0])), + 200, + "User", + ) + == actors[0] + ) + + +@pytest.mark.parametrize( + "data", + [ + {}, + [], + None, + {"username": "ABC", "display_name": "A"}, + {"username": "abc\n", "display_name": "A"}, + {"username": 123, "display_name": "A"}, + {"username": "abc", "display_name": " "}, + {"username": "abc", "display_name": "x" * 101}, + {"username": "abc", "display_name": "A", "extra": True}, + {"username": "abc", "display_name": "\ud800"}, + ], +) +def test_invalid_user(client, data): + if isinstance(data, dict): + data = {"password": PASSWORD, **data} + check(client.post("/api/v1/users", content=json.dumps(data)), 400, "Error") + + +@pytest.mark.parametrize( + "raw", [b"{", b"NaN", b'{"username":"abc", "display_name":NaN}', b"\xff"] +) +def test_malformed_json(client, raw): + check(client.post("/api/v1/users", content=raw), 400, "Error") + + +def test_auth_before_json(client): + check(client.post("/api/v1/chats", content=b"{"), 401, "Error") + + +def test_duplicate_username(client, actors): + check( + client.post( + "/api/v1/users", + json={ + "username": actors[0]["username"], + "display_name": "B", + "password": PASSWORD, + }, + ), + 409, + "Error", + ) + + +def test_unicode_codepoints(client, actors, chat): + user = register(client, display_name="🌍" * 100) + assert user["display_name"] == "🌍" * 100 + text = "🌍" * 4000 + result = check( + client.post( + f"/api/v1/chats/{chat['id']}/messages", + headers=headers(actors[0]), + json={"text": text}, + ), + 201, + "Message", + ) + assert result["text"] == text + assert result["sender_id"] == actors[0]["id"] + + +@pytest.mark.parametrize( + "method,suffix,body", + [ + ("GET", "", None), + ("GET", "/messages", None), + ("POST", "/messages", {"text": "hello"}), + ], +) +def test_acl(client, actors, chat, method, suffix, body): + outsider = headers(actors[2]) + actual = check( + client.request( + method, + f"/api/v1/chats/{chat['id']}{suffix}", + headers=outsider, + json=body, + ), + 404, + "Error", + ) + missing = check( + client.request( + method, + f"/api/v1/chats/{uuid4()}{suffix}", + headers=outsider, + json=body, + ), + 404, + "Error", + ) + assert actual["error"]["message"] == missing["error"]["message"] + + +@pytest.mark.parametrize("value", ["", " \t\n", 42, True, None, "a" * 4001]) +def test_bad_message(client, actors, chat, value): + check( + client.post( + f"/api/v1/chats/{chat['id']}/messages", + headers=headers(actors[0]), + json={"text": value}, + ), + 400, + "Error", + ) + + +def test_sender_not_client_controlled(client, actors, chat): + check( + client.post( + f"/api/v1/chats/{chat['id']}/messages", + headers=headers(actors[0]), + json={"text": "Hi", "sender_id": actors[1]["id"]}, + ), + 400, + "Error", + ) + + +@pytest.mark.parametrize( + "case", + [ + "duplicate", + "unknown", + "no_caller", + "empty", + "wrong_type", + "bad_uuid", + "too_many", + "blank_title", + ], +) +def test_invalid_chat(client, actors, case): + a, b, _ = actors + members = { + "duplicate": [a["id"], a["id"]], + "unknown": [a["id"], str(uuid4())], + "no_caller": [b["id"]], + "empty": [], + "wrong_type": a["id"], + "bad_uuid": ["broken"], + "too_many": [str(uuid4()) for _ in range(101)], + "blank_title": [a["id"]], + }[case] + check( + client.post( + "/api/v1/chats", + headers=headers(a), + json={ + "title": " " if case == "blank_title" else "Title", + "member_ids": members, + }, + ), + 400, + "Error", + ) + + +@pytest.mark.parametrize( + "limit", ["0", "101", "-1", "1.5", "true", "1e1", "", "12"] +) +def test_bad_limit(client, actors, chat, limit): + check( + client.get( + f"/api/v1/chats/{chat['id']}/messages", + headers=headers(actors[0]), + params={"limit": limit}, + ), + 400, + "Error", + ) + + +@pytest.mark.parametrize( + "cursor", ["", "broken", "W10", "e30", "*", "x" * 2049] +) +def test_bad_cursor(client, actors, chat, cursor): + check( + client.get( + f"/api/v1/chats/{chat['id']}/messages", + headers=headers(actors[0]), + params={"cursor": cursor}, + ), + 400, + "Error", + ) + + +def test_pagination(client, actors, chat): + a, b, outsider = actors + sent = [] + path = f"/api/v1/chats/{chat['id']}/messages" + for i in range(23): + sent.append( + check( + client.post( + path, + headers=headers(a if i % 2 else b), + json={"text": f"Msg {i}"}, + ), + 201, + "Message", + ) + ) + got = history(client, a, chat["id"]) + assert got == sorted( + sent, key=lambda m: (m["created_at"], UUID(m["id"]).int) + ) + first = check( + client.get(path, headers=headers(a), params={"limit": 1}), + 200, + "MessagePage", + ) + second = check( + client.get( + path, + headers=headers(b), + params={"limit": 22, "cursor": first["next_cursor"]}, + ), + 200, + "MessagePage", + ) + assert second["items"] == got[1:] + assert second["next_cursor"] is None + chats = check( + client.get("/api/v1/chats", headers=headers(outsider)), 200, "ChatPage" + ) + assert chats["items"] == [] + other = check( + client.post( + "/api/v1/chats", + headers=headers(a), + json={"title": "Other", "member_ids": [a["id"]]}, + ), + 201, + "Chat", + ) + check( + client.get( + f"/api/v1/chats/{other['id']}/messages", + headers=headers(a), + params={"cursor": first["next_cursor"]}, + ), + 400, + "Error", + ) + # Валидный base64/JSON с неверным типом ключа тоже даёт 400. + data = json.loads( + base64.urlsafe_b64decode( + first["next_cursor"] + "=" * (-len(first["next_cursor"]) % 4) + ) + ) + data["at"] = 17 + forged = ( + base64.urlsafe_b64encode(json.dumps(data).encode()) + .decode() + .rstrip("=") + ) + check( + client.get(path, headers=headers(a), params={"cursor": forged}), + 400, + "Error", + ) + + +def test_chat_pagination_scope(client, actors): + a, b, _ = actors + created = [] + for i in range(4): + created.append( + check( + client.post( + "/api/v1/chats", + headers=headers(a), + json={"title": str(i), "member_ids": [a["id"], b["id"]]}, + ), + 201, + "Chat", + ) + ) + page = check( + client.get("/api/v1/chats", headers=headers(a), params={"limit": 2}), + 200, + "ChatPage", + ) + assert page["items"] == created[:2] + last = check( + client.get( + "/api/v1/chats", + headers=headers(a), + params={"limit": 2, "cursor": page["next_cursor"]}, + ), + 200, + "ChatPage", + ) + assert last["items"] == created[2:] + assert last["next_cursor"] is None + check( + client.get( + "/api/v1/chats", + headers=headers(b), + params={"cursor": page["next_cursor"]}, + ), + 400, + "Error", + ) + + +def test_concurrent_messages(client, actors, chat): + barrier = threading.Barrier(10) + a = actors[0] + path = f"/api/v1/chats/{chat['id']}/messages" + + def worker(i): + with httpx.Client( + base_url=BASE_URL, timeout=15, trust_env=False + ) as conn: + barrier.wait(timeout=15) + return [ + check( + conn.post( + path, headers=headers(a), json={"text": f"{i}:{j}"} + ), + 201, + "Message", + )["id"] + for j in range(10) + ] + + with ThreadPoolExecutor(max_workers=10) as pool: + ids = [item for batch in pool.map(worker, range(10)) for item in batch] + rows = history(client, a, chat["id"]) + assert len(rows) == len(ids) == len(set(ids)) == 100 + assert set(ids) == {row["id"] for row in rows} + assert len({row["text"] for row in rows}) == 100 + + +def test_registration_race(client): + username = "race_" + uuid4().hex[:20] + barrier = threading.Barrier(10) + + def worker(_): + with httpx.Client( + base_url=BASE_URL, timeout=15, trust_env=False + ) as conn: + barrier.wait(timeout=15) + result = conn.post( + "/api/v1/users", + json={ + "username": username, + "display_name": "Test", + "password": PASSWORD, + }, + ) + check( + result, + result.status_code, + "User" if result.status_code == 201 else "Error", + ) + return result.status_code + + with ThreadPoolExecutor(max_workers=10) as pool: + statuses = list(pool.map(worker, range(10))) + assert statuses.count(201) == 1 + assert statuses.count(409) == 9 + + +def test_unknown_path(client): + check(client.get("/does-not-exist"), 404, "Error") diff --git a/student-tests/test_attachments.py b/student-tests/test_attachments.py new file mode 100644 index 00000000..2f96574d --- /dev/null +++ b/student-tests/test_attachments.py @@ -0,0 +1,181 @@ +import hashlib +import io +from pathlib import Path +from uuid import uuid4 + +import pytest +from conftest import check, headers +from PIL import Image + +PNG = (Path(__file__).parents[1] / "tests/fixtures/sample.png").read_bytes() + + +def upload( + client, actor, chat, *, data=PNG, filename="Фото 🌍.png", mime="image/png" +): + return client.post( + f"/api/v1/chats/{chat['id']}/attachments", + headers={**headers(actor), "Content-Type": mime}, + params={"filename": filename}, + content=data, + ) + + +def test_attachment_roundtrip_acl_and_message(client, actors, chat): + attachment = check(upload(client, actors[0], chat), 201, "Attachment") + assert attachment["status"] == "ready" and attachment["variants"] == [] + assert attachment["sha256"] == hashlib.sha256(PNG).hexdigest() + assert attachment["size_bytes"] == len(PNG) + path = f"/api/v1/attachments/{attachment['id']}" + assert ( + check(client.get(path, headers=headers(actors[1])), 200, "Attachment") + == attachment + ) + downloaded = client.get(path + "/content", headers=headers(actors[1])) + assert downloaded.status_code == 200 and downloaded.content == PNG + assert downloaded.headers["Content-Type"] == "image/png" + assert not downloaded.history + for suffix in ["", "/content"]: + check( + client.get(path + suffix, headers=headers(actors[2])), 404, "Error" + ) + check(client.get(path + suffix), 401, "Error") + check( + client.get( + path + "/content", + headers=headers(actors[1]), + params={"variant": "thumbnail"}, + ), + 404, + "Error", + ) + sent = check( + client.post( + f"/api/v1/chats/{chat['id']}/messages", + headers=headers(actors[1]), + json={"text": "", "attachment_ids": [attachment["id"]]}, + ), + 201, + "Message", + ) + assert sent["attachment_ids"] == [attachment["id"]] + assert sent["sender_id"] == actors[1]["id"] + + +@pytest.mark.parametrize( + "name", + [ + "../x.png", + "x/y.png", + "x\\y.png", + "x\x00.png", + "x\x7f.png", + "x\n.png", + "a" * 256, + "", + ], +) +def test_filename_guard(client, actors, chat, name): + check(upload(client, actors[0], chat, filename=name), 400, "Error") + + +@pytest.mark.parametrize( + "data,mime,status", + [ + (b"not an image", "image/png", 415), + (PNG, "image/jpeg", 415), + (PNG, "application/octet-stream", 415), + (PNG[:25], "image/png", 415), + (b"", "image/png", 415), + (b"x" * (10 * 1024 * 1024 + 1), "image/png", 413), + ], +) +def test_image_guards(client, actors, chat, data, mime, status): + r = upload(client, actors[0], chat, data=data, mime=mime) + assert r.status_code == status + assert r.headers["x-instance-id"] and r.headers["x-request-id"] + assert r.json()["error"]["request_id"] == r.headers["x-request-id"] + + +def test_jpeg_original_unchanged(client, actors, chat): + stream = io.BytesIO() + Image.new("RGB", (320, 200), (30, 60, 90)).save(stream, format="JPEG") + jpeg = stream.getvalue() + attachment = check( + upload( + client, + actors[0], + chat, + data=jpeg, + filename="camera.jpg", + mime="image/jpeg", + ), + 201, + "Attachment", + ) + r = client.get( + f"/api/v1/attachments/{attachment['id']}/content", + headers=headers(actors[1]), + ) + assert r.content == jpeg + + +def test_cross_chat_link_and_unknown(client, actors, chat): + a = check(upload(client, actors[0], chat), 201, "Attachment") + other = check( + client.post( + "/api/v1/chats", + headers=headers(actors[0]), + json={"title": "Other", "member_ids": [actors[0]["id"]]}, + ), + 201, + "Chat", + ) + for identity in [a["id"], str(uuid4())]: + check( + client.post( + f"/api/v1/chats/{other['id']}/messages", + headers=headers(actors[0]), + json={"text": "", "attachment_ids": [identity]}, + ), + 404, + "Error", + ) + check( + client.post( + f"/api/v1/chats/{chat['id']}/messages", + headers=headers(actors[0]), + json={"text": "", "attachment_ids": [a["id"], a["id"]]}, + ), + 400, + "Error", + ) + + +def test_default_attachments_are_semantically_equal(client, actors, chat): + h = headers(actors[0]) + path = f"/api/v1/chats/{chat['id']}/messages" + first = check( + client.post(path, headers=h, json={"text": "Semantic default"}), + 201, + "Message", + ) + second = check( + client.post( + path, + headers=h, + json={"attachment_ids": [], "text": "Semantic default"}, + ), + 201, + "Message", + ) + assert first == second and first["attachment_ids"] == [] + + +def test_pixel_limit_before_decode(client, actors, chat): + # Compressible synthetic image stays below10MiB but exceeds40M pixels. + stream = io.BytesIO() + Image.new("1", (8000, 5001)).save(stream, format="PNG") + assert len(stream.getvalue()) < 10 * 1024 * 1024 + r = upload(client, actors[0], chat, data=stream.getvalue()) + assert r.status_code == 413 diff --git a/student-tests/test_contract_edges.py b/student-tests/test_contract_edges.py new file mode 100644 index 00000000..81d39edf --- /dev/null +++ b/student-tests/test_contract_edges.py @@ -0,0 +1,26 @@ +import json +from uuid import uuid4 + +import pytest +from conftest import check, headers + + +@pytest.mark.parametrize("encoding", ["utf-16", "utf-32"]) +def test_only_utf8_json(client, encoding): + payload = {"username": "u_" + uuid4().hex[:20], "display_name": "UTF"} + payload["password"] = "Synthetic-encoding-test-123" + result = client.post( + "/api/v1/users", + content=json.dumps(payload).encode(encoding), + headers={"Content-Type": "application/json"}, + ) + check(result, 400, "Error") + + +def test_leading_zero_limit(client, actors, chat): + result = client.get( + "/api/v1/chats/" + chat["id"] + "/messages", + headers=headers(actors[0]), + params={"limit": "0001"}, + ) + check(result, 200, "MessagePage") diff --git a/student-tests/test_history_acl.py b/student-tests/test_history_acl.py new file mode 100644 index 00000000..61bd461c --- /dev/null +++ b/student-tests/test_history_acl.py @@ -0,0 +1,23 @@ +from conftest import check, headers + + +def test_history_acl_precedes_query_validation(client, actors, chat): + path = f"/api/v1/chats/{chat['id']}/messages" + check( + client.get( + path, + headers=headers(actors[2]), + params={"limit": 0, "cursor": "broken"}, + ), + 404, + "Error", + ) + check( + client.get( + path, + headers=headers(actors[0]), + params={"limit": 0, "cursor": "broken"}, + ), + 400, + "Error", + ) diff --git a/student-tests/test_idempotency.py b/student-tests/test_idempotency.py new file mode 100644 index 00000000..bbf61fc4 --- /dev/null +++ b/student-tests/test_idempotency.py @@ -0,0 +1,75 @@ +from concurrent.futures import ThreadPoolExecutor +from uuid import uuid4 + +import httpx +import pytest +from conftest import BASE_URL, check, headers, history + + +@pytest.mark.parametrize("key", [None, "", "a b", "x" * 129, "a/b"]) +def test_key_required_and_valid(client, actors, chat, key): + h = headers(actors[0]) + h.pop("Idempotency-Key") + if key is not None: + h["Idempotency-Key"] = key + check( + client.post( + f"/api/v1/chats/{chat['id']}/messages", + headers=h, + json={"text": "Key"}, + ), + 400, + "Error", + ) + + +def test_parallel_replay_across_instances(client, actors, chat): + h = headers(actors[0]) + path = f"/api/v1/chats/{chat['id']}/messages" + + def send(_): + with httpx.Client(base_url=BASE_URL, trust_env=False, timeout=15) as c: + r = c.post(path, headers=h, json={"text": "Один результат 🌍"}) + return check(r, 201, "Message"), r.headers["x-instance-id"] + + with ThreadPoolExecutor(max_workers=10) as pool: + results = list(pool.map(send, range(30))) + assert len({r[0]["id"] for r in results}) == 1 + assert len({r[1] for r in results}) >= 2 + assert history(client, actors[0], chat["id"]) == [results[0][0]] + check( + client.post(path, headers=h, json={"text": "Другой текст"}), + 409, + "Error", + ) + # Другой пользователь может независимо использовать тот же ключ. + other = headers(actors[1]) + other["Idempotency-Key"] = h["Idempotency-Key"] + second = check( + client.post(path, headers=other, json={"text": "Боб"}), 201, "Message" + ) + assert second["id"] != results[0][0]["id"] + + +def test_replay_rechecks_acl(client, actors, chat): + h = headers(actors[0]) + path = f"/api/v1/chats/{chat['id']}/messages" + check( + client.post(path, headers=h, json={"text": "Existing"}), 201, "Message" + ) + outsider = headers(actors[2]) + outsider["Idempotency-Key"] = h["Idempotency-Key"] + check( + client.post(path, headers=outsider, json={"text": "Existing"}), + 404, + "Error", + ) + check( + client.post( + path, + headers={"Idempotency-Key": uuid4().hex}, + json={"text": "Existing"}, + ), + 401, + "Error", + ) diff --git a/student-tests/test_sessions.py b/student-tests/test_sessions.py new file mode 100644 index 00000000..78a5ce4d --- /dev/null +++ b/student-tests/test_sessions.py @@ -0,0 +1,114 @@ +from uuid import uuid4 + +import httpx +import pytest +from conftest import PASSWORD, TOKENS, check, headers, register + + +@pytest.mark.parametrize( + "password", ["", "x" * 11, "x" * 129, " " * 12, 42, True, None] +) +def test_password_validation(client, password): + check( + client.post( + "/api/v1/users", + json={ + "username": "pwd_" + uuid4().hex[:20], + "display_name": "Test", + "password": password, + }, + ), + 400, + "Error", + ) + + +def test_full_utf8_password(client): + password = "🌍" * 127 + ":" + user = register(client, password=password) + assert ( + check( + client.get("/api/v1/users/me", headers=headers(user)), 200, "User" + ) + == user + ) + + +@pytest.mark.parametrize( + "authorization", [None, "Basic broken", "Bearer unknown", "Basic /w=="] +) +def test_bad_basic(client, authorization): + result = client.post( + "/api/v1/auth/sessions", + headers={"Authorization": authorization} if authorization else {}, + ) + check(result, 401, "Error") + assert ( + result.headers["www-authenticate"] + == 'Basic realm="messenger", charset="UTF-8"' + ) + + +def test_wrong_password_and_unknown_user(client): + user = register(client) + for username in [user["username"], "missing_" + uuid4().hex[:20]]: + result = client.post( + "/api/v1/auth/sessions", + auth=httpx.BasicAuth(username, PASSWORD + "wrong"), + ) + data = check(result, 401, "Error") + assert data["error"]["message"] == "Authentication required" + + +def test_logout_is_not_revived_by_cache(client): + user = register(client) + auth = headers(user) + check(client.get("/api/v1/users/me", headers=auth), 200, "User") + result = client.delete("/api/v1/auth/sessions/current", headers=auth) + assert result.status_code == 204 and result.content == b"" + assert result.headers["x-request-id"] + check(client.get("/api/v1/users/me", headers=auth), 401, "Error") + check( + client.delete("/api/v1/auth/sessions/current", headers=auth), + 401, + "Error", + ) + + +def test_only_current_session_revoked(client): + user = register(client) + another = check( + client.post( + "/api/v1/auth/sessions", + auth=httpx.BasicAuth(user["username"], PASSWORD), + ), + 201, + "Session", + ) + assert another["token"] != TOKENS[user["id"]] + assert len(another["token"]) >= 32 + assert ( + client.delete( + "/api/v1/auth/sessions/current", headers=headers(user) + ).status_code + == 204 + ) + result = client.get( + "/api/v1/users/me", + headers={"Authorization": "Bearer " + another["token"]}, + ) + assert check(result, 200, "User") == user + + +def test_bearer_source_and_ignored_user_header(client, actors): + alice, bob, _ = actors + auth = {**headers(alice), "X-User-Id": bob["id"]} + assert ( + check(client.get("/api/v1/users/me", headers=auth), 200, "User")["id"] + == alice["id"] + ) + result = client.get( + "/api/v1/users/me", auth=httpx.BasicAuth(alice["username"], PASSWORD) + ) + check(result, 401, "Error") + assert result.headers["www-authenticate"] == 'Bearer realm="messenger"' diff --git a/uv.lock b/uv.lock new file mode 100644 index 00000000..76c949f5 --- /dev/null +++ b/uv.lock @@ -0,0 +1,1095 @@ +version = 1 +revision = 5 +requires-python = "==3.14.*" + +[[package]] +name = "annotated-doc" +version = "0.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" }, +] + +[[package]] +name = "anyio" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/98/7e457a3b014976887a050561955c0b76e1e7e2d6e27b78ecef2ef80518f2/anyio-4.16.0.tar.gz", hash = "sha256:59bb03251907983d1603d27c3087ddb1e93299ea2163adcdba37899a4fb12ffb", size = 310971, upload-time = "2026-11-01T11:20:07.282Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/16/7757fb84c819accc7d7e9af5291b261e4abb8627ee040f99e7d35ef2457a/anyio-4.16.0-py3-none-any.whl", hash = "sha256:c66ae634e0b8228396b801741beb3294326d4b6102f7bba4041c0dfb58c29026", size = 134521, upload-time = "2026-11-01T11:20:05.59Z" }, +] + +[[package]] +name = "argon2-cffi" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0b/43/bb8b6e8708d49a5ab36781333af092d9f483b198a2710d01281204640055/argon2_cffi_bindings-26.1.0.tar.gz", hash = "sha256:63505c71542a44b68b1e38060450fb006404170da375feb31af153e7f9c6205d", size = 1790807, upload-time = "2026-08-20T07:44:22.492Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/d2/0ae991f1b2181e5be49007c574710a800ad36c2978683addb3e67c474e55/argon2_cffi_bindings-26.1.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:21ca0396fe5ec995dd54431c32698189666f9224810acfa752e50d2bd94d9df2", size = 25521, upload-time = "2026-08-20T07:32:43.019Z" }, + { url = "https://files.pythonhosted.org/packages/7e/e4/ad91d8297638aa2258aad4501c306aca99480dfe76ccd638173fa3702db9/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78de2d65e0b9ea7ce9d1b1c3e87297b2d7305a02c266ee2a2d6910daddd7ee69", size = 27177, upload-time = "2026-08-20T07:32:44.158Z" }, + { url = "https://files.pythonhosted.org/packages/6f/86/5363df11b86d02cf3662208e7406496327649cc90eb365bf6f4e8a54a41f/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:27f1821903e2ceadcb88ec2b45ef190897b7682449c772f4d9b53e42c520cf29", size = 26597, upload-time = "2026-08-20T07:32:45.172Z" }, + { url = "https://files.pythonhosted.org/packages/f4/b5/a14dcc592652347dad23ee93b278a4da5d2a25c9ed3ebd10d68eea823a4f/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d88e5f7e60f28ae0b0cc6b2f16c43e87cd642a196a86f85e0d8bb6fe016fc16d", size = 27403, upload-time = "2026-08-20T07:32:46.13Z" }, + { url = "https://files.pythonhosted.org/packages/b3/81/b4a20d4902af7f796390bf9245ff83c5217dfa7367efa1d14986956c482b/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:34b7d9c24a4165a2c61cc8ae11d44d48c9ce2830fb536cb7914e11fdd9962728", size = 27132, upload-time = "2026-08-20T07:32:47.13Z" }, + { url = "https://files.pythonhosted.org/packages/7e/1b/c8de358af07b1c490e0fcb863ef98e46ddb486e45567aca5a60bd68d9daa/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:224865cbbcb7a2bd1356741dff12b0134df726b6d44bb7b500df8e303cbd9e81", size = 27588, upload-time = "2026-08-20T07:32:48.087Z" }, + { url = "https://files.pythonhosted.org/packages/48/2f/7ee62a6e79f9309f9d9982d301b22a00010adb580c05c8109b94d7b33de0/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ffff613aaa9ce6236766e2fc6dc560bb5abde7a2e2416e3db1f9ae395a2b4dd4", size = 26785, upload-time = "2026-08-20T07:32:48.977Z" }, + { url = "https://files.pythonhosted.org/packages/e9/10/960d0ee93d4897741bcaf4799c697dae2d81499f66fd1ed042a7dd54c1f4/argon2_cffi_bindings-26.1.0-cp310-abi3-win32.whl", hash = "sha256:a86c069c91a747a2c4e5c51473590aeb48172fff9b2130d23729a42d98665ecb", size = 23898, upload-time = "2026-08-20T07:32:50.114Z" }, + { url = "https://files.pythonhosted.org/packages/6d/3a/0cc14a05810e6add9bce5e87693334baa2222de5f647fa31781885b6573f/argon2_cffi_bindings-26.1.0-cp310-abi3-win_amd64.whl", hash = "sha256:2c36ff87b5dfaa477d0bd51e9d7f6abdae7c8955d2983c97419085d842154b3e", size = 25730, upload-time = "2026-08-20T07:32:51.091Z" }, + { url = "https://files.pythonhosted.org/packages/4e/db/d83cf2af140547f0b9cdaece05b2dc2dcbf991be4667331d073eff771435/argon2_cffi_bindings-26.1.0-cp310-abi3-win_arm64.whl", hash = "sha256:f9c4420a7a864fe1b86ce35befc95b8e39fb852493b81cf798671ddc265de638", size = 24478, upload-time = "2026-08-20T07:32:52.111Z" }, + { url = "https://files.pythonhosted.org/packages/76/38/de696045960f5b846d428c0fb6c130ed3da87aac2af209b05c193815404c/argon2_cffi_bindings-26.1.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:db0fcd827ca61622a01b220aadfbece01939acf53888f2cb98cd93e9b1e2c97e", size = 15449, upload-time = "2026-08-20T07:32:54.075Z" }, + { url = "https://files.pythonhosted.org/packages/91/0a/c25af768f6b75a5a71e31207f87c540656b2808c015260444a22763221ad/argon2_cffi_bindings-26.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:28524438cd3e723f25412f63d4fd516ff5bae9ae5aa56acbe2a1404398a0cf31", size = 25683, upload-time = "2026-08-20T07:32:55.05Z" }, + { url = "https://files.pythonhosted.org/packages/a8/7e/be212c751ab0bcea7f646615f933bf262e8e50b3f7bef32f861d0a2d066b/argon2_cffi_bindings-26.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac82fc756a446b6ccd7139ce70efa9d8bbe541e7ad579a12dcb52764b7175c5f", size = 27311, upload-time = "2026-08-20T07:32:56.166Z" }, + { url = "https://files.pythonhosted.org/packages/a6/ee/f84b28e4afd13d3cac36c1d8fa8c239d2dc2c51cd978d02ee5d5ad98d9bb/argon2_cffi_bindings-26.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6a4e68eed961a8de6928d1c17ff3dc2a547e0e923c17f8f1cd79fb7bc9502f98", size = 26771, upload-time = "2026-08-20T07:32:57.206Z" }, + { url = "https://files.pythonhosted.org/packages/21/c3/95c07a023691ecd529da9cb6a8f0779e13ebc1bdfaa86d145fdc1c6e7e79/argon2_cffi_bindings-26.1.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:151dfaad9de753f4af2a7854e707e4784f2acc434340ade64239c5b104b2d605", size = 27568, upload-time = "2026-08-20T07:32:58.361Z" }, + { url = "https://files.pythonhosted.org/packages/e6/31/3a18e31406d8694b4d6a31573c3e572fff6bed318bb744453eb653766d22/argon2_cffi_bindings-26.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:061a6919145bbf282ebf1f9c59d3135d4833c25313c8595c0d68cf7712ddfce2", size = 27280, upload-time = "2026-08-20T07:32:59.343Z" }, + { url = "https://files.pythonhosted.org/packages/0b/39/d4be4577e178b2397aa5b5575c8a309bf0da2afe05fe0c72c8f398662d63/argon2_cffi_bindings-26.1.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:62ff20cd130c956c7c9144d5fe35228f98b51c579b2439e988b27ef93e16c02a", size = 27776, upload-time = "2026-08-20T07:33:00.325Z" }, + { url = "https://files.pythonhosted.org/packages/71/47/78f4dd96f7411339f723b96fe24039c1bd5835102b8a5ba71ac4ec712ac7/argon2_cffi_bindings-26.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:19423e5d7ac1cc354baab59eaabf18db2ec04ef6593b5abe5a34f323c4a8f87a", size = 26932, upload-time = "2026-08-20T07:33:01.272Z" }, + { url = "https://files.pythonhosted.org/packages/3b/cd/96bfd37434cc0a848a9066c291d84b28846c4c9ea289ed9866b1164d622b/argon2_cffi_bindings-26.1.0-cp314-cp314t-win32.whl", hash = "sha256:4f84cdd868978d7b7350a566c254042d44216d9e37f241f3a6d3b1dfebeede35", size = 24878, upload-time = "2026-08-20T07:33:02.189Z" }, + { url = "https://files.pythonhosted.org/packages/f1/42/d8b6810abd9b1bd2f47ebbccf460da59c9f32e94888bea4f7b137d998797/argon2_cffi_bindings-26.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2b741888c93147444fdfc851abd81cc207f37f7f7da42062a00deb3888e57da8", size = 26656, upload-time = "2026-08-20T07:33:03.222Z" }, + { url = "https://files.pythonhosted.org/packages/a9/d1/095d95eaf2ed1d9f77268cf3291bde148c6cd56121f8db2c74c1ba618a0e/argon2_cffi_bindings-26.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:6ab674f668d5962a3a4136ae0812519b0f1586874263723a32181d60d64137e1", size = 25378, upload-time = "2026-08-20T07:33:04.332Z" }, +] + +[[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 = "certifi" +version = "2026.10.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" }, +] + +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", size = 194064, upload-time = "2026-08-03T21:20:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", size = 196720, upload-time = "2026-08-03T21:20:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/d9/99/c4b0c17cacdc9c3b8f280026286a9826d6a208c0f047591a3c3ce99b91fd/cffi-2.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54", size = 184964, upload-time = "2026-08-03T21:20:19.708Z" }, + { url = "https://files.pythonhosted.org/packages/b3/a9/9db617d05d7367c1ad0ab00b3aa6e6f9281edd689b4ee9ea0e5a84e89c97/cffi-2.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72", size = 184962, upload-time = "2026-08-03T21:20:20.833Z" }, + { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", size = 222328, upload-time = "2026-08-03T21:20:22.118Z" }, + { url = "https://files.pythonhosted.org/packages/80/10/c5c0cbf0a657aecf59ef511409734230bf556f05a0d6c9eed7aa5c0a0166/cffi-2.1.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062", size = 209985, upload-time = "2026-08-03T21:20:23.401Z" }, + { url = "https://files.pythonhosted.org/packages/d5/6c/bfa0b87b03b9238148beca990292843c9396ba069b54496596594173de7b/cffi-2.1.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03", size = 208530, upload-time = "2026-08-03T21:20:24.628Z" }, + { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", size = 221525, upload-time = "2026-08-03T21:20:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", size = 225053, upload-time = "2026-08-03T21:20:26.985Z" }, + { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", size = 223213, upload-time = "2026-08-03T21:20:28.277Z" }, + { url = "https://files.pythonhosted.org/packages/0b/e9/d0061c364cde06ee43168a0d076ac1da512cbc380d44767b844ba34fe2b6/cffi-2.1.1-cp314-cp314-win32.whl", hash = "sha256:1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c", size = 177682, upload-time = "2026-08-03T21:20:44.288Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1c3e01e3ba14c39f6d10bfbac52753b7e22259e38088e5cfe1d704918690/cffi-2.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48", size = 187949, upload-time = "2026-08-03T21:20:45.623Z" }, + { url = "https://files.pythonhosted.org/packages/87/5b/da4e39efe18eeb89cf580ea9cfc66b6a7c3eadb808fc0cc1d3a295cb5a5d/cffi-2.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836", size = 182947, upload-time = "2026-08-03T21:20:46.955Z" }, + { url = "https://files.pythonhosted.org/packages/23/59/40338bf421c5accea1d45158170c87006ef1cd371b05c077e76476949728/cffi-2.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3", size = 188504, upload-time = "2026-08-03T21:20:29.495Z" }, + { url = "https://files.pythonhosted.org/packages/7d/47/5ecf1023850036e674c77ec4de86182d309ae344e39e7cba984b7df5d647/cffi-2.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2", size = 188259, upload-time = "2026-08-03T21:20:31.291Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", size = 223864, upload-time = "2026-08-03T21:20:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/4d/45/ba4c93527bc38616a8bd36488acb69a2212d60486794f0c1f318949bbb76/cffi-2.1.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc", size = 211538, upload-time = "2026-08-03T21:20:33.808Z" }, + { url = "https://files.pythonhosted.org/packages/80/e9/b6ef565e452acb932fb0cb5443f44a78efbd1233e566f02b5a83855e9115/cffi-2.1.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29", size = 210688, upload-time = "2026-08-03T21:20:34.974Z" }, + { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", size = 223803, upload-time = "2026-08-03T21:20:36.564Z" }, + { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", size = 226763, upload-time = "2026-08-03T21:20:37.816Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", size = 225688, upload-time = "2026-08-03T21:20:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d2/3b7176cb570a1d3e27faf67b72f591af508036e0d8b2be2ef9af9e8c84bb/cffi-2.1.1-cp314-cp314t-win32.whl", hash = "sha256:8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4", size = 182868, upload-time = "2026-08-03T21:20:40.388Z" }, + { url = "https://files.pythonhosted.org/packages/56/78/31f00c1bcd97c9bbf55f1bfdf5bc809a5de8887473e90bb9960dca825e80/cffi-2.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e", size = 194104, upload-time = "2026-08-03T21:20:41.725Z" }, + { url = "https://files.pythonhosted.org/packages/7b/1b/58496f2ed0a35de575250c02a43ab3cc2c04d494a88fed31c1cabc0fd176/cffi-2.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5", size = 186402, upload-time = "2026-08-03T21:20:43.042Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/33/1c/f41d4e74c28ab327ff3acd36053f7ea506c55872d7a90b0fa71aa3ab0c89/charset_normalizer-3.5.2.tar.gz", hash = "sha256:39de2a259fc954455c57274dc94c79d5842774e1247a016aff30bc0efed0f4ef", size = 172659, upload-time = "2026-09-30T04:39:23.398Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/ca/7aa91362a2f77ac8e9e28a9b902a74f7d0e11a851ef0d27a74308da8cd90/charset_normalizer-3.5.2-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:1afb975bd5d68d5ce9f6b6d44fdf2f7e34b895a35e95708a7a91b20a3b51d187", size = 226010, upload-time = "2026-09-30T04:36:27.669Z" }, + { url = "https://files.pythonhosted.org/packages/a8/cf/ac8878d0322cf88a1aad4c7b147db32ca0bd806eb0060957b2e31486dbe6/charset_normalizer-3.5.2-cp314-cp314-android_24_x86_64.whl", hash = "sha256:bbbfc8e28816f19d7c0f1816664980c0a9875d01b27cdf8eedddb639d9e108ad", size = 239266, upload-time = "2026-09-30T04:36:29.434Z" }, + { url = "https://files.pythonhosted.org/packages/c9/6d/9a08d7e0b29b7208e2c6c01dc56c8e0520e7c7beadbbfb024b58fd69c8a5/charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7967d08cf06dee78443b874f98c98036f624f3a4e73e11f9f64f5be4d25393cf", size = 206783, upload-time = "2026-09-30T04:36:30.872Z" }, + { url = "https://files.pythonhosted.org/packages/82/44/b0aa350280e6ff5a5492d17cf10460dd39d5ee848f872f7ba2df10607f60/charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c2b5031f63e331e3839b40aed2dd6f191e9c07edbde303e7876846ea1946995", size = 210449, upload-time = "2026-09-30T04:36:32.625Z" }, + { url = "https://files.pythonhosted.org/packages/7c/8a/40db9aa9f5907bb0e6f8b6d64064bf8852fb33d4b813ff9414911df7647c/charset_normalizer-3.5.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fcff63213e8e6e47770541a4607175404f47cbb3ebea7b6058cc82d524a0e424", size = 367815, upload-time = "2026-09-30T04:36:34.197Z" }, + { url = "https://files.pythonhosted.org/packages/7f/72/9c5e7707b57c8ddfa9ddf7b0b1d009d7fbab9e9e887d5b721060f37e307d/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8d86d6fc60743dc916eb79e2eb1ec4818e21e427731543af40a3021851174a13", size = 247095, upload-time = "2026-09-30T04:36:35.803Z" }, + { url = "https://files.pythonhosted.org/packages/83/09/71e453691e927de4ddf792770cfaab3f49d494e222f66ea5e404bbd5e39c/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a881931aa470808df94a8c380eed2bbbc76cd9dc622310f99665658c821eb6d", size = 233942, upload-time = "2026-09-30T04:36:37.407Z" }, + { url = "https://files.pythonhosted.org/packages/9f/86/85c84e4da8b27dd409577d9437926ff581c5f9d3c66038dc68c1a526de51/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8024d00c3faf3fc0c16e07a69f4405e8eac7cc0ab15f65fe6cf43827c4cf72b4", size = 273762, upload-time = "2026-09-30T04:36:38.904Z" }, + { url = "https://files.pythonhosted.org/packages/92/08/564955a4b5f2ccb410ab480bbe8c6a18063ff27f2d35458731c4a5335df9/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4d48f2d08b9de5864e2c8744d4461b862fb149a18274abc8b698c45975573438", size = 269514, upload-time = "2026-09-30T04:36:40.469Z" }, + { url = "https://files.pythonhosted.org/packages/18/24/bad3ac4271589df29cf5ce2f5ae490518a5739358052bd0d61209e6fea54/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34276fd796040bf0993ab33a369aa572e6979c7aab225a88893667ad8eac8f7a", size = 255056, upload-time = "2026-09-30T04:36:42.02Z" }, + { url = "https://files.pythonhosted.org/packages/d6/3e/350d89ad49916b86554d6f5f2d03ec1152148f87e5ff735106c6a03b1a36/charset_normalizer-3.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0521c5665880b33d603717defa76c094048900010897909952397feb3039da56", size = 251311, upload-time = "2026-09-30T04:36:43.577Z" }, + { url = "https://files.pythonhosted.org/packages/56/5b/4970a2d154df502e133402906dd04e3ae7cada7b3011283c88d0479a2585/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:eff0ac9dbe711a4aee69bf04a83896aa9b85f19641264053a9f6d48573abb7dd", size = 250190, upload-time = "2026-09-30T04:36:45.185Z" }, + { url = "https://files.pythonhosted.org/packages/88/8c/f1a91bddc8fb47c2889e29ea7ea49a194eb0d9868675d786806519c00d76/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:1503bccbeb36d5527790c3930327704c39af22de3112f1b1666a9f3ce15ee204", size = 237098, upload-time = "2026-09-30T04:36:46.689Z" }, + { url = "https://files.pythonhosted.org/packages/24/0e/bb5dace3cc7e79068425386a6589c19b5a2ab5fefc2a46abea6919683332/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:52aa6992700996af31f375de0c6bacd402b0097fe40b53c426b9f51a90ebabc7", size = 274228, upload-time = "2026-09-30T04:36:48.31Z" }, + { url = "https://files.pythonhosted.org/packages/9d/79/b849ad523017ea9f5a45581bbebed91439e0cf42fd2860a6f64e358eb5a6/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e09a3942ecbdee5cce73ea9d42da82b81b72ac1bf031ce069b93b5adf4eac8cd", size = 252401, upload-time = "2026-09-30T04:36:50.091Z" }, + { url = "https://files.pythonhosted.org/packages/89/8c/75469d690cf47200bce8f6cad7655724fc23148e147abfc5ce78b5f65863/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:c7c9ab723cde841fefb34efbad91e87f00a674b1fe1cd0784fde742bf2c154dc", size = 271846, upload-time = "2026-09-30T04:36:51.719Z" }, + { url = "https://files.pythonhosted.org/packages/26/cd/6d52d3c7437cdcf2e310ce9f28f282e733d4ef60ed19105d1819c356255f/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ddc7dacc8ece3a182e7f15cb862d1fd616b46d076cb1ae9dd232b2c38b655874", size = 258151, upload-time = "2026-09-30T04:36:53.234Z" }, + { url = "https://files.pythonhosted.org/packages/f7/4c/070b38bdb5f49a70199fce923ec0726a49536a63ab262abbfcaaf351110b/charset_normalizer-3.5.2-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:ee43c17b173d46a3212baa6ead3ae258eeabdae48c263a01ccf0218c366dd655", size = 143570, upload-time = "2026-09-30T04:36:54.816Z" }, + { url = "https://files.pythonhosted.org/packages/81/84/9ebfc8ed6c8c4fcd8e726ff6bf220cc8deb3966e31dce9be8dd8aa017e64/charset_normalizer-3.5.2-cp314-cp314-win32.whl", hash = "sha256:4f87960d57feabfb618e4e0af6e7371645fa26a277860739d6e5d6e0012c92f0", size = 186412, upload-time = "2026-09-30T04:36:56.643Z" }, + { url = "https://files.pythonhosted.org/packages/d1/78/5ed86f743d4bc350db307e7636419a0a5ee1d91806d30c7f667bd5c80dae/charset_normalizer-3.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:e4e81e09c1578b8df602e3db08b0b3ea0a6947ad612f52bf8dc5ea8d47691f0c", size = 210965, upload-time = "2026-09-30T04:36:58.205Z" }, + { url = "https://files.pythonhosted.org/packages/53/94/a3a7698e9b1a395e1eb99ccd9a324be9347973bff4e72db2a06496d7cd27/charset_normalizer-3.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:80d02b6f04e92601a081dd97b23d3128033098bff5d35d392ddcc0476ea11253", size = 200406, upload-time = "2026-09-30T04:36:59.764Z" }, + { url = "https://files.pythonhosted.org/packages/c1/48/c5dd00d5ef7791f02666de250a5bb6071e29b7e133cf4b835800b6d3bc27/charset_normalizer-3.5.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:dca9ab98072a5a54ebacebdc45f53e645336b320c667410b061be1ca588ae709", size = 396871, upload-time = "2026-09-30T04:37:01.543Z" }, + { url = "https://files.pythonhosted.org/packages/12/c8/8379554b42e8368161d898476686947a0fdbd3e8865170d7909dcabfdee8/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f0aa869112ef88429ae17820d99c3dd9504c9e9c671d3c246f3d7442cb051084", size = 249711, upload-time = "2026-09-30T04:37:03.111Z" }, + { url = "https://files.pythonhosted.org/packages/4a/eb/2ddb1035d17320caa9f41682935123a9a250277b261c3efc86b2d2a21343/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c0afc6800ba57ccc350374c5bd6150419915d95ce93cdbab2d783d75eaf30ecb", size = 231146, upload-time = "2026-09-30T04:37:04.721Z" }, + { url = "https://files.pythonhosted.org/packages/4a/24/2ecb4bde104322cd7859d6594fcfa74649f8d90b3221c9feecbef149875b/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7dcd882da75ef9adf94903b1e3b9419e8aa8fb4c7396822b834b9ef7fb96954f", size = 271552, upload-time = "2026-09-30T04:37:06.295Z" }, + { url = "https://files.pythonhosted.org/packages/3f/98/9d5f6ebc3aee9fef5d30b4aff11fb2ab7a1222b4064f8ef2c7c87cde217a/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2e06a3a98f916dd41d27f3105e02e7a40181c98c94b9158733d03a6f80506c09", size = 269810, upload-time = "2026-09-30T04:37:07.905Z" }, + { url = "https://files.pythonhosted.org/packages/09/e1/a3b06a10461b1b7628853c934c644e03bc28e42767116afb52f19a56519b/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6bd128f206a7752ae1f2ab6c61bf8a24ba28913a10df8b14c2637b973ff97a80", size = 259845, upload-time = "2026-09-30T04:37:09.554Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d3/6f561f74a296cf27d61775a1dc665ad13f3bff6a798810ca05907f37a7c4/charset_normalizer-3.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c8f3d67aeaf55f017982b73683f0e7342ba2f6635a78f69ce89ebb26aa411e5c", size = 252825, upload-time = "2026-09-30T04:37:11.274Z" }, + { url = "https://files.pythonhosted.org/packages/26/9f/69e13ca3b18f43e0eafcd34c04a45b732ae22a43b54a5fc9e119103356eb/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fe9753dfee015c570d73df76f899f18444d41388bffcde097deba51c4fadbb9f", size = 252659, upload-time = "2026-09-30T04:37:12.941Z" }, + { url = "https://files.pythonhosted.org/packages/73/a9/ace29806a0dae18939919c76ba526472d83214afa101105fabff2cf30625/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:92888bb3187c5ba50500b00b3b310c9f2c651709d28036077680cb5255450a03", size = 238819, upload-time = "2026-09-30T04:37:14.659Z" }, + { url = "https://files.pythonhosted.org/packages/f8/c1/6116d52a2e3311ec80f21f5fb5e17b27405f10b9608af8f6e69516841a1b/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d008d90a7f2471519aef0c90dfbe73b3e6e4d5e66ac48e19154c17e89e98b604", size = 272973, upload-time = "2026-09-30T04:37:16.346Z" }, + { url = "https://files.pythonhosted.org/packages/19/aa/9955c7e93bba10a9c7e8f7a5031b7ced66f3a1883a55c00712b8d5850ff3/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:31f3930700408d211f13378ccbe1c40845d8da54bd0681fac3a9b5aae81c7aa8", size = 253692, upload-time = "2026-09-30T04:37:18.212Z" }, + { url = "https://files.pythonhosted.org/packages/bb/33/2a6ae7fdc1b10cb581cef91addd8cdfc5f40d50abb5702309369d5834579/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:2a925889534b3748302dae5dead07cc13480de1dac3aea80a941b729b471ef93", size = 268757, upload-time = "2026-09-30T04:37:19.877Z" }, + { url = "https://files.pythonhosted.org/packages/a2/22/80992720a0282cd39bba1db35868e6b9c22f41281160143a836544bc1d8a/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f5ec61164adcec446f8969a3358ec3f9b26bbda3b9213e5586d219afa8df2915", size = 262220, upload-time = "2026-09-30T04:37:21.583Z" }, + { url = "https://files.pythonhosted.org/packages/92/9f/181fd07e1bffea1d95cd80c84ac537354f50699c22cfc4d3c02b6fc16208/charset_normalizer-3.5.2-cp314-cp314t-win32.whl", hash = "sha256:598a11a2c7ebaa5334bf698bf29568c9c390abac6a154d8170fedecd1cea38c5", size = 197797, upload-time = "2026-09-30T04:37:23.235Z" }, + { url = "https://files.pythonhosted.org/packages/49/1c/25d8415ec1c4f2f41f1680435e4c87cfb378ff2f677d950946f2a45d0632/charset_normalizer-3.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:7fdde2c9fd9e3eca40631e024664cf2584272cc8f96308cbe5fdfc930f51d8bc", size = 222765, upload-time = "2026-09-30T04:37:24.891Z" }, + { url = "https://files.pythonhosted.org/packages/3e/b4/46b48f013dadfc0d0d33b375438e31bdf5a989dc68389c6bf627054d4df9/charset_normalizer-3.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d1befeed746d247c81127bb14de9dc3d30edb6e5976d34f83f86ed262b1d9105", size = 210985, upload-time = "2026-09-30T04:37:26.634Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ab/176fbfd5b64939c55d652366aa5b9ef1d767af207a3aa6ebeb0d226c484d/charset_normalizer-3.5.2-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:4275811936e2f06feff5e598fb42a1b7ae852da8e39605211892b56b81a34efd", size = 331815, upload-time = "2026-09-30T04:38:26.216Z" }, + { url = "https://files.pythonhosted.org/packages/7e/84/371eac6b30bdbcbf2d632a1a01809103459216fcaae61b8b8d922c1bfb8a/charset_normalizer-3.5.2-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1c50fe28bbc2ced33386f298650d91218076c05420e6cbd790b913adc41659e7", size = 253276, upload-time = "2026-09-30T04:38:28.032Z" }, + { url = "https://files.pythonhosted.org/packages/43/6f/c4fbae58febff71709c51bc7e18fdfa55341dc382704740f9f0cbf03817b/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d19fbd981a488e22cd04883659ca6b08f50b5974f9fd7c95655ef6a043e5893f", size = 241239, upload-time = "2026-09-30T04:38:29.732Z" }, + { url = "https://files.pythonhosted.org/packages/61/71/458c3f42164a07d0c5210798e9e704b39e540a6793b05aba67f3a35243a9/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0fed1d06615f022ee3b13caf5e8b180cfea32bb2c5aded8a9d44277afc040f93", size = 231121, upload-time = "2026-09-30T04:38:31.462Z" }, + { url = "https://files.pythonhosted.org/packages/09/54/ab9e89367076f6331bb6c65c4bf14a5361fa5191cb6561bf534f18504e1b/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:838dcc90063569a0448120554591a1d6c4a4ffe11babf048908793154ab86ade", size = 260350, upload-time = "2026-09-30T04:38:33.239Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c1/061431ecc688d9d76602502cb57cc01e691e682c18f1beb45f9673b5bbd2/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2ce45c6627b22c47e390bc91a41c3d13032192e699fa0bea96e9671b373d69b0", size = 255430, upload-time = "2026-09-30T04:38:34.865Z" }, + { url = "https://files.pythonhosted.org/packages/8d/1f/20c8949f0676f7ab811abdeb7f4d7f1cbc6e61ff20bef08b44edeb092bc8/charset_normalizer-3.5.2-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0774bf9bf620249fee3e0b8b9fd3065de213be30f3aa94ce2494b3b638949e26", size = 250612, upload-time = "2026-09-30T04:38:36.649Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9e/46f2fa4c431fc98c4ae76a8cb5bdca54e0341e3cfc3fcfd8e82740250818/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1db38f4c5496827c1a501846d64d14c3b80c7e6714e406cd7dc36a9899fa1011", size = 242083, upload-time = "2026-09-30T04:38:38.26Z" }, + { url = "https://files.pythonhosted.org/packages/bd/39/559be29a0c0f086e0bba6922babd38916cc5e0b58ced4de13ee01ea05508/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:304d8e4d493af723536393eee0c689eb7813f4a474c8b479dee63f1fdd98f621", size = 232738, upload-time = "2026-09-30T04:38:39.81Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6c/387b0e4f756a282831c1d9fc6aeb6c51ca4507ca202767c8de15ce9b12e2/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:9b7f416ff0978e2f2249330527f0ad6fa02f4932e6199692d3b52da2048c19e4", size = 260703, upload-time = "2026-09-30T04:38:41.346Z" }, + { url = "https://files.pythonhosted.org/packages/96/92/1fdf015f09ef449f50d3ac4b67c90887c9c318b727daa95cc4f866e6521d/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:01077390b03f7988f11d700a2194e69b119741a86b1a638b1db88891e3eced8e", size = 247622, upload-time = "2026-09-30T04:38:42.937Z" }, + { url = "https://files.pythonhosted.org/packages/dc/3c/8e7b8a5671ad5d433669fb2a76f1a0164df2d9b1718b0206bc2a16d840cc/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:7e841fb9010836c992c9f12fcbd43a831de93a5f726fc1ccd8ca1d0268c5014c", size = 257500, upload-time = "2026-09-30T04:38:44.604Z" }, + { url = "https://files.pythonhosted.org/packages/b4/f0/45b579df5cabc1d5d53ea1cc35e8437d3ca768c0acccc7041517cb6fbb32/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9cae88599c7219005d879f98e5ed53341e9a122af585e1091200358a3003d2a0", size = 255100, upload-time = "2026-09-30T04:38:46.289Z" }, + { url = "https://files.pythonhosted.org/packages/31/68/fdec18a343f5fb3f310588dd478b09ac4799e0b187dbade3a8cd776f03ef/charset_normalizer-3.5.2-cp37-abi3-win32.whl", hash = "sha256:01b0c0d2262a9e28e8484a278c7e1b5d650e3ac8cf2683d2967e25899f208bdf", size = 174499, upload-time = "2026-09-30T04:38:47.999Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8a/b618149cc5207943a0242068d7a27897f56a62947b5a039085f2a22029f8/charset_normalizer-3.5.2-cp37-abi3-win_amd64.whl", hash = "sha256:9f56f72050826f63dcee7a7f55b0a77168cb3bfc553fd405e7f8f9ece75a4036", size = 200092, upload-time = "2026-09-30T04:38:49.707Z" }, + { url = "https://files.pythonhosted.org/packages/03/cf/4c66866fa9e2b1c78e3c911516d1de497a677b7ac60f1eceda74ce777ca3/charset_normalizer-3.5.2-cp37-abi3-win_arm64.whl", hash = "sha256:40ab6bffa02ae10a0581e6c198be7d2d8ca5c2a0c64e4ed3465d766df457573e", size = 294363, upload-time = "2026-09-30T04:38:51.312Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ad/d07d7862a62ffa6d79d68074d14823243dd235a77c45262acbf6adeb28bf/charset_normalizer-3.5.2-py3-none-any.whl", hash = "sha256:b6b751274acb69d77b3323d6b7dbaa3c7fdfc1eb829b7eb61d262f32e1af9685", size = 68872, upload-time = "2026-09-30T04:39:21.828Z" }, +] + +[[package]] +name = "click" +version = "8.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/45/37/edbf1b0707709013c0cf2e8317e03d97ed29bf4cac709fe328904ae92a38/click-8.5.1.tar.gz", hash = "sha256:9bbfada76703fd1d784b83eea012e3e8c6a001a876543ef104fa56aaaeb072b4", size = 399151, upload-time = "2026-11-06T17:37:01.021Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/7d/164b7ffc8624fe9efb4221bf9af485d5c1e41b9ae118045d2b6dc5457d8b/click-8.5.1-py3-none-any.whl", hash = "sha256:8bb5376d2006950386f8c6427613334a2acadc5f559cb80e638d00b4df957e37", size = 126163, upload-time = "2026-11-06T17:36:59.287Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "contourpy" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/5a/a55177dd22553a277388e8a1b3220e92de91bacb28356cdc73caa240121d/contourpy-1.4.0.tar.gz", hash = "sha256:20156f5a1ac4f8ce02656e39a61e82164a3d359796dc8026f75b062783d500e1", size = 13323726, upload-time = "2026-09-11T19:05:05.808Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/75/b0/b548628c8dddf6e5e0a981b7fa8e4c008024df09c7d17c6a9e271edfa0b3/contourpy-1.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a3e67bc1a6a4618a1dac7c3053a9ffece5ddfa2046b2670b342cf430bb0b87d1", size = 297354, upload-time = "2026-09-11T19:03:35.017Z" }, + { url = "https://files.pythonhosted.org/packages/04/5a/513484208742f65af2648c519f0b7ab034616e183c4403538024c136a1ab/contourpy-1.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:072a702e2e178f4fcf96f04775d0c059e4c917925abf0d3208ebb6865df3c23d", size = 283729, upload-time = "2026-09-11T19:03:36.818Z" }, + { url = "https://files.pythonhosted.org/packages/35/da/5a6562febc994b2c4bf9d01e57a50458ef8a2051bb3e7b35a00333e0fc26/contourpy-1.4.0-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:404dbcd9233513dfd1323b66ea593fef90e899f658f6b8a9ed8e93bd0ca669db", size = 357819, upload-time = "2026-09-11T19:03:39.058Z" }, + { url = "https://files.pythonhosted.org/packages/6d/99/7b358ce888aaa426f755daa096c99c59d17c352037344e836f20e5d3b957/contourpy-1.4.0-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:61624f6722480aa7e168fd746164e7bfdf48f8ccb6542f1613741200dc37e2b1", size = 407795, upload-time = "2026-09-11T19:03:41.293Z" }, + { url = "https://files.pythonhosted.org/packages/be/02/34d7548adf08c60967435d79d7a90882eacc84f5093435287974c7e99943/contourpy-1.4.0-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2e741a39dfc96babe1722561e81351aeec104526c57dbe91c167c1db606c2d55", size = 408552, upload-time = "2026-09-11T19:03:42.728Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8c/9677dad226e5aaac5b823d5b09d881ebc32ff1648af417597649841e516c/contourpy-1.4.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e439ab450c93455feb0218532ded3e946ec7a9b5f459069f122cfa44b89229f6", size = 384850, upload-time = "2026-09-11T19:03:44.402Z" }, + { url = "https://files.pythonhosted.org/packages/08/f5/e3fbeaa489c223629fbb434737cb3de4ecaca9cae4825e77b92490f640f8/contourpy-1.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:417be048f7e122cefbe2a34c51a1f2b0410f8eb35796f794d45475ddb7872d9d", size = 1357601, upload-time = "2026-09-11T19:03:46.746Z" }, + { url = "https://files.pythonhosted.org/packages/88/be/55fec293d342c222ed58a5d4056df4362e192af2e59527a3d5d822de8828/contourpy-1.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:43d80072a32299bf945de0a6dd4e034ea0162e832261de2e07a274a5adbba9c9", size = 1427340, upload-time = "2026-09-11T19:03:48.745Z" }, + { url = "https://files.pythonhosted.org/packages/86/40/0faabf453edf59b0e3633381d7ca72c3414fb9b72b5cbb08b06ed792d3e5/contourpy-1.4.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:fa1b787362a3856e63dd2b89449f6c384d55ee1beb8f94f4bcc871b40f02462c", size = 118355, upload-time = "2026-09-11T19:03:50.047Z" }, + { url = "https://files.pythonhosted.org/packages/38/0c/7ea75aa3559ae8a6805015e15a19c92b6480752ecc92526361e5776e88c5/contourpy-1.4.0-cp314-cp314-win32.whl", hash = "sha256:738c44fa71735a617f36da58e32810512407d283d5d1bb5b1cecb00d7eeba7cf", size = 356977, upload-time = "2026-09-11T19:04:11.401Z" }, + { url = "https://files.pythonhosted.org/packages/15/41/3df8cc14bb572c8b447f9dfbc876703f0f2f2896058285b5c87a1d4a638d/contourpy-1.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:181bea01bc742734ae672fa00c717d855dd35e1f029536406538c52e7b0cd73d", size = 240101, upload-time = "2026-09-11T19:04:12.772Z" }, + { url = "https://files.pythonhosted.org/packages/66/01/ee6830a5aa4565662a345172f6f35eeeed625d20f1c9d4ecd35318fe4ade/contourpy-1.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:64039341e2d8804f1a13bda8c69083eab935167bbd7e856cf096241f17d5bd45", size = 576359, upload-time = "2026-09-11T19:04:14.983Z" }, + { url = "https://files.pythonhosted.org/packages/51/af/49ee9c9cf012699e505c1b63c531cc99f19df50f205173092c4d541e3ec7/contourpy-1.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ef47fef9a912c77e3d84b014f701e5a9340f25703e9ed3bcebe37f91fb69dc49", size = 313601, upload-time = "2026-09-11T19:03:51.452Z" }, + { url = "https://files.pythonhosted.org/packages/ad/59/ce411ab2be0f805038626d8f4ca9ce563487ff51ff6c363e7512271564ed/contourpy-1.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:96019f059bcb3774acc0104be3360a57b36d33eaaa2e1d7f77c800ca8e07618b", size = 302812, upload-time = "2026-09-11T19:03:53.022Z" }, + { url = "https://files.pythonhosted.org/packages/95/b0/390915f9af14c1e2d3b2a9ad99d85b98df4352346a51e368cbb825f813c3/contourpy-1.4.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ddf5a2596d716fd3793434844caf31abc7a40b1e8718431420c89858268fb909", size = 348996, upload-time = "2026-09-11T19:03:54.594Z" }, + { url = "https://files.pythonhosted.org/packages/c7/85/e0952576d54322f3e9983b1e049a7a31f42ce82c5c29d01821e6dd3780d7/contourpy-1.4.0-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dd59df9e2fb0aff8bd7fd1adb9f349b7c835245a9d0f18c2f2deeb537190f2b1", size = 400272, upload-time = "2026-09-11T19:03:56.822Z" }, + { url = "https://files.pythonhosted.org/packages/d6/7d/f13543a5e1598e4a4ad01d9d5e2d65f9c09c37660616429913d606c5977d/contourpy-1.4.0-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b7794ea07cab575633daad8d6e963b662053391022294d3aacc1d9ba9ef54114", size = 412895, upload-time = "2026-09-11T19:03:58.487Z" }, + { url = "https://files.pythonhosted.org/packages/c5/a8/6e5eaff53507dfd2dfc428240eecda32453067277d4b3e7ca71210b2d611/contourpy-1.4.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a1c8a74744fa746eeaa12f0f9ed7f8b4add9d8f1b14d95e3b5e133675eac888f", size = 377060, upload-time = "2026-09-11T19:04:00.122Z" }, + { url = "https://files.pythonhosted.org/packages/16/a3/d00e44d35511b3cead5bd794ee672d4eecf30d9de4ceac57a49d6204064f/contourpy-1.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:107ec46f7aa1664266d69b1181aadc953d58d39f7d8d648fa5b795d4a060b0de", size = 1345688, upload-time = "2026-09-11T19:04:02.705Z" }, + { url = "https://files.pythonhosted.org/packages/1e/01/1e533b0cae32c8edd63fe40435ec3b29345dab87321afcd28722d7f957d1/contourpy-1.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5a4c89c7f38a0d7a94356d74e3391073c4325c4d47ad2fd065c3fe7dbae16c0c", size = 1416140, upload-time = "2026-09-11T19:04:04.77Z" }, + { url = "https://files.pythonhosted.org/packages/6d/0c/4ee66759f00d6a5d6909782f14f441d639fa18a4a43142e334351efc47f8/contourpy-1.4.0-cp314-cp314t-win32.whl", hash = "sha256:912c6afaa106e2f74ba22b30416b77ef7eb94e3bdc5a4df51ab147845dba9b6d", size = 371982, upload-time = "2026-09-11T19:04:06.233Z" }, + { url = "https://files.pythonhosted.org/packages/e6/ac/b3e5324138c3e3741f526663f4f265f4f69dfdf26415a39428940864a5f6/contourpy-1.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:ef9440f6f8506246269a82734f5ff9e2e4c5e775b3996fc883cc491c5257eca6", size = 262907, upload-time = "2026-09-11T19:04:07.882Z" }, + { url = "https://files.pythonhosted.org/packages/19/37/c9aa45e47819dc15a38fc5c81a2fb987fde55e9d3b991fbde514e3b6b5f5/contourpy-1.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:fc9feef8f1f001c5b87decadc67c4a5d1eebb62ca39c4763d1237ff62cf2b707", size = 587071, upload-time = "2026-09-11T19:04:09.898Z" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + +[[package]] +name = "fastapi" +version = "0.143.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "opentelemetry-api" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/d5/b0aeb0b303650ac87b0411de4aaf3f901b06042dcc3fb00f30b97b7ff585/fastapi-0.143.3.tar.gz", hash = "sha256:b9ab567ee57afb4454004ce04c889f8f0160ac47946b99795887cd6e88484848", size = 469834, upload-time = "2026-10-16T14:14:13.31Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/1a/03d246befcf307219bb2161c97d8c5d314f84125bf7dd245730a28589828/fastapi-0.143.3-py3-none-any.whl", hash = "sha256:75e8bd68e2f52f77d29b2879749c257d64de2d85282d25270caf2bfccce5efe5", size = 144849, upload-time = "2026-10-16T14:14:11.763Z" }, +] + +[[package]] +name = "fonttools" +version = "4.68.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0c/b5/672312ae80ce8b8eb9779c56052a24c8f36652aa7293a1a420553bcf03e5/fonttools-4.68.0.tar.gz", hash = "sha256:73294e233070f71e2b3653b6bd8564af676d57f26d075761fb06d1ab2e4a7a5d", size = 3848583, upload-time = "2026-10-27T16:30:26.451Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/70/ee6655887166a111d0c4d7ca61f03c90b141cdc6f70c85138fd0b8bfa2e3/fonttools-4.68.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:b2ee7b9c1a5e1d637073c39b0978956febad7e862a1269719f527934c65535a4", size = 3145377, upload-time = "2026-10-27T16:29:03.757Z" }, + { url = "https://files.pythonhosted.org/packages/d6/37/66e7ab417660cb2c65889eb5ad8d80cc5a7cb2c09dd1becdbe6d56bac4fe/fonttools-4.68.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9d80813ae74b969ef2166a3040b591826e80ecd879bdeab7f13f4e8eaf08b345", size = 2634889, upload-time = "2026-10-27T16:29:05.651Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ad/da985167af1988b82112cf133e826cf075cecb28d120778589265cb3125d/fonttools-4.68.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6837def5de49772b82683dadd836df214def04b307cb98d0e7723d49e7e15bb", size = 5420416, upload-time = "2026-10-27T16:29:07.502Z" }, + { url = "https://files.pythonhosted.org/packages/b7/67/e9f2eb2aed41d4ed251a3c6f66e104685f0a03d8ded7ed87f1f0fc63898c/fonttools-4.68.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cbb63b26d33acc3eb61f544c22a0cadbe01682fc064b266bb0e33fa66cea853f", size = 5363969, upload-time = "2026-10-27T16:29:10.172Z" }, + { url = "https://files.pythonhosted.org/packages/e6/06/c4510ac6b43b374b1b707b99fdd0ba1d4059d2fb516584a412c0396fedef/fonttools-4.68.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:81ea963d4390bb9e79f91a905310d91ac7ff7675d8e1c0cfc0f1712521c41a43", size = 5362373, upload-time = "2026-10-27T16:29:12.298Z" }, + { url = "https://files.pythonhosted.org/packages/e0/ef/ea0bf283a30a88a84a47078ff39f7bdefa0346a8bd7737439fd33084031f/fonttools-4.68.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3b9b87645bcdbfc3f30240e2758a37bbef4fdd0f708683b2bfceb60975d63e59", size = 5495553, upload-time = "2026-10-27T16:29:14.614Z" }, + { url = "https://files.pythonhosted.org/packages/95/c0/d493f8c8974859e57920ce193ffbe277423da7eebccbb9241bc31e1b5f1d/fonttools-4.68.0-cp314-cp314-win32.whl", hash = "sha256:39913c1f576af86c69519dc351302332561ee62b39fed04dcfa8019d9c2d129f", size = 2484057, upload-time = "2026-10-27T16:29:16.45Z" }, + { url = "https://files.pythonhosted.org/packages/96/41/c9ca629ffe1b883c1422540a8a11a4ea09616366ab585ab4ee9833f2cd75/fonttools-4.68.0-cp314-cp314-win_amd64.whl", hash = "sha256:1782f2cf952eb262c4126b1f57b5f0e027e71bf2b632350a033dec526f448428", size = 2536130, upload-time = "2026-10-27T16:29:18.399Z" }, + { url = "https://files.pythonhosted.org/packages/17/40/f6264c988076393db3e0b00d6d0ea2a53ce40d445e8a196be241d16d362c/fonttools-4.68.0-cp314-cp314-win_arm64.whl", hash = "sha256:f0b39924698a85bee107184a3c2ee9ae27248144977160534f7d558831db50cf", size = 2508386, upload-time = "2026-10-27T16:29:20.318Z" }, + { url = "https://files.pythonhosted.org/packages/c5/d8/a4d710362f3f23aecc16015eeed1d602187189af7f63a63546233ad2fa73/fonttools-4.68.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:956230858b7a7bb9f5e0971ae07dc64b6155307304acd8c62aedca30e6aae874", size = 3219047, upload-time = "2026-10-27T16:29:22.337Z" }, + { url = "https://files.pythonhosted.org/packages/4d/4d/0d516a1d3d34e84c56237ba1d8dfed8575c350b0e8d39aa30b518d089daf/fonttools-4.68.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b637d82a488116da2869afbddccfd93ca14e3c47b404c8ec5a9bad9d4381b08c", size = 2668060, upload-time = "2026-10-27T16:29:24.536Z" }, + { url = "https://files.pythonhosted.org/packages/4d/40/56893c685cb1ee7d7ee30d0ac94adf92020787cf5a8e15c2e4e6944f0bec/fonttools-4.68.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:419bf78474adaa6fb320a06822f4f941b19345d598a9de379d6e2f0e4d819df6", size = 5593080, upload-time = "2026-10-27T16:29:26.51Z" }, + { url = "https://files.pythonhosted.org/packages/41/b6/bc0bbad6f1aef22519c4e731c6dc8655e92c6f7204277ec36502ea7e76cd/fonttools-4.68.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe80d05dd85e6ac58d0cd4fa10ddb96252a6f1046ee0fd00cd1d48f0c25921ac", size = 5399669, upload-time = "2026-10-27T16:29:28.969Z" }, + { url = "https://files.pythonhosted.org/packages/c1/b4/4404a91dc699dd430732d366996cef6d8c8f61c758b5e544a76903db580a/fonttools-4.68.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:cea1969b9bfe230cb3fd66f1c66da5a63a9a917d9cd25a0839524d3d1a88b40e", size = 5460446, upload-time = "2026-10-27T16:29:31.15Z" }, + { url = "https://files.pythonhosted.org/packages/56/09/66876a0d1a01f7c16eb9f7c8ebcf064ebbd6b249f837691cb5a35780316a/fonttools-4.68.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fde43b9785c7f105aa563b6b5481edabea4ab6be7d9ef14ff4d76225950923e8", size = 5495792, upload-time = "2026-10-27T16:29:33.455Z" }, + { url = "https://files.pythonhosted.org/packages/15/7d/1d702dc628e6f5b0d63be906025afc5e5b487cee48128943bb0a71d2bcb3/fonttools-4.68.0-cp314-cp314t-win32.whl", hash = "sha256:a325e6d7f96f20b3004658c5ed17ccfce5b66277b43ccd883035c61be6945275", size = 2517805, upload-time = "2026-10-27T16:29:36.929Z" }, + { url = "https://files.pythonhosted.org/packages/f3/42/8fa0741e08ae16be66a0d2e6d67f918fa0f2961bad70ccef84f9af0767cc/fonttools-4.68.0-cp314-cp314t-win_amd64.whl", hash = "sha256:e80ac66627a01698675ce6e98d90ea9817d1e06644129ec8b0093f66ff1cbeac", size = 2567666, upload-time = "2026-10-27T16:29:40.081Z" }, + { url = "https://files.pythonhosted.org/packages/13/2f/b73cf496570e8d2c66a6099f825505283ef8e944bd588e0b63036d6b2412/fonttools-4.68.0-cp314-cp314t-win_arm64.whl", hash = "sha256:83bd3d558c15f4e1d87b8f3fcfb337c2bce63c7e5c05212abc8fdcf15e216c54", size = 2532338, upload-time = "2026-10-27T16:29:42.073Z" }, + { url = "https://files.pythonhosted.org/packages/35/74/4ea331ecc65ba05a58b1e4e8ccd604c8a15565f876dfbf93fc2a2ea2e22b/fonttools-4.68.0-py3-none-any.whl", hash = "sha256:d76f8fdcb6936f5e1045a0c9dd721a4bf11112e60d1e243bfa1d39f06a8b3104", size = 1248357, upload-time = "2026-10-27T16:30:24.389Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "idna" +version = "3.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/e1/2069291243c926a2ff1cd706c7f3eeb9b62144bf60f77c9fb9ff2fb26bd3/iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960", size = 21209, upload-time = "2026-10-06T22:48:38.076Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/43/4ca9e49d27a1fcf6bece6f6aec0ea46bb9112489b93d4b688fb415457bdb/iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7", size = 7552, upload-time = "2026-10-06T22:48:36.959Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +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-path" +version = "0.3.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pathable" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6e/45/41ebc679c2a4fced6a722f624c18d658dee42612b83ea24c1caf7c0eb3a8/jsonschema_path-0.3.4.tar.gz", hash = "sha256:8365356039f16cc65fddffafda5f58766e34bebab7d6d105616ab52bc4297001", size = 11159, upload-time = "2025-01-24T14:33:16.547Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/58/3485da8cb93d2f393bce453adeef16896751f14ba3e2024bc21dc9597646/jsonschema_path-0.3.4-py3-none-any.whl", hash = "sha256:f502191fdc2b22050f9a81c9237be9d27145b9001c55842bece5e94e382e52f8", size = 14810, upload-time = "2025-01-24T14:33:14.652Z" }, +] + +[[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 = "kiwisolver" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/07/bd78e6a8fae171ea041ef5bba3ed21a003522fa088834b069b1909981f30/kiwisolver-1.5.1.tar.gz", hash = "sha256:f1303ef2eec81262a4b708c3e858afe58d7c75ad91c1c05266eda7673369859a", size = 104395, upload-time = "2026-08-28T10:28:27.153Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dd/87/2d5dfad0daf17dcc18d98c48ed2332fc3f051cf599e60be6182a30dd4cf1/kiwisolver-1.5.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0324cd2567259b7a095f6cf18a52b0ffc6f3de9e69528ff1bc0e7a37bd43ff1a", size = 62337, upload-time = "2026-08-28T10:26:18.778Z" }, + { url = "https://files.pythonhosted.org/packages/08/c8/83e1624f15d6262b470dbcc80b09979fd4d5b2ea3ddfc6b6e3327e235726/kiwisolver-1.5.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:74ea337e0ec3f6f342a36a4f1b5cd94dd9affddcd28ba9aae2905af932ee8c6b", size = 64513, upload-time = "2026-08-28T10:26:19.909Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2d/827ec30eb07f528c08d8459ffb318ae91a56d793ee8acbea8b491f0ff906/kiwisolver-1.5.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:ee9df1f0d77b9c6e94f4ac0fec533fbddd5ea3a327807f18d7b069ae019ded80", size = 66287, upload-time = "2026-08-28T10:26:21.078Z" }, + { url = "https://files.pythonhosted.org/packages/53/11/5c43a562529dad8def4b81e5e1877c612a7e0298105a5939b3b409d2079c/kiwisolver-1.5.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fc271a6f0a2126958f4090e5507b9da5848927dae331f8f763bd4aa642b3d2cd", size = 123940, upload-time = "2026-08-28T10:26:22.475Z" }, + { url = "https://files.pythonhosted.org/packages/64/db/9bd6c505c95128c258a55236bfbb3a7a3fb6023f863316b6d7d9f3c69052/kiwisolver-1.5.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9b3092d8992a1d69b7a59c3e39f35e1b9be327a17f68a7c35fc17329e337d6f2", size = 66493, upload-time = "2026-08-28T10:26:23.743Z" }, + { url = "https://files.pythonhosted.org/packages/e1/f4/b3007a3ed5c9be73f81161140684cf7d9bdb9c4b632f5f484d2a1c713fb9/kiwisolver-1.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c2306e8bb53601979fcb3fa09cc65e031876d9ae01eff2fcbcd7a84ef94d5bc1", size = 64720, upload-time = "2026-08-28T10:26:24.95Z" }, + { url = "https://files.pythonhosted.org/packages/a1/13/08188f0cafa3a800403e4ff62b9aad4e7a17f9c4c7e080dc8f18c64794cf/kiwisolver-1.5.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:18a0cfb124546a4c2e6087c5f3029c7f44b37c85b142e0ced71f73a7599ac208", size = 1475867, upload-time = "2026-08-28T10:26:26.393Z" }, + { url = "https://files.pythonhosted.org/packages/8a/3e/053bdc3c9abdb8f2606225eda398adca25c0c91ab90add8222a69db65ee0/kiwisolver-1.5.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:34ec467940442c9943016fb2d4c81d1ba84351eeca2f1a78f8bc87f1ba0d414c", size = 1282865, upload-time = "2026-08-28T10:26:28.118Z" }, + { url = "https://files.pythonhosted.org/packages/5e/64/a44c341b36b610588cc2f1e89b3cae072a3119aa8be578e90987cd640751/kiwisolver-1.5.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a83ee7107df13abe42a54a6654670eef9bb39425cf2e27f65e0007465e1286ab", size = 1300865, upload-time = "2026-08-28T10:26:30.125Z" }, + { url = "https://files.pythonhosted.org/packages/60/5e/7e7d716dca38c714478b741257a5b4a321d9932b8d851551a136dcaf3984/kiwisolver-1.5.1-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bebb89489b279b2f5661bbbb2abcc87bcd4a46607bb4a5c966f04f1db6b8df9a", size = 1348071, upload-time = "2026-08-28T10:26:31.829Z" }, + { url = "https://files.pythonhosted.org/packages/10/1a/2b98fdda8bf45b7be317e48ed12393d44334394d315c74b81f4a14c0e31b/kiwisolver-1.5.1-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:509735237ae0d849e8a843551d423d2500d2e0a9ac1611a145658b29c0fb9f85", size = 992191, upload-time = "2026-08-28T10:26:33.544Z" }, + { url = "https://files.pythonhosted.org/packages/b6/55/d893f5ede0e50f9e3fcf01f6015f42ec7d9cd221e26772701fe4a98745f9/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:824c3d763a05ea9e9003610145186b0e9848c7584a5575c79bac5a8e7cd80bad", size = 2233854, upload-time = "2026-08-28T10:26:35.282Z" }, + { url = "https://files.pythonhosted.org/packages/b1/82/f85f6279555a6ee1639fef7bfe83adb037a03e11a6fc9eaa54b8d0380339/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:1fff05e239575b1481b6ed1a782f6fad616efbf1f0b1f44e6e85c4dfe426e483", size = 2330621, upload-time = "2026-08-28T10:26:36.9Z" }, + { url = "https://files.pythonhosted.org/packages/56/31/e11aea078f66fc2fffcc179d38ca90d9da97652a241b64519169742ba46a/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0627b9bceb9c3cdcf12b8a18655eedfed2692b038df27423383c120d0b7dc2d6", size = 1982848, upload-time = "2026-08-28T10:26:39.01Z" }, + { url = "https://files.pythonhosted.org/packages/af/ea/2956b63bf5140ca46aa2c2818e6aa03e2d5754dd2fa41db1c6b28922940c/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:8a708a47ade1fe19e8371d5da076bac0dd4b0a5a7985ad6c637f7f7e361b6baa", size = 2494850, upload-time = "2026-08-28T10:26:40.837Z" }, + { url = "https://files.pythonhosted.org/packages/11/d1/3829542258d8b3fc0898d221e7ef0e2c83eca0d348709bb8dbe54f3d4005/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:007a5553dfc4f4e8d184f588a0200e2cd4b63a59cc8796df3c39909e679dc7a0", size = 2298067, upload-time = "2026-08-28T10:26:42.803Z" }, + { url = "https://files.pythonhosted.org/packages/4e/0e/49522e1ab5788cbaf63a26fbd3b851f9028616828c961b8a31b35cb96df8/kiwisolver-1.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:f4167e87b397f273dc2356fcf1eaf50a6bac51e6105f45103ef7129c8efb0255", size = 72282, upload-time = "2026-08-28T10:26:44.268Z" }, + { url = "https://files.pythonhosted.org/packages/f5/b6/22e7ca5315d363e6f81c9f37c9472e12e7b298731e77c0428e6a911a2c39/kiwisolver-1.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:5c490db2168a508088f59140dd392556a54b8bd1048fc6383c8baff13c359673", size = 69855, upload-time = "2026-08-28T10:26:45.725Z" }, + { url = "https://files.pythonhosted.org/packages/30/8c/03a9cfbe871964c8758a816eb03ac96c806da2795a9a7cd9bf9648bfb594/kiwisolver-1.5.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:4d4ca09bf13cff792b1884f64b98ee6c2467930d632233be25c56b442d99f10e", size = 126289, upload-time = "2026-08-28T10:26:47.023Z" }, + { url = "https://files.pythonhosted.org/packages/f2/e3/14ce3041ca79dff9c9d884ca00c7bf32374e76028a865a9ecd99b4f5a517/kiwisolver-1.5.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:44b8faef94f1857e77fa0238f3390ff1ac51d2ea20a487e2e452a59fd2b5f5ca", size = 67709, upload-time = "2026-08-28T10:26:48.268Z" }, + { url = "https://files.pythonhosted.org/packages/af/c4/45030471a66ec8ef042e9f96ffe1d522c9ab12da180186a0898966fc1385/kiwisolver-1.5.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2ae70bc59790d2af72a3f76f24b272403e135070340281108b447cb77ea70819", size = 65909, upload-time = "2026-08-28T10:26:49.523Z" }, + { url = "https://files.pythonhosted.org/packages/42/73/17dce073a6ae259bb32cf9d686c4079d2e538868bc45967462bf33df914a/kiwisolver-1.5.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:43844c1a7ad6d723d5b5b4c4fc7f5bd399c40e288120d16257c7c9e8765c6e85", size = 1584907, upload-time = "2026-08-28T10:26:50.933Z" }, + { url = "https://files.pythonhosted.org/packages/8c/84/ae3c75909f507283cbfcc7e916c7e822579ef962020b97e6882b27b4478f/kiwisolver-1.5.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22d5e5aaad6be121f2515765e3b1c444352cb8eb4c86510801db8f2e50757316", size = 1392474, upload-time = "2026-08-28T10:26:52.638Z" }, + { url = "https://files.pythonhosted.org/packages/34/31/8bcc83caad5bce8fa4577152389848bf6bc110e51e573a2b4e7c2aa34c89/kiwisolver-1.5.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3fa5855898f6d3d01b72ccd48a2d65cbdee301251603fefe34e2025bddba219c", size = 1405246, upload-time = "2026-08-28T10:26:54.248Z" }, + { url = "https://files.pythonhosted.org/packages/55/72/220345537d790cf4ae54f8acfff4b5cc2468e0702a384d651cf7a771c63e/kiwisolver-1.5.1-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d66a64dd5dec136040ec2ae94aa026a912ee60fdd45bc28d3db30037fd809e88", size = 1456099, upload-time = "2026-08-28T10:26:56.042Z" }, + { url = "https://files.pythonhosted.org/packages/cd/10/3725fd2398f66d18c34b4e0f81a8d03764cd4f4f089f58a527f0b4428086/kiwisolver-1.5.1-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:9e51c119992ea8820706871c30a4642ec76de20ae82f9b50b9a45517d8e9f810", size = 1073695, upload-time = "2026-08-28T10:26:57.658Z" }, + { url = "https://files.pythonhosted.org/packages/86/cb/28d6e09e66b93e4588b2e6b7d84d020ccefea09e2f4de788510a07efeab7/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:70ed9a45c7484d2b30cdacf60d220f494a1763b9fec1ad03285c6553fa0889f2", size = 2335355, upload-time = "2026-08-28T10:26:59.202Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b3/a0f31d5e4e40af7dc97c36b8a74fdd3a36cf3c8bbd098da9a23466ff6a94/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:98b208a7cc42c803445ef551d6753cc42a5ea13e9cab1ee66cd8b9cb70195330", size = 2426524, upload-time = "2026-08-28T10:27:01.181Z" }, + { url = "https://files.pythonhosted.org/packages/2f/c9/728f63bd58c72cafdc79fc306abeeac7391bec03b757a48dadeb30906521/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c6834b92dd2428e2dd85ef3d85f723d3c12f20aaf43a2ddd4f944ca25d833408", size = 2063430, upload-time = "2026-08-28T10:27:03.06Z" }, + { url = "https://files.pythonhosted.org/packages/84/df/ce188b96f92f9a2c958231da140768918cba53c9713dc887b82f85462118/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:5d142e352eb13facc7dd047489aebdff6ba78576c239f1ea04931979caaf0567", size = 2597513, upload-time = "2026-08-28T10:27:05.072Z" }, + { url = "https://files.pythonhosted.org/packages/69/d6/76947c8203768968382e5bd74d9cc95654746703a61ea53015f2c74a2e06/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9b1c4900736e489a812c529100de4b8fb617d4db075e931e213c57424b83d9b", size = 2394488, upload-time = "2026-08-28T10:27:07.423Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d4/14b21e4eb203c4d15425e8b6a2c625a320b4a1f2f7557eead63ffc30ffb7/kiwisolver-1.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5978c3340f16a35c30f8ab2fa7bcf559973c55f1a5ef6970e1f621acf3c4db13", size = 75404, upload-time = "2026-08-28T10:27:08.892Z" }, + { url = "https://files.pythonhosted.org/packages/cb/f5/53157899fc7f45f76421b77b99eb1639dd0f83f26ff9d76300c96bb4a3b0/kiwisolver-1.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ca307d6c259e5c98d3cb9ade55342b47a6839762caf2536f3d7b46ee660cc82e", size = 72946, upload-time = "2026-08-28T10:27:10.944Z" }, +] + +[[package]] +name = "lazy-object-proxy" +version = "1.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d4/8e/f26b09778fcb26261fdeb4cc2b011975292316529bff9b541a5a02acb976/lazy_object_proxy-1.13.0.tar.gz", hash = "sha256:ce34046cb021d69c72d05ddb83821ecfd4d2d0a5d43a93c5cd01c9e34779cf14", size = 45649, upload-time = "2026-10-17T16:38:01.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d0/0b/410ea9a56ad59421d8969535099560f0bad7162d483869e1c07ff5880f35/lazy_object_proxy-1.13.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:62612150e2b67d1cb26c2201d020773e9bab9c596d783d55ada42885a695f749", size = 26856, upload-time = "2026-10-17T16:37:48.864Z" }, + { url = "https://files.pythonhosted.org/packages/8c/97/79ab37585905cf6841134806e73ace576d61a87c4eee333be4622161b23f/lazy_object_proxy-1.13.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ad7630266b5775463f2a1806165c1d9dff07780cf1bba3c53f311e1d026e8921", size = 70985, upload-time = "2026-10-20T01:05:49.274Z" }, + { url = "https://files.pythonhosted.org/packages/18/2e/66bbb45f20aab9e81139e2bf9fea1a29850b5af769cbf7f181221ce062dc/lazy_object_proxy-1.13.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:73f05b09e37b0eb0ca7d6e80e2b0689c49bedac8c5d69667c1ebb9f02a4ed5c7", size = 70984, upload-time = "2026-10-20T01:05:50.548Z" }, + { url = "https://files.pythonhosted.org/packages/74/e0/63dc39750c7b266e9e25022962eba32ba80e4f17fdcd674fc4ad4143fd90/lazy_object_proxy-1.13.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:91a725d3c64dfe13d365cf78c469c2a8f95884859379aeca89cb8d2ed291649a", size = 65689, upload-time = "2026-10-20T01:05:51.765Z" }, + { url = "https://files.pythonhosted.org/packages/e7/6c/b94a8779eec1331477557ca3ea4742860d59dc9bcd4dcf21bcef3cd8c4f2/lazy_object_proxy-1.13.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e28a75d33378141927c08f3eb291cc98d0a22776670ae330f8347f898cd3b175", size = 69492, upload-time = "2026-10-20T01:05:53.116Z" }, + { url = "https://files.pythonhosted.org/packages/60/99/6c3ff4a32f15e807ffb868c47de136ebd4be31e7320af42b699dc43a7495/lazy_object_proxy-1.13.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:a785fe44b61fcbffc0e264fe6b735a909e0b5ef922f0e976e281bbe8477fb47a", size = 65019, upload-time = "2026-10-20T01:05:54.462Z" }, + { url = "https://files.pythonhosted.org/packages/c4/1a/447ff40629a11f879f194e839d59e5a026dd26f4d0eb8672de858644be85/lazy_object_proxy-1.13.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e321425f76451885c93083ecec0850b64de0f83bb94c113e930e8a0a630e45ab", size = 70334, upload-time = "2026-10-20T01:05:55.619Z" }, + { url = "https://files.pythonhosted.org/packages/70/52/2ca84fb914b17d4b02193cbf8b6ba9344b36459944a19711d3da1d14b03d/lazy_object_proxy-1.13.0-cp314-cp314-win_amd64.whl", hash = "sha256:0e52094b7fff1f26f4e227b88be3f350817078e4bb79b4c80846fca0d15efae4", size = 26122, upload-time = "2026-10-17T16:37:53.02Z" }, + { url = "https://files.pythonhosted.org/packages/84/c7/ebbeb84639e84fbf6f07a48373f76fe048d23fbcfd4557509b48f35d284d/lazy_object_proxy-1.13.0-cp314-cp314-win_arm64.whl", hash = "sha256:b2dd1c37d64cf9f3f4a2072971639408989b0803a3b7f05e75c1fe28d1a93c1f", size = 24746, upload-time = "2026-10-17T16:37:53.954Z" }, + { url = "https://files.pythonhosted.org/packages/38/ac/8ff35cc4d1316e056144edfb816dbff9b5db9ccd7e98c69f6b602c11bc29/lazy_object_proxy-1.13.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:348370676ea6d9ed08f9b74545c37e5be4cf009c45b9d50c6aff476fb7fcc7ec", size = 27524, upload-time = "2026-10-17T16:37:49.825Z" }, + { url = "https://files.pythonhosted.org/packages/14/c5/8afe34ead41fdd48a207c4535192a4e931c56c791d5f0a57c0abd4558c1c/lazy_object_proxy-1.13.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:dee2fb3326cd81384d2b752c3f6888d7ed9eba2cdbf0583097b5168b8bb4a703", size = 80523, upload-time = "2026-10-20T01:05:57.129Z" }, + { url = "https://files.pythonhosted.org/packages/38/fd/0e68a385daaf141b1b1d943b132b8a9887bd53abb88886dab286cca9b62e/lazy_object_proxy-1.13.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2b4c446cbc8e411b116c9ee9b475cb664b8bc5c3d912bcbf1bab5c785fc69a02", size = 82823, upload-time = "2026-10-20T01:05:58.56Z" }, + { url = "https://files.pythonhosted.org/packages/91/ce/648e09f90dc59cb6007d9093c2cc17d72e2d93c06553828037126205ea7c/lazy_object_proxy-1.13.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1e671e0e9f2793759f382a69a3853c8742474bc011865ed3595187340ac5956d", size = 74655, upload-time = "2026-10-20T01:05:59.717Z" }, + { url = "https://files.pythonhosted.org/packages/10/4d/811442390862dbf85e00520ecb0cb58c7dbdf824dc563ad933729f9e20f3/lazy_object_proxy-1.13.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a0155084a5dc8ce3e1a3d6e3f2fb4d84d5fc09e66ed84dc0e5f8a2697d421ea0", size = 80848, upload-time = "2026-10-20T01:06:00.884Z" }, + { url = "https://files.pythonhosted.org/packages/24/4e/c30ea3678b50a7ed7774760fbde917106cbb860edb88cc31a17a8385b3d4/lazy_object_proxy-1.13.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2d07e0bde2738922a7117fccc1a82514aefbc9c07ee8ff0bb84a1c606dbb5ac8", size = 74127, upload-time = "2026-10-20T01:06:01.949Z" }, + { url = "https://files.pythonhosted.org/packages/19/d0/862f0f96b031dab7faa036679e2076bbd6a18ea06e34fb1400fca65b03f0/lazy_object_proxy-1.13.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:da9f1b8780678af93c4ddba46826166c53a25d8d71133fc818542bf7b481e033", size = 79497, upload-time = "2026-10-20T01:06:03.122Z" }, + { url = "https://files.pythonhosted.org/packages/d5/50/20454483d8f95a11710b951518f86aaaaaae9195982fe27c12eeed130660/lazy_object_proxy-1.13.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f21b4711e6744d46a4672497ca2db390cbdb03241d9b1654bbf38dbbc4db2a5e", size = 26670, upload-time = "2026-10-17T16:37:50.977Z" }, + { url = "https://files.pythonhosted.org/packages/4a/df/c1ff843fd9c4978d9a50ef2bceda3897d71645d4127ec1413aa15204cb64/lazy_object_proxy-1.13.0-cp314-cp314t-win_arm64.whl", hash = "sha256:de295ae25e5c1fd712088547f251c4b2976d2f60df28057b6c416e771a99842b", size = 25297, upload-time = "2026-10-17T16:37:52.088Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.11.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e7/c8/9aa712a0afb882649424dd8de8ad9aa6235e796e84c6052e8f6dc1598d0d/matplotlib-3.11.2.tar.gz", hash = "sha256:cec596316640f2b394b8f0daa0ea61a8eae82d017b620b9f202befb972a59ea4", size = 32660610, upload-time = "2026-09-11T19:05:31.214Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/b4/4facdb700bc236e4c676495ca3798d8134ab8668cbfe0f6b2e9ebf962a38/matplotlib-3.11.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c9721f81275499da1feeb36a2cf8192ea086283b3bd16b7dc4c9d7aedb7396d6", size = 9478976, upload-time = "2026-09-11T19:04:00.12Z" }, + { url = "https://files.pythonhosted.org/packages/4c/a0/bba05f0a25bfeb0475c2f2a87958b31103aa6b7a5386017afb1a96212825/matplotlib-3.11.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1a3040b209f3968b4e84161df7b174f07a9fad33b0f2d7e48ea3bbd3075e2863", size = 9307932, upload-time = "2026-09-11T19:04:02.976Z" }, + { url = "https://files.pythonhosted.org/packages/d4/42/81d5cba4bb39b41b0998efc880e129f2d7cdb94256ca49678fdcd9c21be5/matplotlib-3.11.2-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf3fe71fbfb8ec0e310e0bc8537c3405a01f38f25f9394ed2135e6202fed542b", size = 10674370, upload-time = "2026-09-11T19:04:06.912Z" }, + { url = "https://files.pythonhosted.org/packages/29/5e/52f56f93d5b20815ee0ae352f7a38eff25580edb180b4fa7df87cfeba68f/matplotlib-3.11.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8c8255de28f986d935a64c9ca71c0ec2d2f41d355691f5ea684725dc91413f71", size = 10954597, upload-time = "2026-09-11T19:04:09.948Z" }, + { url = "https://files.pythonhosted.org/packages/6e/ae/f8918a1b564db49c53cd603eb3c8748c5767e4ce0fb2cf1d7c38653e4c5d/matplotlib-3.11.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a8756cc73d9af9a7fe0deb54ea2e75ef73b01d9e575877e72acad5458e660943", size = 10812583, upload-time = "2026-09-11T19:04:12.887Z" }, + { url = "https://files.pythonhosted.org/packages/ea/61/4315ef0d63937fe56f451887b4a0be3b8e8b22cf1d92a8d157caac54570d/matplotlib-3.11.2-cp314-cp314-win_amd64.whl", hash = "sha256:ecea603dd2fbf8242fd31a305a8b12a4ece2de28096870c65fdd0d1e35b8d9a6", size = 9505972, upload-time = "2026-09-11T19:04:15.788Z" }, + { url = "https://files.pythonhosted.org/packages/d5/00/02398b0a1a62ef73d9af0a957fe1773363eec9a6ca7e433c72ae2790fbce/matplotlib-3.11.2-cp314-cp314-win_arm64.whl", hash = "sha256:01dc8eaaab5a9fce9ff615eca82345728f289e4715b186ee10c6d85272fc26bb", size = 9184534, upload-time = "2026-09-11T19:04:18.691Z" }, + { url = "https://files.pythonhosted.org/packages/ec/c5/1e6ca10baa7e04f113c37856aadb4adc3dbb1c55fc7da6dc830bba1292d7/matplotlib-3.11.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:79a258f58253dfa025af80a9e9bb228d75fced007f0e93ae7423fefbde81a74d", size = 9526415, upload-time = "2026-09-11T19:04:21.39Z" }, + { url = "https://files.pythonhosted.org/packages/e0/93/7561727af07ccc84747953c6a33eee3981cc436d04f465032e707ca0e429/matplotlib-3.11.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c0b83f044ce10a98027b105b3931548719a6e8c7ef986b4362651e0b5367c8dc", size = 9361064, upload-time = "2026-09-11T19:04:24.107Z" }, + { url = "https://files.pythonhosted.org/packages/c1/40/ce270ef2a6794d94a409fe28b8dabedffc07c07f9e5dbb89e0f605bd157d/matplotlib-3.11.2-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e43b188f0a5b75447bcc197728258166aa64365770ed1caa36595a5e1ca4bbba", size = 10684626, upload-time = "2026-09-11T19:04:27.201Z" }, + { url = "https://files.pythonhosted.org/packages/45/46/396e0307dbf1c1f2d0a3654caa6dbc780dd5379f5f11257369cf8d21d9fe/matplotlib-3.11.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3304eb5a59442a8867f6920d484591c0fa09ffc29e9260be2feec3351e25869", size = 10960602, upload-time = "2026-09-11T19:04:30.254Z" }, + { url = "https://files.pythonhosted.org/packages/1c/97/4defb84695477340aa88b27c9482cc1ca4de11f36f66b6c8c0ddd685def1/matplotlib-3.11.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:02329432ae5c6af87cf208ee575b701d698bdf0b1a3bb28cc6d53c36e967e575", size = 10822603, upload-time = "2026-09-11T19:04:32.964Z" }, + { url = "https://files.pythonhosted.org/packages/7d/e7/eab54551c1ec6b72dcd678a078b6c6da8d4c85ec1ff0016e81fe52866304/matplotlib-3.11.2-cp314-cp314t-win_amd64.whl", hash = "sha256:f2ac30cf5eb5dff1b584627ae0b0e1186551a4f69ae3c75073911da497a29170", size = 9551206, upload-time = "2026-09-11T19:04:35.811Z" }, + { url = "https://files.pythonhosted.org/packages/4e/0e/04698032cb4d8fb1e30d8ffec5ded20f6f582b03c8c58b2385c95245f158/matplotlib-3.11.2-cp314-cp314t-win_arm64.whl", hash = "sha256:cf41ecd1b0c0b6f7177ed965a54c2afbe888715c7cf6054dc12d53bc1494002c", size = 9234977, upload-time = "2026-09-11T19:04:38.972Z" }, +] + +[[package]] +name = "minio" +version = "7.2.20" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi" }, + { name = "certifi" }, + { name = "pycryptodome" }, + { name = "typing-extensions" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/40/df/6dfc6540f96a74125a11653cce717603fd5b7d0001a8e847b3e54e72d238/minio-7.2.20.tar.gz", hash = "sha256:95898b7a023fbbfde375985aa77e2cd6a0762268db79cf886f002a9ea8e68598", size = 136113, upload-time = "2025-11-27T00:37:15.569Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/9a/b697530a882588a84db616580f2ba5d1d515c815e11c30d219145afeec87/minio-7.2.20-py3-none-any.whl", hash = "sha256:eb33dd2fb80e04c3726a76b13241c6be3c4c46f8d81e1d58e757786f6501897e", size = 93751, upload-time = "2025-11-27T00:37:13.993Z" }, +] + +[[package]] +name = "mtusi-messenger-lab4" +version = "1.0.0" +source = { virtual = "." } +dependencies = [ + { name = "argon2-cffi" }, + { name = "fastapi" }, + { name = "minio" }, + { name = "pillow" }, + { name = "psycopg", extra = ["binary", "pool"] }, + { name = "pydantic" }, + { name = "redis" }, + { name = "uvicorn" }, +] + +[package.dev-dependencies] +dev = [ + { name = "httpx" }, + { name = "matplotlib" }, + { name = "openapi-spec-validator" }, + { name = "psutil" }, + { name = "pytest" }, + { name = "ruff" }, +] + +[package.metadata] +requires-dist = [ + { name = "argon2-cffi", specifier = ">=25,<26" }, + { name = "fastapi", specifier = "==0.143.3" }, + { name = "minio", specifier = "==7.2.20" }, + { name = "pillow", specifier = "==13.0.0" }, + { name = "psycopg", extras = ["binary", "pool"], specifier = "==3.3.6" }, + { name = "pydantic", specifier = "==2.14.1" }, + { name = "redis", specifier = "==8.1.0" }, + { name = "uvicorn", specifier = "==0.54.0" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "httpx", specifier = ">=0.28,<1" }, + { name = "matplotlib", specifier = ">=3.10,<4" }, + { name = "openapi-spec-validator", specifier = "==0.7.2" }, + { name = "psutil", specifier = ">=7,<8" }, + { name = "pytest", specifier = ">=8,<10" }, + { name = "ruff", specifier = ">=0.14,<1" }, +] + +[[package]] +name = "numpy" +version = "2.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/95/b0/c7453d0b6e2073c3264468b106ee1563750cecc910965e67357e3698c83e/numpy-2.5.4.tar.gz", hash = "sha256:9a94cf751c9ad8ebaa835bcd3d40dacf8534ad086b88c38029b65123c7999d2a", size = 20866315, upload-time = "2026-10-10T20:05:31.422Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/ba/005cb5edd580d2f84d7ca3206b92dc17d4388e56e6f87ffe8f2762f83139/numpy-2.5.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c668b2f0d651605b58892644b0e302c7157f7159544227758c896982ef384b18", size = 17005499, upload-time = "2026-10-10T20:03:37.961Z" }, + { url = "https://files.pythonhosted.org/packages/f3/49/fee7587c33ee35f7977f9051d7f2023d4e7246d62710c80f20c2361ea232/numpy-2.5.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ffa6ce09a1c6a08e9667dd9c97aa0b14184e8d18f2a14b78b2a2328c9147f076", size = 12019666, upload-time = "2026-10-10T20:03:40.606Z" }, + { url = "https://files.pythonhosted.org/packages/d5/b2/c6ce165acffceb15a82c07b9cc77d391f86b3f379ba62911908ae5d34b91/numpy-2.5.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:956555e0603a4d38019ae6925711cb9dc43195c076a928accf7ea5d50bddfe53", size = 5455617, upload-time = "2026-10-10T20:03:43.138Z" }, + { url = "https://files.pythonhosted.org/packages/77/7f/dd85ce260a669a89be06842cf355d7353a33e6cfbc590fb8ebb947d88dc9/numpy-2.5.4-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:2c2c4afffdeb7920e445028dd71eb932cac3e704792e964bc2a232426d4f1255", size = 6791932, upload-time = "2026-10-10T20:03:44.874Z" }, + { url = "https://files.pythonhosted.org/packages/63/d6/34b0a2b0741386a63025a65a2c09caaaaaad6d0ca95b66cd65c30dd7fcb5/numpy-2.5.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4054173604cd8658796053f1f3bc0befb68ec1c0762c57fdad61e199256a8617", size = 15710899, upload-time = "2026-10-10T20:03:46.839Z" }, + { url = "https://files.pythonhosted.org/packages/16/d5/928078d2b28f26829b138b4a6c3980045022fb409f570657a224ae60ef4e/numpy-2.5.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d549420b8858885cea8838a727842249218b9c1da24dd517e25c9c7a948310a3", size = 16721710, upload-time = "2026-10-10T20:03:49.489Z" }, + { url = "https://files.pythonhosted.org/packages/f9/cf/673fd1b8f4cd78eb6320e87ec4c90ac19c095644259e3749853a405c70f4/numpy-2.5.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:823874a507a84af050493b622affde94b6f7c3a0dc22cb2801381bc03b871c00", size = 17066182, upload-time = "2026-10-10T20:03:52.25Z" }, + { url = "https://files.pythonhosted.org/packages/f3/92/a77b5061b1b3e2643928c37976d79ee173e1b171ed158b7a3c61056b41bc/numpy-2.5.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4e263278bfb5ee6409db8aedbc4cc32973b1b82bc1e8d3c668551d04d83a7e37", size = 18480315, upload-time = "2026-10-10T20:03:55.39Z" }, + { url = "https://files.pythonhosted.org/packages/bb/1d/1486ef3d3fb2279fd93c4c43c1bbbf1ca389a19816696684409f71babaab/numpy-2.5.4-cp314-cp314-win32.whl", hash = "sha256:cfd73180400042a7c532d30c5e287bdd03c59ff9ee1b4c0316af0539e29dfe23", size = 6185739, upload-time = "2026-10-10T20:03:58.186Z" }, + { url = "https://files.pythonhosted.org/packages/52/9a/e1e512ebc948d5b9dd33b08736760f0ebbed2848fd4eda1f553088a6dcee/numpy-2.5.4-cp314-cp314-win_amd64.whl", hash = "sha256:2ca144f15135b6212a5c47b1e2aeca6e412f102f95a2d5d88d8aec77eb255de3", size = 12703552, upload-time = "2026-10-10T20:04:00.28Z" }, + { url = "https://files.pythonhosted.org/packages/2c/05/de709a982d7bbcd688a3fad71f002e9ff80c2db39e03ee726609b610f1d1/numpy-2.5.4-cp314-cp314-win_arm64.whl", hash = "sha256:468397ba3c64427474706e5c9123fe266395496714dc684294eac75cd4930d1e", size = 10803901, upload-time = "2026-10-10T20:04:02.659Z" }, + { url = "https://files.pythonhosted.org/packages/13/34/083570ada3bb2a30fbe5d77c8c6fef9141144a15d33e6f793a67e9749ab8/numpy-2.5.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1ef3aa6d7e29bb13677323114280b05acc57607fa2300e66432d665d5418a162", size = 12138695, upload-time = "2026-10-10T20:04:05.012Z" }, + { url = "https://files.pythonhosted.org/packages/94/06/1f9c24db48eef0c2d1207e3b11fffb0478e39dfd8c1e1be7476936885eed/numpy-2.5.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:98b053943e5a0474ec0da309d2cb9d3f18ea57f8a2067c2ab7b5f763d1068380", size = 5574615, upload-time = "2026-10-10T20:04:07.316Z" }, + { url = "https://files.pythonhosted.org/packages/da/0f/593fba2e1560e949123bc7d2fc48b5893d56e58cd4bd5a273d2fbf60b220/numpy-2.5.4-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:b64a85f40e154983960a4167d4c1d57a50c7f109b3d3264a3a984154e90a8454", size = 6889383, upload-time = "2026-10-10T20:04:09.918Z" }, + { url = "https://files.pythonhosted.org/packages/eb/9f/b799dfdce4e05e80ed4bc815c71ff343a11533b2c0ffc221cae8538cda63/numpy-2.5.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a813ed7719bf45463c51779e6a98d0385fe905e48447526938a4b8337333d551", size = 15753763, upload-time = "2026-10-10T20:04:12.278Z" }, + { url = "https://files.pythonhosted.org/packages/34/88/16c5f12f86f5ad2817c4d103205131fc6c8acb3d1878af05a1a4f23ec859/numpy-2.5.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9b80cdf5cedba0e90d93fa5f9a333c4d65bd545cd669b71bb97ce2b703c9d73", size = 16757212, upload-time = "2026-10-10T20:04:14.799Z" }, + { url = "https://files.pythonhosted.org/packages/ff/4f/a1fe40e18a898e6a5089f4f0d891f0a493eb0574d5b34458f0fbe5aa3e5c/numpy-2.5.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2199ed071f460487c8db2c0e5c0b564494190edb4772fe80f9aad88b2604def5", size = 17116471, upload-time = "2026-10-10T20:04:17.58Z" }, + { url = "https://files.pythonhosted.org/packages/aa/46/e923a11c78e65c1722e7aaad817c06bd591324174b9d28ce5d31eee4d432/numpy-2.5.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:64f9c9878c1938476365e11ccfb6b770f3b9e5f045ccddc514235041e6959365", size = 18524063, upload-time = "2026-10-10T20:04:20.365Z" }, + { url = "https://files.pythonhosted.org/packages/5a/fa/84ab064514440c1f64a1b21088f2c82756defdd05e07c75ab233899565b2/numpy-2.5.4-cp314-cp314t-win32.whl", hash = "sha256:64d1c8ac28a4077cf987e0a71a7a0ef7e2df70722f07f0baa42dbb7eb6938647", size = 6340926, upload-time = "2026-10-10T20:04:22.865Z" }, + { url = "https://files.pythonhosted.org/packages/7e/7e/6cd886876f435b10685db9b9f7eeb70356f99e052116f4e5f11c5792c714/numpy-2.5.4-cp314-cp314t-win_amd64.whl", hash = "sha256:067374eb538c34c745436365cf7b0112595c1d326f21ce4ff340f61230239fbb", size = 12901584, upload-time = "2026-10-10T20:04:24.99Z" }, + { url = "https://files.pythonhosted.org/packages/38/1b/3c1684f6a06f7307f2335fca6e486cb162847fb97e91d65f8eb5cabad213/numpy-2.5.4-cp314-cp314t-win_arm64.whl", hash = "sha256:e94aef2c639da4a960ad0db8e06471208d8589974953d78b61d345b4eb99e394", size = 10891152, upload-time = "2026-10-10T20:04:27.52Z" }, +] + +[[package]] +name = "openapi-schema-validator" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema" }, + { name = "jsonschema-specifications" }, + { name = "rfc3339-validator" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8b/f3/5507ad3325169347cd8ced61c232ff3df70e2b250c49f0fe140edb4973c6/openapi_schema_validator-0.6.3.tar.gz", hash = "sha256:f37bace4fc2a5d96692f4f8b31dc0f8d7400fd04f3a937798eaf880d425de6ee", size = 11550, upload-time = "2025-01-10T18:08:22.268Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/21/c6/ad0fba32775ae749016829dace42ed80f4407b171da41313d1a3a5f102e4/openapi_schema_validator-0.6.3-py3-none-any.whl", hash = "sha256:f3b9870f4e556b5a62a1c39da72a6b4b16f3ad9c73dc80084b1b11e74ba148a3", size = 8755, upload-time = "2025-01-10T18:08:19.758Z" }, +] + +[[package]] +name = "openapi-spec-validator" +version = "0.7.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema" }, + { name = "jsonschema-path" }, + { name = "lazy-object-proxy" }, + { name = "openapi-schema-validator" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/82/af/fe2d7618d6eae6fb3a82766a44ed87cd8d6d82b4564ed1c7cfb0f6378e91/openapi_spec_validator-0.7.2.tar.gz", hash = "sha256:cc029309b5c5dbc7859df0372d55e9d1ff43e96d678b9ba087f7c56fc586f734", size = 36855, upload-time = "2025-06-07T14:48:56.299Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/dd/b3fd642260cb17532f66cc1e8250f3507d1e580483e209dc1e9d13bd980d/openapi_spec_validator-0.7.2-py3-none-any.whl", hash = "sha256:4bbdc0894ec85f1d1bea1d6d9c8b2c3c8d7ccaa13577ef40da9c006c9fd0eb60", size = 39713, upload-time = "2025-06-07T14:48:54.077Z" }, +] + +[[package]] +name = "opentelemetry-api" +version = "1.45.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/14/cf3a6b6448849656e1e5f4e2101f3988dc6789724050096aba1bc5ccf592/opentelemetry_api-1.45.2.tar.gz", hash = "sha256:d7b0008e21e5fd61cbe7a7f34ca3b6905a78ab677d9bc395e299359c75cda6b4", size = 73277, upload-time = "2026-10-29T17:29:37.888Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/2d/610db864d7513158cebb8f36cc88e67e73bd6c7aa1905ef18d89e1281c81/opentelemetry_api-1.45.2-py3-none-any.whl", hash = "sha256:2cbd737377e710ee740d261c94e93fa0f08e6d037c18f17513cc0a2d94479a34", size = 60335, upload-time = "2026-10-29T17:29:06.955Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "pathable" +version = "0.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/67/93/8f2c2075b180c12c1e9f6a09d1a985bc2036906b13dff1d8917e395f2048/pathable-0.4.4.tar.gz", hash = "sha256:6905a3cd17804edfac7875b5f6c9142a218c7caef78693c2dbbbfbac186d88b2", size = 8124, upload-time = "2025-01-10T18:43:13.247Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/eb/b6260b31b1a96386c0a880edebe26f89669098acea8e0318bff6adb378fd/pathable-0.4.4-py3-none-any.whl", hash = "sha256:5ae9e94793b6ef5a4cbe0a7ce9dbbefc1eec38df253763fd0aeeacf2762dbbc2", size = 9592, upload-time = "2025-01-10T18:43:11.88Z" }, +] + +[[package]] +name = "pillow" +version = "13.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ce/a4/9cc30690a394a8305e8be4c9036aa16d0dfddadd09079860b582f562496d/pillow-13.0.0.tar.gz", hash = "sha256:cdcd1ba258178f7356d74170c9a81ba4eab6a5d55748bc402a5a2a6fe6be3510", size = 47058631, upload-time = "2026-10-16T22:18:09.718Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/45/fbad9c7f5e2f1745c373a434d46072bc84eddfefaa28b852425ac957fda6/pillow-13.0.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:44629d4498c9cb6b2051806155f22141df0d8a929c56134b166655232dfb2f8c", size = 4190721, upload-time = "2026-10-16T22:16:27.524Z" }, + { url = "https://files.pythonhosted.org/packages/a2/bf/2074902a259a90692c5dbf132885d21671644cbbd3f690047516243a55db/pillow-13.0.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:bf97ba1b5542050e9b0c74e632323b6d8136cc99d64e193abebee22fe6013c76", size = 4290236, upload-time = "2026-10-16T22:16:29.562Z" }, + { url = "https://files.pythonhosted.org/packages/ff/a5/3d1bb93b8ea38d15d21356c1b8e9f50971ac592aaa248f7fb71739094c0e/pillow-13.0.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:aa694c49787040943570d61c9b8fc01271bd2a2cfdd55f0d896f8aecdce1a981", size = 3723093, upload-time = "2026-10-16T22:16:31.249Z" }, + { url = "https://files.pythonhosted.org/packages/84/a1/be060135d85187b25fa8b2573786c0e45c62ae27527fff5257675eb97f4a/pillow-13.0.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:49c12af515073e9bf511e4ef736743bf70d531a643668722279314b937742ba4", size = 5572253, upload-time = "2026-10-16T22:16:33.103Z" }, + { url = "https://files.pythonhosted.org/packages/b5/f4/0bf6f1ac9ba7ee2ffe9914aeb410a1035a0c1a3c42f122388d7fc950bc4b/pillow-13.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d9b0a2bee3f3e03e9f29057aedb807dbf1e1d96ee1b9d0f422d9db6c8583271d", size = 4852269, upload-time = "2026-10-16T22:16:35.102Z" }, + { url = "https://files.pythonhosted.org/packages/83/16/b603274617b3e6728da3a0133d4fba1ea8d7fbe0c4ea5fef9cbffa398b8b/pillow-13.0.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5933fcea5a5ba64c686f55c886a115cbfd92f2900460784a1e79909fdbafd7b6", size = 6516058, upload-time = "2026-10-16T22:16:37.228Z" }, + { url = "https://files.pythonhosted.org/packages/1d/f2/1371707ce438ba9a43f9d24089828494ec6f9396e28cd7903aa704dd6306/pillow-13.0.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e91c2b1cbeae768c98752e67e717e283d68dae45717b41f2d91eaee648e37b7d", size = 7142574, upload-time = "2026-10-16T22:16:39.172Z" }, + { url = "https://files.pythonhosted.org/packages/b9/a9/62cf68587f910bc87c5951bcb6e9430c7643a65076adf5f18b4bf350e2bd/pillow-13.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f6299e494e46253d40c34653cac369412f44ca53b5f85d848d3f95b1ed0546c", size = 6614295, upload-time = "2026-10-16T22:16:41.117Z" }, + { url = "https://files.pythonhosted.org/packages/6c/c9/9e9b48178649730299be0bafbf5f810a5b6977538f5a92d47e4ba5f5d608/pillow-13.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f9bd7d260d986f3553518c5d723544346fa48031f8aef3265d786aeb59845bc0", size = 7224841, upload-time = "2026-10-16T22:16:43.118Z" }, + { url = "https://files.pythonhosted.org/packages/8f/48/c44e91384b1b6c072a714a63d00608acc16a6a968735e478e4be4384e5ac/pillow-13.0.0-cp314-cp314-win32.whl", hash = "sha256:2e31c4e68cffd7b1f116127626813b82fcba19edf6b940a7b0c266d6484d0055", size = 6508694, upload-time = "2026-10-16T22:16:45.883Z" }, + { url = "https://files.pythonhosted.org/packages/50/e2/7ad17747517e4c813dca78257d6bb593466f8231baf1384bc98d92745edb/pillow-13.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:f7cbb7a64e7ec664775195e4f81923bc8a93d9451b963f844e59118f63147a7a", size = 7281830, upload-time = "2026-10-16T22:16:47.725Z" }, + { url = "https://files.pythonhosted.org/packages/41/9f/e5b51f2ce8ef4563215334035403ce61a244f93a2e65c24a940131618f87/pillow-13.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:a6aaa7871aebca081eb5c45f83e845bbd9712ae99fa9286dbfdcee835e63f4b4", size = 2695468, upload-time = "2026-10-16T22:16:49.515Z" }, + { url = "https://files.pythonhosted.org/packages/97/73/a53502f731f6c84805a4ce87a8881e86d07a65aee64728b900d112dc703e/pillow-13.0.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7b999816b5850a35ada08443e6e03945f1f6488144a83afe2d37b240a552aafa", size = 5578196, upload-time = "2026-10-16T22:16:51.291Z" }, + { url = "https://files.pythonhosted.org/packages/21/50/7e949959a56b5559c78ef172b70fc6025706acb289f3f648a15329e4fa6f/pillow-13.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:67871a13cf47275201553b536c025da777f997fa562a19eb798af4ad4b97c18f", size = 4857276, upload-time = "2026-10-16T22:16:53.399Z" }, + { url = "https://files.pythonhosted.org/packages/c9/52/43ded0ac08e77e39d17bd6d894162572201b5e8fdc4a022b14c55a1960a4/pillow-13.0.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e8ca8f69b7c77fa96dad99f8638c1fc4f1c0bed4acaa1baf7a3c31bdb80a0ab1", size = 6607008, upload-time = "2026-10-16T22:16:55.525Z" }, + { url = "https://files.pythonhosted.org/packages/0d/2e/4a57ed216d5bf877387cba4d44c02aa87abe51ad2e06404aa6b597c4da39/pillow-13.0.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6bce6a29c3898191f4c9998e4d4e8f69790caeabde46e54da4bc235ce5bde683", size = 7224281, upload-time = "2026-10-16T22:16:57.738Z" }, + { url = "https://files.pythonhosted.org/packages/5c/3d/2929b248e135752d63aaeabf53f6de797e905b7b6263f9c1e2adade20aba/pillow-13.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:816752a5ef76a80484c8c441c85593b7ea9304f6231fc5776ad1fbff7e773058", size = 6695600, upload-time = "2026-10-16T22:16:59.842Z" }, + { url = "https://files.pythonhosted.org/packages/bc/33/fb0da992cf084ed1ee6ee05e96b6191e35c351eb707ca2df874feb24ce47/pillow-13.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5bdb38ba220b61b4ec31dd1046dea6b016d3c6850a23f43ed8b58332b2fc668e", size = 7300589, upload-time = "2026-10-16T22:17:01.686Z" }, + { url = "https://files.pythonhosted.org/packages/bb/af/c30dd9ef6a3dce84ecb1b2393cac629047a32e66279056c6cb46c3ffd65c/pillow-13.0.0-cp314-cp314t-win32.whl", hash = "sha256:06903aac074d00c988e77a1fc435286dc498506d4ca8d6f69df9babddf4ecc15", size = 6517204, upload-time = "2026-10-16T22:17:03.722Z" }, + { url = "https://files.pythonhosted.org/packages/85/d5/ef3a8ae7609c8ab26570abf18194882534b480d245a9148b895a2262c004/pillow-13.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:9a635068d9793c7f0d929f39f18b58f1bd86c236e8e7b64167b86af9232ebca0", size = 7286695, upload-time = "2026-10-16T22:17:05.543Z" }, + { url = "https://files.pythonhosted.org/packages/84/3c/0861db0c69a03689ebe3e7599d35668a414deb5aaafd8255215e4e62e3d3/pillow-13.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0d1a9cf7bc6917538b20f8d06b9ab2147e542f68849e96fc58eb66bdf6acc692", size = 2698098, upload-time = "2026-10-16T22:17:07.674Z" }, +] + +[[package]] +name = "pluggy" +version = "1.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/db/7fc19e6f2dc92a966727031389fc2e08b558f0f25eb7403c1119ad4713cd/pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8", size = 123304, upload-time = "2026-10-15T09:50:58.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" }, +] + +[[package]] +name = "psutil" +version = "7.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" }, + { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" }, + { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" }, + { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" }, + { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" }, + { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" }, + { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" }, + { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" }, + { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" }, + { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" }, +] + +[[package]] +name = "psycopg" +version = "3.3.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "tzdata", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/26/3ea4ca5eaea1c0debcdf7ee7c1613fbe721dc27a03c461c0817ffd8a0601/psycopg-3.3.6.tar.gz", hash = "sha256:c081f2250df751a943036e42db6df4571c66cd0aabe8291a7a506512b12007d2", size = 168171, upload-time = "2026-09-18T13:22:55.152Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/de/748bd7609c71cae5d737f0ba9192f19329f70180ecda8fff3cac02c5abe3/psycopg-3.3.6-py3-none-any.whl", hash = "sha256:a1db9f7148b06a28606767efaca51fa6f9398c5c0a3810519be69d7000bdb631", size = 215490, upload-time = "2026-09-18T13:15:29.374Z" }, +] + +[package.optional-dependencies] +binary = [ + { name = "psycopg-binary", marker = "implementation_name != 'pypy'" }, +] +pool = [ + { name = "psycopg-pool" }, +] + +[[package]] +name = "psycopg-binary" +version = "3.3.6" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/b9/60711317c284a442511644ea7185b56ebe627606d6741e732cd16108c47b/psycopg_binary-3.3.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:b3f75dee0f9afafabe4edc52c4842f1e1878ed2069bd05b22d6fe961e97e4dba", size = 4720512, upload-time = "2026-09-18T13:20:29.278Z" }, + { url = "https://files.pythonhosted.org/packages/63/da/28befc84454cbc6374550de7746f591f8fe1b6165c1fce249652cc8291c4/psycopg_binary-3.3.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5927b7ba63153cd8e9862987290a2b783a5c590daf2a4ef981700cc3569166d4", size = 4782318, upload-time = "2026-09-18T13:20:35.401Z" }, + { url = "https://files.pythonhosted.org/packages/a4/8a/0d21c2c833cdc0d4244c77e858e0ed37fa2abec2623be4fd686f617109ce/psycopg_binary-3.3.6-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:0bf08b749cc144f33b44a91b78e3f71c60eb07963746a0df5a100b36ce3d7475", size = 5567460, upload-time = "2026-09-18T13:20:41.902Z" }, + { url = "https://files.pythonhosted.org/packages/49/6d/7692d0d4e656b6cc9868d8acc2e3b42f17a0db4a625400a6d093cb0533a1/psycopg_binary-3.3.6-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:31cd942c23f613276b81a6e6598cefa12960058b0f46e1e874b540c793f6aca5", size = 5246902, upload-time = "2026-09-18T13:20:47.661Z" }, + { url = "https://files.pythonhosted.org/packages/d4/c1/b8a1f18fb1b7558a17f57f7cb3fc8bc93189feea2958925950b3acb15743/psycopg_binary-3.3.6-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4690cf67738f0e0e49a32aeec99bf0e4595cc2b4f1af984a4345394b1dcff91a", size = 6847192, upload-time = "2026-09-18T13:20:56.874Z" }, + { url = "https://files.pythonhosted.org/packages/a5/76/404f33519167c65cca88ec4998776f1dbebccc301ee977f0e62c47fb0826/psycopg_binary-3.3.6-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ad1c785e784cfd87e8436c6b7702f2d321fc39601bbaf29bc63a41a867091638", size = 5079573, upload-time = "2026-09-18T13:21:04.155Z" }, + { url = "https://files.pythonhosted.org/packages/f0/d9/79e8fbc8f37262a415f3550f0bcc5f98037442bf3d12ef6cbae2056655ae/psycopg_binary-3.3.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:79a2a1c3449f6c3409427078ed1cec10de79f3023cb5f2504f0597d350ad46c7", size = 4613633, upload-time = "2026-09-18T13:21:10.664Z" }, + { url = "https://files.pythonhosted.org/packages/d4/47/96225db74be7d2ce04b3a58678b53cda610225055edf5faa775c9f501d8b/psycopg_binary-3.3.6-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:86147cb5d140341c3363fb5bacce31f8d5543902a46699d3c536b101bbceaf9e", size = 4293375, upload-time = "2026-09-18T13:21:16.027Z" }, + { url = "https://files.pythonhosted.org/packages/2a/d2/18e9c779a5efd565250329adaf529ecc2b8b2ed5be5cb0f6ccee208cbfd9/psycopg_binary-3.3.6-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:7308c93cf0b19bbaf8e6ff0a6ad50d3c442385739245fe15a8d593bf841734a6", size = 4019883, upload-time = "2026-09-18T13:21:21.587Z" }, + { url = "https://files.pythonhosted.org/packages/ef/28/0cc654afc6c2cda982767f5679d3646b30b1ec86545bdaa9402202d6776c/psycopg_binary-3.3.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:05a83ac9fd52b9bca7cb5ab04b3691163170bd16f53defa27216ea3aa07ee781", size = 4332607, upload-time = "2026-09-18T13:21:27.63Z" }, + { url = "https://files.pythonhosted.org/packages/f1/3e/0a753a74fbd7aef120f286c016e09d3cc3f1daf7688f4a145d27281260b2/psycopg_binary-3.3.6-cp314-cp314-win_amd64.whl", hash = "sha256:1fbd30e537dab22cafdf080608f10148fe2a5f3a61294ddb5113caac8a623840", size = 3755671, upload-time = "2026-09-18T13:21:33.855Z" }, +] + +[[package]] +name = "psycopg-pool" +version = "3.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/74/5e/c0664b968b102ff68b811d999c728546c48d5c1eec03e3bbaf88c0cb4472/psycopg_pool-3.3.3.tar.gz", hash = "sha256:df87b5d9d0ad7db37f6cdad4fa8ce113d250f5997f6db38e9a99192fb67f9e1d", size = 32006, upload-time = "2026-09-22T15:53:24.947Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/b4/452c6607a0f479465cd8a9b0d9956919fcb150050c1f83f9f11e6b8ee8dc/psycopg_pool-3.3.3-py3-none-any.whl", hash = "sha256:9b9cd6a4fcec47a410f7e82d408540e7f77b478509e91b44c1a5457a13e5ff37", size = 40304, upload-time = "2026-09-22T15:53:23.712Z" }, +] + +[[package]] +name = "pycparser" +version = "3.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cb/27/eeb9f307bf07060f3d9f9aa0fb8c15b01bdfded0a941e4b2719c7f94cacd/pycparser-3.12.tar.gz", hash = "sha256:f03387877eab82ce01bbdfd0ba7252ee55a90b1c708d5129e2ce915475cf1db6", size = 158785, upload-time = "2026-10-22T13:40:03.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/ae/315bbeee126a769cbde43cf4908acb4b40408d8bf8bbf334dd7368d8dadf/pycparser-3.12-py3-none-any.whl", hash = "sha256:a076f3f489b39b43ed13563a1dafe42447445bec2e294154ec5c57fcdda4c85e", size = 62600, upload-time = "2026-10-22T13:40:02.021Z" }, +] + +[[package]] +name = "pycryptodome" +version = "4.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/4d/dfbdfacc0579fa4394e3a442f034c2fb41a44d95d21bf9cd85cee89c3df6/pycryptodome-4.5.0.tar.gz", hash = "sha256:51e97a8d1cf101974bc40c20b3191cb1903891e5c172346943d5d4f3bc4f9d83", size = 1863771, upload-time = "2026-11-15T13:03:45.262Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/73/d1058461b29c5092cea78316a033918253223d8f64e928ba10b59e72a75b/pycryptodome-4.5.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:081af2cbd5d85ff282b0f22013b60bd87b7507d87790e0227e42050880adb1d4", size = 1828280, upload-time = "2026-11-15T13:03:07.867Z" }, + { url = "https://files.pythonhosted.org/packages/c1/9d/2f38ba3af1f024adc50eb113d1ff472603756e1e86b73b3c80e2ac958c83/pycryptodome-4.5.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:e031a0a430ce1d8a11ef37f2caaf51c5f1c0d9a037db8ffa2753b28a93fc5005", size = 1578107, upload-time = "2026-11-15T13:03:09.607Z" }, + { url = "https://files.pythonhosted.org/packages/e0/7a/47fcebddc746738a5ca6adb7fb0b19ea74188b83aac8ba03011755861742/pycryptodome-4.5.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:04c1b9feaf73db4f6aae714589bdabdf2c3d991b579976e1f734de6de133a099", size = 2591108, upload-time = "2026-11-15T13:03:11.352Z" }, + { url = "https://files.pythonhosted.org/packages/41/2d/e4d8e0ac2e1192c05ac7078fc37aaeb2bd21083af7c0561092ff3268e19f/pycryptodome-4.5.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3afbe7ecd62357203a588d451c604a61af7d7c9d3f0aa0b792de0612cffb8f8d", size = 3101721, upload-time = "2026-11-15T13:03:13.479Z" }, + { url = "https://files.pythonhosted.org/packages/75/46/e4e348fb1b4bc56704f7696a67f08a39afd7ea6bb751eca858bafbf459b7/pycryptodome-4.5.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:38229c875772dea2bbbe46061e2e5573b5810c52cd7bb5a9225f07cb2c9c00a9", size = 2610488, upload-time = "2026-11-15T13:03:15.134Z" }, + { url = "https://files.pythonhosted.org/packages/a5/c5/6cbd9d4394a94a3c0ee2081f3283736ce17df7e11dfc811ee8722a8a8ced/pycryptodome-4.5.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:33094d990610bf205f2b841599f514429d9ef61aca40e6c11ff1a08aeef5cbb9", size = 3663825, upload-time = "2026-11-15T13:03:16.913Z" }, + { url = "https://files.pythonhosted.org/packages/5a/ac/e0bf3f1d1bd55041051acb543b7a5f291848c62b3f73f2d3fc5badd753c2/pycryptodome-4.5.0-cp39-abi3-win32.whl", hash = "sha256:0a2f83187938665ffd0b80758d3e26e811d01523ba332495ea82fae0f5ca78d0", size = 1360703, upload-time = "2026-11-15T13:03:18.668Z" }, + { url = "https://files.pythonhosted.org/packages/61/04/471045179e76295f5da06e8d1f167054a360d418a90cd3218ed10f99975f/pycryptodome-4.5.0-cp39-abi3-win_amd64.whl", hash = "sha256:b05fed07d07d69c5205689293c3b71a21b8bb4c6f4bb964d1c2d24dfdf22433d", size = 1731036, upload-time = "2026-11-15T13:03:20.355Z" }, + { url = "https://files.pythonhosted.org/packages/0c/bb/997ee5870f70bc3f6d2c611bc4a74a33f7812347ad29799fdbb6bb93072d/pycryptodome-4.5.0-cp39-abi3-win_arm64.whl", hash = "sha256:ae9ad9b4a49f1fb5299b07fb52bf1f00dbe3df0fdce8dd38b9379e5e0b067f46", size = 1417666, upload-time = "2026-11-15T13:03:21.894Z" }, +] + +[[package]] +name = "pydantic" +version = "2.14.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/0b/8e10b2e693af8ec54346a14caf36221334775975a747c9ceaa3f8371d96d/pydantic-2.14.1.tar.gz", hash = "sha256:94f478203dd03404682a1ada216965651dd74b1d2d5ffd62e00e0837caab5c26", size = 900362, upload-time = "2026-10-11T18:37:55.396Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/ea/a56b9fe5066f3537b7882f77e9c5dfb26d8c2eefdaed9b5fc73d57b4dc22/pydantic-2.14.1-py3-none-any.whl", hash = "sha256:9195d967ec791692a04438115466764fb8b9a27b31f14a760437694f40d6b454", size = 488106, upload-time = "2026-10-11T18:37:53.437Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.50.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a6/24/af4ec4be49fbc810f35b0bdcacc3d433b56bbfa469fd3bfd4ae116cd9bf1/pydantic_core-2.50.1.tar.gz", hash = "sha256:e50d7b94baac6c7d09927fa5ca5800a0c7ee5015c7fcff65beb3a1931b5a6e09", size = 513515, upload-time = "2026-10-11T18:35:44.82Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/33/28b96e81677153715e3eafb9f26663a80841e859fde282a380359b0d3fa1/pydantic_core-2.50.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:1cf41f1ae3fa155cf167a72689ad044bcc1e3c97e064123677149bdfb5dafc4a", size = 2224428, upload-time = "2026-10-11T18:33:07.153Z" }, + { url = "https://files.pythonhosted.org/packages/94/40/15c06410c9b7b8da5805d27b64e09bd3f900e986728106db2689dbc51513/pydantic_core-2.50.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4df197990c15b5a37c5a277d131d9f2c67de6133f2e5dafd80d9bba4b99f46f9", size = 2023740, upload-time = "2026-10-11T18:33:08.763Z" }, + { url = "https://files.pythonhosted.org/packages/a1/4e/5eb629f6efc2a27e421d789dd4bfacbb5f6d09c80c28b13d1e87d73163d5/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0036473f5583e6a60e50b8b21651511564277a3f05cc5dab8cf579f552cd5f6c", size = 2049435, upload-time = "2026-10-11T18:33:10.366Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8e/f195aebec49ad12318876ac2368c197a7939f5d52f8e156d2238ef8a4588/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:992c3514ec891fa7858099183e4d64e6bd5a5d4ff452fae29df22faa77a006bb", size = 2172975, upload-time = "2026-10-11T18:33:12.368Z" }, + { url = "https://files.pythonhosted.org/packages/e0/f5/7ad9fb83010cd5ea0948409db105676ed779c4e709e2d3d89b9fe2558794/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:739dc730e6be3bd5ec2f4ab5cfc7eb047cc45fc1497b3bafec74ff2ed07df597", size = 2364197, upload-time = "2026-10-11T18:33:14.244Z" }, + { url = "https://files.pythonhosted.org/packages/ca/fb/bf0aab3e78301d202b82a0322ec968cd703b11fc0623fde9a28708936f62/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:32fad3a91e51b6d2039c572db04a5a873260b399f6bd62c3552671fa7a4a2899", size = 2444259, upload-time = "2026-10-11T18:33:15.79Z" }, + { url = "https://files.pythonhosted.org/packages/45/35/38f6d6564fae57d9b12e5676dfa947e0e7d5c46dbeaa7eb3352261d6d299/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42b54c2c90ad348b5e3a85e03e715d572c1fde357ef104cdfe3b03b697a404ea", size = 2159857, upload-time = "2026-10-11T18:33:17.51Z" }, + { url = "https://files.pythonhosted.org/packages/65/a0/fb0a3ca10f139dcf765b2d312d10cf0f65c57c59993229d00ad12b14ceff/pydantic_core-2.50.1-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:2df1ff41884de2bc4b307bafd7c40a691094fad2ff8e767e5b45a319257bcf4e", size = 2233954, upload-time = "2026-10-11T18:33:19.591Z" }, + { url = "https://files.pythonhosted.org/packages/8c/6a/e63842252702aa4ec6e6b7178ca85e541a77459076592c23ebe2d9840b33/pydantic_core-2.50.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe90228920fd8ff2be62622b6bb8a2b11acd65046d50c6b130614b5879605a20", size = 2243876, upload-time = "2026-10-11T18:33:21.393Z" }, + { url = "https://files.pythonhosted.org/packages/39/25/5991cf8318b37e0dfab47b87541619a1df8501a793cba0d978846cba37a7/pydantic_core-2.50.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:844b869f118e22a41a091bdcedda8a71bc1b0f62c38d1a0c3211cece47e1d8fc", size = 2277908, upload-time = "2026-10-11T18:33:23.324Z" }, + { url = "https://files.pythonhosted.org/packages/a7/3e/3ee8baaa6cc25a6961c69168cf9ff0f002d56f4e0d541ad6724c18fb61f3/pydantic_core-2.50.1-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:2eb75304506894a281d346220a4f7481a1b8729577c5ed2a05395991966a8396", size = 2449285, upload-time = "2026-10-11T18:33:24.942Z" }, + { url = "https://files.pythonhosted.org/packages/c0/c7/acbec6deac13fe697a80c275a9b6661db62c4d323bac8a47347b1f39c7cd/pydantic_core-2.50.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:6b20a4bffabdad0db2927ac034ae3b8a681b1f7a0182f3e60b479ad2fde21ebb", size = 2479013, upload-time = "2026-10-11T18:33:26.925Z" }, + { url = "https://files.pythonhosted.org/packages/10/08/21a3f237b264389f6219d053ee78fc1b5c2fd402c1b1cb2b6cb8b85f9834/pydantic_core-2.50.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:99ba9bc2b8062ea0c326a990f7f00e6530c23579de66dd246e72c4cafef950a5", size = 1484400, upload-time = "2026-10-11T18:33:28.693Z" }, + { url = "https://files.pythonhosted.org/packages/09/ce/077a6d262d12ef09108377ac0717f029f420d773ace63cafd6143af75568/pydantic_core-2.50.1-cp314-cp314-win32.whl", hash = "sha256:cf356f70551d40374eaffb1aa63f1eb6d2006681cbd7a9faea173ce0f4dd7cd2", size = 2103222, upload-time = "2026-10-11T18:33:30.326Z" }, + { url = "https://files.pythonhosted.org/packages/14/4c/350a2415209c43d670eb71d3c040f332c04a30583d39e311b05c7ac15762/pydantic_core-2.50.1-cp314-cp314-win_amd64.whl", hash = "sha256:d32f3acc081cc3923386d88f422cde8892335e95f034e0104bb4cf9310d9915f", size = 2171586, upload-time = "2026-10-11T18:33:32.139Z" }, + { url = "https://files.pythonhosted.org/packages/bf/92/9bea6ca96580a0902fed366f064f0829e404f41889b34543279a1162b888/pydantic_core-2.50.1-cp314-cp314-win_arm64.whl", hash = "sha256:bed5163e03b98bc1fa2eb05d74c63d9c5c95d8ed6254985481640fbf5e237dea", size = 2155773, upload-time = "2026-10-11T18:33:33.896Z" }, + { url = "https://files.pythonhosted.org/packages/86/8c/f121f073cf32bdd5cba7e6230b1ce0ac845b0cf43e44dd597d95af272db2/pydantic_core-2.50.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:9572c1369e9c9da2d64a7b7992c786d90ff295abc93964cfe3125e4290768070", size = 2234017, upload-time = "2026-10-11T18:33:35.588Z" }, + { url = "https://files.pythonhosted.org/packages/a4/69/2bb2bcd6146cffe98d760a46c42ae71efd5151d9b2f9c9bf6619a3b32083/pydantic_core-2.50.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2005207aafe1231315718bf6ed5d064a7300fb4772754af35ee72fc68159492e", size = 2001016, upload-time = "2026-10-11T18:33:37.57Z" }, + { url = "https://files.pythonhosted.org/packages/20/b3/fbf854c7d07ec114260c26e9e2071a4381740f9ae09641dbfcbdf2a18c45/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:64f6047f62a6c5ae08d0a6afb035667aa2d97c3d20d69762e034c5ea144d92a5", size = 2023015, upload-time = "2026-10-11T18:33:39.433Z" }, + { url = "https://files.pythonhosted.org/packages/65/20/6de55b2f92cdb614b745c6e9ced639fc4fd7e1e77604825a88bdece6fcbd/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1ef800dd7d85bcdadf4c3076e4c94e43939493558a3b69a1ea830c706d4617bb", size = 2192543, upload-time = "2026-10-11T18:33:41.381Z" }, + { url = "https://files.pythonhosted.org/packages/0c/d9/19e91c94bd5c405945ce2f15526808aea37e162c253160de8ed7bf70b406/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b0135bcdcaa0f23573f286e4cb5e0fd2962700964ed13df085b85f2b97aeab9e", size = 2388704, upload-time = "2026-10-11T18:33:43.167Z" }, + { url = "https://files.pythonhosted.org/packages/b6/bc/2e24c8415eae1a25ee5a5484946a917123bad2e9d01689a759236928175a/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0b3a6f334c6a2345ca15318ff894502a90012536404b37c844a976c76c846e0b", size = 2464118, upload-time = "2026-10-11T18:33:44.856Z" }, + { url = "https://files.pythonhosted.org/packages/bd/1f/945b8053cb061c64e102bcaf7bfb9ed740c0bd4349f9bb978a7d4ddff4ab/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06e01fbbfdb9be777b316a71b6c49efaf4a08b615d0a98d678cda3023f79d019", size = 2150142, upload-time = "2026-10-11T18:33:46.661Z" }, + { url = "https://files.pythonhosted.org/packages/2b/78/96a3e50bf0d64aaae781107eb9335b7529d05a85793ed6e7241c4cd1d931/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:a29a061fec0b4e2d714f277e70a3a18125ecff803f2fea6eade2f2e53711d112", size = 2245577, upload-time = "2026-10-11T18:33:48.574Z" }, + { url = "https://files.pythonhosted.org/packages/7a/5d/a6038a0322232758a6ebfa709f4ca14a60bf5b93940cd0b345056a557da4/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f5187624823423e1d1b82b1072ac41dc837389e18d3d0572cc19bbee46cd550a", size = 2263728, upload-time = "2026-10-11T18:33:50.527Z" }, + { url = "https://files.pythonhosted.org/packages/0d/4b/76ded3333a457a9344c4f2d63f2d82d0101654b05178fa4ddfe7d3627674/pydantic_core-2.50.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:3e46a9eb0a0901dd6275e6b06ac3a464885ef350ec4121fe486869de8053e4bb", size = 2293630, upload-time = "2026-10-11T18:33:52.362Z" }, + { url = "https://files.pythonhosted.org/packages/a9/00/9eca378335c9c1b72bc779bf6e4c2a82ce784f14ec48a0e87102c9870e05/pydantic_core-2.50.1-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:756d669f04e62ec4148ecfe22be6a4484d9b1181a6ef32e205ebfd200540858b", size = 2468048, upload-time = "2026-10-11T18:33:54.118Z" }, + { url = "https://files.pythonhosted.org/packages/35/ca/e3832e9cf93651251de43c8c5c029ed680a3c1a0a1b17ee26c81bed08cbd/pydantic_core-2.50.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:c516cc5367ca3448995d42cb994bf3f4c9002d2a7c22eac9622551269ad1b807", size = 2512159, upload-time = "2026-10-11T18:33:55.99Z" }, + { url = "https://files.pythonhosted.org/packages/4b/f2/773469b5a10a39116a2cb17edaf6d722f017dd8da07161b371465311c542/pydantic_core-2.50.1-cp314-cp314t-win32.whl", hash = "sha256:9d1bed94af6a63835461f3cf7502058eb166c58c4778e11d0f433cfb1bd69e19", size = 2098406, upload-time = "2026-10-11T18:33:58.043Z" }, + { url = "https://files.pythonhosted.org/packages/ee/42/0bb74f8f25204b259b11ab7c12dc7f180893b6bd706118b385147fb6efd5/pydantic_core-2.50.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c8dce1f1e0e5358b682a6ad3fa5e31b31d4560997b8e61417e9217c8d60f8a0c", size = 2148481, upload-time = "2026-10-11T18:33:59.913Z" }, + { url = "https://files.pythonhosted.org/packages/47/0d/d801646c9679a4e630e15cf521d4108b93854b42a6e6e02391bd4c6b1095/pydantic_core-2.50.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ceff0acc940be2715bd6ad17b24c0e5304abf44f6efd0f81ee8499e640f9dc86", size = 2174972, upload-time = "2026-10-11T18:34:01.875Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.3.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/11/b213bebff182584360cb8d17c72c1677fec5c5c228de439e63bcf8ab1c8f/pyparsing-3.3.3.tar.gz", hash = "sha256:928ae7e20211f3b6f3915a72f06a0cfd29ab9d24279dd6346b6b1a7146397d36", size = 1050487, upload-time = "2026-09-20T20:59:05.609Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/bb/d215ee7c73b61497b28a5503f9f53523f294fcc936762b7caf90e0c1c2b5/pyparsing-3.3.3-py3-none-any.whl", hash = "sha256:ece8c00a69cf01b45d0b1dedabb469c90d8caf996d4fda40f147627a122849a4", size = 126420, upload-time = "2026-09-20T20:59:04.025Z" }, +] + +[[package]] +name = "pytest" +version = "9.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/79/42/bb4641652e58dedeac2ec51abc1f8cae4fee4ec63899a0999016229a0f2a/pytest-9.2.0.tar.gz", hash = "sha256:97c4f3b1f3c7414aa36465e09b8220f1d03627993bd51b1282e193753c80557b", size = 1797555, upload-time = "2026-10-27T21:30:20.728Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/39/1f5d8c8877a0fa327db959c19341d4be61660de1ab6b7391f9eb805bcd67/pytest-9.2.0-py3-none-any.whl", hash = "sha256:07acdcf88ec174f907dc01af70bf52d49b014bbab03faeeade31c96b18c2e588", size = 411776, upload-time = "2026-10-27T21:30:19.131Z" }, +] + +[[package]] +name = "python-dateutil" +version = "4.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/39/b3927f3616f6223832f9b760e4208e8a7c7e1dea2b4d9ad7d32a5d214c3a/python_dateutil-4.0.0.tar.gz", hash = "sha256:d7295ff14fdc0f92f662100bfb6c551d160ca090f2939f1ec5b9794265c03f06", size = 250419, upload-time = "2026-11-01T07:02:42.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/a9/52b89563d154433d79b51ed1eb4842bf7334cb2696891a7fe135618853d7/python_dateutil-4.0.0-py3-none-any.whl", hash = "sha256:a5e246f79eb80475e691bf93862cead98decd8a498cf53ba0516fcdc0f50dc1c", size = 92853, upload-time = "2026-11-01T07:02:40.797Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { 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 = "redis" +version = "8.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a8/99/604f0b666d4c616d891cf77ebb9db6bb21601344c051aebf1b72b9ff915f/redis-8.1.0.tar.gz", hash = "sha256:6e1a19beef9225c83efd689c7e6b7da2d5215b1f42cd13b7fc3714d0a09c7b25", size = 5254356, upload-time = "2026-07-30T08:51:00.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/9d/c5731f6e3608663d4d3656fd8d3aecee8b509c3082818f5a13eae925baea/redis-8.1.0-py3-none-any.whl", hash = "sha256:a4fe1aac3d3b3cc791d4b3d5931c5a956045dc951ee74d1c913ee3ac4d2ee9fb", size = 560618, upload-time = "2026-07-30T08:50:58.497Z" }, +] + +[[package]] +name = "referencing" +version = "0.36.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744, upload-time = "2025-01-25T08:48:16.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775, upload-time = "2025-01-25T08:48:14.241Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490, upload-time = "2021-05-12T16:37:52.536Z" }, +] + +[[package]] +name = "rpds-py" +version = "2026.9.1" +source = { registry = "https://pypi.org/simple" } +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/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" }, +] + +[[package]] +name = "ruff" +version = "0.17.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/84/0e/3d154514b5bad104f7e1c13169c2d09aa9959fccdc06eb47610ccdfa83ed/ruff-0.17.4.tar.gz", hash = "sha256:f32d178b50e826e00f6c6c1be3f56333068acb9b67fe167143527fa9b81e890d", size = 5357750, upload-time = "2026-11-05T18:52:17.638Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/61/c83c78bbb6108f6c6270a106cf12b54175f4f42da088b9bb880f18e31289/ruff-0.17.4-py3-none-linux_armv6l.whl", hash = "sha256:2b08c4ff98dc234f4a3871a3105353b922fa875ea1073ca31001eb8c06bb4d89", size = 10252195, upload-time = "2026-11-05T18:51:36.594Z" }, + { url = "https://files.pythonhosted.org/packages/0a/12/dd158708378866e8b53e145a465dbc51a7cccb9fa197a74d67eaedde7234/ruff-0.17.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:13e781c3c5f663e7fba737eaaeb70dd943dd55171daf316afb25cd5268cfe0c7", size = 10266044, upload-time = "2026-11-05T18:51:39.502Z" }, + { url = "https://files.pythonhosted.org/packages/28/32/89a94a8eb11fd505a381ae6f04e190d038d9958695209dc1786ce5cfcda3/ruff-0.17.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:7ed2f416349944f908f9574215994602242b0836844eba48eec61473033afca0", size = 9432227, upload-time = "2026-11-05T18:51:41.968Z" }, + { url = "https://files.pythonhosted.org/packages/58/de/a392dc38b215798ae72e639d228b7f6c02d826a95d1c0ad7c4c0ee49ef5b/ruff-0.17.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8ea6e0017c785f7282092b11e46338e4ebed1b9e575ebf2e55a8a1eda968241a", size = 10136900, upload-time = "2026-11-05T18:51:44.562Z" }, + { url = "https://files.pythonhosted.org/packages/b7/8f/a880f60f42005f6ffdf58f77af34c7ee327000b5607f48a2f6a69d8b242c/ruff-0.17.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7e061dcc0933c7031a616ac8d66ac540309b2aa21ab558101a8f53e9ac7a1185", size = 10051245, upload-time = "2026-11-05T18:51:46.7Z" }, + { url = "https://files.pythonhosted.org/packages/09/55/98844264108af7d5ec27ca3a9cd5a989094ca657a14599c4b69a537a0e9a/ruff-0.17.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f99e95a1515161138be3cbd1b06c06e739d8feb38ade35564556999fffc3686e", size = 10704341, upload-time = "2026-11-05T18:51:49.228Z" }, + { url = "https://files.pythonhosted.org/packages/28/a2/5edf97659c3ac7c73f978003bd314936f671037fdac6b978e9de3e4b2b65/ruff-0.17.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f28cf0dd37cb172fa5a8d2e92e6ada3a9dbd0609f094ed24039929eef0b7524", size = 11394465, upload-time = "2026-11-05T18:51:51.534Z" }, + { url = "https://files.pythonhosted.org/packages/f2/8f/51371ae856b2bef4d15a044a574695fbc0f6ae63aafa42a2a22428070fb6/ruff-0.17.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6b21c771b296888e8a35c6f48555f4b44e4483f61675d6ed51810a5203469ce6", size = 10988262, upload-time = "2026-11-05T18:51:53.91Z" }, + { url = "https://files.pythonhosted.org/packages/af/1b/62874f14c7873f27c7887d2b1ea41de990e14ba9518801ffe8eacb5d51a6/ruff-0.17.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2cd025509b2e15721b426fc70fd946d71f43b3db3b08e946dfec2d696d911690", size = 10572829, upload-time = "2026-11-05T18:51:56.129Z" }, + { url = "https://files.pythonhosted.org/packages/98/30/860b9dae67432b16b88558a9cb2d3194825fa62838f8b9cc49f5d9022095/ruff-0.17.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:49b77f7b3921669466882a4881168801bdb06ec2cd83fb936049016cf5fdece1", size = 10617545, upload-time = "2026-11-05T18:51:58.172Z" }, + { url = "https://files.pythonhosted.org/packages/0f/08/781a4b41a1c83fd6e30fea610d6502a6f94e49cf94693fd37bdcbc6bfe11/ruff-0.17.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e3b84eb74f260d1c2dbd236fd9d4c011d4fdd0a52bdf8aea57a10e3a1b71fca5", size = 10111955, upload-time = "2026-11-05T18:52:00.59Z" }, + { url = "https://files.pythonhosted.org/packages/3c/e9/94b1c7b677120f30839254518924f73a8157e9bcfa200edcd5796fecdb99/ruff-0.17.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:20e43d7a08e712e33067ba887e6574546c79bd4831596ce8f16803ac7ff9ad90", size = 10058355, upload-time = "2026-11-05T18:52:03.61Z" }, + { url = "https://files.pythonhosted.org/packages/27/5f/a825910b9f309336dc33cb8c0774126662c1d2f765699b3e0a1bd538d01f/ruff-0.17.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:0d1f4848fd2ec0499be4046db9b7dfcc952666885f00233cc7033515282556a8", size = 10415932, upload-time = "2026-11-05T18:52:06.264Z" }, + { url = "https://files.pythonhosted.org/packages/8b/b8/0796468423413ea4df1a6e2442ae26cf49b8f7dda0eecf246e0d5d0dde54/ruff-0.17.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:6007e7f3a0e55b0fbdb947af69cf24c21b4928df6be8ef3e767c69b5ccccf496", size = 10826033, upload-time = "2026-11-05T18:52:08.675Z" }, + { url = "https://files.pythonhosted.org/packages/b9/ab/d8e407669ffe5014429baf780c2df47e001968a6e4c17f615e2e7b13a9ba/ruff-0.17.4-py3-none-win32.whl", hash = "sha256:3971a78cba76298b284c8321e6d40d93045ed348bec5c369d85099efc97fb7cf", size = 9931993, upload-time = "2026-11-05T18:52:11.169Z" }, + { url = "https://files.pythonhosted.org/packages/bd/15/42af8a72d8946e3c9efd2bbf6641e462b6832783b0d043d63ef5b280ba7f/ruff-0.17.4-py3-none-win_amd64.whl", hash = "sha256:67c5a894fc054cf41f75f7afa24815de5a74329d97634126c2a1015740ff4e8c", size = 10292922, upload-time = "2026-11-05T18:52:13.436Z" }, + { url = "https://files.pythonhosted.org/packages/68/9e/f1dbffcfb8ff25dadbc21f87a8b73c3848abe4abada9d4b08ccef8bec40c/ruff-0.17.4-py3-none-win_arm64.whl", hash = "sha256:181ae38a9a8fb94925bf7d0794327b48d7fd7f4b50cfd84c0e999cc09ef8d131", size = 9889396, upload-time = "2026-11-05T18:52:15.549Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "starlette" +version = "1.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/bb/3d8757f21e9a53d9035c9eb039a777047139a16bfdbedfc7a58241c3d914/starlette-1.10.0.tar.gz", hash = "sha256:b8399098d4c1e3522734f7235dc79b1fc967f96cf139c81e0fa30479e0685f9b", size = 2734356, upload-time = "2026-10-24T15:04:12.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/2e/947cfe02def9371c07cd5bf5b6b61c829e9aecb9904db02a66cfafbc1eec/starlette-1.10.0-py3-none-any.whl", hash = "sha256:478c0ab3b4ced6e82719849c118fa406f0278a3499c1a898cd15cd31bdc38ce4", size = 80571, upload-time = "2026-10-24T15:04:10.371Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ff/50/0195198eb1d75bab716bb0a813abea4cc394bfa17a92a189f021a34859af/typing_inspection-0.4.5.tar.gz", hash = "sha256:7f16c411e7930dc79596d42ab44672a3fe5f60eb34b781a1647e7872363120c7", size = 81194, upload-time = "2026-11-04T14:13:23.774Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/0c/ea2544850a7c135e15033a5c7a8e7211136184b7ae63e2239d557c2b3019/typing_inspection-0.4.5-py3-none-any.whl", hash = "sha256:bc210535442b39e1bf2805e0c7a17dfd6a4ace760c84c7f7d16245d23a6b1c39", size = 14874, upload-time = "2026-11-04T14:13:22.616Z" }, +] + +[[package]] +name = "tzdata" +version = "2026.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7a/29/6a1391d31cd00ff9e927215a224a880e1e84e826b64ba80a499e51c074d8/tzdata-2026.6.tar.gz", hash = "sha256:85d2cd9c09f81f0bb29db27759fc83af4f1e620efb814f8c5bf8b4cc4feece6d", size = 201017, upload-time = "2026-10-28T09:57:09.137Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/66/9a06c2227fedfd4919f0eaaa8b94377d9730882a7e4f95823c9a331ab5e1/tzdata-2026.6-py2.py3-none-any.whl", hash = "sha256:0a10eec6e13ef16b627fabed9a5f2ba61a62b1c67f327305f4e7e412a70b4aec", size = 348210, upload-time = "2026-10-28T09:57:07.276Z" }, +] + +[[package]] +name = "urllib3" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e3/05/b17359e1cefb4f909b5e40b1b90a496d987258916dbbf88e842c729f510e/urllib3-2.8.0.tar.gz", hash = "sha256:63bf2ead4c879426ebf22ef2a781eeb4aa3b4ae798a0435506f8687fd5bb9b63", size = 458972, upload-time = "2026-09-15T19:29:36.253Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl", hash = "sha256:0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3", size = 135717, upload-time = "2026-09-15T19:29:34.577Z" }, +] + +[[package]] +name = "uvicorn" +version = "0.54.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/da/34/30e9280707135d2cfc589dfff3cb796bd07a3aeb1a3e415ba09dd89d7bb4/uvicorn-0.54.0.tar.gz", hash = "sha256:a2e33cbfaa0306f8e6b0c13e0cb89d7d7a2da3e62b90c66e18c33d9807b28620", size = 112283, upload-time = "2026-09-25T06:52:37.601Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/0c/b54a4fdd7f90a3af8b02ebc9ce6712c2c208b7926a2f7bad95c33ebbe943/uvicorn-0.54.0-py3-none-any.whl", hash = "sha256:505bdb0f318731d45f1f712071fc781a8981f6847a31c902c9f5e652d4f67faf", size = 87427, upload-time = "2026-09-25T06:52:35.829Z" }, +] -- 2.54.0 From 8e120ec937a84ef17c7a8a1e70b2f78c08dfddf1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=81=D0=BB=D0=BE=D0=B2?= Date: Sun, 15 Nov 2026 20:19:40 +0300 Subject: [PATCH 02/12] test(storage): add crash recovery and concurrent upload experiments --- scripts/verify_storage.py | 495 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 495 insertions(+) create mode 100644 scripts/verify_storage.py diff --git a/scripts/verify_storage.py b/scripts/verify_storage.py new file mode 100644 index 00000000..1626728d --- /dev/null +++ b/scripts/verify_storage.py @@ -0,0 +1,495 @@ +"""Operator checks on the disposable teaching stand, never production.""" + +import argparse +import hashlib +import io +import json +import socket +import statistics +import threading +import time +from concurrent.futures import ThreadPoolExecutor +from datetime import datetime, timezone +from pathlib import Path +from uuid import uuid4 + +import httpx +from PIL import Image + +from scripts import cluster +from scripts.stand import BASE, ROOT, actor, auth, command, compose, ready, sql + +PNG = (ROOT / "tests/fixtures/sample.png").read_bytes() +PREFIX = """import hashlib,io,json,time,urllib.request,urllib.error +from src.object_store import ObjectStore,BUCKET +from src.database import Database +from src.settings import secret +from src.reconcile import reconcile +s=ObjectStore(); d=Database(url=secret('DATABASE_URL'),size=2); d.open() +""" + + +def inside(code): + value = command( + ["docker", "compose", "exec", "-T", "api", "python", "-"], + input=PREFIX + code + "\ns.close(); d.close()\n", + ) + return json.loads(value) + + +def upload(client, session, chat, data=PNG, *, name=None): + return client.post( + f"/api/v1/chats/{chat['id']}/attachments", + headers={**auth(session), "Content-Type": "image/png"}, + params={"filename": name or uuid4().hex + ".png"}, + content=data, + ) + + +def state(identity): + return sql("SELECT state FROM attachments WHERE id='" + identity + "'") + + +def key(identity): + return "objects/" + identity + "/original" + + +def run_reconcile(apply=False): + return inside( + "print(json.dumps(reconcile(d,s,apply=" + str(apply) + ",grace=300)))" + ) + + +def age(identity): + sql( + "UPDATE attachments SET created_at=clock_timestamp()-interval '301 seconds', " + "expires_at=clock_timestamp()-interval '180 seconds' WHERE id='" + + identity + + "'" + ) + + +def percentiles(values): + values = sorted(values) + return { + f"p{p}_ms": round( + values[min(len(values) - 1, int(p * len(values) / 100))], 3 + ) + for p in [50, 95, 99] + } + + +def concurrency(client, session, chat): + stream = io.BytesIO() + Image.effect_noise((1700, 1700), 100).convert("RGB").save(stream, "PNG") + image = stream.getvalue() + assert len(image) < 10 * 1024 * 1024 + ids = compose("ps", "-q", "api").split() + samples, stop = [], threading.Event() + code = ( + "import json,pathlib; p=pathlib.Path('/sys/fs/cgroup'); " + "print(json.dumps({k:int((p/k).read_text()) for k in ['memory.current','memory.peak']}))" + ) + + def sample(): + while not stop.is_set(): + for cid in ids: + samples.append( + { + "at": round(time.monotonic() - started, 3), + "container": cid[:12], + **json.loads( + command( + ["docker", "exec", cid, "python", "-c", code] + ) + ), + } + ) + stop.wait(0.3) + + barrier = threading.Barrier(10) + + def one(_): + with httpx.Client(base_url=BASE, trust_env=False, timeout=60) as c: + barrier.wait(timeout=30) + begin = time.monotonic() + r = upload(c, session, chat, image) + latency = (time.monotonic() - begin) * 1000 + assert r.status_code == 201, (r.status_code, r.text) + a = r.json() + assert a["sha256"] == hashlib.sha256(image).hexdigest() + data = c.get( + f"/api/v1/attachments/{a['id']}/content", headers=auth(session) + ) + assert data.status_code == 200 and data.content == image + return { + "id": a["id"], + "latency_ms": latency, + "instance": r.headers["x-instance-id"], + } + + cpu_before = { + cid: command(["docker", "exec", cid, "cat", "/sys/fs/cgroup/cpu.stat"]) + for cid in ids + } + started = time.monotonic() + thread = threading.Thread(target=sample) + thread.start() + try: + with ThreadPoolExecutor(max_workers=10) as pool: + results = list(pool.map(one, range(10))) + finally: + stop.set() + thread.join(timeout=30) + elapsed = time.monotonic() - started + assert samples + return { + "concurrency": 10, + "requests": 10, + "successes": len(results), + "errors": 0, + "bytes_per_image": len(image), + "pixels": 1700 * 1700, + "duration_seconds": round(elapsed, 3), + "successful_rps": round(10 / elapsed, 3), + "latency_scope": "upload only; duration includes verified downloads and memory sampler", + **percentiles([r["latency_ms"] for r in results]), + "cpu_before": cpu_before, + "cpu_after": { + cid: command( + ["docker", "exec", cid, "cat", "/sys/fs/cgroup/cpu.stat"] + ) + for cid in ids + }, + "memory_samples": samples, + "results": results, + "window_max_memory_current": max(s["memory.current"] for s in samples), + "lifetime_memory_peak": max(s["memory.peak"] for s in samples), + } + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--output", default="evidence/storage-repeat.json") + parser.add_argument("--research", action="store_true") + args = parser.parse_args() + output = Path(args.output) + assert not output.exists(), "Choose a fresh evidence path" + output.parent.mkdir(parents=True, exist_ok=True) + result = { + "source_commit": command(["git", "rev-parse", "HEAD"]), + "date": datetime.now(timezone.utc).isoformat(), + "complete": False, + } + ready() + compose("stop", "reconciler") + orphan = "objects/verification-" + uuid4().hex + "/orphan" + fresh = "objects/verification-" + uuid4().hex + "/fresh" + research_prefix = "objects/research-" + uuid4().hex + "/" + try: + # Its server LastModified must really age; no clock manipulation in S3. + inside( + f"s.put(key={orphan!r},stream=io.BytesIO(b'orphan'),size=6,content_type='application/octet-stream',sha256=hashlib.sha256(b'orphan').hexdigest()); print('true')" + ) + orphan_started = time.monotonic() + with httpx.Client( + base_url=BASE, trust_env=False, timeout=30 + ) as client: + user, _, session = actor(client) + r = client.post( + "/api/v1/chats", + headers=auth(session), + json={ + "title": "Storage verification", + "member_ids": [user["id"]], + }, + ) + assert r.status_code == 201 + chat = r.json() + r = upload(client, session, chat) + assert r.status_code == 201 + saved, uploader = r.json(), r.headers["x-instance-id"] + target = next( + c + for c in cluster.containers() + if cluster.alias(c["Id"]) == uploader + ) + command(["docker", "stop", "--time", "10", target["Id"]]) + try: + time.sleep(3) + download = client.get( + f"/api/v1/attachments/{saved['id']}/content", + headers=auth(session), + ) + assert download.status_code == 200 and download.content == PNG + assert download.headers["x-instance-id"] != uploader + result["upload_replica_stopped_downloaded_elsewhere"] = { + "stopped_container": target["Id"][:12], + "uploader": uploader, + "downloader": download.headers["x-instance-id"], + "sha256": saved["sha256"], + } + finally: + compose( + "up", + "-d", + "--no-build", + "--no-recreate", + "--wait", + "api", + "lb", + ) + ready() + private_code = f""" +checks={{}} +try: + urllib.request.urlopen('http://s3:9000/messenger/{key(saved["id"])}',timeout=3) + raise AssertionError('public object') +except urllib.error.HTTPError as e: checks['anonymous_get']=e.code; assert e.code==403 +for name,operation in [('list_other_bucket',lambda:list(s.client.list_objects('other-private'))),('create_bucket',lambda:s.client.make_bucket('forbidden-bucket')),('write_outside_prefix',lambda:s.client.put_object(BUCKET,'forbidden',io.BytesIO(b'x'),1))]: + try: operation(); raise AssertionError(name) + except Exception as e: + assert getattr(e,'code',None)=='AccessDenied',type(e).__name__; checks[name]='AccessDenied' +try: + urllib.request.urlopen('http://s3:9001/',timeout=2); raise AssertionError('console exposed') +except urllib.error.URLError: checks['console_internal_network']='unreachable' +print(json.dumps(checks)) +""" + result["private_bucket_and_iam"] = inside(private_code) + compose("run", "--rm", "--no-deps", "s3-bootstrap") + assert ( + client.get( + f"/api/v1/attachments/{saved['id']}/content", + headers=auth(session), + ).content + == PNG + ) + result["bootstrap_repeat_preserved_original"] = True + # A partial HTTP body must never create a durable intent or object. + before = int(sql("SELECT count(*) FROM attachments")) + objects_before_abort = inside("print(len(list(s.objects())))") + parsed = httpx.URL(BASE) + with socket.create_connection( + (parsed.host, parsed.port), timeout=3 + ) as raw: + request = ( + f"POST /api/v1/chats/{chat['id']}/attachments?filename=partial.png HTTP/1.1\r\n" + f"Host: {parsed.host}\r\nAuthorization: Bearer {session['token']}\r\n" + "Content-Type: image/png\r\nContent-Length: 100000\r\n\r\n" + ).encode() + PNG[:20] + raw.sendall(request) + time.sleep(1) + assert int(sql("SELECT count(*) FROM attachments")) == before + assert ( + inside("print(len(list(s.objects())))") == objects_before_abort + ) + result["aborted_upload_has_no_intent_or_bytes"] = True + # Failure before any S3 PUT. + name = uuid4().hex + ".png" + sql( + "CREATE FUNCTION student_upload_fault() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION 'synthetic'; END $$; CREATE TRIGGER student_upload_fault BEFORE INSERT ON attachments FOR EACH ROW EXECUTE FUNCTION student_upload_fault()" + ) + objects_before = inside("print(len(list(s.objects())))") + try: + assert ( + upload(client, session, chat, name=name).status_code == 500 + ) + assert ( + int( + sql( + "SELECT count(*) FROM attachments WHERE filename='" + + name + + "'" + ) + ) + == 0 + ) + assert ( + inside("print(len(list(s.objects())))") == objects_before + ) + finally: + sql( + "DROP TRIGGER student_upload_fault ON attachments; DROP FUNCTION student_upload_fault()" + ) + result["pg_intent_failure_has_no_bytes"] = True + # S3 PUT succeeded, then ready UPDATE fails: durable pending is recoverable. + name = uuid4().hex + ".png" + sql( + "CREATE FUNCTION student_ready_fault() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF NEW.state='ready' THEN RAISE EXCEPTION 'synthetic'; END IF; RETURN NEW; END $$; CREATE TRIGGER student_ready_fault BEFORE UPDATE ON attachments FOR EACH ROW EXECUTE FUNCTION student_ready_fault()" + ) + try: + assert ( + upload(client, session, chat, name=name).status_code == 500 + ) + finally: + sql( + "DROP TRIGGER student_ready_fault ON attachments; DROP FUNCTION student_ready_fault()" + ) + pending = sql( + "SELECT id FROM attachments WHERE filename='" + name + "'" + ) + assert state(pending) == "pending" + assert inside( + f"print(json.dumps(s.head(key={key(pending)!r}) is not None))" + ) + age(pending) + # Stop S3; bypass LB health exclusion only from inside the selected API. + compose("stop", "s3") + name = uuid4().hex + ".png" + try: + direct = f""" +request=urllib.request.Request('http://127.0.0.1:8080/api/v1/chats/{chat["id"]}/attachments?filename={name}',data=bytes.fromhex({PNG.hex()!r}),headers={{'Authorization':{auth(session)["Authorization"]!r},'Content-Type':'image/png'}}) +try: urllib.request.urlopen(request,timeout=15); raise AssertionError('S3 down accepted') +except urllib.error.HTTPError as e: print(json.dumps({{'status':e.code,'error':json.loads(e.read())['error']['code']}})) +""" + observed = inside(direct) + assert observed == {"status": 503, "error": "unavailable"} + missing_pending = sql( + "SELECT id FROM attachments WHERE filename='" + name + "'" + ) + assert state(missing_pending) == "pending" + result["s3_unavailable"] = observed + finally: + compose( + "up", "-d", "--no-build", "--no-recreate", "--wait", "s3" + ) + ready() + age(missing_pending) + # Used object missing: preserve metadata ID and the Message link. + used = upload(client, session, chat).json() + sent = client.post( + f"/api/v1/chats/{chat['id']}/messages", + headers={**auth(session), "Idempotency-Key": uuid4().hex}, + json={"text": "", "attachment_ids": [used["id"]]}, + ) + assert sent.status_code == 201 + inside(f"s.delete(key={key(used['id'])!r}); print('true')") + age(used["id"]) + age(saved["id"]) + result["concurrent_uploads"] = concurrency(client, session, chat) + while time.monotonic() - orphan_started < 302: + print( + "Waiting for genuine S3 LastModified grace: " + + str(round(302 - (time.monotonic() - orphan_started))) + + "s", + flush=True, + ) + time.sleep(min(20, 302 - (time.monotonic() - orphan_started))) + inside( + f"s.put(key={fresh!r},stream=io.BytesIO(b'fresh'),size=5,content_type='application/octet-stream',sha256=hashlib.sha256(b'fresh').hexdigest()); print('true')" + ) + before_states = [ + state(i) + for i in [pending, missing_pending, used["id"], saved["id"]] + ] + dry = run_reconcile() + assert [ + state(i) + for i in [pending, missing_pending, used["id"], saved["id"]] + ] == before_states + assert inside( + f"print(json.dumps(s.head(key={orphan!r}) is not None))" + ) + for action in [ + "recover_pending", + "fail_pending_missing", + "mark_missing", + "delete_orphan", + ]: + assert dry["actions"].get(action, 0) >= 1, dry + applied = run_reconcile(True) + assert state(pending) == "ready" + assert ( + state(missing_pending) == "failed" + and state(used["id"]) == "failed" + ) + assert state(saved["id"]) == "ready" + assert ( + int( + sql( + "SELECT count(*) FROM message_attachments WHERE attachment_id='" + + used["id"] + + "'" + ) + ) + == 1 + ) + assert ( + client.get( + f"/api/v1/attachments/{used['id']}", headers=auth(session) + ).status_code + == 409 + ) + assert ( + client.get( + f"/api/v1/attachments/{pending}/content", + headers=auth(session), + ).content + == PNG + ) + assert inside( + f"print(json.dumps(s.head(key={orphan!r}) is None and s.head(key={fresh!r}) is not None and s.head(key={key(saved['id'])!r}) is not None))" + ) + repeat = run_reconcile(True) + assert not repeat["applied"].get("delete_orphan") + assert repeat["linked_protected"] >= 1 + result["reconciliation"] = { + "dry_run": dry, + "apply": applied, + "repeat": repeat, + "s3_grace_wait_seconds": round( + time.monotonic() - orphan_started, 3 + ), + "fresh_and_ready_unlinked_protected": True, + "missing_used_id_and_link_preserved": True, + "dry_run_unchanged": True, + } + if args.research: + cells = [] + for count in [0, 100, 1100]: + if count: + start = 0 if count == 100 else 100 + inside( + f"\nfor i in range({start},{count}):\n s.put(key={research_prefix!r}+str(i),stream=io.BytesIO(b'x'),size=1,content_type='application/octet-stream',sha256=hashlib.sha256(b'x').hexdigest())\nprint('true')" + ) + for repetition in range(3): + measured = run_reconcile() + cells.append( + { + "extra_objects": count, + "repetition": repetition + 1, + **measured, + } + ) + result["cost_research"] = { + "cells": cells, + "repeats": 3, + "method": "same running stand; 0/100/1100 fresh one-byte objects; dry-run; serial ascending dataset; no warmup", + "median_seconds": { + str(n): statistics.median( + c["duration_seconds"] + for c in cells + if c["extra_objects"] == n + ) + for n in [0, 100, 1100] + }, + } + result["complete"] = True + finally: + # Only keys created by this invocation; no broad bucket deletion. + try: + inside( + f"\nfor o in s.objects():\n if o.object_name.startswith({research_prefix!r}) or o.object_name in [{orphan!r},{fresh!r}]: s.delete(key=o.object_name)\nprint('true')" + ) + finally: + compose("up", "-d", "--no-build", "--no-recreate", "reconciler") + output.write_text( + json.dumps(result, ensure_ascii=False, indent=2) + "\n" + ) + print( + "PASS: private S3, failover, bounded concurrent uploads and two-store recovery" + ) + + +if __name__ == "__main__": + main() -- 2.54.0 From fba6b6334e32653bf38576ec7e4dbff4e0626034 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=81=D0=BB=D0=BE=D0=B2?= Date: Sun, 15 Nov 2026 20:33:49 +0300 Subject: [PATCH 03/12] docs(storage): document consistency boundaries and reproducible checks --- .dockerignore | 2 + .env.example | 6 +- .github/pull_request_template.md | 25 ++--- .github/workflows/application.yml | 23 ++++ REPORT.md | 176 ++++++++++++++++++++++++++---- SCHEMA.md | 76 +++++++++++++ infra/s3.Dockerfile | 7 +- research/analyze.py | 58 ++++++++++ scripts/verify_storage.py | 36 +++++- 9 files changed, 364 insertions(+), 45 deletions(-) create mode 100644 .github/workflows/application.yml create mode 100644 SCHEMA.md create mode 100644 research/analyze.py diff --git a/.dockerignore b/.dockerignore index 163b0987..8e5d3661 100644 --- a/.dockerignore +++ b/.dockerignore @@ -31,3 +31,5 @@ contracts *.md Makefile compose.yaml + +.work* diff --git a/.env.example b/.env.example index fdf0138f..2ff55ac9 100644 --- a/.env.example +++ b/.env.example @@ -13,9 +13,9 @@ API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 S3_ENDPOINT=http://s3:9000 S3_REGION=us-east-1 -S3_BUCKET=messenger-attachments -S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id -S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key +S3_BUCKET=messenger +S3_ACCESS_KEY_FILE=/run/secrets/s3_access_key +S3_SECRET_KEY_FILE=/run/secrets/s3_secret_key MAX_UPLOAD_BYTES=10485760 MAX_IMAGE_PIXELS=40000000 diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 1bec5472..2f9afa91 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,18 +1,15 @@ ## Лабораторная 4 -Автор / группа: TODO -Целевая оценка (3/4/5): TODO -Трек 5, если заявлен: TODO +Автор / группа: Маслов / БВТ2301 +Целевая оценка: 5 +Трек: 2 — согласованность PostgreSQL/S3 -Что реализовано и что перенесено: TODO -Команды запуска из чистого clone: TODO -Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO -Источники и использование ИИ: TODO +Перенесена собственная база ЛР3: Bearer, ACL, PostgreSQL/Valkey, две API, HAProxy и идемпотентность сообщений. Добавлены private MinIO, синхронный upload201ready, byte/pixel/MIME/filename limits, авторизованный streaming download, atomic Message links, durable pending intent и dry-run/apply reconciler с grace≥300s. -- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. -- [ ] Контракт и публичные тесты не ослаблены. -- [ ] make check и make test выполнены; приложен реальный вывод. -- [ ] Сценарии отказов/безопасности своего уровня воспроизведены. -- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. -- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. +Запуск: `uv sync --locked`, `make bootstrap`, `VCS_REF=$(git rev-parse HEAD) docker compose up -d --build --wait`. Полные команды и архитектура — [REPORT.md](../REPORT.md), [SCHEMA.md](../SCHEMA.md). + +Результаты runtime-проверок собираются; этот промежуточный шаблон должен быть обновлён после выполнения HTTP/storage/cluster/clean-clone сценариев. Контракт/публичные tests сохранены. Статический check/полная OpenAPI validation/lint прошли. + +Ограничения: один host, LB/PG/S3 — SPOF; HEAD не заменяет periodic checksum audit; inventory reconciler O(objects+rows); удалённый CI не подтверждён. + +Источники: актуальное задание/контракты, собственная ЛР3, официальные библиотеки и исходники MinIO/mc. При разработке кода, тестов и отчёта использовалась помощь ИИ; результаты измерений получаются реальными командами. diff --git a/.github/workflows/application.yml b/.github/workflows/application.yml new file mode 100644 index 00000000..7dc59f0e --- /dev/null +++ b/.github/workflows/application.yml @@ -0,0 +1,23 @@ +name: Application integration +on: [push, pull_request, workflow_dispatch] +permissions: + contents: read +jobs: + application: + runs-on: ubuntu-latest + timeout-minutes: 60 + steps: + - uses: actions/checkout@v4 + - uses: astral-sh/setup-uv@v6 + with: + version: 0.13.7 + - run: uv sync --locked + - run: make bootstrap check validate lint PYTHON=.venv/bin/python + - run: VCS_REF=$(git rev-parse HEAD) docker compose up -d --build --wait + - run: make test test-student PYTHON=.venv/bin/python BASE_URL=http://127.0.0.1:8084 + env: + NO_PROXY: localhost,127.0.0.1 + no_proxy: localhost,127.0.0.1 + - run: make verify VERIFY_OUTPUT=evidence/storage-ci.json + - if: always() + run: docker compose down --volumes --remove-orphans diff --git a/REPORT.md b/REPORT.md index 9ad2b84f..7c7dc074 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,167 @@ -# Отчёт — лабораторная 4 +# Лабораторная 4 — Маслов, БВТ2301 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +Цель — **5, трек 2: согласованность PostgreSQL и S3**. Основа — собственная +реализация ЛР3. Сохранены Bearer-сессии в PostgreSQL, Argon2id, ACL, +keyset pagination, общий Idempotency-Key, HAProxy и две независимые API. +Добавлены приватный S3, вложения и повторяемый reconciler. + +Публикация и окончательные результаты будут внесены после проверок. +Сейчас завершены реализация и статические проверки; runtime-доказательства +ещё собираются. Этот промежуточный статус не является заявлением PASS. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Git, Docker с Compose v2 и uv 0.13.7. Python 3.14.7 загружается через uv. +Docker Desktop использует около 6 GiB памяти на Apple M1 (8 CPU, 8 GiB host). +Первичная компиляция MinIO/клиента требует сеть и время; Go parallelism +ограничен двумя потоками, зависимости и компилятор используют BuildKit cache. -## Архитектура и решения +```sh +uv sync --locked +make bootstrap +VCS_REF=$(git rev-parse HEAD) docker compose up -d --build --wait +make check validate lint PYTHON=.venv/bin/python +make test test-student PYTHON=.venv/bin/python BASE_URL=http://127.0.0.1:8084 +uv run python -m scripts.verify_storage --research --output evidence/storage-repeat.json +uv run python -m scripts.verify_cluster --output evidence/cluster-repeat.json +``` -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +`bootstrap` создаёт отсутствующие `.env`/secret files, существующие сохраняет. +Secret directory имеет mode 0700; files читаются непривилегированными UID +контейнеров через read-only mounts. Их значения не должны попадать в Git. +Сначала стартует PostgreSQL, одноразовый migration применяет SQL по порядку +с checksum и advisory lock. Bootstrap S3 создаёт private bucket/app-user/policy +и переносит повторный запуск. После этого две API, reconciler и LB. -## Доказательства критериев +URL стенда: `http://127.0.0.1:8084`. API/S3/PG/cache не имеют host ports. +Безопасная остановка: `docker compose down` (volumes остаются). +Намеренное удаление **данных только текущего учебного проекта**: +`docker compose down --volumes`; это не обычный restart. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +```sh +# Dry-run: без изменений +docker compose run --rm --no-deps reconciler python -m src.reconcile +# Оператор явно разрешает изменения +docker compose run --rm --no-deps reconciler python -m src.reconcile --apply +# Реальные рестарты всех state services, с прежними volumes +make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8084 +make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://127.0.0.1:8084 +``` -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Не запускать fault scripts параллельно друг с другом или HTTP pytest: +они намеренно останавливают реальные сервисы и временно устанавливают +PostgreSQL triggers. Все их пользователи/картинки синтетические. +Evidence filename должен быть новым, предыдущие результаты сохраняются. -## Эксперименты и отказы +## Версии и ограничения ресурсов -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Полные image digests закреплены в Dockerfile/compose.yaml/infra/s3.Dockerfile: +Python 3.14.7 slim-trixie, uv 0.13.7, PostgreSQL 18.3, Valkey 8.1.3, +HAProxy 3.2.1 alpine. MinIO собирается из commit +`9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a`, release +`2025-10-15T17-29-55Z`; mc — из +`7394ce0dd2a80935aded936b09fa12cbb3cb8096` (2025-08-13). +Go 1.24.8 bookworm закреплён digest, исходные LICENSE включены в образы. +Python dependency lock включает minio 7.2.20 и Pillow 13.0.0. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Процесс | CPU | RAM | +| --- | --- | --- | +| Каждая из двух API | 0.5 | 768 MiB | +| PostgreSQL | 1 | 512 MiB | +| MinIO | 1 | 1024 MiB | +| Valkey | 0.25 | 128 MiB | +| HAProxy | 0.5 | 128 MiB | +| Reconciler | 0.25 | 256 MiB | -## Ограничения и следующие шаги +API: read-only root, UID 10001, no capabilities, no-new-privileges, +128 PIDs, bounded `/tmp` tmpfs 128 MiB. At most two uploads/process, +одна декодируемая картинка/process. Spooled file после 1 MiB переносится в +tmpfs; максимум bytes 10 MiB, pixels 40 млн до decode. Проверяются формат +содержимого, фактический decode, filename; SHA-256 считается на входе. +S3 timeout connect 1/read 3 s, без transparent retry; DB transaction budget +4 s, statement 2.5 s; async ingress deadline 20 s. Отмена Python thread не +прерывает нативный decode, поэтому существенны также pixel/RAM limits. +Download передаёт chunks 64 KiB с закрытием S3 connection. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +`.env.example`: PUBLIC_PORT/API_REPLICAS/API_CPUS/API_MEMORY/DB_POOL_SIZE/ +SESSION_TTL_SECONDS/RECONCILE_GRACE_SECONDS используются Compose. Secret file +names указаны в compose.yaml. APP_HOST/APP_PORT задаются для API в Compose; +endpoint `s3:9000`, region us-east-1, bucket messenger, byte/pixel limits и +24 h idempotency заданы сервером. Это фиксированные параметры реализации, +логические подсказки skeleton не делают их автоматически настраиваемыми. +Сессии — PostgreSQL; Valkey хранит только disposable user cache. + +## Архитектура и критерии + +Подробные переходы и схема: [SCHEMA.md](SCHEMA.md). +`src/attachments.py` коммитит pending intent **до PUT**, затем ready; +201 означает подтверждённые bytes и metadata. Общей PG/S3 транзакции нет. +Readiness проверяет PG и S3. При потере S3 HAProxy может исключить все API и +вернуть собственный 503; прямой внутренний API возвращает JSON unavailable. + +Таблица наблюдений и ссылки на evidence будут заполнены после выполнения +storage, cluster, HTTP и clean-clone проверок. + +## Методика исследования + +Гипотеза: сохранённое до PUT намерение и grace позволяют повторной сверкой +исправлять окна отказов PG/S3 без удаления свежих/используемых bytes. +Полный обход имеет линейную стоимость по числу объектов и metadata. + +`scripts/verify_storage.py --research`: реальные отказы INSERT/ready UPDATE +через временные PG triggers, недоступность S3, abort HTTP, отсутствие +используемого оригинала, old orphan и fresh orphan. Объект orphan реально +стареет ≥300 s по S3 LastModified. Dry-run, apply, повторный apply. +Cost: 0/100/1100 дополнительных свежих объектов по 1 byte, по три dry-run +на одном стенде, без warmup, последовательно по возрастанию; учитываются +objects/rows scanned, HEAD/bytes read/duration. Это стоимость обхода, +не измерение максимальной пропускной способности S3. Dataset создаётся под +уникальным test prefix и удаляется только в своей области. + +10 потоков одновременно загружают одинаковое синтетическое PNG 1700×1700, +каждый сравнивает оригинал. Измеряются upload p50/p95/p99, ошибки/RPS, +cgroup memory.current samples и lifetime memory.peak обеих API, cpu.stat +до/после. Duration/RPS включают downloads и sampler; latency — upload only. +memory.peak может включать прежние запросы, поэтому отдельно показан +максимум memory.current в окне. Небольшая серия не является production SLA. + +## Вопросы защиты + +**Почему volume API не равно S3?** Volume принадлежит контейнеру/host и сам +по себе не задаёт объектный HTTP API, bucket policy, общую адресацию и +независимый lifecycle. В этой реализации у API вообще нет persistent volume; +другая реплика читает общий S3 по metadata PostgreSQL. + +**Когда можно вернуть 201?** После фактической проверки изображения, +успешного PUT и COMMIT ready. Если COMMIT не подтверждён, нельзя обещать +201. Клиент может потерять ответ после успешной записи; upload не имеет +Idempotency-Key, поэтому слепой повтор может создать другое вложение. + +**PUT прошёл, COMMIT не прошёл?** Уже есть durable pending intent. После +grace reconciler проверяет размер/checksum и переводит в ready. При +отсутствующих/других bytes ставит internal failed. Очищать файл вслепую +при неизвестном результате COMMIT опасно. Восстановление уже пропавших +bytes только из checksum невозможно. + +**Почему случайный key/private bucket не заменяют ACL?** Пользователи +могут узнать ID из сообщения; key не доказывает membership. Каждый GET +сначала проверяет Bearer и JOIN members, чужой/отсутствующий объект — 404. +Private bucket защищает обход API; application IAM ограничивает последствия +ошибок backend, но не принимает пользовательские решения о доступе. + +## Источники, помощь и границы + +Использованы задание и неизменённые контракты текущего репозитория, +собственный код ЛР3, FastAPI/Pydantic, psycopg, minio SDK, Pillow, +[исходники MinIO](https://github.com/minio/minio), +[исходники mc](https://github.com/minio/mc), +[S3 uploads](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html). +При проектировании, написании кода, тестов и отчёта использована помощь ИИ; +фактические результаты должны подтверждаться сохранёнными командами. +Код и данные других студентов не использовались. + +Один host/LB/PG/S3 — SPOF; нет защиты от потери единственного диска, +backup/restore S3, TLS и monitoring. Ready HEAD не проверяет весь checksum +на каждом проходе. Reconciler хранит полный inventory в RAM, metadata failed +сохраняет для диагностики. Повреждение S3 нельзя исправить без резервной копии. +CI workflow приложен; удалённый запуск не подтверждён. diff --git a/SCHEMA.md b/SCHEMA.md new file mode 100644 index 00000000..bc1f3277 --- /dev/null +++ b/SCHEMA.md @@ -0,0 +1,76 @@ +# Бинарные данные и два независимых хранилища + +```mermaid +flowchart LR + C[Клиент] --> L[HAProxy :8084] + L --> A[API × 2] + A --> P[(PostgreSQL)] + A --> S[(Приватный MinIO)] + A --> V[(Valkey: кэш пользователей)] + R[Reconciler: 60 секунд] --> P + R --> S +``` + +`users/chats/members/messages/sessions/idempotency` перенесены из собственной +ЛР3. Новые таблицы: `attachments` и `message_attachments`. Состав участников +чата неизменяемый. PostgreSQL хранит metadata и ACL, S3 — оригинальные bytes. +Временный файл в API ограничен размером, удаляется при закрытии запроса и +не является источником истины. API-процессы не обмениваются локальными файлами. + +```mermaid +sequenceDiagram + participant C as Клиент + participant A as API + participant P as PostgreSQL + participant S as S3 + C->>A: Bearer, filename, PNG/JPEG bytes + A->>A: ACL, лимиты bytes/pixels, decode, SHA-256 + A->>P: COMMIT pending intent, UUID/key, срок 120 с + A->>S: PUT оригинала + A->>P: COMMIT ready при действующем намерении + A-->>C: 201 ready +``` + +Общей транзакции PostgreSQL+S3 нет. Если INSERT намерения не прошёл, PUT не +выполняется. Если PUT не прошёл, остаётся pending без объекта. Если PUT +прошёл, а ready UPDATE/COMMIT нет, остаётся pending с bytes. Неопределённый +результат COMMIT нельзя исправлять безусловным DELETE файла: COMMIT мог +успешно завершиться, хотя клиент потерял ответ. + +Reconciler по умолчанию выполняет **dry-run**. `--apply` разрешает изменения. +Автоматический процесс запускает apply каждые 60 секунд. Grace не менее +300 секунд; возраст берётся из PostgreSQL clock и S3 LastModified. + +| Состояние | Действие после grace | +| --- | --- | +| Объект без metadata | Повторная проверка metadata и HEAD; удалить старый orphan | +| pending + корректные размер/SHA-256 bytes | ready | +| pending без bytes / с другим размером/checksum | failed с безопасной причиной | +| ready с bytes, включая файл без Message | Сохранить | +| ready без bytes | failed, сохранить ID, metadata и Message links | +| failed, связанный с Message | Сохранить | +| failed без Message со старым объектом | Повторно проверить свежесть HEAD; удалить bytes | +| Свежий объект | Сохранить | +| AccessDenied / 5xx / network error | Завершить проход с ошибкой; не считать объект отсутствующим | + +Во внешнем контракте ЛР4 Attachment имеет только статус `ready`. Внутренние +pending/failed возвращают `409 conflict`, после проверки ACL. ЛР5 меняет +этот контракт на четыре публичных состояния и требует другого обработчика. + +Связь Message↔Attachment вставляется в одной PostgreSQL-транзакции с Message +и Idempotency-Key. Композитные FK проверяют одинаковый chat_id; FOR SHARE +на вложении защищает проверку ready от конкурентного изменения состояния. +Несколько сообщений могут использовать одно вложение своего чата. + +S3 app-user разрешены ListBucket/GetBucketLocation и object CRUD только +`messenger/objects/*`. Root credentials доступны лишь серверу и bootstrap. +Bucket private, S3-порт не опубликован на host, console слушает container +loopback. Авторизованный download проксируется через API; случайный key +не заменяет проверку membership. + +Ограничения: полный LIST и выборка metadata имеют стоимость O(objects+rows) +и линейную память reconciler. Ready-проверка использует HEAD, не полный +периодический аудит битовой целостности. Metadata failed сохраняются для +диагностики. Reconciler обнаруживает пропажу bytes, но не восстанавливает +данные из checksum. Единственный Docker-host, LB, PostgreSQL и MinIO — +общие точки отказа; репликация API этого не устраняет. diff --git a/infra/s3.Dockerfile b/infra/s3.Dockerfile index d0f0b99c..783ba43e 100644 --- a/infra/s3.Dockerfile +++ b/infra/s3.Dockerfile @@ -3,8 +3,11 @@ ENV CGO_ENABLED=0 GOMAXPROCS=2 GOFLAGS=-p=2 GOTOOLCHAIN=local FROM toolchain AS minio-build WORKDIR /source -RUN git init . && git remote add origin https://github.com/minio/minio.git && \ - git fetch --depth 1 origin 9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a && git checkout --detach FETCH_HEAD +RUN curl --http1.1 -fsSL --connect-timeout 10 --max-time 1800 --retry 2 \ + --speed-time 60 --speed-limit 1024 \ + https://codeload.github.com/minio/minio/tar.gz/9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a \ + -o /tmp/source.tgz && \ + tar xzf /tmp/source.tgz --strip-components=1 && rm /tmp/source.tgz RUN --mount=type=cache,target=/go/pkg/mod,sharing=locked \ --mount=type=cache,target=/root/.cache/go-build,sharing=locked \ go build -trimpath -ldflags='-s -w -X github.com/minio/minio/cmd.Version=2025-10-15T17:29:55Z -X github.com/minio/minio/cmd.ReleaseTag=RELEASE.2025-10-15T17-29-55Z -X github.com/minio/minio/cmd.CommitID=9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a' -o /out/minio . diff --git a/research/analyze.py b/research/analyze.py new file mode 100644 index 00000000..384d9eab --- /dev/null +++ b/research/analyze.py @@ -0,0 +1,58 @@ +"""Plot only measured storage evidence; no reconstructed timing samples.""" + +import argparse +import json +from pathlib import Path + +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("input") + parser.add_argument("--output", default="evidence/storage-research.png") + args = parser.parse_args() + data = json.loads(Path(args.input).read_text()) + assert data["complete"] + series = data["cost_research"] + fig, axes = plt.subplots(1, 2, figsize=(11, 4), layout="constrained") + for cell in series["cells"]: + axes[0].scatter( + cell["objects_scanned"], + cell["duration_seconds"], + color="#176b87", + alpha=0.65, + ) + axes[0].set( + xlabel="Objects scanned (including real attachments)", + ylabel="Dry-run duration, seconds", + title="Inventory cost: 3 repeats per dataset", + ) + measured = data["concurrent_uploads"] + ids = sorted({s["container"] for s in measured["memory_samples"]}) + for i, cid in enumerate(ids): + points = [ + s for s in measured["memory_samples"] if s["container"] == cid + ] + axes[1].plot( + [s["at"] for s in points], + [s["memory.current"] / 2**20 for s in points], + label=f"API {i + 1} cgroup current", + ) + axes[1].set( + xlabel="Time, seconds", + ylabel="Memory, MiB", + title="10 simultaneous uploads, verified downloads", + ) + axes[1].legend(fontsize=8) + for ax in axes: + ax.grid(alpha=0.2) + fig.savefig(args.output, dpi=160) + print("Saved measured inventory and memory figure") + + +if __name__ == "__main__": + main() diff --git a/scripts/verify_storage.py b/scripts/verify_storage.py index 1626728d..7ed61de4 100644 --- a/scripts/verify_storage.py +++ b/scripts/verify_storage.py @@ -182,6 +182,9 @@ def main(): "complete": False, } ready() + from scripts.verify_cluster import snapshot + + result["runtime"] = snapshot() compose("stop", "reconciler") orphan = "objects/verification-" + uuid4().hex + "/orphan" fresh = "objects/verification-" + uuid4().hex + "/fresh" @@ -209,6 +212,14 @@ def main(): r = upload(client, session, chat) assert r.status_code == 201 saved, uploader = r.json(), r.headers["x-instance-id"] + failed_old = upload(client, session, chat).json() + sql( + "UPDATE attachments SET state='failed',error_code='synthetic' WHERE id='" + + failed_old["id"] + + "'" + ) + age(failed_old["id"]) + grace_started = time.monotonic() target = next( c for c in cluster.containers() @@ -241,7 +252,12 @@ def main(): ) ready() private_code = f""" +from src.errors import DomainError checks={{}} +try: + s.head(key='forbidden'); raise AssertionError('HEAD outside IAM prefix') +except DomainError as e: + assert e.status==503; checks['denied_head_is_not_missing']=e.status try: urllib.request.urlopen('http://s3:9000/messenger/{key(saved["id"])}',timeout=3) raise AssertionError('public object') @@ -367,17 +383,26 @@ except urllib.error.HTTPError as e: print(json.dumps({{'status':e.code,'error':j age(used["id"]) age(saved["id"]) result["concurrent_uploads"] = concurrency(client, session, chat) - while time.monotonic() - orphan_started < 302: + while time.monotonic() - grace_started < 302: print( "Waiting for genuine S3 LastModified grace: " - + str(round(302 - (time.monotonic() - orphan_started))) + + str(round(302 - (time.monotonic() - grace_started))) + "s", flush=True, ) - time.sleep(min(20, 302 - (time.monotonic() - orphan_started))) + time.sleep( + min(20, max(0, 302 - (time.monotonic() - grace_started))) + ) inside( f"s.put(key={fresh!r},stream=io.BytesIO(b'fresh'),size=5,content_type='application/octet-stream',sha256=hashlib.sha256(b'fresh').hexdigest()); print('true')" ) + failed_fresh = upload(client, session, chat).json() + sql( + "UPDATE attachments SET state='failed',error_code='synthetic' WHERE id='" + + failed_fresh["id"] + + "'" + ) + age(failed_fresh["id"]) before_states = [ state(i) for i in [pending, missing_pending, used["id"], saved["id"]] @@ -395,6 +420,7 @@ except urllib.error.HTTPError as e: print(json.dumps({{'status':e.code,'error':j "fail_pending_missing", "mark_missing", "delete_orphan", + "delete_failed_object", ]: assert dry["actions"].get(action, 0) >= 1, dry applied = run_reconcile(True) @@ -430,6 +456,9 @@ except urllib.error.HTTPError as e: print(json.dumps({{'status':e.code,'error':j assert inside( f"print(json.dumps(s.head(key={orphan!r}) is None and s.head(key={fresh!r}) is not None and s.head(key={key(saved['id'])!r}) is not None))" ) + assert inside( + f"print(json.dumps(s.head(key={key(failed_old['id'])!r}) is None and s.head(key={key(failed_fresh['id'])!r}) is not None))" + ) repeat = run_reconcile(True) assert not repeat["applied"].get("delete_orphan") assert repeat["linked_protected"] >= 1 @@ -441,6 +470,7 @@ except urllib.error.HTTPError as e: print(json.dumps({{'status':e.code,'error':j time.monotonic() - orphan_started, 3 ), "fresh_and_ready_unlinked_protected": True, + "old_failed_unlinked_deleted_and_fresh_failed_protected": True, "missing_used_id_and_link_preserved": True, "dry_run_unchanged": True, } -- 2.54.0 From 3d5a5ca84afff44f7b36250013c54a087dd3a0b9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=81=D0=BB=D0=BE=D0=B2?= Date: Sun, 15 Nov 2026 20:42:45 +0300 Subject: [PATCH 04/12] build(storage): verify pinned source with Go checksum database --- REPORT.md | 6 +- evidence/migrations-first.json | 23 +++++++ infra/fetch-source.go | 107 +++++++++++++++++++++++++++++++++ infra/s3.Dockerfile | 13 ++-- 4 files changed, 143 insertions(+), 6 deletions(-) create mode 100644 evidence/migrations-first.json create mode 100644 infra/fetch-source.go diff --git a/REPORT.md b/REPORT.md index 7c7dc074..bd5137d2 100644 --- a/REPORT.md +++ b/REPORT.md @@ -13,7 +13,11 @@ keyset pagination, общий Idempotency-Key, HAProxy и две независ Нужны Git, Docker с Compose v2 и uv 0.13.7. Python 3.14.7 загружается через uv. Docker Desktop использует около 6 GiB памяти на Apple M1 (8 CPU, 8 GiB host). -Первичная компиляция MinIO/клиента требует сеть и время; Go parallelism +Первичная компиляция MinIO/клиента требует сеть и время. Исходный ZIP +MinIO с точным module version скачивается восемью потоками HTTP Range, +с ограниченным timeout/числом повторов; затем стандартный `go mod download` +проверяет h1 через Go checksum database перед сборкой. Проверки TLS и +checksum не отключены. Go parallelism ограничен двумя потоками, зависимости и компилятор используют BuildKit cache. ```sh diff --git a/evidence/migrations-first.json b/evidence/migrations-first.json new file mode 100644 index 00000000..fdfa6e82 --- /dev/null +++ b/evidence/migrations-first.json @@ -0,0 +1,23 @@ +{ + "date": "2026-11-15T17:40:32.062021+00:00", + "source_commit": "fba6b6334e32653bf38576ec7e4dbff4e0626034", + "runtime_image_revision": "f449033e15f989aeaf35c776245cb4286e1f0ed5", + "command": "docker compose run --rm --no-deps migrate; repeat", + "migrations": [ + { + "name": "001_core.sql", + "checksum": "4f91a73b92b768c48703b1adc1752b8c65f5e9da3da7c1f8b2db6d3dcb3c9efe" + }, + { + "name": "002_idempotency.sql", + "checksum": "b24f77687546b4f8d68cabb7009fc2b3db3d138c3c7a1eab32357e41cc0d6b13" + }, + { + "name": "003_attachments.sql", + "checksum": "6558f17559d4f96878400915d80a09a1fe5e9bcf7eeb6b0b04794d63ba03f3bd" + } + ], + "fresh_postgres_volume": true, + "repeat_idempotent": true, + "result": "PASS" +} diff --git a/infra/fetch-source.go b/infra/fetch-source.go new file mode 100644 index 00000000..48506cac --- /dev/null +++ b/infra/fetch-source.go @@ -0,0 +1,107 @@ +// Fetch the immutable module ZIP in bounded HTTP ranges. The subsequent +// go mod download validates its h1 checksum through the Go checksum database. +package main + +import ( + "fmt" + "io" + "net/http" + "os" + "path/filepath" + "sync" + "time" +) + +func main() { + const version = "v0.0.0-20251015172955-9e49d5e7a648" + const total int64 = 25342606 + const chunk int64 = 512 * 1024 + const source = "https://proxy.golang.org/github.com/minio/minio/@v/" + version + ".zip" + directory := "/go/pkg/mod/cache/download/github.com/minio/minio/@v" + if err := os.MkdirAll(directory, 0755); err != nil { + panic(err) + } + target := filepath.Join(directory, version+".zip") + if info, err := os.Stat(target); err == nil && info.Size() == total { + fmt.Println("Source ZIP cached; Go will validate checksum") + return + } + client := &http.Client{Timeout: 90 * time.Second} + jobs := make(chan int64) + errors := make(chan error, 64) + var group sync.WaitGroup + for worker := 0; worker < 8; worker++ { + group.Add(1) + go func() { + defer group.Done() + for start := range jobs { + end := min(start+chunk, total) - 1 + part := fmt.Sprintf("%s.part-%d", target, start) + if info, err := os.Stat(part); err == nil && info.Size() == end-start+1 { + continue + } + var last error + for attempt := 0; attempt < 4; attempt++ { + req, _ := http.NewRequest("GET", source, nil) + req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", start, end)) + response, err := client.Do(req) + if err != nil { + last = fmt.Errorf("source range request failed") + continue + } + expected := fmt.Sprintf("bytes %d-%d/%d", start, end, total) + if response.StatusCode != 206 || response.Header.Get("Content-Range") != expected { + response.Body.Close() + last = fmt.Errorf("unexpected source range response: HTTP %d", response.StatusCode) + continue + } + data, err := io.ReadAll(io.LimitReader(response.Body, end-start+2)) + response.Body.Close() + if err != nil || int64(len(data)) != end-start+1 { + last = fmt.Errorf("incomplete source range") + continue + } + if err := os.WriteFile(part, data, 0644); err != nil { + last = err + continue + } + last = nil + fmt.Printf("Source part %d verified\n", start/chunk+1) + break + } + if last != nil { + errors <- last + } + } + }() + } + for start := int64(0); start < total; start += chunk { + jobs <- start + } + close(jobs) + group.Wait() + close(errors) + for err := range errors { + panic(err) + } + out, err := os.Create(target + ".partial") + if err != nil { + panic(err) + } + for start := int64(0); start < total; start += chunk { + part, err := os.Open(fmt.Sprintf("%s.part-%d", target, start)) + if err != nil { + panic(err) + } + if _, err := io.Copy(out, part); err != nil { + panic(err) + } + part.Close() + } + if err := out.Close(); err != nil { + panic(err) + } + if err := os.Rename(target+".partial", target); err != nil { + panic(err) + } +} diff --git a/infra/s3.Dockerfile b/infra/s3.Dockerfile index 783ba43e..d62fa197 100644 --- a/infra/s3.Dockerfile +++ b/infra/s3.Dockerfile @@ -3,11 +3,12 @@ ENV CGO_ENABLED=0 GOMAXPROCS=2 GOFLAGS=-p=2 GOTOOLCHAIN=local FROM toolchain AS minio-build WORKDIR /source -RUN curl --http1.1 -fsSL --connect-timeout 10 --max-time 1800 --retry 2 \ - --speed-time 60 --speed-limit 1024 \ - https://codeload.github.com/minio/minio/tar.gz/9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a \ - -o /tmp/source.tgz && \ - tar xzf /tmp/source.tgz --strip-components=1 && rm /tmp/source.tgz +COPY infra/fetch-source.go /tmp/fetch-source.go +RUN --mount=type=cache,target=/go/pkg/mod,sharing=locked \ + --mount=type=cache,target=/root/.cache/go-build,sharing=locked \ + go run /tmp/fetch-source.go && \ + go mod download -json github.com/minio/minio@v0.0.0-20251015172955-9e49d5e7a648 && \ + cp -a /go/pkg/mod/github.com/minio/minio@v0.0.0-20251015172955-9e49d5e7a648/. /source/ RUN --mount=type=cache,target=/go/pkg/mod,sharing=locked \ --mount=type=cache,target=/root/.cache/go-build,sharing=locked \ go build -trimpath -ldflags='-s -w -X github.com/minio/minio/cmd.Version=2025-10-15T17:29:55Z -X github.com/minio/minio/cmd.ReleaseTag=RELEASE.2025-10-15T17-29-55Z -X github.com/minio/minio/cmd.CommitID=9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a' -o /out/minio . @@ -21,6 +22,7 @@ RUN --mount=type=cache,target=/go/pkg/mod,sharing=locked \ go build -trimpath -ldflags='-s -w' -o /out/mc . FROM python:3.14.7-slim-trixie@sha256:51dafde81dbdb6ebde285137a295cf18a47ca95234fe388a343719cb97305b3d AS server +LABEL org.opencontainers.image.revision=9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a org.opencontainers.image.version=RELEASE.2025-10-15T17-29-55Z COPY --from=minio-build /out/minio /usr/local/bin/minio COPY --from=minio-build /source/LICENSE /licenses/minio.LICENSE COPY --chmod=755 infra/s3-entrypoint.sh /usr/local/bin/s3-entrypoint @@ -31,6 +33,7 @@ EXPOSE 9000 HEALTHCHECK --interval=2s --timeout=2s --start-period=10s --retries=30 CMD ["python","-c","import urllib.request; urllib.request.urlopen('http://127.0.0.1:9000/minio/health/ready',timeout=1).read()"] FROM python:3.14.7-slim-trixie@sha256:51dafde81dbdb6ebde285137a295cf18a47ca95234fe388a343719cb97305b3d AS bootstrap +LABEL org.opencontainers.image.revision=7394ce0dd2a80935aded936b09fa12cbb3cb8096 org.opencontainers.image.version=RELEASE.2025-08-13T08-35-41Z COPY --from=mc-build /out/mc /usr/local/bin/mc COPY --from=mc-build /source/LICENSE /licenses/mc.LICENSE COPY --chmod=755 infra/s3-bootstrap.sh /usr/local/bin/s3-bootstrap -- 2.54.0 From f5a7a74f679d936d851fa0e58f6cfb59dcd62c50 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=81=D0=BB=D0=BE=D0=B2?= Date: Sun, 15 Nov 2026 20:52:35 +0300 Subject: [PATCH 05/12] test(storage): cover chunked limits and preserve fault cleanup --- evidence/minio-source-verification.json | 12 ++++++++++++ infra/s3.Dockerfile | 10 ++++++++-- scripts/verify_storage.py | 14 +++++++++----- student-tests/test_attachments.py | 13 +++++++++++++ 4 files changed, 42 insertions(+), 7 deletions(-) create mode 100644 evidence/minio-source-verification.json diff --git a/evidence/minio-source-verification.json b/evidence/minio-source-verification.json new file mode 100644 index 00000000..f3d8eb3e --- /dev/null +++ b/evidence/minio-source-verification.json @@ -0,0 +1,12 @@ +{ + "source_origin": { + "VCS": "git", + "URL": "https://github.com/minio/minio", + "Hash": "9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a" + }, + "version": "v0.0.0-20251015172955-9e49d5e7a648", + "module_checksum": "h1:6TdolSCLSs2nwm8i0PpWDqf9iX2Ty9WQK8wmr7dCnUM=", + "go_mod_checksum": "h1:yCWDkwWO9IWpGsT4mreDDN/B/QVmK2zC666uInRAcqE=", + "validation": "standard go mod download with default Go checksum database after ranged HTTPS download", + "compiler_build_status": "in progress; source validation only" +} diff --git a/infra/s3.Dockerfile b/infra/s3.Dockerfile index d62fa197..d971a03e 100644 --- a/infra/s3.Dockerfile +++ b/infra/s3.Dockerfile @@ -7,11 +7,17 @@ COPY infra/fetch-source.go /tmp/fetch-source.go RUN --mount=type=cache,target=/go/pkg/mod,sharing=locked \ --mount=type=cache,target=/root/.cache/go-build,sharing=locked \ go run /tmp/fetch-source.go && \ - go mod download -json github.com/minio/minio@v0.0.0-20251015172955-9e49d5e7a648 && \ + for attempt in 1 2 3 4; do \ + go mod download -json github.com/minio/minio@v0.0.0-20251015172955-9e49d5e7a648 && break; \ + test "$attempt" -lt 4 || exit 1; sleep 1; \ + done && \ cp -a /go/pkg/mod/github.com/minio/minio@v0.0.0-20251015172955-9e49d5e7a648/. /source/ RUN --mount=type=cache,target=/go/pkg/mod,sharing=locked \ --mount=type=cache,target=/root/.cache/go-build,sharing=locked \ - go build -trimpath -ldflags='-s -w -X github.com/minio/minio/cmd.Version=2025-10-15T17:29:55Z -X github.com/minio/minio/cmd.ReleaseTag=RELEASE.2025-10-15T17-29-55Z -X github.com/minio/minio/cmd.CommitID=9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a' -o /out/minio . + for attempt in 1 2 3; do \ + timeout 900s go build -trimpath -ldflags='-s -w -X github.com/minio/minio/cmd.Version=2025-10-15T17:29:55Z -X github.com/minio/minio/cmd.ReleaseTag=RELEASE.2025-10-15T17-29-55Z -X github.com/minio/minio/cmd.CommitID=9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a' -o /out/minio . && break; \ + test "$attempt" -lt 3 || exit 1; sleep 1; \ + done FROM toolchain AS mc-build WORKDIR /source diff --git a/scripts/verify_storage.py b/scripts/verify_storage.py index 7ed61de4..81c2e92d 100644 --- a/scripts/verify_storage.py +++ b/scripts/verify_storage.py @@ -289,10 +289,14 @@ print(json.dumps(checks)) (parsed.host, parsed.port), timeout=3 ) as raw: request = ( - f"POST /api/v1/chats/{chat['id']}/attachments?filename=partial.png HTTP/1.1\r\n" - f"Host: {parsed.host}\r\nAuthorization: Bearer {session['token']}\r\n" - "Content-Type: image/png\r\nContent-Length: 100000\r\n\r\n" - ).encode() + PNG[:20] + ( + f"POST /api/v1/chats/{chat['id']}/attachments?filename=partial.png HTTP/1.1\r\n" + f"Host: {parsed.host}\r\nAuthorization: Bearer {session['token']}\r\n" + "Content-Type: image/png\r\nContent-Length: 10000000\r\n\r\n" + ).encode() + + PNG + + b"x" * (2 * 1024 * 1024) + ) raw.sendall(request) time.sleep(1) assert int(sql("SELECT count(*) FROM attachments")) == before @@ -302,10 +306,10 @@ print(json.dumps(checks)) result["aborted_upload_has_no_intent_or_bytes"] = True # Failure before any S3 PUT. name = uuid4().hex + ".png" + objects_before = inside("print(len(list(s.objects())))") sql( "CREATE FUNCTION student_upload_fault() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION 'synthetic'; END $$; CREATE TRIGGER student_upload_fault BEFORE INSERT ON attachments FOR EACH ROW EXECUTE FUNCTION student_upload_fault()" ) - objects_before = inside("print(len(list(s.objects())))") try: assert ( upload(client, session, chat, name=name).status_code == 500 diff --git a/student-tests/test_attachments.py b/student-tests/test_attachments.py index 2f96574d..eaad5bcf 100644 --- a/student-tests/test_attachments.py +++ b/student-tests/test_attachments.py @@ -179,3 +179,16 @@ def test_pixel_limit_before_decode(client, actors, chat): assert len(stream.getvalue()) < 10 * 1024 * 1024 r = upload(client, actors[0], chat, data=stream.getvalue()) assert r.status_code == 413 + + +def test_chunked_body_limit_without_content_length(client, actors, chat): + r = client.post( + f"/api/v1/chats/{chat['id']}/attachments", + headers={**headers(actors[0]), "Content-Type": "image/png"}, + params={"filename": "chunked.png"}, + content=iter([b"x" * (10 * 1024 * 1024 + 1)]), + ) + assert r.request.headers.get("content-length") is None + assert r.status_code == 413 + assert r.json()["error"]["code"] == "payload_too_large" + assert r.json()["error"]["request_id"] == r.headers["x-request-id"] -- 2.54.0 From 3fd912fccb761d7010783363fa49337542ffa4e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=81=D0=BB=D0=BE=D0=B2?= Date: Sun, 15 Nov 2026 21:28:49 +0300 Subject: [PATCH 06/12] test(storage): record verified faults and isolate inventory cost --- REPORT.md | 19 +- evidence/cluster-first.json | 4458 +++++++++++++++++++++++ evidence/http-first.json | 17 + evidence/minio-source-verification.json | 82 +- evidence/storage-first.json | 502 +++ evidence/storage-research.png | Bin 0 -> 85372 bytes research/cost.py | 159 + scripts/verify_storage.py | 9 +- 8 files changed, 5239 insertions(+), 7 deletions(-) create mode 100644 evidence/cluster-first.json create mode 100644 evidence/http-first.json create mode 100644 evidence/storage-first.json create mode 100644 evidence/storage-research.png create mode 100644 research/cost.py diff --git a/REPORT.md b/REPORT.md index bd5137d2..387d2780 100644 --- a/REPORT.md +++ b/REPORT.md @@ -6,8 +6,9 @@ keyset pagination, общий Idempotency-Key, HAProxy и две независ Добавлены приватный S3, вложения и повторяемый reconciler. Публикация и окончательные результаты будут внесены после проверок. -Сейчас завершены реализация и статические проверки; runtime-доказательства -ещё собираются. Этот промежуточный статус не является заявлением PASS. +Публичный smoke и 108 собственных HTTP-проверок прошли на полном стенде +(362.40 s). Проверки отказов/исследование и clean clone ещё выполняются; +окончательная готовность будет указана после их завершения. ## Запуск из чистого clone @@ -18,7 +19,8 @@ MinIO с точным module version скачивается восемью по с ограниченным timeout/числом повторов; затем стандартный `go mod download` проверяет h1 через Go checksum database перед сборкой. Проверки TLS и checksum не отключены. Go parallelism -ограничен двумя потоками, зависимости и компилятор используют BuildKit cache. +задан `GOMAXPROCS=2` и `GOFLAGS=-p=2`; зависимости и компилятор +используют BuildKit cache. ```sh uv sync --locked @@ -103,8 +105,15 @@ endpoint `s3:9000`, region us-east-1, bucket messenger, byte/pixel limits и Readiness проверяет PG и S3. При потере S3 HAProxy может исключить все API и вернуть собственный 503; прямой внутренний API возвращает JSON unavailable. -Таблица наблюдений и ссылки на evidence будут заполнены после выполнения -storage, cluster, HTTP и clean-clone проверок. +| Проверка | Команда | Наблюдение | Доказательство | +| --- | --- | --- | --- | +| SQL migrations | `docker compose run --rm --no-deps migrate`, повтор | 3 migrations, checksum match, repeat idempotent | [migrations-first.json](evidence/migrations-first.json) | +| Публичный API | `make test` | PASS: upload201, Message, original SHA-256 и ACL | [http-first.json](evidence/http-first.json) | +| Прежние возможности и негативные файлы | `uv run pytest student-tests -q` | 108 passed, 362.40 s; в том числе chunked >10 MiB, corrupt/MIME/pixels/filename/foreign chat | [http-first.json](evidence/http-first.json) | +| Закреплённый S3 | `go mod download`, `minio --version`, inspect | module h1 verified; binary 2025-10-15/go1.24.8/arm64; 2 API, реальные CPU/RAM/ports | [minio-source-verification.json](evidence/minio-source-verification.json) | + +Строки storage/cluster/research/clean clone будут добавлены после выполнения +этих проверок. Source HTTP = `f5a7a74`, OCI revision API совпадает с ним. ## Методика исследования diff --git a/evidence/cluster-first.json b/evidence/cluster-first.json new file mode 100644 index 00000000..aca94543 --- /dev/null +++ b/evidence/cluster-first.json @@ -0,0 +1,4458 @@ +{ + "date": "2026-11-15T18:22:35.520155+00:00", + "source_commit": "f5a7a74f679d936d851fa0e58f6cfb59dcd62c50", + "complete": true, + "before": [ + { + "role": "api", + "container": "c9c495521bf2", + "pid": 39030, + "started_at": "2026-11-15T18:03:15.404279669Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "role": "api", + "container": "2af84f3c87dd", + "pid": 80780, + "started_at": "2026-11-15T18:13:52.321424672Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "role": "cache", + "container": "e33ddf35f293", + "pid": 5356, + "started_at": "2026-11-15T17:39:31.281698344Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 134217728 + }, + { + "role": "lb", + "container": "6d7d02d323ed", + "pid": 39796, + "started_at": "2026-11-15T18:03:26.954206841Z", + "ports": { + "8080/tcp": [ + { + "HostIp": "127.0.0.1", + "HostPort": "8084" + } + ] + }, + "cpu_nano": 500000000, + "memory_limit": 134217728 + }, + { + "role": "postgres", + "container": "a5ffac5a4228", + "pid": 5418, + "started_at": "2026-11-15T17:39:31.614022427Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 536870912 + }, + { + "role": "reconciler", + "container": "c94b86137075", + "pid": 94299, + "started_at": "2026-11-15T18:20:05.941649137Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 268435456 + }, + { + "role": "s3", + "container": "acc08930aff2", + "pid": 82901, + "started_at": "2026-11-15T18:14:38.360606722Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 1073741824 + } + ], + "parallel_replay": { + "requests": 30, + "messages": 1, + "instances": [ + "ba0474b668fd43b294ece08957bf0648", + "e91b8ff7122d4842abb3aa0ff38e0352" + ] + }, + "atomic_rollback_and_5xx_retry": true, + "expired_key_can_be_reused": true, + "failovers": [ + { + "confirmed_writes": 194, + "successful_reads": 187, + "errors": 8, + "successful_rps": 25.32, + "first_success_after_action_seconds": 4.086, + "action": { + "finished": 3.064 + }, + "observations": [ + { + "at": 0.007, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.072, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.13, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.208, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.266, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.325, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.383, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.446, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.507, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.571, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.634, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.69, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.751, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.808, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.869, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.927, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 0.985, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 1.05, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 1.157, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 1.257, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 1.354, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 1.456, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 1.556, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 1.628, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 1.707, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 1.775, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 1.884, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 1.975, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 2.075, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 2.189, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 2.279, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "at": 2.349, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 2.424, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 2.628, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 2.731, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 2.834, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 2.927, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 3.022, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.086, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.149, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.208, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.267, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.324, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.382, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.445, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.511, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.573, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.634, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.701, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.755, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.819, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.886, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 4.953, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.018, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.087, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.155, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.239, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.313, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.388, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.454, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.541, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.616, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.683, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.758, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.833, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.9, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 5.968, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.036, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.105, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.168, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.238, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.317, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.388, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.451, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.517, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.577, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.646, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.709, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.765, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.821, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.886, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 6.951, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.02, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.086, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.151, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.221, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.291, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.366, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.436, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.512, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.587, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.654, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.718, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.787, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.859, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.925, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 7.992, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.063, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.136, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.211, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.276, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.348, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.43, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.497, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.561, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.628, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.71, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.772, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.844, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.909, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 8.977, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.042, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.106, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.166, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.23, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.299, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.361, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.428, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.499, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.567, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.639, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.713, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.786, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.862, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.928, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 9.99, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.055, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.117, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.187, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.254, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.321, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.388, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.462, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.53, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.6, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.676, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.745, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.818, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.884, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 10.95, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.007, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.069, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.138, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.2, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.259, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.318, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.383, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.449, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.507, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.574, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.644, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.718, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.787, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.854, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 11.931, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.018, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.087, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.158, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.228, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.297, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.368, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.438, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.506, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.571, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.641, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.709, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.781, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.86, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 12.928, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 13.001, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 13.068, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 13.137, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 13.225, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 13.424, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 13.52, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 13.63, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 13.726, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 13.822, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 13.93, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.024, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.092, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.15, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.217, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.285, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.352, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.423, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.492, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.56, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.627, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.694, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.768, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.836, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.902, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 14.968, + "instance": "ba0474b668fd43b294ece08957bf0648" + } + ], + "confirmed_preserved": true, + "duplicate_texts": false, + "stopped": { + "role": "api", + "container": "c9c495521bf2", + "pid": 39030, + "started_at": "2026-11-15T18:03:15.404279669Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + } + }, + { + "confirmed_writes": 217, + "successful_reads": 211, + "errors": 7, + "successful_rps": 28.43, + "first_success_after_action_seconds": 2.72, + "action": { + "finished": 2.697 + }, + "observations": [ + { + "at": 0.013, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.08, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.148, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.214, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.278, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.352, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.417, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.475, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.536, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.589, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.647, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.71, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.774, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.872, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 0.983, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 1.072, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 1.175, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 1.275, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 1.376, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 1.44, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 1.545, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 1.647, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 1.744, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 1.848, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 1.947, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 2.01, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 2.063, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "at": 2.13, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.191, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.246, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.308, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.36, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.412, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.471, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.533, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.596, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.659, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.72, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.786, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.853, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.914, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.977, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.033, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.096, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.163, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.242, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.308, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.376, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.446, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.516, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.576, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.636, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.702, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.761, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.823, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.879, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.942, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.001, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.058, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.121, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.196, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.262, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.336, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.404, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.479, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.545, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.612, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.676, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.741, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.8, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.861, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.93, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.003, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.074, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.148, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.22, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.292, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.363, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.449, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.522, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.592, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.663, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.738, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.811, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.882, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.948, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.008, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.07, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.133, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.194, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.259, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.317, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.383, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.443, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.51, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.578, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.645, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.71, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.778, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.843, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.91, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.977, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.053, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.126, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.197, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.264, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.329, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.397, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.463, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.532, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.607, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.675, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.732, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.803, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.878, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.949, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.024, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.096, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.167, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.24, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.299, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.366, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.43, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.492, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.559, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.623, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.691, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.754, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.811, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.875, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.942, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.011, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.078, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.146, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.219, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.295, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.371, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.443, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.525, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.622, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.724, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.829, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.93, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.02, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.08, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.176, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.243, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.31, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.378, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.447, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.51, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.575, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.64, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.7, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.759, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.826, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.891, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.954, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.013, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.07, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.134, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.203, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.272, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.348, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.415, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.489, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.563, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.637, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.707, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.77, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.847, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.92, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.992, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.066, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.133, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.204, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.278, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.344, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.412, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.474, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.539, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.615, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.687, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.756, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.82, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.885, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.943, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.009, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.075, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.142, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.207, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.272, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.334, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.397, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.459, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.529, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.603, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.669, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.745, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.812, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.879, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.946, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.013, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.081, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.146, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.214, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.296, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.363, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.428, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.498, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.564, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.63, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.705, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.77, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.836, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.898, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.964, + "instance": "6a4f6dc699ed419dad620c988fe79946" + } + ], + "confirmed_preserved": true, + "duplicate_texts": false, + "stopped": { + "role": "api", + "container": "2af84f3c87dd", + "pid": 80780, + "started_at": "2026-11-15T18:13:52.321424672Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "ba0474b668fd43b294ece08957bf0648" + } + } + ], + "rolling": { + "confirmed_writes": 609, + "successful_reads": 608, + "errors": 34, + "successful_rps": 26.97, + "first_success_after_action_seconds": 40.906, + "action": { + "finished": 40.838 + }, + "observations": [ + { + "at": 0.016, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.108, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.162, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.228, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.294, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.362, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.431, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.496, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.585, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.66, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.717, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.78, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.849, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.909, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 0.964, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.024, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.078, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.148, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.212, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.268, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.417, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.493, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.558, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.62, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.684, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.744, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.803, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.87, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 1.954, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.017, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.084, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.141, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.198, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.257, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.314, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.376, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.459, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.525, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.603, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.68, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.74, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.806, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.86, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.913, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 2.976, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.036, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.096, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.161, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.224, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.292, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.35, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.409, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.471, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.537, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.597, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.655, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.766, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.834, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.897, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 3.959, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.018, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.086, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.15, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.213, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.278, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.34, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.402, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.463, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.524, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.59, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.651, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.711, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.781, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.837, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.9, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 4.958, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.016, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.08, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.139, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.203, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.265, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.327, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.391, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.459, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.514, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.58, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.646, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.707, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.777, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.842, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.905, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 5.964, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.021, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.08, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.148, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.206, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.272, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.339, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.397, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.463, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.525, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.59, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.657, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.748, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.806, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.865, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.928, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 6.988, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.057, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.124, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.189, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.255, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.316, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.38, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.444, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.501, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.568, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.633, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.704, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.812, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 7.907, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.015, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.115, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.213, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.301, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.37, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.437, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.501, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.571, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.639, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.7, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.78, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.84, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.899, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 8.965, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.028, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.09, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.148, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.207, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.266, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.328, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.396, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.478, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.544, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.601, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.659, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.727, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.793, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.859, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.93, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 9.997, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.061, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.12, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.18, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.243, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.307, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.381, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.446, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.506, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.569, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.628, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.687, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.763, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.845, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.911, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 10.969, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.036, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.104, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.171, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.238, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.302, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.364, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.429, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.501, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.57, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.631, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.699, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.761, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.834, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.906, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 11.975, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.05, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.114, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.191, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.256, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.326, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.394, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.458, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.543, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.605, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.673, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.746, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.843, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 12.96, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.025, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.088, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.151, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.229, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.309, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.508, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.61, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.68, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.75, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.836, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 13.949, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.048, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.178, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 14.342, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 14.415, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.475, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 14.543, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 14.603, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.676, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 14.738, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 14.807, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 14.878, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 14.955, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 15.025, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 15.117, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 15.209, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 15.274, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 15.342, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 15.408, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 15.48, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 15.552, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 15.62, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 15.689, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 15.769, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 15.833, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 15.905, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 15.978, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 16.044, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 16.11, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 16.183, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 16.267, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 16.34, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 16.402, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 16.462, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 16.525, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 16.593, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 16.655, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 16.718, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 16.786, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 16.846, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 16.916, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 17.006, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 17.074, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 17.147, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 17.212, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 17.283, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 17.353, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "at": 17.427, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 17.497, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 17.565, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 17.64, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 17.716, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 17.813, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 17.888, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 17.964, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 18.027, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 18.114, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 18.175, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 18.25, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 19.426, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 19.502, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 19.581, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 19.653, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 19.727, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 19.801, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 19.878, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 19.943, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.007, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.074, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.134, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.208, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.284, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.355, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.415, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.477, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.543, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.609, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.674, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.736, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.8, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.86, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.923, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 20.988, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.046, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.113, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.182, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.251, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.318, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.39, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.458, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.53, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.603, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.668, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.735, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.798, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.86, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.928, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 21.994, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 22.056, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 22.117, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 22.186, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 22.259, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 22.332, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 22.398, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 22.46, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 22.527, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 22.59, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 22.65, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 22.727, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 22.794, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 22.871, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 22.944, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.013, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.081, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.161, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.228, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.292, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.359, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.426, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.496, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.557, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.627, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.695, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.761, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.831, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.898, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 23.964, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 24.029, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 24.095, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 24.164, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 24.235, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 24.328, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 24.426, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 24.53, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 24.628, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 24.728, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 24.826, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 24.927, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.013, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.084, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.15, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.217, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.286, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.346, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.407, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.471, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.535, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.599, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.664, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.727, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.789, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.854, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.921, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 25.983, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.058, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.123, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.192, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.259, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.325, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.393, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.458, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.525, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.59, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.651, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.715, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.776, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.837, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.903, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 26.97, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.052, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.129, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.194, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.275, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.339, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.412, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.497, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.561, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.625, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.684, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.744, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.8, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.856, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.915, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 27.983, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.05, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.115, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.172, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.235, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.296, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.357, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.425, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.484, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.549, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.625, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.694, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.759, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.826, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.888, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 28.956, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 29.037, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 29.118, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 29.214, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 29.326, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 29.421, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 29.509, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 29.621, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 29.717, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 29.812, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 29.905, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 29.964, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.03, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.091, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.16, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.224, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.286, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.348, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.414, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.474, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.542, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.599, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.657, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.72, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.79, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.851, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.918, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 30.991, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.055, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.12, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.188, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.252, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.32, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.382, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.446, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.514, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.577, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.644, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.707, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.773, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.84, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.905, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 31.977, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.042, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.115, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.18, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.241, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.314, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.374, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.443, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.508, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.578, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.636, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.702, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.761, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.825, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.883, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 32.95, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 33.013, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 33.074, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 33.137, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 33.197, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 33.261, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 33.334, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 33.417, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 33.475, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 33.556, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 33.627, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 33.69, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 33.752, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 33.812, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 33.87, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 33.938, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 34.005, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 34.073, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 34.13, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 34.192, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 34.254, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 34.312, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 34.375, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 34.445, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 34.511, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 34.574, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 34.643, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 34.705, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 34.775, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 34.837, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 34.906, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 34.97, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 35.048, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 35.124, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 35.192, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 35.253, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 35.316, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 35.387, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 35.521, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 35.584, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 35.694, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 35.758, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 35.826, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 35.893, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 35.964, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 36.038, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 36.107, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 36.174, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 36.248, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 36.315, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 36.388, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 36.459, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 36.53, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 36.602, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 36.666, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 36.729, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "at": 36.794, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "at": 36.863, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 36.934, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 37.001, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 37.083, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 37.153, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 37.224, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 37.293, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 37.368, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 37.458, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 38.603, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 38.68, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 38.755, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 38.823, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 38.894, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 38.959, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.025, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.096, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.165, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.231, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.291, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.353, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.416, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.503, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.576, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.643, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.708, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.775, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.841, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.91, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 39.979, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.052, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.118, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.186, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.252, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.319, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.391, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.463, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.538, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.612, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.686, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.762, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.831, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.906, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 40.978, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.052, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.121, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.201, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.272, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.349, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.413, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.476, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.565, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.634, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.695, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.758, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.819, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.883, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 41.945, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.009, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.078, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.145, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.218, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.284, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.421, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.517, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.578, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.643, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.708, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.774, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.838, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.909, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 42.977, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 43.045, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 43.118, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 43.196, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 43.306, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 43.405, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 43.515, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 43.706, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 43.813, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 43.923, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 44.015, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 44.102, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 44.163, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 44.253, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 44.324, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 44.404, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 44.483, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 44.671, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 44.752, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 44.826, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 44.91, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "at": 44.976, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + } + ], + "confirmed_preserved": true, + "duplicate_texts": false, + "before": [ + { + "role": "api", + "container": "c9c495521bf2", + "pid": 536, + "started_at": "2026-11-15T18:23:01.344627468Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "6a4f6dc699ed419dad620c988fe79946" + }, + { + "role": "api", + "container": "2af84f3c87dd", + "pid": 1911, + "started_at": "2026-11-15T18:23:32.450473386Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "940942b16d664ce38af7c0db8fa979fa" + }, + { + "role": "cache", + "container": "e33ddf35f293", + "pid": 5356, + "started_at": "2026-11-15T17:39:31.281698344Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 134217728 + }, + { + "role": "lb", + "container": "6d7d02d323ed", + "pid": 39796, + "started_at": "2026-11-15T18:03:26.954206841Z", + "ports": { + "8080/tcp": [ + { + "HostIp": "127.0.0.1", + "HostPort": "8084" + } + ] + }, + "cpu_nano": 500000000, + "memory_limit": 134217728 + }, + { + "role": "postgres", + "container": "a5ffac5a4228", + "pid": 5418, + "started_at": "2026-11-15T17:39:31.614022427Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 536870912 + }, + { + "role": "reconciler", + "container": "c94b86137075", + "pid": 94299, + "started_at": "2026-11-15T18:20:05.941649137Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 268435456 + }, + { + "role": "s3", + "container": "acc08930aff2", + "pid": 82901, + "started_at": "2026-11-15T18:14:38.360606722Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 1073741824 + } + ], + "after": [ + { + "role": "api", + "container": "99db7624c4ec", + "pid": 2618, + "started_at": "2026-11-15T18:23:49.098497838Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "7675c0f93b74423d8c2206f5492f21f3" + }, + { + "role": "api", + "container": "b0a345f04e5b", + "pid": 3409, + "started_at": "2026-11-15T18:24:08.65538843Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "19362ec512e143f6b7a5aa8ddc8109c2" + }, + { + "role": "cache", + "container": "e33ddf35f293", + "pid": 5356, + "started_at": "2026-11-15T17:39:31.281698344Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 134217728 + }, + { + "role": "lb", + "container": "6d7d02d323ed", + "pid": 39796, + "started_at": "2026-11-15T18:03:26.954206841Z", + "ports": { + "8080/tcp": [ + { + "HostIp": "127.0.0.1", + "HostPort": "8084" + } + ] + }, + "cpu_nano": 500000000, + "memory_limit": 134217728 + }, + { + "role": "postgres", + "container": "a5ffac5a4228", + "pid": 5418, + "started_at": "2026-11-15T17:39:31.614022427Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 536870912 + }, + { + "role": "reconciler", + "container": "c94b86137075", + "pid": 94299, + "started_at": "2026-11-15T18:20:05.941649137Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 268435456 + }, + { + "role": "s3", + "container": "acc08930aff2", + "pid": 82901, + "started_at": "2026-11-15T18:14:38.360606722Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 1073741824 + } + ] + }, + "replay_after_replacement": true, + "public_failover": "Executing explicit failover hook; hook output suppressed to avoid leaking secrets.\n{\"observed_instances_before\": 2, \"successful_writes\": 123, \"failed_attempts\": 3, \"first_recovery_seconds\": 2.635}\nPASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.", + "public_persistence": "Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.\nPASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.", + "after_persistence": [ + { + "role": "api", + "container": "99db7624c4ec", + "pid": 7567, + "started_at": "2026-11-15T18:25:23.088247673Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "1bc05e903ca54f3498aca9b1cec61bdb" + }, + { + "role": "api", + "container": "b0a345f04e5b", + "pid": 7483, + "started_at": "2026-11-15T18:25:22.717902089Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "5383b6087a8c478bb7ed3ec4371c194c" + }, + { + "role": "cache", + "container": "e33ddf35f293", + "pid": 7268, + "started_at": "2026-11-15T18:25:21.717046214Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 134217728 + }, + { + "role": "lb", + "container": "6d7d02d323ed", + "pid": 7163, + "started_at": "2026-11-15T18:25:21.610361422Z", + "ports": { + "8080/tcp": [ + { + "HostIp": "127.0.0.1", + "HostPort": "8084" + } + ] + }, + "cpu_nano": 500000000, + "memory_limit": 134217728 + }, + { + "role": "postgres", + "container": "a5ffac5a4228", + "pid": 7246, + "started_at": "2026-11-15T18:25:21.70517763Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 536870912 + }, + { + "role": "reconciler", + "container": "c94b86137075", + "pid": 94299, + "started_at": "2026-11-15T18:20:05.941649137Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 268435456 + }, + { + "role": "s3", + "container": "acc08930aff2", + "pid": 7196, + "started_at": "2026-11-15T18:25:21.649267714Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 1073741824 + } + ] +} diff --git a/evidence/http-first.json b/evidence/http-first.json new file mode 100644 index 00000000..851b23db --- /dev/null +++ b/evidence/http-first.json @@ -0,0 +1,17 @@ +{ + "date": "2026-11-15T18:04:52.576254+00:00", + "source_commit": "f5a7a74f679d936d851fa0e58f6cfb59dcd62c50", + "result": "PASS", + "smoke": { + "command": "make test PYTHON=.venv/bin/python BASE_URL=http://127.0.0.1:8084", + "seconds": 8.702, + "exit_code": 0, + "output": ".venv/bin/python tests/smoke.py --base-url \"http://127.0.0.1:8084\" \nPASS: lab4 public API scenario; infrastructure and grading evidence remain separate.\n" + }, + "http": { + "command": ".venv/bin/pytest student-tests -q", + "seconds": 362.959, + "exit_code": 0, + "output": "........................................................................ [ 66%]\n.................................... [100%]\n108 passed in 362.40s (0:06:02)\n" + } +} diff --git a/evidence/minio-source-verification.json b/evidence/minio-source-verification.json index f3d8eb3e..1da57808 100644 --- a/evidence/minio-source-verification.json +++ b/evidence/minio-source-verification.json @@ -8,5 +8,85 @@ "module_checksum": "h1:6TdolSCLSs2nwm8i0PpWDqf9iX2Ty9WQK8wmr7dCnUM=", "go_mod_checksum": "h1:yCWDkwWO9IWpGsT4mreDDN/B/QVmK2zC666uInRAcqE=", "validation": "standard go mod download with default Go checksum database after ranged HTTPS download", - "compiler_build_status": "in progress; source validation only" + "compiler_build_status": "PASS", + "runtime_version": "minio version RELEASE.2025-10-15T17-29-55Z (commit-id=9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a)\nRuntime: go1.24.8 linux/arm64\nLicense: GNU AGPLv3 - https://www.gnu.org/licenses/agpl-3.0.html\nCopyright: 2015-0000 MinIO, Inc.", + "runtime_snapshot": [ + { + "role": "api", + "container": "c9c495521bf2", + "pid": 39030, + "started_at": "2026-11-15T18:03:15.404279669Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "role": "api", + "container": "2af84f3c87dd", + "pid": 39163, + "started_at": "2026-11-15T18:03:15.735686586Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "17cd27ba20064c5eb9580379e963f419" + }, + { + "role": "cache", + "container": "e33ddf35f293", + "pid": 5356, + "started_at": "2026-11-15T17:39:31.281698344Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 134217728 + }, + { + "role": "lb", + "container": "6d7d02d323ed", + "pid": 39796, + "started_at": "2026-11-15T18:03:26.954206841Z", + "ports": { + "8080/tcp": [ + { + "HostIp": "127.0.0.1", + "HostPort": "8084" + } + ] + }, + "cpu_nano": 500000000, + "memory_limit": 134217728 + }, + { + "role": "postgres", + "container": "a5ffac5a4228", + "pid": 5418, + "started_at": "2026-11-15T17:39:31.614022427Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 536870912 + }, + { + "role": "reconciler", + "container": "c94b86137075", + "pid": 39092, + "started_at": "2026-11-15T18:03:15.578851294Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 268435456 + }, + { + "role": "s3", + "container": "acc08930aff2", + "pid": 38412, + "started_at": "2026-11-15T18:03:03.039434803Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 1073741824 + } + ], + "runtime_image_revision": { + "api": "f5a7a74f679d936d851fa0e58f6cfb59dcd62c50", + "s3": "9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a", + "bootstrap": "7394ce0dd2a80935aded936b09fa12cbb3cb8096" + } } diff --git a/evidence/storage-first.json b/evidence/storage-first.json new file mode 100644 index 00000000..91f2434b --- /dev/null +++ b/evidence/storage-first.json @@ -0,0 +1,502 @@ +{ + "source_commit": "f5a7a74f679d936d851fa0e58f6cfb59dcd62c50", + "date": "2026-11-15T18:13:30.360880+00:00", + "complete": true, + "runtime": [ + { + "role": "api", + "container": "c9c495521bf2", + "pid": 39030, + "started_at": "2026-11-15T18:03:15.404279669Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "role": "api", + "container": "2af84f3c87dd", + "pid": 39163, + "started_at": "2026-11-15T18:03:15.735686586Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "17cd27ba20064c5eb9580379e963f419" + }, + { + "role": "cache", + "container": "e33ddf35f293", + "pid": 5356, + "started_at": "2026-11-15T17:39:31.281698344Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 134217728 + }, + { + "role": "lb", + "container": "6d7d02d323ed", + "pid": 39796, + "started_at": "2026-11-15T18:03:26.954206841Z", + "ports": { + "8080/tcp": [ + { + "HostIp": "127.0.0.1", + "HostPort": "8084" + } + ] + }, + "cpu_nano": 500000000, + "memory_limit": 134217728 + }, + { + "role": "postgres", + "container": "a5ffac5a4228", + "pid": 5418, + "started_at": "2026-11-15T17:39:31.614022427Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 536870912 + }, + { + "role": "reconciler", + "container": "c94b86137075", + "pid": 39092, + "started_at": "2026-11-15T18:03:15.578851294Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 268435456 + }, + { + "role": "s3", + "container": "acc08930aff2", + "pid": 38412, + "started_at": "2026-11-15T18:03:03.039434803Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 1073741824 + } + ], + "upload_replica_stopped_downloaded_elsewhere": { + "stopped_container": "2af84f3c87dd", + "uploader": "17cd27ba20064c5eb9580379e963f419", + "downloader": "e91b8ff7122d4842abb3aa0ff38e0352", + "sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75" + }, + "private_bucket_and_iam": { + "denied_head_is_not_missing": 503, + "anonymous_get": 403, + "list_other_bucket": "AccessDenied", + "create_bucket": "AccessDenied", + "write_outside_prefix": "AccessDenied", + "console_internal_network": "unreachable" + }, + "bootstrap_repeat_preserved_original": true, + "aborted_upload_has_no_intent_or_bytes": true, + "pg_intent_failure_has_no_bytes": true, + "s3_unavailable": { + "status": 503, + "error": "unavailable" + }, + "concurrent_uploads": { + "concurrency": 10, + "requests": 10, + "successes": 10, + "errors": 0, + "bytes_per_image": 6017095, + "pixels": 2890000, + "duration_seconds": 5.149, + "successful_rps": 1.942, + "latency_scope": "upload only; duration includes verified downloads and memory sampler", + "p50_ms": 2162.965, + "p95_ms": 4465.512, + "p99_ms": 4465.512, + "cpu_before": { + "c9c495521bf2e0eb21d94eebc8ac06ea3735ee282401f8bbf4918203b05e69ea": "usage_usec 148242470\nuser_usec 139413925\nsystem_usec 8828544\nnice_usec 0\nnr_periods 5268\nnr_throttled 2720\nthrottled_usec 566509749\nnr_bursts 0\nburst_usec 0", + "2af84f3c87dd51105775135adaa2864b852c68c3b3d929f566d714ee4bbf13a2": "usage_usec 7938759\nuser_usec 7311622\nsystem_usec 627137\nnice_usec 0\nnr_periods 338\nnr_throttled 144\nthrottled_usec 17342812\nnr_bursts 0\nburst_usec 0" + }, + "cpu_after": { + "c9c495521bf2e0eb21d94eebc8ac06ea3735ee282401f8bbf4918203b05e69ea": "usage_usec 150694911\nuser_usec 141253264\nsystem_usec 9441647\nnice_usec 0\nnr_periods 5320\nnr_throttled 2767\nthrottled_usec 573793811\nnr_bursts 0\nburst_usec 0", + "2af84f3c87dd51105775135adaa2864b852c68c3b3d929f566d714ee4bbf13a2": "usage_usec 9567439\nuser_usec 8568377\nsystem_usec 999061\nnice_usec 0\nnr_periods 386\nnr_throttled 171\nthrottled_usec 20452342\nnr_bursts 0\nburst_usec 0" + }, + "memory_samples": [ + { + "at": 0.0, + "container": "c9c495521bf2", + "memory.current": 128004096, + "memory.peak": 215093248 + }, + { + "at": 0.931, + "container": "2af84f3c87dd", + "memory.current": 128983040, + "memory.peak": 152731648 + }, + { + "at": 2.318, + "container": "c9c495521bf2", + "memory.current": 163500032, + "memory.peak": 215093248 + }, + { + "at": 3.846, + "container": "2af84f3c87dd", + "memory.current": 126009344, + "memory.peak": 152731648 + }, + { + "at": 4.515, + "container": "c9c495521bf2", + "memory.current": 153980928, + "memory.peak": 215093248 + }, + { + "at": 4.862, + "container": "2af84f3c87dd", + "memory.current": 125583360, + "memory.peak": 152731648 + } + ], + "results": [ + { + "id": "7df54468-dffb-48e1-b435-bb64e73b087c", + "latency_ms": 774.2156249878462, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "id": "e1ba3763-89f2-497f-a152-6008f4737e08", + "latency_ms": 1630.1402079989202, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "id": "69c854d8-ca53-46aa-9dbd-646b68bc42be", + "latency_ms": 3091.3296249927953, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "id": "03328959-bf30-4e57-a233-4084e599bbfc", + "latency_ms": 2098.3562500041444, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "id": "483eff54-3137-4764-bc89-3feccf7d00e6", + "latency_ms": 4303.714374982519, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "id": "f4eb43f0-65bf-462c-bfd2-9c8d88ff1d34", + "latency_ms": 1105.6364579999354, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "id": "90a80cf9-d955-4bcc-9f16-01587a3f2f66", + "latency_ms": 3825.5119579844177, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "id": "3e2a2c9c-4204-4883-b18a-5b1deeca70c3", + "latency_ms": 2162.9652910050936, + "instance": "ba0474b668fd43b294ece08957bf0648" + }, + { + "id": "ea4b8e91-80fe-4741-8d0b-c77d2da6656f", + "latency_ms": 4465.512333001243, + "instance": "e91b8ff7122d4842abb3aa0ff38e0352" + }, + { + "id": "031a9c2b-4c93-4dd4-935b-8104080a0a86", + "latency_ms": 1169.7680839861277, + "instance": "ba0474b668fd43b294ece08957bf0648" + } + ], + "window_max_memory_current": 163500032, + "lifetime_memory_peak": 215093248 + }, + "reconciliation": { + "dry_run": { + "apply": false, + "grace_seconds": 300, + "objects_scanned": 20, + "rows_scanned": 20, + "head_requests": 8, + "bytes_read": 111817, + "fresh_protected": 13, + "ready_protected": 5, + "linked_protected": 0, + "actions": { + "delete_orphan": 1, + "recover_pending": 1, + "fail_pending_missing": 1, + "delete_failed_object": 1, + "mark_missing": 1 + }, + "applied": {}, + "details": [ + { + "action": "delete_orphan", + "identity": "objects/verification-f49e0d70d0f54f62bce62b4a3dccdbdc/orphan" + }, + { + "action": "recover_pending", + "identity": "06e24ef9-2a84-43d1-bc08-facf33155e9f" + }, + { + "action": "fail_pending_missing", + "identity": "44b0d154-ed76-4f79-a356-7feb85a3b14c" + }, + { + "action": "delete_failed_object", + "identity": "54e914d0-5a4c-4dc9-982c-ef887467700c" + }, + { + "action": "mark_missing", + "identity": "fa66fcd8-ca7e-41e4-8f25-25ff119c38e9" + } + ], + "duration_seconds": 0.0604, + "complete": true + }, + "apply": { + "apply": true, + "grace_seconds": 300, + "objects_scanned": 20, + "rows_scanned": 20, + "head_requests": 10, + "bytes_read": 111817, + "fresh_protected": 13, + "ready_protected": 5, + "linked_protected": 0, + "actions": { + "delete_orphan": 1, + "recover_pending": 1, + "fail_pending_missing": 1, + "delete_failed_object": 1, + "mark_missing": 1 + }, + "applied": { + "delete_orphan": 1, + "recover_pending": 1, + "fail_pending_missing": 1, + "delete_failed_object": 1, + "mark_missing": 1 + }, + "details": [ + { + "action": "delete_orphan", + "identity": "objects/verification-f49e0d70d0f54f62bce62b4a3dccdbdc/orphan" + }, + { + "action": "recover_pending", + "identity": "06e24ef9-2a84-43d1-bc08-facf33155e9f" + }, + { + "action": "fail_pending_missing", + "identity": "44b0d154-ed76-4f79-a356-7feb85a3b14c" + }, + { + "action": "delete_failed_object", + "identity": "54e914d0-5a4c-4dc9-982c-ef887467700c" + }, + { + "action": "mark_missing", + "identity": "fa66fcd8-ca7e-41e4-8f25-25ff119c38e9" + } + ], + "duration_seconds": 0.106004, + "complete": true + }, + "repeat": { + "apply": true, + "grace_seconds": 300, + "objects_scanned": 18, + "rows_scanned": 20, + "head_requests": 6, + "bytes_read": 0, + "fresh_protected": 13, + "ready_protected": 6, + "linked_protected": 1, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.102749, + "complete": true + }, + "s3_grace_wait_seconds": 331.301, + "fresh_and_ready_unlinked_protected": true, + "old_failed_unlinked_deleted_and_fresh_failed_protected": true, + "missing_used_id_and_link_preserved": true, + "dry_run_unchanged": true + }, + "cost_research": { + "cells": [ + { + "extra_objects": 0, + "repetition": 1, + "apply": false, + "grace_seconds": 300, + "objects_scanned": 18, + "rows_scanned": 20, + "head_requests": 6, + "bytes_read": 0, + "fresh_protected": 13, + "ready_protected": 6, + "linked_protected": 1, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.183485, + "complete": true + }, + { + "extra_objects": 0, + "repetition": 2, + "apply": false, + "grace_seconds": 300, + "objects_scanned": 18, + "rows_scanned": 20, + "head_requests": 6, + "bytes_read": 0, + "fresh_protected": 13, + "ready_protected": 6, + "linked_protected": 1, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.043382, + "complete": true + }, + { + "extra_objects": 0, + "repetition": 3, + "apply": false, + "grace_seconds": 300, + "objects_scanned": 18, + "rows_scanned": 20, + "head_requests": 6, + "bytes_read": 0, + "fresh_protected": 13, + "ready_protected": 6, + "linked_protected": 1, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.046774, + "complete": true + }, + { + "extra_objects": 100, + "repetition": 1, + "apply": false, + "grace_seconds": 300, + "objects_scanned": 118, + "rows_scanned": 20, + "head_requests": 6, + "bytes_read": 0, + "fresh_protected": 112, + "ready_protected": 6, + "linked_protected": 1, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.078726, + "complete": true + }, + { + "extra_objects": 100, + "repetition": 2, + "apply": false, + "grace_seconds": 300, + "objects_scanned": 118, + "rows_scanned": 20, + "head_requests": 6, + "bytes_read": 0, + "fresh_protected": 112, + "ready_protected": 6, + "linked_protected": 1, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.088476, + "complete": true + }, + { + "extra_objects": 100, + "repetition": 3, + "apply": false, + "grace_seconds": 300, + "objects_scanned": 118, + "rows_scanned": 20, + "head_requests": 6, + "bytes_read": 0, + "fresh_protected": 112, + "ready_protected": 6, + "linked_protected": 1, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.206964, + "complete": true + }, + { + "extra_objects": 1100, + "repetition": 1, + "apply": false, + "grace_seconds": 300, + "objects_scanned": 1118, + "rows_scanned": 20, + "head_requests": 6, + "bytes_read": 0, + "fresh_protected": 1112, + "ready_protected": 6, + "linked_protected": 1, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.197227, + "complete": true + }, + { + "extra_objects": 1100, + "repetition": 2, + "apply": false, + "grace_seconds": 300, + "objects_scanned": 1118, + "rows_scanned": 20, + "head_requests": 10, + "bytes_read": 0, + "fresh_protected": 1108, + "ready_protected": 10, + "linked_protected": 1, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.145977, + "complete": true + }, + { + "extra_objects": 1100, + "repetition": 3, + "apply": false, + "grace_seconds": 300, + "objects_scanned": 1118, + "rows_scanned": 20, + "head_requests": 16, + "bytes_read": 0, + "fresh_protected": 1102, + "ready_protected": 16, + "linked_protected": 1, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.199997, + "complete": true + } + ], + "repeats": 3, + "method": "same running stand; 0/100/1100 fresh one-byte objects; dry-run; serial ascending dataset; no warmup", + "median_seconds": { + "0": 0.046774, + "100": 0.088476, + "1100": 0.197227 + } + } +} diff --git a/evidence/storage-research.png b/evidence/storage-research.png new file mode 100644 index 0000000000000000000000000000000000000000..0008d204a4b7673ac516fd3f86728d971403a938 GIT binary patch literal 85372 zcma&OcT`hb*DoAUEN}!HARR?Tr70aE#fAz33P^8ChlJiCAfTcsO`1rFO7A_Pg(}hn z1f+xz0@8#KLJI*xxhv;9=lS06{o{_CF&q*I+1Y!qHRrEQ-agj4e}b8t83KWvc=+J1 z4g_*!5&~g-aqI~A4t%|#AN;52dC$;O*TvS;=b5_=MDv-aE6l|c=I~t5+s56)!Nplh z{KgG&Nl`(2Pfu45MF|P`e_tW);%+DLB61nL3FNrz10xRzyPg` zFf1(F=0*CI(75`RmX=|Cn^X_8`A>>c>pv9iY*GEz`{vh=(+~UiL)Gx^>v@}h zpFtoeUmW`Hla}|VT>tw-_1vld`J*=w-v9pSq}r3Iz#HJ{StX0$y{g~S(?i8(&?@`> z3ymp``h@` z=N0f#x1M^x^-5>FBA;^LD1M~Q$K`3B&OMdAjW`q>m+enkT=-}e_2dabHey}2gM55V zoqkTU*gA%e*ph}F_2b8n=bNC5YrTly2M)Jf5f|5T8ZPXAeS)Xbs+~1K!os{KMa~C0 zq3XtY=1j)usG-vKOk6E(xo*8q0rKL4BcTDYLo8_=e|WrFgEUl-ROd``#G#6q3%+g`J(g#$g8$qsKnCqN_(Zh_Rm9M6->coG zJ$qzE?Duvkoy*7@RcPJwkGWI_OBe|rqJ6w3${CH-lhy7lia#cO=KH)dN z@bk+Z#p(A_L7R2y$9yz zQe1|g8kl8uJdl)|ud)c*zLz2k*C{ft8gD)sk^Q?e{oSA)(~BSH6x=f}Yo`|`OW7?V zgZJI|Se4Lt@09d_<(fyBD2iARWypZ?OIN#w^=bN>H^39)5ZJ%-RMf)+b`nUt9~x4w0nQ*$dx`WP%x^or_cscBQ&m z$mQMQgGU7dCyPgNpWM06@0aOKo+wh;-@2olqva)REcVl9+^v0fAtKKlQ_J)4*){#b z+^?|VLZgtqZSZOG9R{pOS%$ z)39EWxS46!bqy7xI&YFF<~z=%k?&Z8(J&*K}0ht`BIB<;syS z_PjYIwD#o{*o^l^5LA4QNJ+g8pQ7jEx2G?a?*?{TuS|xq)e>bFNni!C9VWbIq9||A zobkbj2DFB=u~`urAg|hb)1dfE3zr#YE~zy!-20ZU6ky6HGMI6nO)hf+Hc^kw>WBKS zeAXx#$$S_m{Vv)Whtf;&J??mVl!u4894@_Jvfa(!p%(1 zJCuA+XV2L5Pr%uAscY6PRSIpPoBY#oYZX+qjU&#}AA=*&oZ}GGNVDvv{*U@6iVhuR zt)5ukL&)S8OoQg|sUQ1s z7{z<%&}f@{kVK|DPlo~X(e*`OVVuKDa*(QGyespWhNWmYkM>vJ{mu8D&; zLQx%SWgkfeSpTxKxhM-uc!xdV!Z=Y_1ZQviG6UgIR1$o!H&Qjy1sRp)?VWt!J$z3d z)e{f1z?-*E;2Qdj_+IfWQ<6{7lyTHCRB-p%xPD2LRs8!XY{fcW-6^Ha#sQaHB%mPz zBdk^iIfX^Hk!p<^0{vcR%!Wpz-PfrXa&T(q4chvR+MCEy_t`G#KB+Ok%NnQPuoTvW z3u94kq}`aZ{w15P_|7WA!TXhfP}n-d6>0T^YqJ$4Brdzu*u}E#_4&GX*e7X+4=&VY zd;^PkbrUB$J9{-D8&siTD!K6>+kan)IzG)W0ZNt&4h3I8O}~?9I95Ngu`sBs#LvS+ z448?%A1LGa>%r!PEa+Hm)Rk5?8moXZ?^+dD_Kw4a$%{(5S{4Y()BO1&!?G5i<(m20 zKBW78v02?t(C%uxbkhAUSr>fmkeqeLNei%N8L29uIW>gy`*)b3`^rIu@=RK_Ln1hQ zmt7k7=DJx;*rJtpa!b5PV|mJPRa2mJQ}))nCC(#L;%1)(?JNjefUrMb)cvMa#iW>dqQSz@$87?xJ@74r;f*Iz6jm5$*e(bR$bDlaC3sV^N(1Mbr319EM z8whNij)L~~Ktap$p@BN?)~&SVxm#+A$ z=aDo}Y;3DFQv=sJJJTyb^Cf^5H7f!tL%yGokPt#CU~?mqTc#_CkI5!E8`fS>(y%x& z5)dgAC4ZqC2`5ir8hD(mn+<9`7pzGR*m9f6I`d-Fni!lzP~m(k*hHv=rNY)Fu!*ij z$vTgp+cK*sp>UF^2cMjZ-PXrk);3AF!PGt+C)#1ELxw!1x zoquR&qr6TsPBRC283Nq4J;L zk=?j-`EoY2B#p2-oQ8;Q*~Y8a^oW|*kCJkZHqvp-0A4mUx~)Reuid1E5)eBG7piDk zRmScqpAb+U@3CwD@THfbVS6qmWF+6BF{t(czlqU!@ZcDctkNj#w;sTVjE3+&K77b^ z^C<4ioukxw-(OGe*QDhDM0bQA{o+xVU<#?jHyU>wzcEU~1%hRvUL|E4k|h*7Oe(ErxIqYcbzCv;JZ)R}3J;rrU;&2a1o=Mw#O?I~TCEo+z zK8OCVub?50A(vf_wu-~&1>+}Wqq(HM^T9?1Fk<0SeK!X&IZV-_4`!H5)BP9oJd@nO zk~?&?A6pi*=Z{{h_r|hnNAoL<&oBPUiz|8F7U7Wot7BnpYbsoTkwG`5#Hu~2VSkTS z*Y^wHRn^CRjCKk}E`7>0nC1TD2s0WWwCgL%0*H+#D086-+=H&Lb19-%o(n(IQrYw5 z{I!8PkHcz{%^v(P=sg}l#yIl_s6bsS!!DWhp)~z)A27W+ z$e>S)H2}BOI5l!wmvzVEzJcPz@sSXu9g6m&)noiA%&_%|kHTzbHX})m^iH*0-9ckh#~v3FVUQ<|+Y57% zW^(uBut93B;Q}QYeWlM@$KlXCM|kOhpu}TK+A8X=bx8=?u8*IpGFQZs0t>z{dtmBX z7dlcw>gGjk^oR7F4%ERVhNWF(z2uAC+ozG28;6E_Kqn+e@rn6PDmj<%2nYzQdCm2t z%xfw8uaE7&;%hW+|2R4Q6#yN{o>^Pk*2MnjA{Jauscfawh&c8}GRff8>3?>M3Zv_= zQP*%q)!=3p-0x_~AtI#4raKXqcD-+*_EdWvqO^Uf z{$X|S!M0Lo3gHZ3ViDGmUT=Ld*SK=K9KKS&bwih=cvyHZe?@ntVN-eAyjzAD%+E%rOMZQ_psyDH`I!kUGVOZXtNBYnXV^1_;mA|IR z|FwTmj?jbNn%hGguKd)J3|i|H?liaC-C7ONa+NJtk~rkb&-3=QW2MOz??;xz^S?S9 z5VXzh<;H{krW>(hBacIq()cn`JqI3kCN`3U@NVsVA%4nRlVN%#&uGwzx5iL48i43= zO3oRnu*x_p_W?EdAZbxXR4QC9ew*-rut@+`)q z4IV4yrHJcJNc4nQ(}yAWbzb5HUR*XG(eKtfS@>8cv*>8~ielU==AfC)ogZ)DRP!9^ zZu2+}T0^GSBmO9|{)((sdq2m?OO`!mah?Cxmkd!ZfXb zXxsx-e6*iYMSY>>Rj41%Pn0Y*>gMvlmazEc%iqy}w8xY@!_#@Zhu&#d>U9Hh?8mo~lbG01+DtS5ZGbycDKbVr%AI~S9iC|?G8@LBNU zRVFlc_(`rgG#x-PmUYbAxJ)l*s33i*s; zhajnGFRA`{ub2i}X8bbR z97Z+2s%`kHfRC$;+(>y|Ip4VT``!8ZPFQIR>tAqX4fZ%5<}S$-&g}>L)J9&!WsS7o zd_N7zt&f+Wd^gwR^&sLBBOdY-5_LHB>f!SY@{nULklv`PFms;BRDKQZSw;?r0$T3;s~`taO9ejsUMtvHrSV6MFrv-&WE*avkJ4VBi{EO)$CgM&J~uDs5Z!tp0=ftj<+!~n?rSu zsJI6pY+ol$j5P3kX)yV&n2Eh9t0On-Vj$mO(u{jACZv&uOsqfF^lDma))UuJ=vuEW z-=K}+y~8JfBl>l(0YZ4p?~x-mp?*XQ8=}D5c(9u;SaR34(VzE4=;H2rpAVDY9fiG( zLHz7kl~WbyrqkP)CT!kaZZih_xbPsOfc;zw<$53H(H=+gU6y z3mF3h>@aij>va$7ws~amvbag5{TF}=!c%jeWT@4GOM$06jJsTOyUamh{fE?0p;3jj z03A;cl|H-Uvj;B!aiee4Fg9h^kv{q9zd&bHdWU=vGCxvcVIfBd^hg(HGbu4&#YOVS zU6V8VVkVLb(^YGWm1>PR$;K_+p}9Gx4;g2s8ken3U;>D(Y$|_g)D7a)==2s2XtG)G zpD*D9fhR;@N}%@m?9s@L+8)X#0zibg-_c%ZxF$1VI$f-dR93?7F#A9Ubh6ahDa4UJ zvjb3S63&?4u*LCD|Nb3s0+v~1L`2sb6`EDjxIe~jAm>9s_;mPv&B*Wqm~Q?LqUG;$ zhQ;fzEe0?^I&Kp6VC`qW+qtaZSTUk|9ehfpVq|mD6#$E4p^!4ZI3O_B-7yFs` zto8M)z#yP_;b*foQz~t`IoQ4LgtK}j0old_c~wac@2Oi(Ia^QmUd+p>C3?*Lcu3g- zCqfpNs9Tcs*^N)6Lsqk5!?N2NiJ}j^cQ=7FbvTLu?kDHkw)cBj`%l}Mj#y@N{g_&7 zTkmmDnyvs`n`7eA+@6yhn?$^Tfe((Yg08^STgL15?UaLfSpL%jj!}x=Y8z)=H(&^V zQd}CqLBHGymv;Ph#bV>Gaa!&pq}|VZB{``%Ksay&1bQ_1V6c^Zyyfb(!jdDORsVq7 z_$k`2S)c+4mOftxtVYCEEQ8CDfopI10f@VI_wHeSi+bO(eXw+`p;qZHUmo7u#JPm1 zzD^sJnLyfgY2e((FabWbP($nrD1&$+pt|?b6aEEtm3=3*0BJLZmY?~|W=oRVV>Wc?N?LJ+aTn`bg#>fq z@1RjQ0CKIkn46&ocwfx=VdP1a)kUa-(K+6mzCZWu#@u4kK5IUDHBJ`Y0-X;zl9U`J2P~#8UghigeDOJwI;z0y}3>ImhdwCi!rX{_Kz} zxA=mX2#ptxLwU7lPi%+(=!o=+O#_Q@iivx`DcmavMGnlJ)W2nj^fqs~;n8ulpm%)-malTxD_DHLD7et!gU1M;DtJFpon8v`ggj_|DmVV|4Nk zofv~d%jG6~ttM}{=%tcMeW90)_8v`izA9W!4R`XZ-(Bl=KHA}}h(v4}$r+X8)5Q&v zJoZ>crJ5{i*!_?xem=r)+d&p$WRzY%Ho+F7&c6;mdp0 z#jue(E4Qqx$DSP(kd>tG`(G`uSOyV6E4S3WQ$2bWoa283(RSP=NmEw65ES>t{)}+C zqCgjw6<80?Qzd)4Tr}0{4|Tj(*2UL)nYrSjQ!&VYm(MuyB;+JN%EGq&0#~FXOVG`N zj4Oq@I8Y7p&fj@meWq8|ef%;_1r^2T?LM&SRxx<>`bW7gv9l8PACvvu-QUM2Eghae z#CG#Dxq&9$x@lX<77LaMbhs=k!(8|txe;Fv8iaG#;z7X5zPWz%mlm!U-34%IQ^^W# zI79X1Y)Y(a@w-%5O0&@Ka`&ajCr5J91Zn}irhr0UJ?nI=@HFwtkO>uVn--w+}{zo zt_>iQR12s?Z|NM_W|QrbuRS^k7$VDk-TvXDtO=YiD*W!hKX>X}kaNa(s9&?3mC#i> zug{Y;>_d%j@g|>2_5Y#OklpS-{CZI-MJM+e`Kl3F-sCk$W*`;sa|rOWtJcCVBPs3` zX)&pR*^{#KvumYkmss?bK>uBq8e{#)L@f+Y)l6*YQ)3wGT(9&eb6gx2S;{Xc9soF$ z?9EtYH*z&6^#f@{15}iT`XV(YDd#7}E=;q0BD z=bf&u!ODOAJfIN{#yc06x_+!`I|~TSvUjIH7k-Xu%H<0idmG4d#W&|dZy@1jowdJiJ#mD@6r?NK( z=s%6LN5JICbFP`?@M%nwSnD-2j1kXr4Ma1K1$oIU>sF&8-@lwjv~1&S`O4t5RkcbZ z%O1wKP5hdUiE&I1OA{6aH%bt-oKs31Id}&!QR=ZKh6no@C)sBmOE4P)8sdD&tc7wu zzV5bq+n!I-KBb}SY9QxoOP<_&&T;()RoK?{krvofv9wW~=Qt$dppRJ0FZkavn>y0SF>$^gh$grd;P zE?K*hm2j(v<$Q+Q_lL84w>Jf zKE@tWJ>dr7-Jv;CxqLQ4rv`~;#36`=0=En=>7%^c*Sbnmx+LuVN$IeZ|K5@_Cn~*A z>ILOomEg+CR4aau1J?O)<)TWGL$%+lLa|v_|B%_qzIXyr!IYeo2ESxVEEPN$W>9@* zy$}{jGB`rc$le&#R;kf|8o|AOxwrV^fR5E)oYdfTy&`TE$Z>Ab*aO{LGd9=DdR@(n z1|HXQ=hSQq*wOd^Msyn~TJ|-j1h@wvJ2zj|$MRs6URRB*NG4ftp6iOj>e#*qboDq@ zmV0?K3mxnb!iSshy<(;1{5K8p-X$V92WY9ue)WR8bH4N8uo^?*s>$^`n>1qDonus= zg3rg>?Ybi2Lg)!$(?)o+%#3KMZMS&!eoA`-(Yv9)_l|MO?Vh+K`fUQ9bxcIo_?ovT zyuHg`-%kernw9U<+=_Get!2LPY@d}BT<9RTZF~t{Jh8BXF;5B@E>uw^IdoDuUo}>C1`}masZc-^E1}ET zW@D_moT@)gB!2ou3o>HvOD#V%vk|JPf4`gflwRQG*F`uZ?_NhnQHkzLIf2 zn)Q8VxBBA2KU~rKN5GF8?bSqpjURq;kS6)!B_+;o5O|?|(?dO#>vx8q^_cW=S_HZk zBhbvBKv%3Em2IIYPwl{^hMUKU*3NkvVg+yIg0B~}lG1`#L$|ltUrbXEPu+#Esy>*A ziqDcQl@0~&mWI?`<~$1L%<`VKd}>QyT0zOY1m#+B>eNItlEj+dtg>Luc$G(7BXgr23`uZqo=}6I9}d0Szb1nhB2<pJ zUK8#}23Tp%eK`Q< zr*i__7 zB@N@1zIOK`JA2<1VT?f&*57Yz=fOL;)WXo4Qi3E|$~VKSLI~_nXHS&;{?_y%rNBFs zpvo{Y;)_`Q_ILH>eN(=TOU@!w#^K3(g^(9N%67WUkD>r7H3U5sQQj_QlWt>G`UJX3 zfXT#_cd4o5_>>QAhG5P_C}8_KG~4-nOeZha?vVqkyh0Dqq6w*ymL1|`74eKcKMm4+ z7IW1Z?3dAl!YoWT90=E?ER$oMvkZrh*tfnu;n3^U4Fe8J-ZC}nEllMbsw&=rTkM=e z_pl<$SQz=ZJzl{~r3UkN?e&b%R-)+T(@2H`Kwv;fuza+;r!{h~8l@?5DU<4_vn*xY zrCjhXUEi!CwOAWhLXAooWKOkC^a@;8G%?ZV!LiAriU&1X&jA_g)|sfj`2QFUQ(N$L z-w?x!#-Unv zrYa}hKVO6ucJ;JqQ4)J@(UXkV#5P-KtcXGJFW_L0YuTtN%v7{$oi*v>A{wm&-KF{v z3HYr?{J--DER}_Lo&ffkJ9Hm)=XvWQ{9_I2<)~I6DQ1*)4k+;pb5(sdl+c#8Q0-x> z5w#{iC6ef$S$6MUah8)tL2#BCY;J87AGG$&fcIDYz@ss(uUS8~fOcngB5OW9KzwC9 z6^IPvO>UHs4OBfb>MI~#&RCq4H^kDfF%om%^#-A^P|gbTkz73;r7F?6G-DYI;ss{R zj|(U>SvN~bqgp>lC4m}J!nkm+a3rS(i7VXyO3F16Y}Yzz6fFatTxBg>f>ydst5K_q zSPF9Nh*#o+_I7Ig#C|>(5*K@w&R2+?FBc3eOLybYJK+QERic_2l;WWBWs?YcV8Qa+ zK+@5;lGx5AEuXgx#;*pNyo_U$R&7YI=g zft|iT4YwHIzYix&s2O1oW>3hCe;&7{d3u+RDBd;x*-{=bS{6s@GYW4e;m~ylKG4gh z0A4n%>YVkjhxaP?b;Jtc*D7c2+r@{c`qcvb($GsUi<4w!Qi;N7bib>M3P(pZkW|L0 z!<*qt@KYXAIIT}S&qQ^k6a37oKs`6MM8y`M$GFTC)%s|G@o=pD6|Yw(e@#1 z#BmA`S6?9z4PZ%xK)!l)R823YmfF~t*v+4=w|WjudPWqJYcyff1Ta+#9r=T~o%V7X z-DA~mE(0lm|Lm{`Z?0_=5)zR?>j; ze%@jlihbYT=3)@6A8`t!UdGZVT_T@iyG!QLf1#4^{$}*?HVE0%dE<*8-%f z#!14+KuL?gmE#MHQ+&pvn(F#5Ghxg)TXP>PDO&Mso`-B5(<3UzU^b-^e z8$){nV7dZUO-dvOr`<)dAv}ai#H>{T&2J7Q@W{7O=cRC#pkK(NG(9Gp7zjWL1%4m5 zjN=RtcVo%Lb<51#xWqwT$<#NDefR6z~o;&w!<!S7ZE7Fh^eUn3!&OhfmMNXXjp~j9q#!ovaJ4*yzBHfBhquw}2_V;(- zT$xnt7`?|tk@`$*&*B+x zX=$`AMMD0b?{(Zfx-uCRL^mym%SfO(EFIv-Y-q=1e~X+ApgX7Ik(Frw2dJV^JG9kP zlWdf!q#|oa=im08kpezQr~DB#vF+RD!qQg1Ibl-?KBHyao|lY0;!!K!QU>?OW!l7) z>AgUa?TFvTENRJ`TqHN>K6>Qg-}`1ED-peZ;_Be8O*m;#d8O$Pw@Ofb9lWu~TT58V zeGT8W0NWGgfi7OXoU!F{5sA51nXbD1RG1*oK2~ z%POsp{BUbuAg1BiyB3@4Y!Jbu(WqBxxiX22O>2&a6l{*d^v^VTONR~0hS<>a)H6p} zDvcoBh9|#i?OxawWh(S~Q2IHU>35;-If&rF%jKOzkd8Cv3|2&k59Vb4zjMYfHb!%m zN*Zo9%RxGV4^Kh_1p=~-6d_ixV1w$~f4>3}6APS+nqTROvL_)i2e}MKA%6C&zuSyK z#JE6eb3j9)=H`^XPlw}ikjexP>k%M4&tHb9HmgEdA!{*1)3rePK7=khwgj>SznME2 z|9M+T#1TeUNKCkKm17nt)_K;Q9~?(ZzW^SY54_Y;)|2`mcHw@nrw+u8KiDMGe`~u} zF>S1@^r~5{XOP@c$cvk&rq;Iu{nqvW^NtXRYCmT(;lzKRLLyFsWBmL0zecUWx&Qlk zaXo^0{@wYTAkvjnT`fP9`y}ih{qml@0}@tGJUuIc^Rr%e^}*40XYgIs)v8Nj)3S`N zOfgJ^)2C0nlPCyfWZnBWZ#t@|s?BXX5)FpbHXdT5uhkx>MIo(4L@xU1W8Wxzc_{xS$dHDd?QHVVXuO#Sxobv||75$qy!UBnE_e}4aWB*mh> zZ2z6aFk%W=YnWYUM&_n66a5v$QQXO`6StqW1)m#z{n#)#Oj6M~Is(~o5*N+%lT-&IETmc<{_n{sSPKyXm67U+qIrs5 zi`7r0I}j80cM|1V%JxP{AawNyXfw-DJa8sqnBssQn97-dk5Mh{Jpts(hJ>rSud_bf zzi{Eg_$3DUmsYg5QBmH6DIhJ^kSm8gek>o;_-^y>QjIy}{bAyc;IS*?p^dHPk=09r z|Bn|hKEC6$s^rn>-&JlS<~~M>it1G&2|h{xei+EYv%|bGEw9r8HWuF3)Y8`9`tPP7 zH-4Z8@mY8jjpX*97ryYs+9X}QaN+jfHto9%p!z%WyIcc-NzlPFok}qJU}Zj(aakD1 zlB%+&E@3l(=Wj~Kuw6+KWOEvb-P=|PUc@Pj*UX%rWq-X6xpi5>wD^V;r#%kj25N=% z%feYjBqeXZeXE=x@>GZDz0|+aRv=xiVM1{jd};HamGXIX4DEtci{>wqwCVZ-z~j*G zws%8d#^5g`CnskPxONMXauYwly*(oX04b+xcRrmV&@&~nCTug}AoYB!867J%w}7OW zR60RknE-(< z7R+8q1)2jzaj3#hTM0nFvOP2IJkP_#*ORIOsoJK6kpc-RDCuX5SbBx*0X>mKA0uDyGJD)TGt18Y`b*7 zY(SH03J2heS?$BS1cu zK5Rkz0cJe%#j7V7@7=q%0PuS)uvVYuXz_7=GebLr`~Wb=bIdXR^klg6%dDa}kOjCD zpb}7w*$08NO4q5|X&`muya&o!iH;JpZufM`#&KnSK74Vn(l<*3 znmoCl_k?mSVwc?g@dKVvt;Q~9+ISB~T^^}yEATW&Z;Iae&&qF$$Vy2Cc%I*Pl7aI_ zH4yP-JpVlAgq2O|>iagw?piW%u?QYHiUWH7?6T8Haaxq}j=c{7WJgq#z`#X_pXe3( zK*$MR`Rg-8jW^wve64A{{gvwSF+Qsrqnce2GfhVbWP zOVfH=af=+WfXzJHSMCl+2#gk=-W-!7Br28dSZy0q1OK@iXD_78X$YiVMtHv77zrO} zR@%m2IQ#7A^yv-q9EQog95rjbk;2qV-{d~D!irvZAwsNsmH{k0mH_l#|!vHYT{ zd?B{X0%7sdT#$2)4ZZPr{nKp4?oAd)L&w%LTJpDmV(m^f>S_gJDkG6|SDaN*JjNic_11dLKC&g8fvMaf=ksha>wSExTdu#UysjF7KY0W?qg9p}|=? zr3VThtF-Pb+l)GQqa~|SS~%VJYjORWI;V6McbJ%Q<>R19s0D?Mj|RXlDrE$O7t0-(wQ=0p7B`@ zf7znpdU08|A4M~%7asXEw7f$?6HH65sfe1@{xY+Tm-GPnisgaD@ht1+^vAGYPhD4f z0@6VBVhVNP*MK_YiNjxhWV%+-trn8yg=G3FY0NPUE~QCz>c{Vr%vFy##f)df#j1%z zj_a2t{>%-%rDvJNP6n=z+AGB2GR6n)Kv>(%7yew~e5~qI$d+lld%fPhv=B)wa1JARE z)HJ4&ExIp2N%^Or8=ccwbr3pUF~+K~!1Y7TBD;!LidN%(DE83V0Dv6~9xZ&hW{{tW zBI8Q9*`G_AUY14nxbzh~y&CLq_s>TbWYOOj-P^c3K#Dk#`D`!?Pt2-8Zr^WebJpBX z9ctXkA(P{ckyF}F{Jyzm=H5+|&ea*t@)ym8cV8=zkbTzj@~`{4Mkgwl@pT1)>uLc; zC(6O#QjP*Lt5X`xd}Vx+aY|geQ72KcldX;kenMlRIahVFFY;V6h%s911W2da_*wMLwKp249Au_M zPkI5JxK6`^p4*DG(6@m9%6$UDNoba@c+hr@n47RPqlkwEd9q+|gK7>;yM80Pv{`d0 zd3IZ1O5tZgEbdRJw=5Z?ESKlXxE;P2;-w38(clt+$V|_WK}D?t`!&7C0N4+}aX_UZ zt6fg_9&@0F5?GkWoD9us!ElWHeNtBhh%okL#ewinDIoUKI%#8X*>hRAG4r z7}pX1=^(?r&KP^BX{{3l%UpP8;6O|_EE=!96Pa)D#QM#bCXPUpGMjMqyLWRPx62o? z1IYUvU=6A6EZq$oqL!XHYl3$6a(HeYxY{N?PpGhqUanv7^|V+Y_vrJgI^VK-6Qb&t zOG7CvG&Dr3Q=-(BE#BJa*#sY)t<(IZV*E+z_Sj98?Z7&H4HcyYB)4~xB5Q&%QanL4 zNe+3m!!FT$U~?AWjnJ5Alg~K-&TuRFdkSvFnW#naE-=bAi&oFlmAoj0xsRUrJupCd zt^FM#VyfDiZ8>75Sae0P8YK%X0Y7C;A`i2dz(@ngS0 z-L;N3(yRx=K381nGi%O=zeHaAi~p%NeNw_0{>4y`JP|wxeOM^_o(;={X z>GUclXtKxuuLE!bioPqBlR?l?O$msdk^=!KW1gH~ZNPPz2FhvRlAn^@Q*db0eu##@ zG#Poepps)Mv+&VrcksL4K&p1uc1GqNF0K!~Xm_x&N76}=+H0;pf?p~OTn^+AM1pZ) zO?m{eiU3N`S$BRGbt6?G-P>U(FDR~6X96_CY>p8o%e)K>FxQMGFa%0s)M>tYl0JRQ zSxO(=F{^Fk5HtP*W;N(q=K`aFgIKgB5Yn3xn8sk%STI8H6hL2eBTQ&z$-fkM2afZD2VfhGZa)NHV|Ea|UQ1gLoQ2c!opijxF!aHTEnUMoDkPkC$ z$Bc7Kb@wrQ9_#GhbG&2d5hiz2%Es-^gE&s{k&nqNl?ZYW9DAl<^iDWl;59YG9cV2&!Y`Nj!)wWuRdUx7KK?zXhv;khC>*~LXOymr-e}ky2 z8-sj+s92(G4!HNrlRJP4{G||0sn;~Jx=`0AvP69Q56OSbt^X)aS+VuI#+HkLqoCPd zh2CWzVV7w(4GrO)Ft-D(_&|qWr}D=;1l|x`i}mu9dF*a%vsHYKWDY$->fPlgPAKnB=5y zL-hkg+ty^;g?Az!LR~^?U9da~UvfX_6fo>}I(GH&Tk7nWD~ro4 zFR*>b=GJ|%@z_s>%!B(-~*SeL&5;W$<8Zeo3d%uqcu~fg~MQL$7kD zZtNL3%x+}jWF3o$LsP*51r+_9xZrXK;lt|w6SwZm8V%nvw^>QC`};ptp2Dwr-L!BF zF4ik^-ohOgG)SdquZuqoIfD_9n(pPFfIWE_pf+!Svt&dmQ>V zB{nwp8G;}3`B-VKi;7Z$XWhW5frXN}{oION9r~6YoX{K?kKK=T!zErsy3iyYx`YOz zqaQ{FY=^mtX(xQ`o^hr@W*$6x^q${u=9C<}bl6e0#6GG;t=ZXghbO_wLLf}C2piC3 zOrOz!0Ovqi9NGbqTeE1O4ZVC{V00RjGkcv$rXsVuXmwova zXgJ@TpZxgP&Ax4cm$P{LVQl0;<`REY4D0+X*^4U=pQVG-(0jgadQXBk>x0JkYb|Om zez2G0Yge7u67oN{ifI{`63?sW4wV^Z<%&MQX={CJZx=a#zS#@ty{Fpj`R35y?jG3d znk=izqXg=l88ic6ed$WeTNloz2xG|pUye7megEzV=0c2XJ@bfF_D6MO>!s>mod90f zX8==L`Q8{U>ucN@0OQp%E)zHVaC9w4FqrTCyOHl^0r;$}3niL+gh0D0>HR&b1sE>9 zg5B%8x&EG~ZS(g#iA6w_2Z8XA2dMhY7JVlO-neDcPRQ-pGdbkLx8#OA?S$%Ul)ZPi z`o$;BqXEjF|IDgf@t?B4SCn4-<{hyF(gKyBr6e=zrg;m`)C&-ox( zT{A&%&X8@V)?TF@hgJ0+(*`XXE5H8j=U>(Ds$Bycn+}+SD`A<62_mJR)a@4 zHGJG1Scl7_u+9&cxS`&KAYPZqt0Ex=mRz^1XDZVkb42Jb@K+;Xcdq=x_5BjgtZKZ3 zcSgMK+NgeF!~EkxW`xcVOO`mNdfkY|`o6{!hpSh^;z!FK*#!CN*aRVr9mm>{U(4?W z2S;>Y5GA0Iyb1vnZukw?OQf9pTbn3XxXMI_ERW~YFSnTtbQR;@tJQLB zS%iR?rUn={_yyd_U$tINoPrgn>@(CN2gYkWhR`k+J;_qSgDO8+IK_W~j5l44@FI;p z1x}Lzkh&-!Gw1};C3I}0rMzt|r``36dl^N)NF6Hw)_ORo_4vPQJv$fImv48GT?yCn zyr7%*JHMZDk7pI_R6fhpyY)OTO*HH+(|~@lX)+P?(y*>&#;x4-AgsOVG1G4;cw>7Wl; z0H@c#nBafpGJ+;9{!g5v{*@e#s)8DN8F!{N?2T0hAX$E3178c8Ha~B-yWh7T+isN+GSm2g-IC+yCuKw}OFRZ7n>*Dq!H|b89R%0ygU0{*kuX<8q-lkv zQSO%zP+I7JqTt*)QX=l3Pp#r044=UP*kgu4%X&HGs=YeL87TEXw6;biHm25)Lr3YI z#|HyO1#9*}k!46cDS>c%b(Tj@d~QZ~H{%;~$_JaQ%{!Uz8e*N(B`CGp`KgLU<)~eu zJy)c3eb&Z8&47wk)>i9w|8t1yvlC5V-gw9i1z0v60EX(&4@^Gp-t?4Liw^62(d--D(Dm#lxTS! z>`;g@U~(Kj4z@&hqF4L#DPK^XV?J$GRxZwG;)?p>6)nEpF3~~c&GQXJR%B@iKS&dg zQU87s*`6f02Q}yR`XXKbN_t=1AtQK38F(@5f6m6g;}By$jJchsm-j)$9|Lr6G4pzP zYfDiPFxg%R7)UiyIMwxb1BwZ(1l28i;rcO4thDJbMO7W z`S%=W*n2xNx-5($74sMKCxAx6{?F-=J0*P>rAEsidq&wuj9eVV zD7iVBqSRuVO!GR!-8G1z-P`QTY{&^Q957l#V ze~U_MXrL8$JK`nH8t_8*T9PW~84fL83Em45tz!juUrWuZdG5+Q$81}@YOd=fDRuLd zmveqEg3-kyfda%0yPiTtz>jlsTp@jictFh@DbB9lUbfjT#;>cmX=Leu7IW|c58Nf zOK{{$Cskw9v!OVP5=S*C+1kN8#CoY@rlrETc7IEpr1+=hVv(ONwmt}rY_AMn+^odCu`% zqYvPvPtUk$rdju}z1JxZ~+);L5(t@mXF?8Va?+kdox+#79Z|HpJjAKLK$C9n$y!AbRe;qvs|-vD2k0vx%RWm=GC1I120l z&>`93uV25O^7c@+YDZ#)1PseZR)mu#Zs(gmZ<2kjdq&&WjoxxH?=>hTr{oJ{Hhx_< z1RRMMEX7cF;FE(Tcn5oS>K0d0j+W6yf>MS-`YXM1w+hCr-YlG?i>S3-iD5z1k<0sEv5_aD(}oT5j94B}z3>wr{3SvFhe| zQ&z=VBkBfuq`C~&Hm+g6?A}hh#?D+9%$f;3C;8!CHZ{Ou5d*Erc#%4sJgq4;+gti} z)vGB@3d^7eExRhzy>APGsq_*5S@p^=-Es^9+LpUaQyL}v?LQsN(j3X$#p+uyQKT4M zGH9ZXV>Ui{#ZKot(*|(I+K=}iGx)`C))-c4O$QsDZ=WuZWQH*vn$M4f>J@lJxlGF> zQak+SJ*It4+qf|UT_!X`wC&xjSUTlA-~FsKN10MFPL1;Q%(u86P;N)SpVnFCU!E*r zlwf>4<(2E)eubQrx3v(a&Xe!LS*Q4-4xJFkAvK6z`yq{0(g=`c7Y1I*OPqZaqM97W zyZC7cBw>~FP5uN_AxM2x1Qrqd>?|92h8dE@gg@l7!fqlDy>Tg$HLx7xa@lRpG-_Hv zn1@daj*3peFLS^eH*k=ccU3a7Q-}c4aUDb_Dd94ewsXR7TJKKqN*P)%2z5pJVgxaO z2KRbBi_@*dLkL+CK82AdGpAtsmrX=PXIB*~LaZNxlhSTqtZ;B^D3+99+PYdgxxIp&? z1X`Uog78-ryD!g76YD&v#m z%nJxY14u*ZP^`_ZRnkuV>XxcKP3fuHP8=RS3I#&rD0(lY>O_V4Lop?(GL9wRBS*ai z{^`mWixz+~PF(DoRr4ruYg%!6(F2{)A0P2bJ)p5pYEyH2d;>R}Wz^R*7}myAA-6Vt zY+GwwA^qp7M#Tq>=tjOfczyFPXbH^MPx2+0Xs*m!z_mq~O1~V)?2c3?rxrfoIj@y|en&?e^*mX71vK=xJT7!-hqT*}MY82lCNH9hMXPNjpf~IN;cb%VEsr>}fz1SMj z2~+{NG~-n%*268weByhJ&-Q_+$24;M#~GVDQ)!6it#6{IUA!P)#2tKr)RU&5)$VzB z&z~-^A8;Uq?F*wJO*!5E=WC9~SabAGzc_^OqmsAl@15**hMlQgBrP6Vhwh+9m7x1F zv~O3kvb4$n5)Mpct;=o$FzOq0w4X_29%^ga8&Cbz`GSD-SIsVg>EixVhG&Q^ zy6LyD`~#)@HL-_460z8Rlo*q!&SJAy@up!+0za>(HGU|RNij+_+;&Bu;vK7X8ka3# zv!cJY<>CXKdz69_m*VrSu+@f?Qva=Qk7*q8i_O9av4yB-Gy~0U<8i4Vm#c7^kG@w_ zI%QC`&tlq$&KPrdJSEn)(cXxz9FtftU~{7vD9Uk=kJ9qfO+27tS1NF8;x8$c{fS_% z^7R?F?{i}3FdX@Ei z(A{eVqj!6U0T&xDR&Ua~pKH^4Wxm-oUG2p*?Ik-r0CN2X>@85di)N_W*Uql1zkB~C?+2cdzlevEnR1``#-*KeB=PRM_dQTWG9;I0HHFZGq$I8CTRgQ~=O`~ntweuKbmHIcMzQDe zD`S?kpF8)w=gmJ)~CsqFS(}6cPjCAOBc|DSlho4zt&8Y)?2$OdB>J21cWY6ZZX}rE_{8^ zIu8{{z>U;2<|tOw+^1Zt1|R z^p>2*kXoF5+rD*|{}M(@hwkgJnAqC4?-J0%`78jIYX$s|zzhqlIRwS;f=6xhs!$ua0OwI%9y!(Yu8qrKzn>ur!H?(iA9dhMd?emAowAM8rl5 z%?lmvDQ3#DXp4UcZIFD`iOf$?clLXtTEENRE4$9GXZ=u++5NuUvh{U^NhMQyE01_N z3;*trug%t#*n@5@D*8}opcvlJ+wXh+JRmSo?RkSj1kZ_djtp&$D&Awx>;eM>t~~z< zz#?ZHUQSQ;&Rc_4F61e0uv!7LJdI7)k<__r`|fVfx2Uz$?Cmvb2dA6pburF_Ha{mZ z<hU!fc1Ucz)2%2k&+H5wVh-}X$~Q1e*r9wS_%_Z23f zBZvSf2}#vNT^Hdz?|xs?=e#WtjV~vm6NH5DgHc!tKD0Q^xoB%M7e4@huNrn+73Kt@EUN%!+ zgPg0bUl)=dT+4t;E3)Yoy8xL}9z~w3b0JN002H|vt!NBbP#|3NNB-?n`?pG8FrY6K z8E;YnZbzRha({cH_hSv9Y0Y$v_KXPCa3XcL>}lN!4Y%5GfpkX#+7d9AX!qb2i}~Jp zOYJkGS5PQ7WAa&Y6w@nPT^ruGrCqqeIlbrH>D`LNki+=iNQKRWFbYewd$rUgAt52m z=(2|UtSNc+CEnj-uCk0q#~JJMmwarXyvDqr2$r0&7wyteVcbo}#u*jMC-(z!K_Kcb z#DEy-XIHnU=R0>6NFD9~M7BS0sNkfjSa};!>}2l1Yl2+i`=mU#Y}**7z~(?rmCLnN z#e_^;ZNOFeM%x^zcQ0BPe`kDdEHGIxz7k(REJmudjY}Uwt9C@}2_jZ`a zSVC9fB0@w(ZMKX|5?eFf zA8?r=linUF;TQLh7P_fs9od$Auku35b{@n3zk1!E*duPiOs&5pjR-f3pyB-Ji>_Iw zf?-a0P7JT1@O6o$J?REP9rM|nh9^Dz7Yv-X-3>0bJb5#6^F^o<_!6&X#@d$i{KK*@ zKI_mM0?P)}Y9Eh;D82~ND_{=_$|`uJt}}n$OkXHt+bp?z2m5!Q1b>@AbW{IDW=I`){nZtZ1sx9_G63uO*f8jfJz*3oEuYY z1Cd<@P@?zS%T=wRx5@k zoA3Sogo_-VTM)xr8)RA_@)}rCr`&tkbN&elaV};NL5>9-Nn$;%^859M+9^#t$|O`& zv>9t7Qcn4~EyWCoy^1~KIq(|IaNJ0s6MP?|jg$JHdv}k&miztT|F6_7R5mI#_{-o% zfMN}#Ss5oaJ4tQ@F?NwIMEPpWuWU?qhD3?J2dE_R4J=0!C$hP!XYVp!3tc@Jvyiwj z`9iUzH;zAUQ7oN{&VN%9znZ+cI4stx>`~1T9JWJ;pNNH|;=s(s?iR3)RS9&A`p{KIk*|O8-b%C3*vrXsRJTq?90zdM|m zN$`7wdIiWMC&$u3hy+sUsHrk=u5>^qOb0|;I`e(tAR*&Q*zmkMz?*w59Hg+FGUF~aJPnQxDT_%gj073YsS7j3=i7N2Fl)0)? zVI0W3Dpso0d*xs?6-v!|Q}UwQuWUq*pWw68s)kZ$A**{$0LA7ca zBtmD8p`ev=u|?k?w`WYgkY?{wzF$%F%>0qv^d>yiZYTIT^u;>srt;ffMK6Y^SAf1Y z!CI2m{KM5)A!DpSJ30YdZ-=e&cJHIO; z(3-&j^gKBT|D2_H*@LVMM-Jm;wHFRIS8iva-(PZ^(d3>f&vjL|YZBypSn}bmyL~lB z@t+fq_B-Se`&5q!FKcq@qzSURz3up6kUmGh+U>}$ESA(}S&gx81m6qoMY@68LxQC) z%tNPlB+H54^M`ue`g^PZGA_b)8L>Wlp&LEHP0G+RA|zin*o9(mqf`e~Ye~ElCRcB@ zp+$S&?b=^)#r9Plu`msAJ)&lO$Pq&#@oF?5`QIx~nVuLbofNNT^4Hh48t z0zq+<<2M9nKqo9cgKSX-mcJ|~cp_eM9>otDsgxULmpN1H{rKe!rw?tB@i&i2jw?lM zSQIAdsziA1Q=DfR;A+|WETfI(!(ACX^(Om+AUv#5I7fBgk+CS51VnGCqW)-5$&Ot7f$f_54|t51P* zpE7Z+27j3Yzj{aEsS8(&3CBpJ>TgxTd9=;m)ydlK`{mnyCS|pLb|As%f?cK%!ldMG z-mKVHCMYdEV7TTf%_#0zx%s)awruv@^XJd^?d~k_|2IwFw~xu^_DL`7T#Qlbp(x8j zV=~A5l<9-2to=#W1X;;q*{C7-1NQHGcF;F+mw)Yu+t1Z8SUi#Q1y5BA=xJFw~vOOWm@k12x zN0s9I$`L%_=%!|LBf?IGIuuDh;g=&2-WC?(c0ZmACTxm;&aB~+tDJhj_nGa?b;e-& zi2v4id|W0WH&?No)llc;HMoi+lGuU7Odp9+9_;TD;*=^rqCG4%?aDjNnAKvRjBjH# z3=tMe7ezmQeMB1pGGgThFLm{;3wuSE)xH*=(op+rq-dxrw=>C_>74=A!pkV*+bhoC zKHdB*nKYN*x5;B}8oBHE#vqNh60^4ppQ?!S+4#2BFvg&Hy9!hY^?%ndc}|8qd;2`u zrJfESJf2q=y38vY;y!SCvD8pc_!IKZd|(}j5>Yj-EFAIJ)+)~En3>wv&?>eFqG}KV zX$-Otp-{9na)aoant105_w$tMw|DVrSB7ts1G|vI-J+UDbSmDxdb5`xGY~RB5vX#j zTv%t;m@3}5f6@0EB=GsvJ2Cbpz*venrWLMu@SGNq(L0d%&uJRYf4?QK2a~MX;UzgulkQFzDYQSQ@gU(Z zm$RiEGoQZD)}_(6g?Bsh6JI;Hmg-0%ERC;dYIRzNCGhW6lfAg>(4TLTUAg5h+w;qn zIIY5jW^Fawmu&wmF#IGgYESj){;gaYZ8LupO@K?aV}55W)a4QNrQrG^mu4GYGE#FV z9tUgJ&WHU9-1M%NxsLn%iylu1FFvMgxuv($Y+=_Ou`>$T84Kb}(Ufccs>=wg^6-@*p4$+Xjn13Z{Rb5tM zloOOQ`*{>!Fc4{b=gh$en2bTuMbC9HrJ5?fssU~H)RKkq3XlRJwD9Vq|Bc#k#4ohH zRAM&g>US8C(^xOSWN`POb;Ee+POWNaBf4@(v9N7!|S0K z$_XS8Y7X^3hg7%BhtdU)h?x1SL{`xrwdI4gszoWp=Z6)lW+HSpMpV_YqVz`(akiLr zF?o{{8oMGT-b@~@)3%C4u1x8_Jv*NDy!O&l$yc^ffuXP&1_*pQBKO-gxhE!mBH_@~ z9C#XDhIF=}r3VLsh=PJEsqTib+LdhD=3Zt{tDXJF_j>uEx>~EBIaM?H&d%YMy1cUj ze^s%~nEsM)QQX772Jq{9DnH+6d#{=D%6Y+T3p;saJFT>ggWwhWN-!A*LZU|%1Rd&) z52f-_it76q9B*j+Lqyz2?ZXi0nck!PukdytOUG>W*Hx5)iE`F1UvvDbncw~o{T70?W2k* z?N3hm?5r+dV~ZcU#O4xe@uL|fI?pxZ8@tX?J-)Wndv9U44`DwrL8bJh8y0DS%G&DX z?T*A)nSZ*>6SXoty^C068R>nmXAJc=oS0vjO|d~QD2kpB*L=}K>YET}rYZ3n^tS1# zYNHvmmcIVapEoPZj{y1_KRyY$|F@ zwf2c4I&LV6;3IqSAJ?xWFHLBVslDPgj7RHMd-xK+W_IgQ)?YhM$`IWW)~RhmzkL~h z-YeL`%;R-Q_W#|!`5u79;Y$LSMc6*+gp=C2Ne$1QePvd@@#th%+VEI!wQEfZzfrBm z?wudwKIC1h+cVM@Fv5aMAJ&TxP2k@Z5D69E3r)O}bfm5RnMDuz43hMsXGNDndwitP z4EN?>I&q4g_|^+~#jxOo8~@M1QdSs-r5W7Cta9T~tX)(5?ae&TY!B(3UqS`Eqq&3j zsg8B7FqeE@ZYMj#qpMAEFA|xuz*@yGw8gOK z<>cjeTUMKW9((cZnSGn&`@a>8?-_&T>0wjcp!1s2&LZYbd=S9PQzX$MGu_MEa%vR9 zoy_h*MrY0|Z}*QfqLkA(7E11UT_GobLDUEf$IwuCaIhm)5h#)9(#)Q;jL)z3%{SgS z+JwkFP$=$K=eAUPL}bWI-=dUk_KsS-K)rrV(I}b3TX{$1#0%ic^msKdFXm$|8?I3- zp+>RGiR#=?2|%+SX2?kU0)D(AXR<~FA4UVzs=8p_aoUIhO!g~qbcXEdV4DGrzU`B? z%bqLm##-Ytp#$dOD0zSx6{1L29b#S;MpMpFu5yW_SV^WfBqw zx(rW`0=R1@fHygf5!Y`lw*T&T9mIZqMnCi34xp=t>ouT>IY4cXD2);4k?V!yJ3um$c2m(afG>CLKkJUVnU93S{5{bLK}7K(hZ1 z%u#S=(g7ZKa^*D}-3S5a130AN)28rxKbHfSA$9=7;!h)JP~GY4Vk6X)YAPCx7Ek)( zi7o7`Id))ttK43ni7Uabem}Xs9uJn8lL^1>1T?neCxli>j)@ICztqDJpXH;YD)xKT z5H&Ic=`%1hX9DSmfjD{Rm#Q!kDkz{S3+VWp2oYal%h6?hwiha9Aui4A?;Jsl9 zbpsNgV-x{sOe%Ag6J&@Op@B4d{j@22=>oH*o<{-``^lwG9MlIi1}p$FcU95 z{o6l4)00)A5waE@n=JGKm(l@9qj*w_gwy~~{?XpvfYpjP41W%JNy=m@FIj@gONPI) z!McOUCpwC4^rO^AftKk4F+nCk4TzbvWyxZfud(K`O*qM`H_CbNL@u1I+_xIL!hixVC@k)hv?J?a6NO+~& zy$Mu#il(X*Dd=kf$`Isbq;!L;{uPBJI5i4k6Gt42$gx3souAVhyR+Mh&9(U1wODH7 z03k+h4LgI<^8FJxU>?$hZ5t>VmFRdSBzkb(%~{BRDU+KX10!F;NH7D+)d%M0;1Ktm zb)| zRo4$C&3Yh5QHnFh4S*Uf-ukm4FyaQeXu%7&UjwXlW8B3mR|l6_vGA&QX{Kv1Q|x|c zlJ)9?+|Tt zbsK$V=wweb8TQCDPWxRX@^346vAxO=Rh1fCA`ru$5}0}v5)RCD`4@)fp#th?OA#TQ zGpBNlh&se3X-L`bRY3-8Wzt(<&$gpwjvPA1yK>VFBiN`$Q&B~YwyXZw><1ccEyPH= zP(N4HUQR?1ZmXUuj;9 zxZMneCh&ytxvy5ld6>vh(FEANoZLg2uGYy;BkGs7*}&#eWDP1CZ`@4RAM0$yRb46x+z+JoGL;?K?GjiBo>VW;KICYQfQ)L0Z5^0ZO`54&;10ZAZ4RtfAAz;0 zTPs5=eV4~nG~xioZK}x~4cGFt~TW zGs+gw=$ZUm(L&hPp9KHFprDq;B}B}N_~O7BH0*BBGjak`F3lRlw;=}w{3i!~BfY^TP z0s%4_8sH)G*oL8DH!&qG_eu-0-) zR_XjR7jRrnLNICEa#tO%o_glvOhnG9T?`Ly=oV8 z*2Pxi@x26IZc5)v?L2f4U)6!$!;XH_slJ)cNgb3Mvpi7@6l zbdGfYXYR4C8Ec*t_jr*|8(O!jO;hJSM%eR|4(5Y$O=P?qRIue_xsPUGodq+02q>*a zHPrR0d=W`j*g0h)a6dRW5-O60VE&6cJ2x%zq#9VEW}?GCJTMk<;Wj|*4ddOvV|6v( z$a0}JbeC;9YBdbh>K_XmMP!H=|3)cfn_|*GT_)C=5Msv_q5tC*za=#o`Iz{5Td}Pq zTw3yu-ae%$ujCQ zWQkjrUh;W&_)tP`HK^0a6>@u-RCii$;2LaSN+zJ{N31N)c05`HUFo zXe3as5CTxqgedz!V2WN`LBQ}`~^yutM4;_Tp{pRuxS`rQ-f*bQimo z^}9y;dbCCLIY1ayOH`{0J(0N-2TxHd@5~=NhV{@ot;%`{0 z+1?cFHracK1$1drBRL6>gPm?ky#bP~lQ4R5tnIL>NEOT^m_g3Yhw838{tqKlh$0~Q z;+x$;5^70EWHo@sWzAe{32o!M?2vSsqCRBURwHV6!Ou^y9IQYzg2=myVA`E)4e3z@ z_zep|{fbP7QEi8!rsjBxstf;wTYKpVBcLgS)F{X9XbI>I*Q z{9NFLBu0~P^YM1+T-ohrpm7bWit67+giG(=(EQ4BaYbZf)8cd=k*XRbj)yu}_WBwl zZ>BS7F2x)yeRaNtDrsSX`}C2^bQqKckKt4u`Z=^`0@$|bFg z?wHZwYq{_D4y`RsXF}a)h=f}(dzpu&LWsi}m~RYb>$2Xx?;}JR#Zb0>e0s{o{F{-* zw_rJ+x&%6ku0?!dj2#avu0tIv_}o4!R^$rd9+#pbkq}?_ye6bue!;Fa83}a0H|G^x?YfRp6TP^zkQh*HU{}5h4WSZf2Pyx=jz0 zSbc>%>E?iuaH(R3!X@Jsr&0!@CoNLYt73#UY?>JQfTq+Rd`AsZ;!=?2SMEAHbBLur zh&dHzh+2Y2Q{cN!jknk0RCjw77o;=6M_~pkxBYm(=BbOXSxvf4ku7_dGw8yB{xC`j zu26yLT}V@gu%aI%Gg)mp$f(5cv631w)45N{9hYB~+o9%E(&vbwOlzsrP2dVwbdnBR z%2JXZth>C09p1(>Zf+(I$1Fsm83ID~4Bc4adoI17K{8QfvXij#ZQoJBQFBOGaT;Az zfA=SV=y%RRCtk%~X!n2j|C8`SOZJqKY=fwq<)c6r`T5Fkx z(9bupqauJo$(axy_(Z2^8Cxo{w*KDxGoxfkoc3O5*!H`?;Jvi}1`f&f|G16qsQqFk z824KOH;5XMX|nx_kMfaNc~ki7JnUi9rvTz9QCwT(+}2v=_F>PN#w_iEMv2|b$F0_C3{d{Bk>DopO!*xR^Ndbn~HPBI@601eBVV4TjIlRe$aq=XL3jB=nd?CW?LD zT1&rOdW-yC1^XdtE0|`|0>nh}UpD6|eKNY_C?Z^Z8}u4OA+aOxavL`%wGSp1YU=w)PTMkP_$2)uciKWRRV^NwJqx8;zCy}^&IWL zP-Y_c+KdZ!av0y+pA)6G)YisGCA-pbpC@kN*%F&qSdxyaZkbO_WTdAcCyPo9*Osq{ zPq6S-3cRRBF@5|Dnr9K87*q7E74eKl*rGdLvoWhS|;hr8m&A)Oj zM)+FK1<6%Uk50w*ghkbZ!HX{gtejH*0CI8$-*?%AERG1Wxg4aug`CKC01=MoL?Kh5 z;S++nNVwsMb0YV@8{J|Gd5&#gX9CQ~CAId0S94SO+jfSb5K@{@jT-I9$i- zaD|7LUI(M{V69oWEe*0mkdeEuXa?OECfw^D z(|UW3+a8VOgR&R33WA*HeiE}^;OFJntUk!4Ogy_QDm3nW4nf_@Ks2F<9nS#KM1T`Y zKw8>JuxjCznB71Y%*)w3vkikPMIi`a5n_ax44p$OW}(7&{Tp6@YM_=*@EPeX=2To} z_3-aVI`!g|>~FJVpJ~@$Z&VQ)BJ~PC$uhyc+RzG*RaF$kg-Bm&k#V1~xArbPUV9N$ z;<@T*^Zngb7`u!hJ=Dtp1?T~yLqbmP3$1=mU})`xU{t5%mOnQUrI8d&FQX8?WOJN6rQvn37CX6~npQ@CUsaw$m zK{mNohPVMDGo++?ojs)zf9zenO=u1grYgW0nGa@GK$wc#2aNFxlcJ$-P%VZ?0o) zoh9Kq!%~_HGOig%&_ZL}cFr^S4Fo^gc>}U%^t~cEQKn}z@EsJ9?LxauSfwH!j|veK zE=#Phqn?nisu1L^!1{D;vN3|MNl3nx+8$V4`zRz*eR0V8b1yPa!wX_n>6%MmLZK@r zRVD7fi{b0?s?hFPvLkxc4{#Sq5kZAsWOhDg2>UU{mkcezEz zOV`L!a>seB9q{aKG=~RODO8>?8QC4AyK${D+n!ODFw-nS3+C_ko5UmLH`wg;%|}Q7 z@=~U?Q!fc_30(cfN8fWvzZcr=`{tdjUR>~2`fM_>=IBQ9aHMi1LRhm7oZs9G^~oUK zpggEX=zn9WNSS;cY5^dvkyTj10)t55d8I%E6$K78_0K+`{easc=OHIL{3|E{Z-3r- zUMN}H@0Dt6Tfz8VvkU-TP#^g-!aLRuU?;fAoj&+5wup?U$2|*8$`*bm6X|RSFZZIM zp?A2N{!o3&6ubM)Wyo$v1e-{YCO|`==?;c5Gw**QRST^5TsUsiVSLLETfslS=6l_P zpsuq#eV3Sje1$Pt0L3mIk;}>In(RDvkocqqjv&Us&_gqaV!m+kZ-0}C$lxxLY66ex zz&CsvpLsruuW+0M&QX&aK^R_NG;!!z0!PA&%q1$-jT*RsptpVKYwgg+FYRYW7-b9IQSse6;4uF;F&b zJOt@wprlR z`1lsT-s-NOaXV_14n@N+XSUh8MGj9z7?=W?P~fI=>BldZDy_{MLYq$lcB?J4v8%bQ zlcR*%9+_lBf0KoNE)Qx<%lcr}8F$DRhWywRh`{9$5NPd(aj{s$1`0I`t*+#s)#^KJ zxNHMB$dZ}jayR!2bFNW1&rm0x3;aAaYTiDBLtN_a4w5?HQlC77C2nqsL@f2%LXDAd zMlQni1XIyTdqiIiKck^6CX@qRbp{M}0lN`3;_gPOAhS`xb7AWdWO`OH-zvEXt^fFR z>fd)IAgM+=gfS3YU5T+BFOa*Lrj^A7JaG9BJ97SWjZ`|qtI@EwpGqNsA_tYLogDa> z;PT+7fzQnY3_->anj4;Q!62iu8Bb|CQ5QBjp1e8>s})rMwE zF$h0EGkcLVpE*ifPg|-6j$GnXZyK?1C_iDmI_v%);u37;ez^l?$J0dG5N6M!WQCH!r;Y=^e5Z zx73bJ7i`M`pX}1dca$9R6z9*@DJfOYtD0phPPZ++49p}&E^55K`94B$woOjLW64_l zBR@ZaA6I0ly}hQ=`w8;GJ>|qqJh0HoJVs3+?{2Uh?8_h z57CRkhk=QC9DQ^~vD_w^Wlz=3esL7HExHz|bObh4${m6`=55oB{ozK%a0S(9o*cNg zwy_HwZak-_A8K*m<>7{T!r71(uY!m^jUN1<0UAUFN#6swAQ3w3N$4QHB1c0dY%3%{ zY~uB&|CS>Gwg|(zo8+XF5qEex9v?v9%dUx7WAIf%?46ViDaF(sXyYKuU3fa_*Q`ypU*y%&w zouxBIwHkn+8g`6lh@%fN+e^AksYMH!!DL-0M7fWQJzLTL_kQ9E2ErJ2|&$`iqVM-|KaLE|Y*VUP zw`PNBv0o)Syr@y8hNk<{6$Q6Vw*|%WdnmQpvEIK9y975uXJQxbl5?v(x1LoaY+z@VtE)jX(!sff?bS#(SlqBx&kG$z^+EE$ z0-&fA80p*r6i$1bE9|T%h0SmM_iZ*l)#o?oal~nmyB$qi--DtpusraZ_bXK?5}JeL zLsl3;=8dRr-|cVTzMUSo0TF(y{tli5i&UH0T8j0LdEuQ zs23XAROInP;zt=t?9T&Fd`G~Kx6|MM?R%%! z`j|UZpRh0nI7OvT%jiQ9`|+&Or>>-=jo;cF{;1H8i$LNs@r+E7ctYzW>F(0Fye6CoPa@AA>k&{7B94jC~C zcUK7+r7=8Q85hx9aJQG^<&`Ahw=!U#LzKgi2#W{vra5I5EcQfjM{1>OaEfAyp9v$d zQTgRmuUTdrlnF5>{PX9E<>GNeY#vpGRyd*;S0BIVOf-joALS9sy*HZVxRS=>l0&Q9zYLD140X|Lv3AmI#%!%Il$bCO$ z2O9@uadc=>9Bv{72#Vnm$^b%L=zPs|VEII7!q~K2x@tHbRiT=6N+vZ=d`sTR#~fk? zR15+wE8%YlallP1fDw9utnt)C?HoYpM_mVUh4K;xOew3C#j-dk?tXBxP>P5hjjO51EGOLpPu3PbhIm0 z#;3ZXklx}gpl({wgOU)31b-$s!IhuDF?eNU*}T zf@;4SOE2-%A08eJ9LVeP3rJjnXCh zVk~fjGpgmRno1H#2?awDFl-scFm3<>OE~}WEbxV4tyLX4hLRBihI;39vcAHogJhUN zbg@3@MNkkf3Mxk>r+6^BU%6cN4m<$w7a{VYm1Yo7sT?G>hTcc#ko(!-^0|Y=obEZql7{Sk>p|nA_ zw_bD=T+EJt`D2(sDtsRs)PPKY#sLq#=g_Y#wto0$xiD-&-QtbI6G`so=85VB`FgW) zUy<{U>;G4ziwB)tkX2v`_WqA^dMTMB zHELAi>u1fDcApT+H`JEVdjFy76U_8WKo6zEj9Lj0V!%y`NUj6-$p=H2s4e^{6gyDq z=0F^V6A6gaK*Ea+pa=|D5%8A+PQ(UMF>()O@9jSaPw5(D;RQh?LoyJhrjxj-OV$Xe z2~R*s)CZQB;nNnicHpyPv&B%dDVtm6g(DUC-XITk=<6r#sIBg%r5P zaZ!Fm2?6s6)@9643vufXWCoTIRZz6CxB|T5VLTKA!3S&1PE(`Q0!_&YgS(9Coyc(su}BID}N5G17DH?<`ERuGU_HMkyVnQFC`*}QGbQ&xTOab!*aP@7vv_L z>+gb+{l{;l3PGtI-(?R3l{Q$o5D9Y>Y-?Ma>0^22b}*IfVTJVF_r5G$``=NYo&Rp~ zk_<&J2~2atmRXpuEtY%3LD&Q9)hA=z$f5Sw3~CZWIu5$An|~0poAY}fDM73d)LOem zw}Od9sQ%^E`j@9><$qx8-+`w+C(@TNeg(qx92el^h0m5rVZ}_jQfiz_3^XB0eEhF~ zy1x&j2WKv|)bWdvMGz{pMBYA-Fk?u(R+{8U40!TI@A8U!;Q)MN6><8oswFLZoheAk2(^0xFP9uj=!>tYzbnez_T@W)8$+7EV zhAnKItNptf9IdZk)-?VJ1n=rqxeZszJOkzF$@w>)5G{D=?mAWPVTjXr*f1F!I-w6iEa(^vL1>OHRvgDd+)lii^9wuWM<2V zQ;e7m#WEifG9*bRItvxRmy@eg3DpNip_SEzRDeY|r|-iXpTmWmW~3S)pM$ItBHFyS zkY^;@SvA*q9=;+50%nr=2=Rr!y$~24Mp^kPPmFso{2a+|nH<5gqSqHE>ocfAOz8Kz zrcb$c@ebFN+f_ePn4aCv@HETJccwyd*PZcXOlmUM`YQhlGcBw{zMXRG1k-^6+2|m) z>q~A@d|lc4QRiQLn~cNc8P^)Pc`;c3-;)q!FuV$rY8a3@iFm{c+^IHzW~pl**P9UD z*Ttq^j_9&|KveimM>x^=-g%MlzyxL>G&54IoX4qYbsimbeRps)47h+1H-NNW%}D;H zN?*6BwM^b&34jTx{VkJaw5OgL!$vg@T7C!YIh&oU2oIycm~SMl=PV%yg6>uXoIMK7J(>AnKcD5U72^jDN1F(iXrZaluXMJ2NQB9Re=dc;FRV7d!h%vfX%1?V1TyK)<_>aWmi>yvU<8d#Ch=fVf13fJCIDv&g>ovBt0m&8>{^HQbXq^>4^DX z6iZ?g&fqGfW%L2M+#lMoVf*)XswHM^DX;y`!}lJWRI;c(E$7IKJVmJYV1m~s90s72 ziigKR0I(cUcIrSZ(IJ*giD_xvP?t(n{Chh_O!`YcDJN%P>^&Gl$iJp%e8<;_(J*LSNx0`CyZ*ovK61@!c_zp!EJUF zM}f-M83wYKfsspUF+Al~bP~W0DKWXQqs%x$bAYj<|8pNgx^ypY? z`nbFa^k&>bLP9Ml10ZkvN5R$W^cBu;r`Yz}3InnR{neAQLj`Heq4xe9ETBe-H!G6-)Hr@UlAbHv#`XqJY!_p?2nQjP;Z` zr6M!j9Cssy(u9B{juKwbx$|%5K7*zbAqwEUP=%1QLa4MFUhP#|$lk!Lk)MMp%n0;# zAj0XTw};|N9S+BSs%{u5k_L(;t$9xvYY`)YeTB^Bfem1+@-g!F__D0S+l7M&qlrM_ z)~}G$vjAh{cC&fF_!9`?;XwM^>rW1-Lx+rmIGBd<`MeP-2E+AYg*&^uyk0~;@nnxk ze>2DrPrBA-_Zv5e7eRUh3QQmU2BKQ>q2^{F@0|zS#<9(>FV3(}123rtyVhS;?H`^0 zW4eo6EkqRK;E(01m<7h(vEByWC0DAl&)}rs(UgbiIOlq2m>!WNIZ*NA3G-ZbKPtrP z$kDCL|Dv>w-@=1<*DyzK2DOwZnDe0|=%DGh7D6N9?aLAg`MIsM5rhyhx0IxbmI= zy->mK{(w>ygGWCvE>Qd{D+l0DkFq{;!P8`~P1Vndy65Gt0V0kUg2?QC*OZznQ%KDV&G}?I;n`ayC-Nvqp@DLUH}b zaequ8`-T_8qkvx@1^!PG>jDLSHX*yK`O!G?8+2na9b+fW&9Z9C(^*Sv9%e5&u_vaA z0oIKYne$u!n=>Tg6)&8%CK&2S{;;sFpTwwKY+cx({c@@dEeJUak(Vo!OwuhsW0fwf zFE!|(q93aG=(QC?54(SnGFa5ARu@(L1tQ^`PYKVdp&_#jZ(rtKB)PRl(?jR2c^Xy~ zyAPfF?>3RR4Tk&F=LVAF+d}U8YrtcJ54BUQJ5<;#4QKdc09fFMT)Tgfyj&nCkr>d8 zALHABfaT7DLCGITjBUbeQWl~wNFn91*>-2 z##E^xns z5a0-w$nTDl8hgWRLUF+9`iJ5)kNV%nW2ly$t&`Ted8`y6=NDQ$)=*Y?cjO2QX&#>$ zK9@Wau+$f>F~{Bi(L)rh{kry?i({ujfjvR%d3l};aT3aL?Al%&N~&P_bs_)5LSl8{ z{gAuG!_3AT8!7%>iL#ujb5aAYgQD?5C;Mmx*S>&+M`bJ4Zpp2ZI^UP;fixd`D0WAR z@dO$Aj7ofp3R0j=x@d%(2DUw|{~37#n-cfyehkJakxkd*x@7hGRS$5=no&%6`=u{; zB68ZLei(Me2D1Q>$G@Sq^Y8zEW4x~?1duOGLu^joIsRwf!?jX` zUWc7bOqK;Y;4J7@tNF(_yPL81`Mm1!WEqx`4{)DU58Npow&us zwI5w|yA4f6WnRT7xHZ{uHiK9hLX6yUcN+1!{=O|J-R^awD(pmEsB-o*ItoM4NE?gx zP!o)*K8K$)@GTX05dv;qGXH|@y2b|$&aTU z9;+wHbAV!4qhlSJ!)2`95ysXzL5VAE%RD~E0cBF=!FbwLzIk~!d9$00SdFFAjXc-N z~A2j?CK<3_~iPy10BkXgmj~^8(r-w;~8hl1Hl6jJi{_;<(<-qq6J@b?M^M zRLPd^A>^|BKE0p!cwg^CR(L`L-|>h4s!9d1Ov`u{SJcvkH9ZGczYt3?HBeMXw4}&| z9h6NT4KaawzXM$gY7FW>g!M0NiOtD}cLL)=Hfai=WK4KfNruSe`-ew2kYVX-SJVl6 z%p|hhzUL37>42PLVPQ%5_U$Z*<}>g~C9}EuTlb%SbJH&S59id9Wp{i3V&0#y&4;uP zf0Dsxd33_jfv%Dg)O>+M#kgZz)PK)+{U-OW)qt3A!BB=BL!0&-7${O{=LI-+^8T^P z_XNmpjTgQ;SR4{aY81;XVN^zD404niJgWkrt2S{-F`a`ni4vND86}?q`y+fk%U6nNn(8qjcEpt#wtU-V%1_k(EnLE=jr|c4bK4D zM=Hff$|cjSszA>l1x=B>eUv28?h(?|f<`&!RGYXN6i@&3&WxAPwTF`jdrHCcMG1}r1^is zLYT=n==8UcYrFYd_Pkk$wt0mOlH^P z!X3YYvzrKDzd!P06Fn-??sQe!DQj7N`)Rt8!c&|>4v4>+8g7%=yK1R^i9$BZ_vdBX z8_)@W*V~QaSeF!lC|JMR7{`L05>i@8VW_QFhH-j#M_Q}y7J1SVX{jA8g@UDF+p`F? z;dxb`K7Fz)3Y8eQN238Zho6_KW3aKLF`<~o0lw>cd3i;?l=l=65vf-nFvxK*x&G)Y zD4@sf!ENdHu3!$Q*YgoyG9m;rSPc2RrYU)>B;oB{0|A{|>aNumWe1?vi3KY97_@1D z{5Hy_Px+3=6QCMbNpPO=0{bX`nT>9<3IQ>uWYUY z9=|*_1gH!Y`_w6Aw-TKxrSx~E+m7zzx+crYG(C9a>36xryJ;=w{X9AC)fT|ffA8xWbR4(Y zs0}W@t)j!2iDp3exP3A)6}eFf4#xQY5>OxaS$SbTxic1BpZ;%*vxs`0sK&T%UF~y? zws_f|+d=Cxczt|)7!vR60;m@$>LzK$dC04(oXjNesC1)7wB#;P%j&%|f^&NxW&c}> zy(WzJS9D~D&2p-C+n8_pXhhfVzyDEJTv3vssd`=;QCn|Um2&a$Q~`Ih|Gq35nfdSS zvsbi7OPyEgkQ{EAhF_tA%zuoCI((m4PPz8&JI<{cBVgt|71E;Nd#%4INppt*2tP7R zD6uqGaBX$(=KWbsPCAq31eMU*C}8wL4Y$W>ZFNH(H4yfVldfAOo#HNf7Py?=L>DqecR1O=NA?ihnvU*FjY*(Rqp5l=D;*s^3UrPI8xQD*3|D4R$!3#mf_;(s~eF%zxga?BTbDaDbCRK#l8`*Me`i zj`@U9n2$i;$clih@|tOgk{a}ndXe||fIXM{D&3rqU!~@Z$rmYay-mtl!4#yFXz;(C z_gGxIPOwK>D~xi62^esoXA40FUR3X)Lx&O*-IULI{{Xlab;d9=YLmi_FO6z@pr5ZY zYyuTAF~6QoB)+j^J=Hm*M=Idz)6D)h6VCc`0!ce46y0h{H0yW0RHK|wIBMl9eOKg+ z6wf<|ZVKycXE8@~mgTd}MT|6oUQYtoaywCf!lCm2b&^S0S()4367%c>dN<(1O0(@d z{V!wViB!Xn%R95K=UGa9n2Z7lo8%+WUHL+oY4+>=q1hjn99OvsX-CNoVY<+gF}=$6 zeca_otz?N%o^hrwCd$55kq%CniJH1xIrgJInuqX9n5 z@jiRSaqfI}e;05s`*-=qBnOX)nOWzFE5+&Ar>h)YR=-lWbkcEf5}6BS&qYcaZil`; zwqoW%K-V!CS8wd^GN5*;V5era`iE9oWztDyJVr!e~kLhM+!097TlxV23 zksRXs6a&$Qs~Vm!>71Z>yxO_p*4f@_JzzqTa+J**H~tf|vypu+QWH-VKgS>~OHux( zCHLGJcL+*-+dDnd2~`{!7bWN&=Q8xEdW$wj7Y1ELh)QFq3_nvgw`cL<*?@ItBp;B) z)Jz37VED!Zr73spFTgl_-gA=yKYsl1%4vSs3iaZ%lSVW+Dx?~`IyZ(9gtGAKg?GBV zO*QcWJ=IrGjIPTPvjZ%pb2iCG*qQN;mj&Z1=;OHBNh@j}v(rg>AJ$sts7HngJ!o4G zcoC8Wow+5LYfmb&;VYqA=mE(ag2lDjHkPcobFdtZo0#Dq5tZ|pe4Ko)|MTbL-^Nnf z`i~7(qEM@f&vJPIw9`t0&Y?CUeb>EQUdCS|O)2};SsgFk+VLaJJX)PuYH*=Mc$44E z&R~Z09lNDRW?zJ%CSmr`JA9 zOv$n|uef(1&*78jRs@>0s00i_IXH?5pqqU`tJki*5MkS= zVt?6l&rI|Cx_iFtixQs2um5Hoa@CoALFf9~bHl~O(uj-e54)H6+^$SK{_szv&fRH9 zEh=H1m2TFW0u&!;>6HBmeup~V{@L^FdZvA+VxumHUIS;yvS-%5xY!1H)K z$=S4qEsntYMH`yzp_Yir{`JsTNQ5pIC9$GI(NvSnywT_xq`rTNYg)#uZFsvpdQdSi zW3ad)PMJf@$Y~rWUGLgbqD4VuB{!M?1G*fv`Q^8mdDKoh;8Ju3Dq0Q)RWBCe1%)Wu zs%HtGw#=M9TZQh;zCOc3Rn$HzvR-BM7#^npsihekNv&)!2wBfTnCD%aTq)7!W1<{4 znk?(way8;#pB2Kb@K{SFnx7!o+&`PZ`~-zvni=WHK=cH*?W2mfmmqoxA0{&DgH-78@$td47o#K`#b1hS1Ip|eYG7Mnu(GYy!Qw- zOwfrq)eihsO+63TyQ;Hu1`#yYV|GZvf((T#>q2q4*{DTb^I2tDfwwD!my#r*0F}z# zw@)yenJ1|AwH~4f%pr5^J9^Zy9+1Dq=roN>WLMkqVgb`^$b}Pxk#^;{*woZt)YlL3 z8m6n?fJ#V?KP3J_#5&BrOYUg>jf!0b#(>@2-0v3bijEac)Jpe$dVZ!Jr+Nf9zYZT( zDwAZkX3veb^G)7clP`49OZnkEa!!hCoD5RY(L(o-Q#uTfy%4MowXL-Fr&}&-r2$Y2 zb-kc2pLuoYI5@#khoGSj{eCg>5Ema`@_YO5;CoWeFsxX?s=uQa^F?g9Z~g@DUxCHC z`@jLiSFd09W>g6UAxHRDdb;DS*7cOUKc5d_=+jSh84HEzYg}y%EaQYqS{?J;Jw2-+f32pJGAzsmmw&#{ zGO?}fcGiyGYQVpgTn$PZs%Xmv=nmXUU8GuOb0a0r&hL1 zh#B2lbJ33(Leo82OdqMX4T*mH;eCrA%^iNxwi_O{I&s69VQd+R2BL~xT$1?mW&%fa zVx98CAxYKx z9P(4c7IMUKbjDTCG6)^J%N_txVW0l!zyKea0*O(W($jW4Uaph} zM85~I^djr^=&6f?#fwq0mwrhGxN=HW;A_z4{rKoEQWC^9RZ#BT%Wxew!~}`><;#~V zq1LhZ(fzU>*WP^2CfeJzBuIhU02Q}Px%pml8TMikhGJ7x22}T%C@b7G{OOuNh$``wVs$CW{hHYWD%zZjD$uL2`REV1bKG zQS8E4Zd^FH^cE*?w`Exe-GTZV=Rj=I$#%e`Tu?&SItWotPFFE=9BZ8w9J`$xp8Hk!Ta_Un9F1yP!9U6+GdEV^>DJh=Bdc+_Ew<@lfzMx7p`ZpkaGkRi%pQ7raF1*V6ZHt79;- zQB=;JeViG!zBDAdopb!FNy|j>OAbys8oK>BYt@=k6C7#d=rdUIXy;_NDX>f%j|?)I z-N0hSdJ0s?H~n9zq+ImBW9}? z_#mZXOX6zk?S5cF{`lrUPP*y+Crx5*f470VM}(V`!gNzG9gZF4~}toJYg2w1GF}n{cHqf$=E- zV3jz4;{oq*brK2oI%{T%1WTq-PgwyuPiL>)yjQZcn3!a?xjPAVq83K4vkjH9gzP6I z5`P&=q&Puwm09K+A6;SU+AGcRkKcVFxuV|QMwP}kV_Ugm#epxh(uk^EKW7gnE*PX- z?JjEl{OoUqyAG8xqb`q>qW+0Kj$itc7}pq;iOM6~x=1-ws14GL7<)lhUv~5s#GxXZ z&X7+#?b05>S8iG8*d=Er!9Xo&T}UlI*pSh0o6S7%J5ZDm-Q7O4OZ{!*`OGPNmnyh= zS9b{W@|JI!LY0lP^e(=TN{A45;TA}3M@=5Qj-mw^c*eYL{`$>3KcmU!rf{t-MVD{_ z5(~#fXb0_M0@tiv8v>xHucfJ>LFdZVtLn0siHNw%p1dlhwjo)E#~qmry<`C(Fk9Kw zXVxOwAd@?6x%}Ao;u;!CNj0H&LXjT=Xeep`1VMPGQ@+}g!)BxxaXS9s*?db%O1v;F z%JMOG(ZAQO^%g7wY!ZfEL}131-szCc{j^?0w~*3~%E=sSF9T%) zN6yEjJ&dFlrciCA(UPzoK5_)xyQ-yzuG{%Sm$+4(Td`vN)P|)aN$_H*%gVKnt$(DV zuyRKEV?N~)1r^U7&=N8-GP`+sm55*!Q%IvGX>W%T_JqL=r$)r~bC)k)W@2UKMipC+ z6s4d<5n0&|Kp@?ATdjOk7G*r;GOj9>Y>prmnJ0Phwn zF@tHfdhHCeja*=2Vlv11fe}ad!eg9B zCy%MJcUCXcZNj#9{^(us-6Y_rdnOg)7tR^mUX`A>S^NLct5LIKwZW*$C=1l(*U58b z{P-u}t5HUOf!ZeP3n8=vLhHF_DKt;v=iqo{v-P8ZZ3sCd?KoPUYl=97h^>$5#Mc&E zw^l(k(b&H87qBf6=nK(zg%IVkxZ?}H6~=4k%&h>aS)eHIv#x`DXj9(3#E*7>2}nD_ zeKF~!V(PUdJ|pBkSk>N=Q}h5|DzZS6RCenF@2XGXc=1xgh?HLyn;xz=`hMgFWlzA` zuA3?IBA&&r#{#Ni&RhE8cUFS*vxdZ!%-Udv)EckWNqfDUNi(^8x;?a{K?_AlZ4#}avsO&CDAsRpCK2KTr@~e zPmfmJe%0@oN3vfU7iK3^b=eE!l4Mptvgf@yO$A3&RXs`WaW6aab@K`XQnM@sNN_l( z4ec>oGel~}tqi3V+I1@33vCM8%o$;8-8JJ4kI*jSIOpZvjffxFNye5p)wDtgrf$PD z%tAt5ssI#LI}0|YzRb^fzcUshW!2(CnNZb*8!nI3*7p1?6_of|7XZJrjWqe&aeJHQ zvq)A5N`%N!aWeBKuM9~sPb$3VpsD0(|jTpYfl?2=CMtU|`T z0B{qx+c&;1p$xw+W+>)c5P z;LfteAqwE*MxQ+!4d0iNzqbXob*?kY)WbAnQ&w(3B7v1bvLdO z6~O6pl)2?S)5GG5?%N&%N-+>?T6NmQs^djry#^uF2|UT{)iCGSbZQq_eiUkz(ZM6; zizf{-t+Nj(Y2Q2cwl3L^+!OJ1lBufVa1S*M+Tv0WarvfImaXoE=6;MpmAG7CJZCC00^M=Zo(iw$98c5k4Oo{FcmPO2b2K4j|%Z4xpZ{M|oY*T7j*vXjT zt5>eXLy-xV0IcYnt}ZiDTx-jiVvv_q(JdZ@;@dx^c2c-}IM4^O8Q<92`vsOlb z#KacM>sQWdK1VSXoPTahd;V-+6h>n5iD3NYt(!OfF$Xf7M-*%TzdOq18dpHvjxpZI zezA(_D?~r67WXXW%a-7M(?&z*{&�M=!S8nJzisG%hJDM=S<;qWpZ8s_BWOh}2j^vk{B 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 literal 0 HcmV?d00001 diff --git a/research/cost.py b/research/cost.py new file mode 100644 index 00000000..b331a6ca --- /dev/null +++ b/research/cost.py @@ -0,0 +1,159 @@ +"""Controlled inventory experiment on the teaching stand, with own fixtures.""" + +import argparse +import json +import statistics +from datetime import UTC, datetime +from pathlib import Path +from uuid import uuid4 + +import httpx + +from scripts.stand import BASE, actor, auth, command, compose, ready, sql +from scripts.verify_storage import PNG, PREFIX, inside + + +def probe(): + # Run the actual code with the reconciler service's .25 CPU /256 MiB. + code = ( + PREFIX + + """ +import pathlib,resource +started=time.process_time() +result=reconcile(d,s,apply=False,grace=3600) +result['cpu_seconds']=time.process_time()-started +result['rss_peak_bytes']=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss*1024 +result['cgroup_memory_peak_bytes']=int(pathlib.Path('/sys/fs/cgroup/memory.peak').read_text()) +print(json.dumps(result)); s.close(); d.close() +""" + ) + return json.loads( + command( + [ + "docker", + "compose", + "run", + "--rm", + "--no-deps", + "-T", + "reconciler", + "python", + "-", + ], + input=code, + ) + ) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--output", default="evidence/cost-repeat.json") + args = parser.parse_args() + output = Path(args.output) + assert not output.exists() + output.parent.mkdir(parents=True, exist_ok=True) + prefix = "objects/cost-" + uuid4().hex + "/" + result = { + "date": datetime.now(UTC).isoformat(), + "source_commit": command(["git", "rev-parse", "HEAD"]), + "complete": False, + "cells": [], + "warmups": [], + "method": "0/100/1100 extra fresh one-byte objects; one warmup then 3 repeats per dataset; real reconciler service .25 CPU/256MiB; grace3600; 8 PNG fixtures with deliberately aged PG metadata (2days); other runtime objects remain real", + "fixture_rows": 8, + "grace_seconds": 3600, + } + chat = None + ready() + compose("stop", "reconciler") + try: + with httpx.Client( + base_url=BASE, trust_env=False, timeout=20 + ) as client: + user, _, session = actor(client) + r = client.post( + "/api/v1/chats", + headers=auth(session), + json={ + "title": "Controlled inventory", + "member_ids": [user["id"]], + }, + ) + assert r.status_code == 201 + chat = r.json()["id"] + seed = f""" +from uuid import uuid4 +data=bytes.fromhex({PNG.hex()!r}) +for i in range(8): + identity=uuid4(); key={prefix!r}+'ready-'+str(i) + s.put(key=key,stream=io.BytesIO(data),size=len(data),content_type='image/png',sha256=hashlib.sha256(data).hexdigest()) + with d.connection() as c: + c.execute("INSERT INTO attachments(id,chat_id,owner_id,filename,content_type,size_bytes,sha256,object_key,state,uploader_instance,expires_at,created_at) VALUES(%s,%s,%s,'fixture.png','image/png',%s,%s,%s,'ready','cost-fixture',clock_timestamp()-interval '1 day',clock_timestamp()-interval '2 days')",(identity,{chat!r},{user["id"]!r},len(data),hashlib.sha256(data).hexdigest(),key)) +print('true') +""" + inside(seed) + for count in [0, 100, 1100]: + if count: + start = 0 if count == 100 else 100 + inside( + f"\nfor i in range({start},{count}):\n s.put(key={prefix!r}+'extra-'+str(i),stream=io.BytesIO(b'x'),size=1,content_type='application/octet-stream',sha256=hashlib.sha256(b'x').hexdigest())\nprint('true')" + ) + result["warmups"].append({"extra_objects": count, **probe()}) + for repeat in range(3): + cell = { + "extra_objects": count, + "repetition": repeat + 1, + **probe(), + } + result["cells"].append(cell) + assert cell["complete"] and not cell["applied"] + assert cell["ready_protected"] >= 8 + controls = { + (v["rows_scanned"], v["head_requests"], v["bytes_read"]) + for v in result["cells"] + } + assert len(controls) == 1, ( + "Age boundary changed work; choose a fresh stand" + ) + for count in [0, 100, 1100]: + assert ( + len( + { + v["objects_scanned"] + for v in result["cells"] + if v["extra_objects"] == count + } + ) + == 1 + ) + result["stable_rows_head_bytes"] = list(next(iter(controls))) + result["median_seconds"] = { + str(n): statistics.median( + v["duration_seconds"] + for v in result["cells"] + if v["extra_objects"] == n + ) + for n in [0, 100, 1100] + } + result["complete"] = True + finally: + if chat: + sql( + "DELETE FROM attachments WHERE chat_id='" + + chat + + "' AND uploader_instance='cost-fixture'" + ) + inside( + f"\nfor o in s.objects():\n if o.object_name.startswith({prefix!r}): s.delete(key=o.object_name)\nprint('true')" + ) + compose("up", "-d", "--no-build", "--no-recreate", "reconciler") + output.write_text( + json.dumps(result, ensure_ascii=False, indent=2) + "\n" + ) + print( + "PASS: controlled inventory cost, 9 measurements and constant metadata/HEAD work" + ) + + +if __name__ == "__main__": + main() diff --git a/scripts/verify_storage.py b/scripts/verify_storage.py index 81c2e92d..e3944c19 100644 --- a/scripts/verify_storage.py +++ b/scripts/verify_storage.py @@ -386,7 +386,14 @@ except urllib.error.HTTPError as e: print(json.dumps({{'status':e.code,'error':j inside(f"s.delete(key={key(used['id'])!r}); print('true')") age(used["id"]) age(saved["id"]) + # Fresh cgroups make memory.peak specific to this experiment. + compose("restart", "api") + cluster.wait_count(2) + ready() result["concurrent_uploads"] = concurrency(client, session, chat) + result["concurrent_uploads"][ + "api_restarted_before_memory_measurement" + ] = True while time.monotonic() - grace_started < 302: print( "Waiting for genuine S3 LastModified grace: " @@ -464,7 +471,7 @@ except urllib.error.HTTPError as e: print(json.dumps({{'status':e.code,'error':j f"print(json.dumps(s.head(key={key(failed_old['id'])!r}) is None and s.head(key={key(failed_fresh['id'])!r}) is not None))" ) repeat = run_reconcile(True) - assert not repeat["applied"].get("delete_orphan") + assert not repeat["applied"] assert repeat["linked_protected"] >= 1 result["reconciliation"] = { "dry_run": dry, -- 2.54.0 From 869cff59d9878ce98640a71382c79e5f94c2bf76 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=81=D0=BB=D0=BE=D0=B2?= Date: Sun, 15 Nov 2026 21:35:50 +0300 Subject: [PATCH 07/12] docs(storage): report controlled cost and verified consistency guarantees --- .github/pull_request_template.md | 9 +- REPORT.md | 78 ++++++- evidence/cost-controlled-first.json | 271 +++++++++++++++++++++++ evidence/storage-research-controlled.png | Bin 0 -> 81792 bytes research/analyze.py | 6 + scripts/verify_storage.py | 4 +- 6 files changed, 357 insertions(+), 11 deletions(-) create mode 100644 evidence/cost-controlled-first.json create mode 100644 evidence/storage-research-controlled.png diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 2f9afa91..fecdae96 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -8,7 +8,14 @@ Запуск: `uv sync --locked`, `make bootstrap`, `VCS_REF=$(git rev-parse HEAD) docker compose up -d --build --wait`. Полные команды и архитектура — [REPORT.md](../REPORT.md), [SCHEMA.md](../SCHEMA.md). -Результаты runtime-проверок собираются; этот промежуточный шаблон должен быть обновлён после выполнения HTTP/storage/cluster/clean-clone сценариев. Контракт/публичные tests сохранены. Статический check/полная OpenAPI validation/lint прошли. +Результаты: public smoke PASS; 108 HTTP tests PASS; реальные отказы двух API, +rolling/persistence PASS; private S3/IAM/bootstrap, PG/S3 faults, dry-run/apply/repeat +и 10 concurrent uploads PASS. Контролируемое исследование: 26/126/1126objects, +30rows/8HEAD/0GETbytes, 3 измерения на размер +warmup; медианы0.194/0.204/0.409s. +Raw: evidence/http-first.json, storage-first.json, cluster-first.json, +cost-controlled-first.json. Отчёт содержит SHA, методы, RAM/CPU, ограничения и +ответы защиты. Clean-clone повтор выполняется; результат будет добавлен. +Контракт и публичные tests сохранены. Ограничения: один host, LB/PG/S3 — SPOF; HEAD не заменяет periodic checksum audit; inventory reconciler O(objects+rows); удалённый CI не подтверждён. diff --git a/REPORT.md b/REPORT.md index 387d2780..0117a045 100644 --- a/REPORT.md +++ b/REPORT.md @@ -7,8 +7,8 @@ keyset pagination, общий Idempotency-Key, HAProxy и две независ Публикация и окончательные результаты будут внесены после проверок. Публичный smoke и 108 собственных HTTP-проверок прошли на полном стенде -(362.40 s). Проверки отказов/исследование и clean clone ещё выполняются; -окончательная готовность будет указана после их завершения. +(362.40 s). Проверки отказов/исследование прошли; повтор в чистом clone ещё выполняется. +Окончательная готовность будет указана после его завершения. ## Запуск из чистого clone @@ -111,9 +111,19 @@ Readiness проверяет PG и S3. При потере S3 HAProxy может | Публичный API | `make test` | PASS: upload201, Message, original SHA-256 и ACL | [http-first.json](evidence/http-first.json) | | Прежние возможности и негативные файлы | `uv run pytest student-tests -q` | 108 passed, 362.40 s; в том числе chunked >10 MiB, corrupt/MIME/pixels/filename/foreign chat | [http-first.json](evidence/http-first.json) | | Закреплённый S3 | `go mod download`, `minio --version`, inspect | module h1 verified; binary 2025-10-15/go1.24.8/arm64; 2 API, реальные CPU/RAM/ports | [minio-source-verification.json](evidence/minio-source-verification.json) | +| Failover файла | `uv run python -m scripts.verify_storage --research --output evidence/storage-repeat.json` | API загрузившая файл реально остановлена, другая вернула прежний SHA-256 | [storage-first.json](evidence/storage-first.json) | +| Ограниченные credentials/private bucket/bootstrap | Та же storage-проверка | anonymous403, forbidden operations AccessDenied, denied HEAD→503, console недоступна из сети, повтор bootstrap сохранил файл | [storage-first.json](evidence/storage-first.json) | +| Обрыв и ошибки PG/S3 | Та же storage-проверка | частичный upload2MiB без intent/bytes; INSERT failure без PUT; pending после PUT/ошибки UPDATE восстановлен; S3down→503 | [storage-first.json](evidence/storage-first.json) | +| Пределы RAM | Та же storage-проверка | 10/10 uploads и 10/10 originals; память/CPU/latencies записаны | [storage-first.json](evidence/storage-first.json) | +| Orphan/missing, dry-run/apply/repeat | Та же storage-проверка | 5 ожидаемых действий, все применены; повтор0 действий; fresh/ready/used защищены, ID/links сохранены | [storage-first.json](evidence/storage-first.json) | +| Реальные отказы/идемпотентность/rolling | `uv run python -m scripts.verify_cluster --output evidence/cluster-repeat.json` | две API остановлены по очереди; общий replay и rollback; rolling; подтверждённые сообщения без дублей | [cluster-first.json](evidence/cluster-first.json) | +| Полный restart с volumes | Та же cluster-проверка, public resilience | API/PG/cache/S3/LB изменили StartedAt, прежние token/metadata/bytes сохранены | [cluster-first.json](evidence/cluster-first.json) | +| Стоимость обхода | `uv run python -m research.cost --output evidence/cost-repeat.json` | 9 измерений +3 warmups, фиксированные 30rows/8HEAD/0GETbytes, 0/100/1100extra | [cost-controlled-first.json](evidence/cost-controlled-first.json) | -Строки storage/cluster/research/clean clone будут добавлены после выполнения -этих проверок. Source HTTP = `f5a7a74`, OCI revision API совпадает с ним. +Source первых HTTP/storage/cluster = `f5a7a74`, OCI revision API совпадает с ним. +Контролируемый cost harness — `3fd912f`, исполняемый `src/reconcile.py` тот же. +В чистом clone дополнительно проверяются module hashes/OCI revision обеих API +и полный набор сценариев; его результат будет внесён после завершения. ## Методика исследования @@ -125,11 +135,20 @@ Readiness проверяет PG и S3. При потере S3 HAProxy может через временные PG triggers, недоступность S3, abort HTTP, отсутствие используемого оригинала, old orphan и fresh orphan. Объект orphan реально стареет ≥300 s по S3 LastModified. Dry-run, apply, повторный apply. -Cost: 0/100/1100 дополнительных свежих объектов по 1 byte, по три dry-run -на одном стенде, без warmup, последовательно по возрастанию; учитываются -objects/rows scanned, HEAD/bytes read/duration. Это стоимость обхода, -не измерение максимальной пропускной способности S3. Dataset создаётся под -уникальным test prefix и удаляется только в своей области. +Первичный cost в storage-first.json оставлен как разведочный: между +повторами HEAD count менялся 6→10→16, когда concurrent upload rows достигли +300s. Его время нельзя приписать одному размеру inventory при прочих равных. + +Для окончательного исследования используется `research/cost.py`: +8 PNG-fixtures с metadata, намеренно состаренными в PG на 2 дня; grace 3600 s, +0/100/1100 добавочных свежих объектов по 1 byte. Остальные реальные строки +стенда учитываются; invariant фиксирует 30rows/8HEAD/0GETbytes во всех 9 cells. +Один warmup на dataset, затем 3 измеряемых dry-run, по возрастанию размера. +Каждый probe — новый контейнер **reconciler .25 CPU / 256 MiB**, не API. +Duration измеряется внутри reconcile (не включает запуск контейнера/seed), +CPU — process_time, RSS peak — Linux ru_maxrss, cgroup peak включает startup. +Временные fixtures и bytes удаляются только по собственным chat/prefix. +Это стоимость обхода, не максимальная пропускная способность S3. 10 потоков одновременно загружают одинаковое синтетическое PNG 1700×1700, каждый сравнивает оригинал. Измеряются upload p50/p95/p99, ошибки/RPS, @@ -138,6 +157,47 @@ cgroup memory.current samples и lifetime memory.peak обеих API, cpu.stat memory.peak может включать прежние запросы, поэтому отдельно показан максимум memory.current в окне. Небольшая серия не является production SLA. +## Наблюдения и границы эксперимента + +Storage: orphan действительно старел 331.301s; часы S3 не менялись. +Dry-run нашёл по одному delete_orphan/recover_pending/fail_pending_missing/ +delete_failed_object/mark_missing. Apply выполнил их, повторный apply не +изменил ничего. Fresh orphan, fresh failed и ready без Message сохранились; +у missing used сохранены metadata ID и Message link, внешний GET→409. +Данные пропавшего original не «восстановлены» по checksum. + +10 одновременных uploads: PNG 6,017,095 bytes, 2,890,000 pixels; 10/10 успехов, +ошибок 0, оригиналы совпали. Серия 5.149 s, 1.942successful uploads/s с учётом +скачивания и sampler; upload p50=2162.965ms, p95=p99=4465.512ms. +Это одна короткая серия, p95/p99 на 10 запросах совпадают с максимумом. +Sampled cgroup memory.current max по API 123.01/155.93 MiB; memory.peak +145.66/205.13 MiB. Последнее включает предыдущую работу, поэтому это верхняя +граница для данной серии. В clean-clone повторе API специально рестартуют +перед экспериментом, чтобы peak относился к новым cgroups. + +| Дополнительные объекты | Фактически scanned | Медиана времени, s | Диапазон 3 повторов, s | +| --- | --- | --- | --- | +| 0 | 26 | 0.193719 | 0.189185–0.210146 | +| 100 | 126 | 0.204344 | 0.196670–0.210975 | +| 1100 | 1126 | 0.409094 | 0.391053–0.610401 | + +При этих условиях увеличение inventory повысило стоимость. Код хранит +inventory в dict и обходит его целиком: O(objects+rows) времени/памяти. +Три размера и три повтора не доказывают точную линейную зависимость: +есть fixed HEAD cost, pagination LIST после 1000 keys, quota scheduling и +нагрузка общего ноутбука. CPU процесса 0.0368–0.1059 s; RSS peak 58.82–59.82 MiB, +cgroup peak 41.60–43.10 MiB. RSS и cgroup учитывают общие страницы по-разному; +это разные показатели. Небольшой dataset не доказывает пригодность полного +inventory для миллионов объектов. Следующий шаг — пагинация/partitioning +и ограниченные пачки metadata; это предложение, не измеренная оптимизация. + +![Measured inventory cost and sampled API memory](evidence/storage-research-controlled.png) + +Process failover: первая API: 194 подтверждённых записи / 8 временных ошибок, +восстановление 4.086 s; вторая: 217 / 7 / 2.720 s. Rolling: 609 записей / 34 ошибки, +подтверждённые записи сохранены. Public failover: 123 записи / 3 ошибки, +восстановление 2.635 s. Это не zero-error rolling и не HA единственного host. + ## Вопросы защиты **Почему volume API не равно S3?** Volume принадлежит контейнеру/host и сам diff --git a/evidence/cost-controlled-first.json b/evidence/cost-controlled-first.json new file mode 100644 index 00000000..04c2934b --- /dev/null +++ b/evidence/cost-controlled-first.json @@ -0,0 +1,271 @@ +{ + "date": "2026-11-15T18:28:56.018046+00:00", + "source_commit": "3fd912fccb761d7010783363fa49337542ffa4e0", + "complete": true, + "cells": [ + { + "extra_objects": 0, + "repetition": 1, + "apply": false, + "grace_seconds": 3600, + "objects_scanned": 26, + "rows_scanned": 30, + "head_requests": 8, + "bytes_read": 0, + "fresh_protected": 26, + "ready_protected": 8, + "linked_protected": 0, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.189185, + "complete": true, + "cpu_seconds": 0.039170499000000136, + "rss_peak_bytes": 61718528, + "cgroup_memory_peak_bytes": 43945984 + }, + { + "extra_objects": 0, + "repetition": 2, + "apply": false, + "grace_seconds": 3600, + "objects_scanned": 26, + "rows_scanned": 30, + "head_requests": 8, + "bytes_read": 0, + "fresh_protected": 26, + "ready_protected": 8, + "linked_protected": 0, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.210146, + "complete": true, + "cpu_seconds": 0.05308141700000002, + "rss_peak_bytes": 61693952, + "cgroup_memory_peak_bytes": 43950080 + }, + { + "extra_objects": 0, + "repetition": 3, + "apply": false, + "grace_seconds": 3600, + "objects_scanned": 26, + "rows_scanned": 30, + "head_requests": 8, + "bytes_read": 0, + "fresh_protected": 26, + "ready_protected": 8, + "linked_protected": 0, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.193719, + "complete": true, + "cpu_seconds": 0.036812661999999996, + "rss_peak_bytes": 61718528, + "cgroup_memory_peak_bytes": 44134400 + }, + { + "extra_objects": 100, + "repetition": 1, + "apply": false, + "grace_seconds": 3600, + "objects_scanned": 126, + "rows_scanned": 30, + "head_requests": 8, + "bytes_read": 0, + "fresh_protected": 126, + "ready_protected": 8, + "linked_protected": 0, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.19667, + "complete": true, + "cpu_seconds": 0.03935812599999999, + "rss_peak_bytes": 62033920, + "cgroup_memory_peak_bytes": 43622400 + }, + { + "extra_objects": 100, + "repetition": 2, + "apply": false, + "grace_seconds": 3600, + "objects_scanned": 126, + "rows_scanned": 30, + "head_requests": 8, + "bytes_read": 0, + "fresh_protected": 126, + "ready_protected": 8, + "linked_protected": 0, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.210975, + "complete": true, + "cpu_seconds": 0.05283020999999999, + "rss_peak_bytes": 61865984, + "cgroup_memory_peak_bytes": 44126208 + }, + { + "extra_objects": 100, + "repetition": 3, + "apply": false, + "grace_seconds": 3600, + "objects_scanned": 126, + "rows_scanned": 30, + "head_requests": 8, + "bytes_read": 0, + "fresh_protected": 126, + "ready_protected": 8, + "linked_protected": 0, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.204344, + "complete": true, + "cpu_seconds": 0.05048583700000009, + "rss_peak_bytes": 61677568, + "cgroup_memory_peak_bytes": 43831296 + }, + { + "extra_objects": 1100, + "repetition": 1, + "apply": false, + "grace_seconds": 3600, + "objects_scanned": 1126, + "rows_scanned": 30, + "head_requests": 8, + "bytes_read": 0, + "fresh_protected": 1126, + "ready_protected": 8, + "linked_protected": 0, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.409094, + "complete": true, + "cpu_seconds": 0.0955386250000001, + "rss_peak_bytes": 62730240, + "cgroup_memory_peak_bytes": 44974080 + }, + { + "extra_objects": 1100, + "repetition": 2, + "apply": false, + "grace_seconds": 3600, + "objects_scanned": 1126, + "rows_scanned": 30, + "head_requests": 8, + "bytes_read": 0, + "fresh_protected": 1126, + "ready_protected": 8, + "linked_protected": 0, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.391053, + "complete": true, + "cpu_seconds": 0.09063437099999994, + "rss_peak_bytes": 62652416, + "cgroup_memory_peak_bytes": 45195264 + }, + { + "extra_objects": 1100, + "repetition": 3, + "apply": false, + "grace_seconds": 3600, + "objects_scanned": 1126, + "rows_scanned": 30, + "head_requests": 8, + "bytes_read": 0, + "fresh_protected": 1126, + "ready_protected": 8, + "linked_protected": 0, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.610401, + "complete": true, + "cpu_seconds": 0.10586249599999986, + "rss_peak_bytes": 62672896, + "cgroup_memory_peak_bytes": 44793856 + } + ], + "warmups": [ + { + "extra_objects": 0, + "apply": false, + "grace_seconds": 3600, + "objects_scanned": 26, + "rows_scanned": 30, + "head_requests": 8, + "bytes_read": 0, + "fresh_protected": 26, + "ready_protected": 8, + "linked_protected": 0, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.20732, + "complete": true, + "cpu_seconds": 0.05440116500000003, + "rss_peak_bytes": 61632512, + "cgroup_memory_peak_bytes": 44158976 + }, + { + "extra_objects": 100, + "apply": false, + "grace_seconds": 3600, + "objects_scanned": 126, + "rows_scanned": 30, + "head_requests": 8, + "bytes_read": 0, + "fresh_protected": 126, + "ready_protected": 8, + "linked_protected": 0, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.198799, + "complete": true, + "cpu_seconds": 0.04178633399999998, + "rss_peak_bytes": 61964288, + "cgroup_memory_peak_bytes": 43732992 + }, + { + "extra_objects": 1100, + "apply": false, + "grace_seconds": 3600, + "objects_scanned": 1126, + "rows_scanned": 30, + "head_requests": 8, + "bytes_read": 0, + "fresh_protected": 1126, + "ready_protected": 8, + "linked_protected": 0, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.31776, + "complete": true, + "cpu_seconds": 0.08349883400000002, + "rss_peak_bytes": 62627840, + "cgroup_memory_peak_bytes": 45318144 + } + ], + "method": "0/100/1100 extra fresh one-byte objects; one warmup then 3 repeats per dataset; real reconciler service .25 CPU/256MiB; grace3600; 8 PNG fixtures with deliberately aged PG metadata (2days); other runtime objects remain real", + "fixture_rows": 8, + "grace_seconds": 3600, + "stable_rows_head_bytes": [ + 30, + 8, + 0 + ], + "median_seconds": { + "0": 0.193719, + "100": 0.204344, + "1100": 0.409094 + } +} diff --git a/evidence/storage-research-controlled.png b/evidence/storage-research-controlled.png new file mode 100644 index 0000000000000000000000000000000000000000..7d66a46432eac3d7deb0a8e3c6bd4aabff12f041 GIT binary patch literal 81792 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 BwTA!z literal 0 HcmV?d00001 diff --git a/research/analyze.py b/research/analyze.py index 384d9eab..a31b3b73 100644 --- a/research/analyze.py +++ b/research/analyze.py @@ -13,11 +13,15 @@ import matplotlib.pyplot as plt def main(): parser = argparse.ArgumentParser() parser.add_argument("input") + parser.add_argument("--cost-input") parser.add_argument("--output", default="evidence/storage-research.png") args = parser.parse_args() data = json.loads(Path(args.input).read_text()) assert data["complete"] series = data["cost_research"] + if args.cost_input: + series = json.loads(Path(args.cost_input).read_text()) + assert series["complete"] fig, axes = plt.subplots(1, 2, figsize=(11, 4), layout="constrained") for cell in series["cells"]: axes[0].scatter( @@ -41,6 +45,8 @@ def main(): [s["at"] for s in points], [s["memory.current"] / 2**20 for s in points], label=f"API {i + 1} cgroup current", + marker="o", + markersize=3, ) axes[1].set( xlabel="Time, seconds", diff --git a/scripts/verify_storage.py b/scripts/verify_storage.py index e3944c19..d09cab87 100644 --- a/scripts/verify_storage.py +++ b/scripts/verify_storage.py @@ -30,8 +30,10 @@ s=ObjectStore(); d=Database(url=secret('DATABASE_URL'),size=2); d.open() def inside(code): + containers = compose("ps", "-q", "api").split() + assert containers, "No running API in this project" value = command( - ["docker", "compose", "exec", "-T", "api", "python", "-"], + ["docker", "exec", "-i", containers[0], "python", "-"], input=PREFIX + code + "\ns.close(); d.close()\n", ) return json.loads(value) -- 2.54.0 From 78670b9fa67202ddc26570daa245c75d1837991a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=81=D0=BB=D0=BE=D0=B2?= Date: Sun, 15 Nov 2026 21:59:08 +0300 Subject: [PATCH 08/12] fix(auth): avoid redundant password hashing in registration races --- evidence/clean-clone-first-failed.json | 11 +++++++++++ src/repository.py | 9 +++++++++ src/service.py | 23 ++++++++++++++++++----- student-tests/conftest.py | 4 ++++ student-tests/test_attachments.py | 4 +--- 5 files changed, 43 insertions(+), 8 deletions(-) create mode 100644 evidence/clean-clone-first-failed.json diff --git a/evidence/clean-clone-first-failed.json b/evidence/clean-clone-first-failed.json new file mode 100644 index 00000000..4702e76d --- /dev/null +++ b/evidence/clean-clone-first-failed.json @@ -0,0 +1,11 @@ +{ + "date": "2026-11-15T18:42:26.500607+00:00", + "source_commit": "869cff59d9878ce98640a71382c79e5f94c2bf76", + "fresh_secrets_environment_and_volumes": true, + "command": "python scripts/verify_clean.py", + "fixed_host_port_for_restart": 49840, + "static_checks": ".venv/bin/python scripts/check_contract.py\nPASS: offline skeleton structure, local refs and Python syntax; application NOT tested.\n.venv/bin/python scripts/validate_openapi.py\nPASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.\n/.local/bin/uv run --locked ruff format src student-tests scripts/bootstrap.py scripts/stand.py scripts/cluster.py scripts/verify_clean.py scripts/verify_cluster.py scripts/verify_storage.py\n32 files left unchanged\n/.local/bin/uv run --locked ruff check src student-tests scripts/bootstrap.py scripts/stand.py scripts/cluster.py scripts/verify_clean.py scripts/verify_cluster.py scripts/verify_storage.py\nAll checks passed!", + "smoke": "python3 tests/smoke.py --base-url \"http://127.0.0.1:49840\" \nPASS: lab4 public API scenario; infrastructure and grading evidence remain separate.", + "failed_action": ".venv/bin/pytest student-tests -q", + "result": "INCOMPLETE" +} diff --git a/src/repository.py b/src/repository.py index d960d7d9..f9374231 100644 --- a/src/repository.py +++ b/src/repository.py @@ -92,6 +92,15 @@ class PostgresRepository: return None, None return user_dto(row), row["password_hash"] + def username_exists(self, *, username: str) -> bool: + with self.database.connection() as conn: + return ( + conn.execute( + "SELECT 1 FROM users WHERE username=%s", (username,) + ).fetchone() + is not None + ) + def add_session( self, *, digest: bytes, user_id: UUID, created_at, expires_at ): diff --git a/src/service.py b/src/service.py index 373741bd..6d5f5ace 100644 --- a/src/service.py +++ b/src/service.py @@ -2,6 +2,7 @@ import base64 import hashlib import re import secrets +import threading from datetime import timedelta from uuid import UUID, uuid4 @@ -62,6 +63,7 @@ class MessengerService: self.repository = repository self.passwords = passwords self.session_ttl = session_ttl + self.registration_locks = [threading.Lock() for _ in range(64)] def identify(self, *, value: str | None) -> User: token = bearer(value) @@ -74,11 +76,22 @@ class MessengerService: def register( self, *, username: str, display_name: str, password: str ) -> User: - encoded = self.passwords.hash(password=password) - return self.repository.add_user( - user=User(uuid4(), username, display_name, utcnow()), - password_hash=encoded, - ) + # Bound lock memory and avoid running Argon2 for every local duplicate. + # Different replicas still race safely through PostgreSQL UNIQUE. + stripe = hashlib.sha256(username.encode()).digest()[0] % 64 + lock = self.registration_locks[stripe] + if not lock.acquire(timeout=8): + raise DomainError(503, "unavailable", "Registration busy") + try: + if self.repository.username_exists(username=username): + raise DomainError(409, "conflict", "Username already exists") + encoded = self.passwords.hash(password=password) + return self.repository.add_user( + user=User(uuid4(), username, display_name, utcnow()), + password_hash=encoded, + ) + finally: + lock.release() def login(self, *, authorization: str | None): try: diff --git a/student-tests/conftest.py b/student-tests/conftest.py index c575c2a9..7c1f2dfb 100644 --- a/student-tests/conftest.py +++ b/student-tests/conftest.py @@ -34,7 +34,11 @@ def check(result: httpx.Response, status: int, schema: str) -> dict: 401: "unauthorized", 404: "not_found", 409: "conflict", + 413: "payload_too_large", + 415: "unsupported_media_type", + 429: "rate_limited", 500: "internal_error", + 503: "unavailable", }[status] ) return payload diff --git a/student-tests/test_attachments.py b/student-tests/test_attachments.py index eaad5bcf..183a4126 100644 --- a/student-tests/test_attachments.py +++ b/student-tests/test_attachments.py @@ -92,9 +92,7 @@ def test_filename_guard(client, actors, chat, name): ) def test_image_guards(client, actors, chat, data, mime, status): r = upload(client, actors[0], chat, data=data, mime=mime) - assert r.status_code == status - assert r.headers["x-instance-id"] and r.headers["x-request-id"] - assert r.json()["error"]["request_id"] == r.headers["x-request-id"] + check(r, status, "Error") def test_jpeg_original_unchanged(client, actors, chat): -- 2.54.0 From 6f8e4f127dee8857a3af908a9fb1d575f8907d90 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=81=D0=BB=D0=BE=D0=B2?= Date: Sun, 15 Nov 2026 22:02:36 +0300 Subject: [PATCH 09/12] test(auth): verify registration conflict handling across ten race repeats --- REPORT.md | 9 ++ evidence/registration-race-first-failure.txt | 102 +++++++++++++++++++ evidence/registration-race-fixed.json | 67 ++++++++++++ 3 files changed, 178 insertions(+) create mode 100644 evidence/registration-race-first-failure.txt create mode 100644 evidence/registration-race-fixed.json diff --git a/REPORT.md b/REPORT.md index 0117a045..e18084f8 100644 --- a/REPORT.md +++ b/REPORT.md @@ -5,6 +5,15 @@ keyset pagination, общий Idempotency-Key, HAProxy и две независимые API. Добавлены приватный S3, вложения и повторяемый reconciler. +В clean-clone проверке обнаружена и исправлена гонка регистрации: все +конкуренты одного username без пользы выполняли Argon2, один мог получить +503 при лимите CPU. Теперь 64 bounded locks сериализуют локальные повторы, +перед KDF проверяется существование имени. Между API арбитр — прежний +PostgreSQL UNIQUE, хеширование остаётся вне SQL-транзакции. Argon2id и +лимит двух KDF/process не ослаблены. [Первый отказ](evidence/registration-race-first-failure.txt) +сохранён; после исправления [10 повторов по10 запросов](evidence/registration-race-fixed.json) +дали каждый раз один201/девять409, без503. Полный clean clone повторяется. + Публикация и окончательные результаты будут внесены после проверок. Публичный smoke и 108 собственных HTTP-проверок прошли на полном стенде (362.40 s). Проверки отказов/исследование прошли; повтор в чистом clone ещё выполняется. diff --git a/evidence/registration-race-first-failure.txt b/evidence/registration-race-first-failure.txt new file mode 100644 index 00000000..06d0c00f --- /dev/null +++ b/evidence/registration-race-first-failure.txt @@ -0,0 +1,102 @@ +Traceback (most recent call last): + File "/scripts/verify_clean.py", line 215, in + main() + ~~~~^^ + File "/scripts/verify_clean.py", line 130, in main + receipt["http_tests"] = run( + ~~~^ + [".venv/bin/pytest", "student-tests", "-q"], cwd=clone, env=env + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + ) + ^ + File "/scripts/verify_clean.py", line 55, in run + raise RuntimeError(redact(result.stdout + result.stderr)) +RuntimeError: ...........................................................F............ [ 66%] +.................................... [100%] +=================================== FAILURES =================================== +____________________________ test_registration_race ____________________________ + +client = + + def test_registration_race(client): + username = "race_" + uuid4().hex[:20] + barrier = threading.Barrier(10) + + def worker(_): + with httpx.Client( + base_url=BASE_URL, timeout=15, trust_env=False + ) as conn: + barrier.wait(timeout=15) + result = conn.post( + "/api/v1/users", + json={ + "username": username, + "display_name": "Test", + "password": PASSWORD, + }, + ) + check( + result, + result.status_code, + "User" if result.status_code == 201 else "Error", + ) + return result.status_code + + with ThreadPoolExecutor(max_workers=10) as pool: +> statuses = list(pool.map(worker, range(10))) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +student-tests/test_api.py:406: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ +/.local/share/uv/python/cpython-3.14.7-macos-aarch64-none/lib/python3.14/concurrent/futures/_base.py:645: in result_iterator + yield _result_or_cancel(fs.pop()) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +/.local/share/uv/python/cpython-3.14.7-macos-aarch64-none/lib/python3.14/concurrent/futures/_base.py:312: in _result_or_cancel + return fut.result(timeout) + ^^^^^^^^^^^^^^^^^^^ +/.local/share/uv/python/cpython-3.14.7-macos-aarch64-none/lib/python3.14/concurrent/futures/_base.py:454: in result + return self.__get_result() + ^^^^^^^^^^^^^^^^^^^ +/.local/share/uv/python/cpython-3.14.7-macos-aarch64-none/lib/python3.14/concurrent/futures/_base.py:396: in __get_result + raise self._exception +/.local/share/uv/python/cpython-3.14.7-macos-aarch64-none/lib/python3.14/concurrent/futures/thread.py:86: in run + result = ctx.run(self.task) + ^^^^^^^^^^^^^^^^^^ +/.local/share/uv/python/cpython-3.14.7-macos-aarch64-none/lib/python3.14/concurrent/futures/thread.py:73: in run + return fn(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^ +student-tests/test_api.py:398: in worker + check( +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +result = , status = 503, schema = 'Error' + + def check(result: httpx.Response, status: int, schema: str) -> dict: + assert result.status_code == status, result.text + assert result.headers["x-request-id"] + assert result.headers["x-instance-id"] + assert result.headers["content-type"].startswith("application/json") + payload = result.json() + spec = {"$ref": f"#/components/schemas/{schema}", **CONTRACT} + Draft202012Validator(spec, format_checker=FormatChecker()).validate( + payload + ) + if schema == "Error": + assert payload["error"]["request_id"] == result.headers["x-request-id"] + assert ( + payload["error"]["code"] +> == { + 400: "invalid_request", + 401: "unauthorized", + 404: "not_found", + 409: "conflict", + 500: "internal_error", + }[status] + ) +E KeyError: 503 + +student-tests/conftest.py:32: KeyError +=========================== short test summary info ============================ +FAILED student-tests/test_api.py::test_registration_race - KeyError: 503 +1 failed, 107 passed in 377.89s (0:06:17) + diff --git a/evidence/registration-race-fixed.json b/evidence/registration-race-fixed.json new file mode 100644 index 00000000..5aa335c5 --- /dev/null +++ b/evidence/registration-race-fixed.json @@ -0,0 +1,67 @@ +{ + "source_commit": "78670b9fa67202ddc26570daa245c75d1837991a", + "date": "2026-11-15T19:00:28.275924+00:00", + "complete": true, + "runs": [ + { + "repeat": 1, + "seconds": 1.6275634999910835, + "exit_code": 0, + "output": ". [100%]\n1 passed in 1.17s\n" + }, + { + "repeat": 2, + "seconds": 1.1972682919877116, + "exit_code": 0, + "output": ". [100%]\n1 passed in 0.83s\n" + }, + { + "repeat": 3, + "seconds": 1.2752694170048926, + "exit_code": 0, + "output": ". [100%]\n1 passed in 0.90s\n" + }, + { + "repeat": 4, + "seconds": 1.3356571669864934, + "exit_code": 0, + "output": ". [100%]\n1 passed in 0.97s\n" + }, + { + "repeat": 5, + "seconds": 1.1046671249787323, + "exit_code": 0, + "output": ". [100%]\n1 passed in 0.74s\n" + }, + { + "repeat": 6, + "seconds": 1.2911863749905024, + "exit_code": 0, + "output": ". [100%]\n1 passed in 0.93s\n" + }, + { + "repeat": 7, + "seconds": 1.6777148330002092, + "exit_code": 0, + "output": ". [100%]\n1 passed in 1.32s\n" + }, + { + "repeat": 8, + "seconds": 1.4123140000156127, + "exit_code": 0, + "output": ". [100%]\n1 passed in 1.03s\n" + }, + { + "repeat": 9, + "seconds": 1.2036787920224015, + "exit_code": 0, + "output": ". [100%]\n1 passed in 0.83s\n" + }, + { + "repeat": 10, + "seconds": 1.2103008750127628, + "exit_code": 0, + "output": ". [100%]\n1 passed in 0.84s\n" + } + ] +} -- 2.54.0 From 2554cb75c5a01f4c200abdde7071fcaa3b608183 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=81=D0=BB=D0=BE=D0=B2?= Date: Sun, 15 Nov 2026 22:21:16 +0300 Subject: [PATCH 10/12] docs(storage): record complete clean clone verification --- evidence/clean-clone-first.json | 4714 +++++++++++++++++++++++++++++++ 1 file changed, 4714 insertions(+) create mode 100644 evidence/clean-clone-first.json diff --git a/evidence/clean-clone-first.json b/evidence/clean-clone-first.json new file mode 100644 index 00000000..68d503fe --- /dev/null +++ b/evidence/clean-clone-first.json @@ -0,0 +1,4714 @@ +{ + "date": "2026-11-15T19:03:16.176768+00:00", + "source_commit": "6f8e4f127dee8857a3af908a9fb1d575f8907d90", + "fresh_secrets_environment_and_volumes": true, + "command": "python scripts/verify_clean.py", + "fixed_host_port_for_restart": 52008, + "static_checks": ".venv/bin/python scripts/check_contract.py\nPASS: offline skeleton structure, local refs and Python syntax; application NOT tested.\n.venv/bin/python scripts/validate_openapi.py\nPASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.\n/.local/bin/uv run --locked ruff format src student-tests scripts/bootstrap.py scripts/stand.py scripts/cluster.py scripts/verify_clean.py scripts/verify_cluster.py scripts/verify_storage.py\n32 files left unchanged\n/.local/bin/uv run --locked ruff check src student-tests scripts/bootstrap.py scripts/stand.py scripts/cluster.py scripts/verify_clean.py scripts/verify_cluster.py scripts/verify_storage.py\nAll checks passed!", + "smoke": "python3 tests/smoke.py --base-url \"http://127.0.0.1:52008\" \nPASS: lab4 public API scenario; infrastructure and grading evidence remain separate.", + "http_tests": "........................................................................ [ 66%]\n.................................... [100%]\n108 passed in 380.09s (0:06:20)", + "storage": { + "source_commit": "6f8e4f127dee8857a3af908a9fb1d575f8907d90", + "date": "2026-11-15T19:13:28.175560+00:00", + "complete": true, + "runtime": [ + { + "role": "api", + "container": "cf7980262f50", + "pid": 50197, + "started_at": "2026-11-15T19:13:02.806283293Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "85715808d66b464a8ee8b1b56cd5c9de" + }, + { + "role": "api", + "container": "22664db55f19", + "pid": 50221, + "started_at": "2026-11-15T19:13:02.827565293Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "003104329d7d4b898205cf12e339560e" + }, + { + "role": "cache", + "container": "b4885e9057d5", + "pid": 49923, + "started_at": "2026-11-15T19:13:02.11530071Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 134217728 + }, + { + "role": "lb", + "container": "bf5b1211c8f9", + "pid": 49927, + "started_at": "2026-11-15T19:13:02.11018996Z", + "ports": { + "8080/tcp": [ + { + "HostIp": "127.0.0.1", + "HostPort": "52008" + } + ] + }, + "cpu_nano": 500000000, + "memory_limit": 134217728 + }, + { + "role": "postgres", + "container": "d396724f5d8f", + "pid": 49970, + "started_at": "2026-11-15T19:13:02.15088096Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 536870912 + }, + { + "role": "reconciler", + "container": "11e467c4c787", + "pid": 8691, + "started_at": "2026-11-15T19:03:39.987622088Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 268435456 + }, + { + "role": "s3", + "container": "0a5f16a1da1e", + "pid": 49845, + "started_at": "2026-11-15T19:13:01.994279293Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 1073741824 + } + ], + "upload_replica_stopped_downloaded_elsewhere": { + "stopped_container": "22664db55f19", + "uploader": "003104329d7d4b898205cf12e339560e", + "downloader": "85715808d66b464a8ee8b1b56cd5c9de", + "sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75" + }, + "private_bucket_and_iam": { + "denied_head_is_not_missing": 503, + "anonymous_get": 403, + "list_other_bucket": "AccessDenied", + "create_bucket": "AccessDenied", + "write_outside_prefix": "AccessDenied", + "console_internal_network": "unreachable" + }, + "bootstrap_repeat_preserved_original": true, + "aborted_upload_has_no_intent_or_bytes": true, + "pg_intent_failure_has_no_bytes": true, + "s3_unavailable": { + "status": 503, + "error": "unavailable" + }, + "concurrent_uploads": { + "concurrency": 10, + "requests": 10, + "successes": 10, + "errors": 0, + "bytes_per_image": 6017095, + "pixels": 2890000, + "duration_seconds": 5.429, + "successful_rps": 1.842, + "latency_scope": "upload only; duration includes verified downloads and memory sampler", + "p50_ms": 2767.956, + "p95_ms": 5002.469, + "p99_ms": 5002.469, + "cpu_before": { + "cf7980262f5026ccea9037881d4bfb6d446f1afadb84f49a64b6ca1cef8f95bd": "usage_usec 5378906\nuser_usec 5002940\nsystem_usec 375966\nnice_usec 0\nnr_periods 131\nnr_throttled 103\nthrottled_usec 12621040\nnr_bursts 0\nburst_usec 0", + "22664db55f19ab18daa0e0992b9e7eebe8a038557914499cf74f00d5ef541b9a": "usage_usec 5237467\nuser_usec 4972102\nsystem_usec 265365\nnice_usec 0\nnr_periods 131\nnr_throttled 101\nthrottled_usec 11862161\nnr_bursts 0\nburst_usec 0" + }, + "cpu_after": { + "cf7980262f5026ccea9037881d4bfb6d446f1afadb84f49a64b6ca1cef8f95bd": "usage_usec 7933189\nuser_usec 6985254\nsystem_usec 947934\nnice_usec 0\nnr_periods 184\nnr_throttled 152\nthrottled_usec 20596284\nnr_bursts 0\nburst_usec 0", + "22664db55f19ab18daa0e0992b9e7eebe8a038557914499cf74f00d5ef541b9a": "usage_usec 6944167\nuser_usec 6350957\nsystem_usec 593210\nnice_usec 0\nnr_periods 182\nnr_throttled 131\nthrottled_usec 14680526\nnr_bursts 0\nburst_usec 0" + }, + "memory_samples": [ + { + "at": 0.0, + "container": "cf7980262f50", + "memory.current": 107278336, + "memory.peak": 142950400 + }, + { + "at": 1.002, + "container": "22664db55f19", + "memory.current": 123514880, + "memory.peak": 142704640 + }, + { + "at": 2.32, + "container": "cf7980262f50", + "memory.current": 144879616, + "memory.peak": 144879616 + }, + { + "at": 3.419, + "container": "22664db55f19", + "memory.current": 113655808, + "memory.peak": 142704640 + }, + { + "at": 4.135, + "container": "cf7980262f50", + "memory.current": 145022976, + "memory.peak": 150933504 + }, + { + "at": 5.021, + "container": "22664db55f19", + "memory.current": 113893376, + "memory.peak": 142704640 + } + ], + "results": [ + { + "id": "45058be5-e26e-4ff1-9910-9d0284f16535", + "latency_ms": 3958.2263750198763, + "instance": "d9173447e4ef491a9ac0b563b9fcbc9c" + }, + { + "id": "d5349a92-d1e6-4e6c-9300-76cdbf093ce5", + "latency_ms": 2060.015333001502, + "instance": "d9173447e4ef491a9ac0b563b9fcbc9c" + }, + { + "id": "10f215be-bd57-4d9b-a86f-3d19623ed0c8", + "latency_ms": 2076.839875022415, + "instance": "b5a12687d1fa41beb37b2a7931f0c79c" + }, + { + "id": "3fa5a53b-669f-4127-b6c7-78b1d7b6f2fd", + "latency_ms": 2767.9564169957303, + "instance": "d9173447e4ef491a9ac0b563b9fcbc9c" + }, + { + "id": "2064e4d7-552e-4ff8-9e6a-88217aabd2f6", + "latency_ms": 1382.3261659999844, + "instance": "b5a12687d1fa41beb37b2a7931f0c79c" + }, + { + "id": "eeddbe16-169c-4277-b8a3-aa594d14af28", + "latency_ms": 1688.7768750020768, + "instance": "d9173447e4ef491a9ac0b563b9fcbc9c" + }, + { + "id": "3dd48aa6-f765-40c2-98d7-fa4116639685", + "latency_ms": 976.4150840055663, + "instance": "b5a12687d1fa41beb37b2a7931f0c79c" + }, + { + "id": "313eea18-fe04-44bf-a28b-52b2166179b2", + "latency_ms": 5002.469375001965, + "instance": "d9173447e4ef491a9ac0b563b9fcbc9c" + }, + { + "id": "ce25b11d-3208-4484-a0ac-61431b76374e", + "latency_ms": 3487.6271249959245, + "instance": "d9173447e4ef491a9ac0b563b9fcbc9c" + }, + { + "id": "7086a13b-a208-49dc-8369-03cf3f53e5b7", + "latency_ms": 4463.048375007929, + "instance": "d9173447e4ef491a9ac0b563b9fcbc9c" + } + ], + "window_max_memory_current": 145022976, + "lifetime_memory_peak": 150933504, + "api_restarted_before_memory_measurement": true + }, + "reconciliation": { + "dry_run": { + "apply": false, + "grace_seconds": 300, + "objects_scanned": 22, + "rows_scanned": 22, + "head_requests": 10, + "bytes_read": 111817, + "fresh_protected": 13, + "ready_protected": 7, + "linked_protected": 0, + "actions": { + "delete_orphan": 1, + "fail_pending_missing": 1, + "recover_pending": 1, + "mark_missing": 1, + "delete_failed_object": 1 + }, + "applied": {}, + "details": [ + { + "action": "delete_orphan", + "identity": "objects/verification-a48997814ded4e989dbd30742e37fde4/orphan" + }, + { + "action": "fail_pending_missing", + "identity": "2dbdd8cb-64e0-4974-8a6d-c3b28bcbc41c" + }, + { + "action": "recover_pending", + "identity": "c752bee5-b01b-41e9-b00d-dd02fb29d50e" + }, + { + "action": "mark_missing", + "identity": "cc2c8099-a23c-4a04-9027-d3ce4fe1df0b" + }, + { + "action": "delete_failed_object", + "identity": "edf31e32-84c8-4570-acb5-f6cca1c0e487" + } + ], + "duration_seconds": 0.218304, + "complete": true + }, + "apply": { + "apply": true, + "grace_seconds": 300, + "objects_scanned": 22, + "rows_scanned": 22, + "head_requests": 12, + "bytes_read": 111817, + "fresh_protected": 13, + "ready_protected": 7, + "linked_protected": 0, + "actions": { + "delete_orphan": 1, + "fail_pending_missing": 1, + "recover_pending": 1, + "mark_missing": 1, + "delete_failed_object": 1 + }, + "applied": { + "delete_orphan": 1, + "fail_pending_missing": 1, + "recover_pending": 1, + "mark_missing": 1, + "delete_failed_object": 1 + }, + "details": [ + { + "action": "delete_orphan", + "identity": "objects/verification-a48997814ded4e989dbd30742e37fde4/orphan" + }, + { + "action": "fail_pending_missing", + "identity": "2dbdd8cb-64e0-4974-8a6d-c3b28bcbc41c" + }, + { + "action": "recover_pending", + "identity": "c752bee5-b01b-41e9-b00d-dd02fb29d50e" + }, + { + "action": "mark_missing", + "identity": "cc2c8099-a23c-4a04-9027-d3ce4fe1df0b" + }, + { + "action": "delete_failed_object", + "identity": "edf31e32-84c8-4570-acb5-f6cca1c0e487" + } + ], + "duration_seconds": 0.123041, + "complete": true + }, + "repeat": { + "apply": true, + "grace_seconds": 300, + "objects_scanned": 20, + "rows_scanned": 22, + "head_requests": 8, + "bytes_read": 0, + "fresh_protected": 13, + "ready_protected": 8, + "linked_protected": 1, + "actions": {}, + "applied": {}, + "details": [], + "duration_seconds": 0.102448, + "complete": true + }, + "s3_grace_wait_seconds": 334.035, + "fresh_and_ready_unlinked_protected": true, + "old_failed_unlinked_deleted_and_fresh_failed_protected": true, + "missing_used_id_and_link_preserved": true, + "dry_run_unchanged": true + } + }, + "cluster": { + "date": "2026-11-15T19:10:19.405751+00:00", + "source_commit": "6f8e4f127dee8857a3af908a9fb1d575f8907d90", + "complete": true, + "before": [ + { + "role": "api", + "container": "e05ff3e9bffe", + "pid": 8842, + "started_at": "2026-11-15T19:03:40.38511538Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "role": "api", + "container": "826dbec1f35c", + "pid": 8766, + "started_at": "2026-11-15T19:03:40.193473172Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "role": "cache", + "container": "b4885e9057d5", + "pid": 7984, + "started_at": "2026-11-15T19:03:27.760175305Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 134217728 + }, + { + "role": "lb", + "container": "bf5b1211c8f9", + "pid": 9431, + "started_at": "2026-11-15T19:03:50.613696802Z", + "ports": { + "8080/tcp": [ + { + "HostIp": "127.0.0.1", + "HostPort": "52008" + } + ] + }, + "cpu_nano": 500000000, + "memory_limit": 134217728 + }, + { + "role": "postgres", + "container": "d396724f5d8f", + "pid": 8048, + "started_at": "2026-11-15T19:03:27.968282597Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 536870912 + }, + { + "role": "reconciler", + "container": "11e467c4c787", + "pid": 8691, + "started_at": "2026-11-15T19:03:39.987622088Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 268435456 + }, + { + "role": "s3", + "container": "0a5f16a1da1e", + "pid": 7917, + "started_at": "2026-11-15T19:03:27.449801097Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 1073741824 + } + ], + "parallel_replay": { + "requests": 30, + "messages": 1, + "instances": [ + "00479ff2407345c3a934eda19fadcc16", + "b0476ac5adb946b4a5b4ac4ed4045878" + ] + }, + "atomic_rollback_and_5xx_retry": true, + "expired_key_can_be_reused": true, + "failovers": [ + { + "confirmed_writes": 180, + "successful_reads": 171, + "errors": 10, + "successful_rps": 23.32, + "first_success_after_action_seconds": 4.642, + "action": { + "finished": 3.637 + }, + "observations": [ + { + "at": 0.008, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.072, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.135, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.201, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.288, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.361, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.438, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.514, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.573, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.639, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.698, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.755, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.826, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.9, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 0.968, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.027, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.091, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.162, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.237, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.311, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.383, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.461, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.53, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.598, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.66, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.72, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.79, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.868, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 1.966, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 2.069, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 2.174, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 2.272, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 2.37, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 2.432, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 2.494, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 2.549, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 2.639, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 2.748, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 2.837, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 2.952, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 3.036, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 3.092, + "instance": "00479ff2407345c3a934eda19fadcc16" + }, + { + "at": 3.149, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 3.211, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 3.271, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 3.327, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 3.389, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 3.444, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 3.506, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 3.562, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 4.642, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 5.715, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 5.792, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 5.865, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 5.942, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.013, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.083, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.144, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.212, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.275, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.329, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.397, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.459, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.546, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.61, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.68, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.748, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.817, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.882, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 6.948, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.015, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.076, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.138, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.211, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.288, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.354, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.427, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.501, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.573, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.642, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.713, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.78, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.849, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.917, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 7.988, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 8.059, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 8.127, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 8.2, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 8.261, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 8.319, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 8.384, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 8.491, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 8.596, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 8.687, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 8.792, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 8.993, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 9.205, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 9.268, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 9.326, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 9.385, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 9.443, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 9.511, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 9.58, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 9.644, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 9.707, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 9.777, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 9.841, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 9.904, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 9.962, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.025, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.084, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.155, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.221, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.293, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.356, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.414, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.481, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.547, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.609, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.671, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.737, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.809, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.877, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 10.937, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.007, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.07, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.134, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.198, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.259, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.328, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.385, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.444, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.51, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.57, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.64, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.715, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.791, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.855, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.922, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 11.987, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 12.07, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 12.144, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 12.213, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 12.281, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 12.346, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 12.419, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 12.483, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 12.548, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 12.611, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 12.856, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 12.921, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.001, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.159, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.226, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.299, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.367, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.435, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.501, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.566, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.629, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.693, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.759, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.817, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.886, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 13.952, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.018, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.088, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.16, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.222, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.29, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.359, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.428, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.495, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.564, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.626, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.686, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.758, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.817, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.88, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 14.948, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + } + ], + "confirmed_preserved": true, + "duplicate_texts": false, + "stopped": { + "role": "api", + "container": "e05ff3e9bffe", + "pid": 8842, + "started_at": "2026-11-15T19:03:40.38511538Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "00479ff2407345c3a934eda19fadcc16" + } + }, + { + "confirmed_writes": 199, + "successful_reads": 187, + "errors": 13, + "successful_rps": 25.6, + "first_success_after_action_seconds": 3.879, + "action": { + "finished": 2.839 + }, + "observations": [ + { + "at": 0.013, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 0.078, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 0.145, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 0.207, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 0.279, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 0.349, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 0.416, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 0.514, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 0.591, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 0.646, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 0.705, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 0.761, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 0.824, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 0.942, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 1.036, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 1.131, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 1.238, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 1.328, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 1.431, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 1.49, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 1.587, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 1.687, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 1.779, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 1.88, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 1.983, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 2.091, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 2.146, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + }, + { + "at": 2.209, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.265, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.326, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.385, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.437, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.488, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.548, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.6, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.649, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.7, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.753, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.817, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 3.879, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 3.949, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.011, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.076, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.132, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.197, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.267, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.335, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.404, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.488, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.556, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.623, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.698, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.765, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.834, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.902, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 4.968, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.037, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.102, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.159, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.228, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.291, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.36, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.433, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.5, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.57, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.642, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.709, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.775, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.838, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.915, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 5.984, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.055, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.113, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.179, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.241, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.302, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.363, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.426, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.494, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.566, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.637, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.709, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.774, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.841, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.906, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 6.967, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.033, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.107, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.177, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.246, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.312, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.386, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.462, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.536, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.607, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.672, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.746, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.817, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.891, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 7.959, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.022, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.086, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.15, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.217, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.286, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.348, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.413, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.47, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.535, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.592, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.657, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.715, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.782, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.852, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.919, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 8.992, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 9.064, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 9.141, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 9.214, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 9.287, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 9.358, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 9.437, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 9.51, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 9.681, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 9.774, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 9.879, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 9.973, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 10.083, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 10.24, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 10.307, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 10.367, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 10.432, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 10.503, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 10.569, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 10.633, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 10.696, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 10.764, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 10.831, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 10.897, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 10.962, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.022, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.08, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.148, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.217, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.284, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.353, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.428, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.502, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.575, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.643, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.715, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.786, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.865, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 11.936, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.011, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.077, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.145, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.207, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.263, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.327, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.387, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.454, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.526, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.595, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.671, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.744, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.817, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.883, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 12.948, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.015, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.081, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.148, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.212, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.279, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.342, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.408, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.473, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.536, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.599, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.665, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.733, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.804, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.881, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 13.952, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.021, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.086, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.151, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.232, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.297, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.355, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.414, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.481, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.549, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.622, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.695, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.765, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.84, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.912, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.984, + "instance": "ccd4bf67914f47b1831898341b925d6f" + } + ], + "confirmed_preserved": true, + "duplicate_texts": false, + "stopped": { + "role": "api", + "container": "826dbec1f35c", + "pid": 8766, + "started_at": "2026-11-15T19:03:40.193473172Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "b0476ac5adb946b4a5b4ac4ed4045878" + } + } + ], + "rolling": { + "confirmed_writes": 619, + "successful_reads": 617, + "errors": 37, + "successful_rps": 27.37, + "first_success_after_action_seconds": 39.366, + "action": { + "finished": 39.307 + }, + "observations": [ + { + "at": 0.016, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.078, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.142, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.22, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.285, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.349, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.417, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.488, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.56, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.631, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.7, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.763, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.838, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.909, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 0.989, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.058, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.115, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.178, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.23, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.293, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.351, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.414, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.47, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.54, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.606, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.669, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.729, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.816, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.883, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 1.945, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.005, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.063, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.136, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.194, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.248, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.305, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.36, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.428, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.508, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.59, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.651, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.718, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.781, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.84, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.9, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 2.963, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 3.016, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 3.08, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 3.149, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 3.22, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 3.284, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 3.352, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 3.414, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 3.477, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 3.553, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 3.644, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 3.701, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 3.762, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 3.829, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 3.887, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 3.955, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.027, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.09, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.147, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.206, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.271, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.333, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.406, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.485, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.551, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.616, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.68, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.746, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.817, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.889, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 4.946, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.011, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.073, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.144, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.211, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.271, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.336, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.397, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.458, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.526, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.589, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.666, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.733, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.808, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.878, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 5.955, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.025, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.087, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.148, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.213, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.277, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.343, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.408, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.475, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.534, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.597, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.664, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.73, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.789, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.854, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.92, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 6.978, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 7.044, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 7.11, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 7.169, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 7.232, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 7.3, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 7.363, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 7.428, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 7.501, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 7.57, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 7.674, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 7.767, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 7.876, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 7.975, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 8.585, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 8.663, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 8.732, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 8.83, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 8.93, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.036, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.124, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.226, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.292, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.357, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.424, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.49, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.549, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.612, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.686, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.756, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.828, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.909, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 9.979, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.044, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.111, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.179, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.246, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.311, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.375, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.434, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.511, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.578, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.645, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.711, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.782, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.847, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.914, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 10.98, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.047, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.114, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.177, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.239, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.297, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.363, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.429, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.499, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.566, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.63, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.687, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.756, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.817, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.882, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 11.947, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.013, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.08, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.146, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.221, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.289, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.354, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.429, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.491, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.57, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.633, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.689, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.747, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.816, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.876, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.933, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 12.996, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.054, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.118, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.189, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.262, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.331, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.391, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.456, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.522, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.583, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.646, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.707, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.775, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.848, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.911, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 13.994, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 14.063, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.121, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 14.189, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 14.258, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.327, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 14.392, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 14.468, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.543, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 14.614, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 14.675, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.743, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 14.807, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 14.874, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 14.938, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 15.0, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 15.065, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 15.139, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 15.209, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 15.287, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 15.359, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 15.431, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 15.502, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 15.571, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 15.63, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 15.696, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 15.765, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 15.832, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 15.897, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 15.959, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 16.026, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 16.085, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 16.148, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 16.215, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 16.276, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 16.342, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 16.403, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 16.469, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 16.543, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 16.616, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 16.684, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 16.757, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 16.817, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 16.879, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "at": 16.939, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 17.004, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 17.07, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 17.134, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 17.216, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 17.284, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 17.356, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 17.424, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 17.501, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 17.567, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 18.685, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 18.757, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 18.831, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 18.931, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 19.021, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 19.124, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 19.23, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 19.333, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 19.393, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 19.462, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 19.527, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 19.596, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 19.664, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 19.728, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 19.798, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 19.867, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 19.94, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.012, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.076, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.15, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.212, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.27, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.335, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.397, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.454, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.521, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.581, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.646, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.713, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.813, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.879, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 20.945, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.004, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.063, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.125, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.195, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.267, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.342, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.424, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.494, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.564, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.626, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.689, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.75, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.809, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.877, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 21.952, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.024, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.083, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.16, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.226, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.295, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.359, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.42, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.484, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.546, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.61, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.676, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.737, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.807, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.877, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 22.948, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.004, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.062, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.121, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.188, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.253, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.318, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.38, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.447, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.506, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.576, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.638, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.718, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.816, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 23.919, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.034, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.119, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.223, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.322, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.389, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.456, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.514, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.579, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.637, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.704, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.765, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.831, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.896, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 24.96, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.031, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.099, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.159, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.226, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.288, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.355, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.413, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.478, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.543, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.603, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.668, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.734, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.794, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.86, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.927, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 25.986, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.058, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.131, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.191, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.259, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.325, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.391, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.458, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.525, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.598, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.684, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.751, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.817, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.89, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 26.957, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.017, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.092, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.158, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.222, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.292, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.368, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.435, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.504, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.603, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.672, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.732, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.8, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.859, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.921, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 27.983, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.053, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.12, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.183, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.258, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.328, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.398, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.458, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.527, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.595, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.659, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.721, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.793, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.859, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.927, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 28.985, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 29.047, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 29.112, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 29.177, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 29.237, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 29.302, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 29.374, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 29.447, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 29.537, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 29.631, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 29.726, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 29.833, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 29.939, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.022, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.126, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.202, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.267, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.338, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.463, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.533, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.594, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.657, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.724, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.791, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.855, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.916, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 30.983, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.054, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.121, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.185, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.254, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.314, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.385, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.448, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.511, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.578, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.643, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.712, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.773, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.834, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 31.971, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 32.035, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 32.139, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 32.21, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 32.276, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 32.354, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 32.423, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 32.483, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 32.559, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 32.62, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 32.688, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 32.754, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 32.818, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 32.887, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 32.953, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 33.017, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 33.084, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 33.151, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 33.216, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 33.283, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 33.353, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 33.419, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 33.493, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 33.561, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 33.624, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 33.689, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 33.752, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 33.813, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 33.884, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 33.953, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 34.018, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 34.092, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 34.164, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 34.242, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 34.314, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 34.381, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 34.445, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 34.573, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 34.64, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 34.712, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 34.783, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 34.848, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 34.91, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 34.978, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 35.043, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 35.107, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 35.166, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 35.231, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 35.298, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 35.372, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "at": 35.443, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "at": 35.502, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 35.571, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 35.642, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 35.71, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 35.779, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 35.841, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 35.901, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.028, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.09, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.159, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.219, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.28, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.347, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.413, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.478, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.539, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.607, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.666, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.732, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.799, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.859, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.929, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 37.997, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.071, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.145, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.215, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.289, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.359, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.434, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.503, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.57, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.641, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.7, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.765, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.832, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.899, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 38.973, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.04, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.108, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.176, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.235, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.298, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.366, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.43, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.49, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.558, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.622, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.688, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.748, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.815, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.877, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 39.944, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.012, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.086, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.161, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.235, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.305, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.381, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.458, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.521, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.591, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.666, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.731, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.79, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.851, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.911, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 40.978, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.047, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.115, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.182, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.248, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.315, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.387, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.452, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.517, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.584, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.649, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.713, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.774, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.831, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.898, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 41.957, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 42.022, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 42.087, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 42.171, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 42.28, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 42.372, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 42.484, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 42.58, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 42.675, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 42.736, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 42.798, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 42.858, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 42.926, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 42.985, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.05, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.116, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.187, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.258, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.32, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.385, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.451, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.524, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.593, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.651, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.712, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.77, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.839, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.898, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 43.959, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.023, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.089, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.155, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.22, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.278, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.341, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.402, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.474, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.551, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.62, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.685, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.752, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.812, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.875, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 44.938, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "at": 45.003, + "instance": "06bad473cb87422b828f150b9e0141f0" + } + ], + "confirmed_preserved": true, + "duplicate_texts": false, + "before": [ + { + "role": "api", + "container": "e05ff3e9bffe", + "pid": 43321, + "started_at": "2026-11-15T19:10:44.119731215Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "ccd4bf67914f47b1831898341b925d6f" + }, + { + "role": "api", + "container": "826dbec1f35c", + "pid": 44705, + "started_at": "2026-11-15T19:11:15.178702549Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "e37e0a151e064d0eb2bde6d84b4d3b18" + }, + { + "role": "cache", + "container": "b4885e9057d5", + "pid": 7984, + "started_at": "2026-11-15T19:03:27.760175305Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 134217728 + }, + { + "role": "lb", + "container": "bf5b1211c8f9", + "pid": 9431, + "started_at": "2026-11-15T19:03:50.613696802Z", + "ports": { + "8080/tcp": [ + { + "HostIp": "127.0.0.1", + "HostPort": "52008" + } + ] + }, + "cpu_nano": 500000000, + "memory_limit": 134217728 + }, + { + "role": "postgres", + "container": "d396724f5d8f", + "pid": 8048, + "started_at": "2026-11-15T19:03:27.968282597Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 536870912 + }, + { + "role": "reconciler", + "container": "11e467c4c787", + "pid": 8691, + "started_at": "2026-11-15T19:03:39.987622088Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 268435456 + }, + { + "role": "s3", + "container": "0a5f16a1da1e", + "pid": 7917, + "started_at": "2026-11-15T19:03:27.449801097Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 1073741824 + } + ], + "after": [ + { + "role": "api", + "container": "cf7980262f50", + "pid": 45414, + "started_at": "2026-11-15T19:11:31.449613043Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "f22acb88cbe84011a66ea08d460ecf67" + }, + { + "role": "api", + "container": "22664db55f19", + "pid": 46205, + "started_at": "2026-11-15T19:11:50.182849968Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "06bad473cb87422b828f150b9e0141f0" + }, + { + "role": "cache", + "container": "b4885e9057d5", + "pid": 7984, + "started_at": "2026-11-15T19:03:27.760175305Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 134217728 + }, + { + "role": "lb", + "container": "bf5b1211c8f9", + "pid": 9431, + "started_at": "2026-11-15T19:03:50.613696802Z", + "ports": { + "8080/tcp": [ + { + "HostIp": "127.0.0.1", + "HostPort": "52008" + } + ] + }, + "cpu_nano": 500000000, + "memory_limit": 134217728 + }, + { + "role": "postgres", + "container": "d396724f5d8f", + "pid": 8048, + "started_at": "2026-11-15T19:03:27.968282597Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 536870912 + }, + { + "role": "reconciler", + "container": "11e467c4c787", + "pid": 8691, + "started_at": "2026-11-15T19:03:39.987622088Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 268435456 + }, + { + "role": "s3", + "container": "0a5f16a1da1e", + "pid": 7917, + "started_at": "2026-11-15T19:03:27.449801097Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 1073741824 + } + ] + }, + "replay_after_replacement": true, + "public_failover": "Executing explicit failover hook; hook output suppressed to avoid leaking secrets.\n{\"observed_instances_before\": 2, \"successful_writes\": 124, \"failed_attempts\": 2, \"first_recovery_seconds\": 2.262}\nPASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.", + "public_persistence": "Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.\nPASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.", + "after_persistence": [ + { + "role": "api", + "container": "cf7980262f50", + "pid": 50197, + "started_at": "2026-11-15T19:13:02.806283293Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "85715808d66b464a8ee8b1b56cd5c9de" + }, + { + "role": "api", + "container": "22664db55f19", + "pid": 50221, + "started_at": "2026-11-15T19:13:02.827565293Z", + "ports": {}, + "cpu_nano": 500000000, + "memory_limit": 805306368, + "instance": "003104329d7d4b898205cf12e339560e" + }, + { + "role": "cache", + "container": "b4885e9057d5", + "pid": 49923, + "started_at": "2026-11-15T19:13:02.11530071Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 134217728 + }, + { + "role": "lb", + "container": "bf5b1211c8f9", + "pid": 49927, + "started_at": "2026-11-15T19:13:02.11018996Z", + "ports": { + "8080/tcp": [ + { + "HostIp": "127.0.0.1", + "HostPort": "52008" + } + ] + }, + "cpu_nano": 500000000, + "memory_limit": 134217728 + }, + { + "role": "postgres", + "container": "d396724f5d8f", + "pid": 49970, + "started_at": "2026-11-15T19:13:02.15088096Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 536870912 + }, + { + "role": "reconciler", + "container": "11e467c4c787", + "pid": 8691, + "started_at": "2026-11-15T19:03:39.987622088Z", + "ports": {}, + "cpu_nano": 250000000, + "memory_limit": 268435456 + }, + { + "role": "s3", + "container": "0a5f16a1da1e", + "pid": 49845, + "started_at": "2026-11-15T19:13:01.994279293Z", + "ports": {}, + "cpu_nano": 1000000000, + "memory_limit": 1073741824 + } + ] + }, + "both_replicas_runtime_hashes_and_revision_match": true, + "fsck": "", + "checks_completed": true, + "result": "PASS" +} -- 2.54.0 From 7263949ec6d37afdae2f9ae2ad8af33d18699d30 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=81=D0=BB=D0=BE=D0=B2?= Date: Sun, 15 Nov 2026 22:21:47 +0300 Subject: [PATCH 11/12] docs(storage): finalize verified results and pull request description --- .github/pull_request_template.md | 2 +- REPORT.md | 29 ++++++++++++++++++++++++----- 2 files changed, 25 insertions(+), 6 deletions(-) diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index fecdae96..d4ad7140 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -14,7 +14,7 @@ rolling/persistence PASS; private S3/IAM/bootstrap, PG/S3 faults, dry-run/apply/ 30rows/8HEAD/0GETbytes, 3 измерения на размер +warmup; медианы0.194/0.204/0.409s. Raw: evidence/http-first.json, storage-first.json, cluster-first.json, cost-controlled-first.json. Отчёт содержит SHA, методы, RAM/CPU, ограничения и -ответы защиты. Clean-clone повтор выполняется; результат будет добавлен. +ответы защиты. Clean clone PASS: 108 tests, cluster/storage matrix, runtime hashes/OCI revision обеих API, fsck; receipt evidence/clean-clone-first.json. Контракт и публичные tests сохранены. Ограничения: один host, LB/PG/S3 — SPOF; HEAD не заменяет periodic checksum audit; inventory reconciler O(objects+rows); удалённый CI не подтверждён. diff --git a/REPORT.md b/REPORT.md index e18084f8..73739811 100644 --- a/REPORT.md +++ b/REPORT.md @@ -12,12 +12,12 @@ keyset pagination, общий Idempotency-Key, HAProxy и две независ PostgreSQL UNIQUE, хеширование остаётся вне SQL-транзакции. Argon2id и лимит двух KDF/process не ослаблены. [Первый отказ](evidence/registration-race-first-failure.txt) сохранён; после исправления [10 повторов по10 запросов](evidence/registration-race-fixed.json) -дали каждый раз один201/девять409, без503. Полный clean clone повторяется. +дали каждый раз один201/девять409, без503. Полный повтор из чистого clone прошёл: [receipt](evidence/clean-clone-first.json). -Публикация и окончательные результаты будут внесены после проверок. +Проверки и исследование завершены; PR публикуется по результатам проверки. Публичный smoke и 108 собственных HTTP-проверок прошли на полном стенде -(362.40 s). Проверки отказов/исследование прошли; повтор в чистом clone ещё выполняется. -Окончательная готовность будет указана после его завершения. +(362.40 s). Проверки отказов/исследование прошли; повтор в чистом clone также PASS (108 tests, 380.09 s). +Runtime проверен на двух API; receipt содержит исходный commit. ## Запуск из чистого clone @@ -132,7 +132,7 @@ Readiness проверяет PG и S3. При потере S3 HAProxy может Source первых HTTP/storage/cluster = `f5a7a74`, OCI revision API совпадает с ним. Контролируемый cost harness — `3fd912f`, исполняемый `src/reconcile.py` тот же. В чистом clone дополнительно проверяются module hashes/OCI revision обеих API -и полный набор сценариев; его результат будет внесён после завершения. +и полный набор сценариев; итоговый receipt — evidence/clean-clone-first.json. ## Методика исследования @@ -247,3 +247,22 @@ backup/restore S3, TLS и monitoring. Ready HEAD не проверяет вес на каждом проходе. Reconciler хранит полный inventory в RAM, metadata failed сохраняет для диагностики. Повреждение S3 нельзя исправить без резервной копии. CI workflow приложен; удалённый запуск не подтверждён. + +## Итоговая проверка из чистого clone + +[evidence/clean-clone-first.json](evidence/clean-clone-first.json): PASS, +source `6f8e4f127dee8857a3af908a9fb1d575f8907d90`. Новые secrets, env, +volumes, API image и фиксированный случайный host port; check/validate/lint, +public smoke, 108 HTTP tests (380.09 s), полная cluster/storage матрица, +hashes исходников и OCI revision обеих API совпали; git fsck PASS. +Временный стенд и только его volumes удалены в finally. + +Реальное старение S3 334.035 s; пять ожидаемых действий dry-run/apply, +повтор 0; fresh/ready/used данные защищены. C10: 10/10, ошибок0, +6,017,095 bytes/image, 5.429 s включая verified downloads/sampler; +1.842 successful uploads/s, upload p50 2767.956 ms, p95=p99 5002.469 ms. +После рестарта API новые cgroups: sampled memory.current max 138.30 MiB, +memory.peak max 143.94 MiB (включает startup до серии). +Контролируемое исследование 9cells выполнено отдельно и не выдаётся +за повторённое в clean clone. Старый failed receipt сохранён для истории. +Последующие коммиты меняют только отчёт/evidence, проверенный runtime сохранён. -- 2.54.0 From ab12d3eb781f03fb5655fd7c6b8c15d15bf77c24 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=81=D0=BB=D0=BE=D0=B2?= Date: Sun, 15 Nov 2026 22:31:04 +0300 Subject: [PATCH 12/12] docs(storage): link submitted pull request --- REPORT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/REPORT.md b/REPORT.md index 73739811..0ebf6bcd 100644 --- a/REPORT.md +++ b/REPORT.md @@ -14,7 +14,7 @@ PostgreSQL UNIQUE, хеширование остаётся вне SQL-транз сохранён; после исправления [10 повторов по10 запросов](evidence/registration-race-fixed.json) дали каждый раз один201/девять409, без503. Полный повтор из чистого clone прошёл: [receipt](evidence/clean-clone-first.json). -Проверки и исследование завершены; PR публикуется по результатам проверки. +Проверки и исследование завершены. PR: [ЛР4 №144](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab4/pulls/144). Публичный smoke и 108 собственных HTTP-проверок прошли на полном стенде (362.40 s). Проверки отказов/исследование прошли; повтор в чистом clone также PASS (108 tests, 380.09 s). Runtime проверен на двух API; receipt содержит исходный commit. -- 2.54.0