diff --git a/.dockerignore b/.dockerignore index bc16e55..ff084d9 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,15 @@ __pycache__ node_modules evidence .DS_Store +# Not needed in the image (only requirements.txt, src/, migrations/ and the contract are copied) +.pytest_cache +student-tests +bench +tests +contracts/* +!contracts/openapi.json +examples +scripts +infra +docs +*.md diff --git a/.env.example b/.env.example index 714c807..c84d354 100644 --- a/.env.example +++ b/.env.example @@ -5,7 +5,19 @@ APP_PORT=8080 APP_ENV=lab SESSION_TTL_SECONDS=3600 # Choose credentials locally. File paths contain no secret values. +# The files are created by `python scripts/init_secrets.py` and mounted by compose as secrets. DATABASE_URL_FILE=/run/secrets/database_url # Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres +# valkey = sessions live only in Valkey (AOF, appendfsync always); postgres = table `sessions`. +SESSION_STORE=valkey CACHE_URL_FILE=/run/secrets/cache_url +# Additional settings of this implementation (defaults shown; all optional): +LOG_LEVEL=info +DB_POOL_MIN=1 +DB_POOL_MAX=10 +DB_TIMEOUT_SECONDS=3 +CACHE_TIMEOUT_SECONDS=0.5 +PASSWORD_HASH_CONCURRENCY=2 +DOCS_ENABLED=true +# Host port of the API (compose publishes it on 127.0.0.1 only) +APP_PUBLISH_PORT=8080 diff --git a/.gitattributes b/.gitattributes index fe0e860..3c10fe5 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,3 +1,5 @@ # LF everywhere: identical files on Windows/Linux and inside `git archive | docker build -`. * text=auto eol=lf *.png binary +# cmd.exe expects CRLF in batch files. +*.cmd text eol=crlf diff --git a/.gitignore b/.gitignore index b5a7189..ed8abe8 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,4 @@ coverage/ .vscode/ # Keep small, sanitized evidence summaries in evidence/ under version control. # Inspect git diff --cached: ignore rules are not a secret scanner. +.pytest_cache/ diff --git a/Dockerfile b/Dockerfile index 026e683..470f37a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,10 +1,10 @@ # syntax=docker/dockerfile:1 -# In-memory messenger, lab 1. Build: docker build -t mtusi-messenger:lab1 . +# Messenger API, lab 2 (PostgreSQL + Valkey). Built by compose.yaml (services api, migrate). # # Python is interpreted, so there is no separate compile stage; the image # contains only the interpreter, locked dependencies and the source code. -# Base image is pinned by version AND digest (python 3.13.15, Debian 12 bookworm). -FROM python:3.13.15-slim-bookworm@sha256:2325bb286ec344af3e5898cc224b5844e2707ac6e26b1632516fd3edc84a5e26 +# Base image is pinned by version AND digest (python 3.13.16, Debian 12 bookworm). +FROM python:3.13.16-slim-bookworm@sha256:a1165e272e578941b84abc79e4ab38a0305cd12803a5c4247979ac7655f4d641 ENV PYTHONDONTWRITEBYTECODE=1 \ PYTHONUNBUFFERED=1 \ @@ -25,17 +25,22 @@ RUN groupadd --system --gid 10001 app \ && useradd --system --uid 10001 --gid app --no-create-home --shell /usr/sbin/nologin app COPY src/ ./src/ +# Versioned SQL migrations, applied by `python -m messenger.migrate` (compose service migrate). +COPY migrations/ ./migrations/ # Course contract, served read-only at /openapi.json for Swagger UI (/docs). COPY contracts/openapi.json ./contracts/openapi.json -# Defaults make `docker run` work without an .env file; --env-file overrides them. +# Non-secret defaults; compose.yaml passes the rest. Passwords come only as files +# (DATABASE_URL_FILE / CACHE_URL_FILE -> Docker secrets), never as ENV or COPY. ENV PYTHONPATH=/app/src \ APP_HOST=0.0.0.0 \ APP_PORT=8080 \ APP_ENV=lab \ LOG_LEVEL=info \ SHUTDOWN_TIMEOUT_SECONDS=8 \ - DOCS_ENABLED=true + DOCS_ENABLED=true \ + SESSION_TTL_SECONDS=3600 \ + DATABASE_URL_FILE=/run/secrets/database_url USER app:app EXPOSE 8080 diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..1f76ebe --- /dev/null +++ b/compose.yaml @@ -0,0 +1,108 @@ +# Lab 2 stand: API + PostgreSQL + Valkey. Start from a clean clone: +# python scripts/init_secrets.py # once: random local credentials into ./secrets (git-ignored) +# cp .env.example .env # optional overrides +# docker compose up -d --build --wait +# Images are pinned by version AND digest. Passwords are passed only as secret files. +name: mtusi-lab2 + +x-api-env: &api-env + APP_ENV: ${APP_ENV:-lab} + LOG_LEVEL: ${LOG_LEVEL:-info} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_STORE: ${SESSION_STORE:-valkey} + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + DB_POOL_MIN: ${DB_POOL_MIN:-1} + DB_POOL_MAX: ${DB_POOL_MAX:-10} + DB_TIMEOUT_SECONDS: ${DB_TIMEOUT_SECONDS:-3} + CACHE_TIMEOUT_SECONDS: ${CACHE_TIMEOUT_SECONDS:-0.5} + PASSWORD_HASH_CONCURRENCY: ${PASSWORD_HASH_CONCURRENCY:-2} + DOCS_ENABLED: ${DOCS_ENABLED:-true} + +services: + postgres: + image: postgres:18.6-bookworm@sha256:afc7e2d441324c0388fa80c3d24f733b4194a4eb7f47dd8ee2b08eb1a24a647c + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: [postgres_password] + volumes: + - pgdata:/var/lib/postgresql # PostgreSQL 18 image keeps PGDATA under this path + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger -q"] + interval: 2s + timeout: 3s + retries: 30 + start_period: 10s + stop_grace_period: 30s # clean shutdown checkpoint instead of crash recovery + restart: unless-stopped + + valkey: + image: valkey/valkey:8.1.3-bookworm@sha256:fea8b3e67b15729d4bb70589eb03367bab9ad1ee89c876f54327fc7c6e618571 + # The password goes into a config include readable only by the valkey user, + # so it never appears in the process arguments. docker-entrypoint.sh drops root. + command: + - sh + - -c + - >- + umask 077 && + printf 'requirepass %s\n' "$$(cat /run/secrets/valkey_password)" > /tmp/requirepass.conf && + chown valkey /tmp/requirepass.conf && + exec docker-entrypoint.sh valkey-server /etc/valkey/valkey.conf + secrets: [valkey_password] + volumes: + - ./infra/valkey/valkey.conf:/etc/valkey/valkey.conf:ro + - valkeydata:/data + healthcheck: + test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/valkey_password)\" valkey-cli ping | grep -q PONG"] + interval: 2s + timeout: 3s + retries: 30 + start_period: 5s + restart: unless-stopped + + migrate: + build: . + image: mtusi-messenger:lab2 + command: ["python", "-m", "messenger.migrate"] + environment: + DATABASE_URL_FILE: /run/secrets/database_url + secrets: [database_url] + depends_on: + postgres: + condition: service_healthy + healthcheck: + disable: true + restart: "no" + + api: + build: . + image: mtusi-messenger:lab2 + environment: *api-env + secrets: [database_url, cache_url] + ports: + - "127.0.0.1:${APP_PUBLISH_PORT:-8080}:8080" # only on localhost of the host + depends_on: + postgres: + condition: service_healthy + valkey: + condition: service_healthy + migrate: + condition: service_completed_successfully + stop_grace_period: 10s + restart: unless-stopped + +volumes: + pgdata: + valkeydata: + +secrets: + postgres_password: + file: ./secrets/postgres_password + valkey_password: + file: ./secrets/valkey_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url diff --git a/docs/DATA_MODEL.md b/docs/DATA_MODEL.md new file mode 100644 index 0000000..d6d7f3b --- /dev/null +++ b/docs/DATA_MODEL.md @@ -0,0 +1,41 @@ +# Модель данных lab2 + +Схема: [migrations/0001_init.sql](../migrations/0001_init.sql). Источник истины для пользователей, чатов, участников и сообщений — PostgreSQL 18. Для сессий источник истины — хранилище, выбранное через `SESSION_STORE`. По умолчанию это Valkey с AOF, его можно переключить на таблицу `sessions` в PostgreSQL. + +## Таблицы и ограничения + +| Таблица | Ключ | Ограничения | Зачем | +| --- | --- | --- | --- | +| `users` | `id uuid` | `UNIQUE (username)`, `CHECK` формата username, длина `display_name` | уникальность имени держит БД, а не код: гонку регистрации разрешает уникальный индекс | +| `chats` | `id uuid` | FK `created_by → users`, длина `title` | `last_message_at` — «часы» чата для упорядочивания сообщений | +| `chat_members` | `(chat_id, user_id)` | FK на `chats` и `users`, `UNIQUE (chat_id, position)` | `position` хранит порядок `member_ids`; `chat_created_at` — копия времени чата для keyset-списка чатов | +| `messages` | `id uuid` | FK `(chat_id, sender_id) → chat_members`, длина `text` | отправитель обязан быть участником — это гарантирует сама БД | +| `sessions` | `token_hash bytea` | FK `user_id → users`, длина хеша 32 байта | хранится SHA-256 токена; сам токен не хранится нигде | +| `schema_migrations` | `version` | checksum файла | какие миграции применены; изменённую задним числом миграцию мигратор не применит | + +**Почему `bytea` для текста.** Контракт разрешает символ U+0000, а тип `text` в PostgreSQL не может содержать байт NUL (`DataError`). Поэтому `display_name`, `title` и `text` хранятся как байты UTF-8. Длину в code points проверяет API, а `CHECK` в байтах — страховка (1 code point ≤ 4 байта). + +## Индексы и запросы + +- `messages_chat_keyset (chat_id, created_at, id)`. Первая страница — `WHERE chat_id=$1 ORDER BY created_at, id LIMIT n`, следующая — `WHERE chat_id=$1 AND (created_at, id) > ($2, $3) ORDER BY ... LIMIT n`. Сравнение строк `(created_at, id) > (...)` попадает в `Index Cond`: поиск начинается прямо с позиции cursor и читает только `n+1` строк. Запросов два, а не один с `($2 IS NULL OR ...)`: иначе при generic plan условие cursor уходит в `Filter`, и поздняя страница сканирует всю историю чата до неё. +- `chat_members_user_keyset (user_id, chat_created_at, chat_id)` — список чатов пользователя тем же keyset-способом. +- `users_username_key` — вход по username и уникальность. +- `sessions_expires_at` — очистка истёкших сессий. + +## Транзакционные границы + +| Операция | Транзакция | Что гарантирует | +| --- | --- | --- | +| Регистрация | один `INSERT` | `UniqueViolation` → 409; ровно одна строка при гонке | +| Создание чата | `INSERT chats` → `INSERT chat_members` (все участники одним запросом) → `COMMIT` | неизвестный участник вызывает FK-ошибку **после** вставки чата; откат удаляет и чат, и частичное членство | +| Сообщение | проверка членства → `UPDATE chats SET last_message_at = greatest(clock_timestamp(), last_message_at + 1 мкс) RETURNING` → `INSERT messages` → `COMMIT` | строка чата заблокирована до конца транзакции, поэтому писатели одного чата идут по очереди. Время сообщений строго растёт **в порядке коммитов**: страница по cursor не пропустит сообщение, закоммиченное «задним числом» | +| Вход | `SELECT` пользователя, проверка Argon2id, запись сессии | неверный пароль ничего не пишет | +| Logout | `DELETE` сессии (или `DEL` в Valkey) | повтор с тем же токеном — 401 | + +Чтение истории не требует snapshot между HTTP-запросами (так в контракте): новое сообщение появится на следующей странице. Список чатов сортируется по `chats.created_at = clock_timestamp()` без блокировки. Два чата, создаваемые одновременно, могут закоммититься не в порядке времени. Тогда у обхода, который уже начался, такой чат может оказаться «до» cursor; новый обход его увидит. Чаты создаются редко, поэтому мы не сериализуем их глобальным замком; это ограничение описано в REPORT.md. + +## Сессии + +- Токен: `secrets.token_urlsafe(32)` — 256 бит случайности, в ответе 43 символа. В хранилище лежит только SHA-256 токена. Для случайного 256-битного значения быстрого хеша достаточно, медленный KDF нужен только для низкоэнтропийных паролей. +- `SESSION_STORE=valkey` (по умолчанию): ключ `session:`, значение `{user_id, expires_at}`. Срок жизни задаётся абсолютным `PXAT expires_at`, поэтому рестарт его не продлевает. Включён `appendonly yes` + `appendfsync always`: подтверждённые вход и logout сохраняются до ответа клиенту. Valkey — **единственное** хранилище сессий, это не кэш над PostgreSQL. Поэтому нет второй копии, которая могла бы «оживить» отозванный токен после отказа. Если Valkey недоступен, проверить сессию нельзя: защищённые запросы и logout получают 503, анонимный доступ не открывается. +- `SESSION_STORE=postgres`: таблица `sessions`, проверка `expires_at > now()` в запросе. diff --git a/infra/valkey/valkey.conf b/infra/valkey/valkey.conf new file mode 100644 index 0000000..510785b --- /dev/null +++ b/infra/valkey/valkey.conf @@ -0,0 +1,17 @@ +# Valkey is the single store of sessions (SESSION_STORE=valkey), so it must be durable. +# AOF with fsync on every write: a confirmed login or logout survives a crash/restart, +# a logout can never be lost and "resurrect" a token. Sessions are small and rare +# writes, so the fsync cost is acceptable here (see REPORT.md). +appendonly yes +appendfsync always +appenddirname "appendonlydir" +# RDB snapshots are not needed on top of AOF. +save "" +dir /data +port 6379 +protected-mode yes +# Sessions are never evicted silently: if memory is full, writes fail and login returns 503. +maxmemory 128mb +maxmemory-policy noeviction +# Password, generated by scripts/init_secrets.py and written here at container start. +include /tmp/requirepass.conf diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 0000000..aef95c4 --- /dev/null +++ b/migrations/0001_init.sql @@ -0,0 +1,65 @@ +-- 0001: initial schema of the messenger (lab 2). Design rationale: docs/DATA_MODEL.md +-- Applied once by `python -m messenger.migrate`; the version is recorded in schema_migrations. + +-- User-supplied free text (display_name, title, message text) is stored as UTF-8 in BYTEA: +-- the contract allows U+0000, and PostgreSQL TEXT cannot contain NUL bytes. +-- Lengths are limited in code points by the API; the CHECKs below are byte-level safety nets +-- (one code point is at most 4 bytes in UTF-8). + +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name bytea NOT NULL, + password_hash text NOT NULL, -- Argon2id PHC string, never the password + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT users_username_key UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_len CHECK (octet_length(display_name) BETWEEN 1 AND 400) +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title bytea NOT NULL, + created_by uuid NOT NULL REFERENCES users (id), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + -- Per-chat clock: created_at of the newest message. Updating this row serialises writers + -- of one chat, so message timestamps strictly increase in commit order (see DATA_MODEL.md). + last_message_at timestamptz, + CONSTRAINT chats_title_len CHECK (octet_length(title) BETWEEN 1 AND 400) +); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id), + user_id uuid NOT NULL REFERENCES users (id), + position smallint NOT NULL, -- order of member_ids sent by the creator + chat_created_at timestamptz NOT NULL, -- copy of chats.created_at for keyset listing + PRIMARY KEY (chat_id, user_id), + CONSTRAINT chat_members_position_key UNIQUE (chat_id, position) +); +-- GET /chats of one user: (user_id, created_at, id) range scan, no sort. +CREATE INDEX chat_members_user_keyset ON chat_members (user_id, chat_created_at, chat_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL, + sender_id uuid NOT NULL, + text bytea NOT NULL, + created_at timestamptz NOT NULL, + -- The sender must be a member of this chat: enforced by the database, not only by the API. + CONSTRAINT messages_sender_is_member FOREIGN KEY (chat_id, sender_id) + REFERENCES chat_members (chat_id, user_id), + CONSTRAINT messages_text_len CHECK (octet_length(text) BETWEEN 1 AND 16000) +); +-- History page: WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT n +-- becomes an index range scan that starts exactly at the cursor. +CREATE INDEX messages_chat_keyset ON messages (chat_id, created_at, id); + +-- Sessions for SESSION_STORE=postgres (the default store is Valkey; see docs/DATA_MODEL.md). +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY, -- SHA-256 of the token; the token is not stored + user_id uuid NOT NULL REFERENCES users (id), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + expires_at timestamptz NOT NULL, + CONSTRAINT sessions_token_hash_len CHECK (octet_length(token_hash) = 32) +); +CREATE INDEX sessions_expires_at ON sessions (expires_at); diff --git a/requirements.in b/requirements.in index 7aa83dd..bdaae42 100644 --- a/requirements.in +++ b/requirements.in @@ -1,8 +1,16 @@ # Direct runtime dependencies. The pinned lock with hashes is requirements.txt: -# docker run --rm -v "$PWD:/w" -w /w python:3.13.15-slim-bookworm \ -# sh -c "pip install -q pip-tools==7.6.1 && pip-compile --generate-hashes --strip-extras -o requirements.txt requirements.in" +# docker run --rm -v "$PWD:/w" -w /w python:3.13.16-slim-bookworm \ +# sh -c "pip install -q pip-tools==7.6.1 && pip-compile --generate-hashes --strip-extras --no-emit-index-url -o requirements.txt requirements.in" starlette==1.7.0 uvicorn==0.54.0 # Fast C parser/event loop used by uvicorn in the container (Linux only). -httptools==0.8.0 -uvloop==0.22.1 ; sys_platform != "win32" +httptools==0.9.0 +uvloop==0.23.0 ; sys_platform != "win32" +# PostgreSQL driver (libpq bundled in the binary wheel) and its async connection pool. +psycopg==3.3.6 +psycopg-binary==3.3.6 +psycopg-pool==3.3.3 +# Valkey client (Valkey speaks the Redis protocol). +redis==8.1.0 +# Argon2id password KDF. +argon2-cffi==25.1.0 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..78a3b4a --- /dev/null +++ b/requirements.txt @@ -0,0 +1,452 @@ +# +# This file is autogenerated by pip-compile with Python 3.13 +# by the following command: +# +# pip-compile --generate-hashes --no-emit-index-url --no-index --output-file=requirements.txt --strip-extras requirements.in +# +anyio==4.15.1 \ + --hash=sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101 \ + --hash=sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94 + # via starlette +argon2-cffi==25.1.0 \ + --hash=sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1 \ + --hash=sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741 + # via -r requirements.in +argon2-cffi-bindings==26.1.0 \ + --hash=sha256:061a6919145bbf282ebf1f9c59d3135d4833c25313c8595c0d68cf7712ddfce2 \ + --hash=sha256:0cc40f7b4050bb93eb67de95d2d759322fc7ce4930b9d645581ecf4913ec651e \ + --hash=sha256:151dfaad9de753f4af2a7854e707e4784f2acc434340ade64239c5b104b2d605 \ + --hash=sha256:19423e5d7ac1cc354baab59eaabf18db2ec04ef6593b5abe5a34f323c4a8f87a \ + --hash=sha256:19b562b1de4b9052ef1214a2821c44b6e6f22945daa102c32ae4eff929d8b6d8 \ + --hash=sha256:1a0a29ed86960e44eaace7e081bdfab4f08b012fd96ec8edba71e2ad020939e4 \ + --hash=sha256:1af817e84578ef8b7295ad17de0f9896e4c8520dbf2233c7aa5aa3d487256fc4 \ + --hash=sha256:1b0bcac4d490a237e18cf91f57352920c29f77f2fa39efd0813fb81298bf17ba \ + --hash=sha256:1d98e33bd8bd67d7206c124e200bf2229c4cfa8c9c19f7b44a897f0fc71837eb \ + --hash=sha256:21ca0396fe5ec995dd54431c32698189666f9224810acfa752e50d2bd94d9df2 \ + --hash=sha256:224865cbbcb7a2bd1356741dff12b0134df726b6d44bb7b500df8e303cbd9e81 \ + --hash=sha256:242bb0cda2ae3650764fc194593d9ea45fc9e72729acd89778c7cfe184cec2a5 \ + --hash=sha256:27f1821903e2ceadcb88ec2b45ef190897b7682449c772f4d9b53e42c520cf29 \ + --hash=sha256:28524438cd3e723f25412f63d4fd516ff5bae9ae5aa56acbe2a1404398a0cf31 \ + --hash=sha256:2b741888c93147444fdfc851abd81cc207f37f7f7da42062a00deb3888e57da8 \ + --hash=sha256:2c36ff87b5dfaa477d0bd51e9d7f6abdae7c8955d2983c97419085d842154b3e \ + --hash=sha256:34b7d9c24a4165a2c61cc8ae11d44d48c9ce2830fb536cb7914e11fdd9962728 \ + --hash=sha256:49d525938467d52c923a890153c99087c9d5a937d1f6b585dbdba34ec82e397a \ + --hash=sha256:4f84cdd868978d7b7350a566c254042d44216d9e37f241f3a6d3b1dfebeede35 \ + --hash=sha256:62ff20cd130c956c7c9144d5fe35228f98b51c579b2439e988b27ef93e16c02a \ + --hash=sha256:63505c71542a44b68b1e38060450fb006404170da375feb31af153e7f9c6205d \ + --hash=sha256:6376d4b3aca039375ca8bf92f770da0ec424a1ce3a37077a8d3c557411aa56ca \ + --hash=sha256:6a4e68eed961a8de6928d1c17ff3dc2a547e0e923c17f8f1cd79fb7bc9502f98 \ + --hash=sha256:6ab674f668d5962a3a4136ae0812519b0f1586874263723a32181d60d64137e1 \ + --hash=sha256:7014ab7e6f5d8511af92544667a0346ea6dfc314ea9a7cad1dba9fdb5c9a6e33 \ + --hash=sha256:76ae29acace5d33355344612844d588e19deaaba4639d8bb01601e4b1418ef36 \ + --hash=sha256:78de2d65e0b9ea7ce9d1b1c3e87297b2d7305a02c266ee2a2d6910daddd7ee69 \ + --hash=sha256:9bacedc04b0402837586a17f0919e3dfdd95291f441f1f56bd80ec274c2840a1 \ + --hash=sha256:a86c069c91a747a2c4e5c51473590aeb48172fff9b2130d23729a42d98665ecb \ + --hash=sha256:ac82fc756a446b6ccd7139ce70efa9d8bbe541e7ad579a12dcb52764b7175c5f \ + --hash=sha256:af11ac37a7c53dc16cb7950a6190851b0870fe218b6c60c0bb7ac355234e3083 \ + --hash=sha256:b70225b5fd1e0d2ef4f7fd30d24658454535f0924dff0caca5dc08efbbbadfbb \ + --hash=sha256:c49e853a3bef9dd10329f31f702e7fa9b5c58229ff9c2ff6d069efaf09177c08 \ + --hash=sha256:ccaf0a46cbb380f1fd102a874e32aa629fd3cb0c0e94f4943fa1f6d5edc5dac6 \ + --hash=sha256:d157ddfab1e8b21f2f1dedda9c09645d98b5ed0b667b0626be600a345d426440 \ + --hash=sha256:d88e5f7e60f28ae0b0cc6b2f16c43e87cd642a196a86f85e0d8bb6fe016fc16d \ + --hash=sha256:db0fcd827ca61622a01b220aadfbece01939acf53888f2cb98cd93e9b1e2c97e \ + --hash=sha256:df612391feca41c44d20118f3b88d1b86419465cd1f5496859f715ca60ec2210 \ + --hash=sha256:f0c3103fcff20183e593459cfea6e012281c0e76ae3ed8b5565ad1b92eac3990 \ + --hash=sha256:f9c4420a7a864fe1b86ce35befc95b8e39fb852493b81cf798671ddc265de638 \ + --hash=sha256:ffff613aaa9ce6236766e2fc6dc560bb5abde7a2e2416e3db1f9ae395a2b4dd4 + # via argon2-cffi +cffi==2.1.1 \ + --hash=sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e \ + --hash=sha256:06c72bb76605a4b0cd0aad6930b69d4baf7dd5d806cfc409b824191099700e66 \ + --hash=sha256:0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2 \ + --hash=sha256:154852545011f779917b11c78db2358d095da62a9a172b78ad0a583ee5adc0d0 \ + --hash=sha256:194cffa889098ced9976c3fc6340305e43f6303657d298da55366907c05c22d6 \ + --hash=sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971 \ + --hash=sha256:1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c \ + --hash=sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d \ + --hash=sha256:1dea0e4d7d4f11f619fe8c1d76caf49e24405b4b5743c0e3be16a500ecd930c9 \ + --hash=sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517 \ + --hash=sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735 \ + --hash=sha256:246fa40ce8645a614ff682e0b70f37134e460eaf93a775e0cbe3cca585a67a80 \ + --hash=sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f \ + --hash=sha256:27350daa11d4f10c540e6e89dada4c54feb7256ad03e9a4dc075ebad7ba360d1 \ + --hash=sha256:28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29 \ + --hash=sha256:2ae64be792b8966f2c69538199728b290e34726562896df1e5dc8ffd8d8188e8 \ + --hash=sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c \ + --hash=sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e \ + --hash=sha256:3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48 \ + --hash=sha256:3311ed60d36f83378794e1009ac6258bafbf81f7888b4caa7b35a521e3f95813 \ + --hash=sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac \ + --hash=sha256:34e261f78cb6ceaaa36f42f2613f4380d94d9c759a9c73c769ee6e0247364632 \ + --hash=sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6 \ + --hash=sha256:398aff33cee2767e3e781d2554c54bd0dff386bb437581e0d8011fde1a942ec1 \ + --hash=sha256:3d22a20b1fb1632cc72c22f95f7b0d2961c3e1c235f245ba4c606c4771035659 \ + --hash=sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688 \ + --hash=sha256:42e2f76b9455f5a9a844f770bf3e200ed3da0e15f5df3db9c31fe80b04b3d004 \ + --hash=sha256:42f6930c31dc7f50732c9ae793c2786c7b6b044195967bbdde40bb9be81c4cc0 \ + --hash=sha256:456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062 \ + --hash=sha256:471cee653ae88de62096552e6d24ccb4a5adb8c8c9f10b5054d0122c15bf2779 \ + --hash=sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94 \ + --hash=sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50 \ + --hash=sha256:4be96343e422f2dfcd12ab5c9f5aebe03f82f737c6bffeca6830b3875cb44aab \ + --hash=sha256:4f42141fc14250de6dde5ee7ea4432be017252d91f19c5ad043c084cea629cac \ + --hash=sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6 \ + --hash=sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676 \ + --hash=sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1 \ + --hash=sha256:5a59cc1c4442bc3d5c703bf720b51138d0bfc173618807c9ee2490a7541dd3d9 \ + --hash=sha256:5bb4e7ea95dcd6a014a6fef62e62467d67d8e582326443f3d68e71d6320a9fcf \ + --hash=sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13 \ + --hash=sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e \ + --hash=sha256:616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e \ + --hash=sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973 \ + --hash=sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527 \ + --hash=sha256:661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72 \ + --hash=sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890 \ + --hash=sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c \ + --hash=sha256:6e192623c49c94421616a5778fba35cf0d5a8d000650c1967ef4448ee5cdd990 \ + --hash=sha256:7225e4514edb64eb6740324353e0da0711954fd8d7da4576755b1c6e09b697cd \ + --hash=sha256:75f80557d1389eddbd0de2681f6a390a0c5338c31ddaa821381c203fc3fd50d9 \ + --hash=sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94 \ + --hash=sha256:7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3 \ + --hash=sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80 \ + --hash=sha256:7ce713ace7c0e4520535b42b77eaa742c16dab813978064913e5a3cf82973b41 \ + --hash=sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5 \ + --hash=sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c \ + --hash=sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a \ + --hash=sha256:8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4 \ + --hash=sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e \ + --hash=sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6 \ + --hash=sha256:9f8d177621de5cb38ee3e731eda45d421db093ec0739f46a5594babda7987a98 \ + --hash=sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b \ + --hash=sha256:a48d62ab9d6f4f98c983223a547af44be6ca3691074c31cecced6facd3ba2dc1 \ + --hash=sha256:a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03 \ + --hash=sha256:a6e721d4b0e45d5b65e87534470e67b18dcd092c83f68fba09f152b9cbc061af \ + --hash=sha256:a730a083190634c65cca36ba5f489531576ebd79bcd5c8e172130f6453127231 \ + --hash=sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2 \ + --hash=sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3 \ + --hash=sha256:ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836 \ + --hash=sha256:ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5 \ + --hash=sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399 \ + --hash=sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96 \ + --hash=sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e \ + --hash=sha256:baed1e86cc735622097354b9d1281406caf42ff42a886d29faa8e8d1630333be \ + --hash=sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf \ + --hash=sha256:c26608d2222fb1e94487e4a387d85f13eb55d5ed725cb25a0c589ac4ee60e7bc \ + --hash=sha256:c7659f22557c5a0bc4855cd635f55edec690cc008a40768527762cb9fb263455 \ + --hash=sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0 \ + --hash=sha256:c8d2c9fd1f2d16f780d15127abb050d13d1a76c03a4bd87d7e4980e45e511e12 \ + --hash=sha256:ca82be1a1d406ecfe1d25dc16cb33488e5a16bf4438c9fb590484ea29d92478b \ + --hash=sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7 \ + --hash=sha256:d18e5ac0f2f03f4f518d3e23db0f0cad7faa1da8620e9c09461d443bbf6e6692 \ + --hash=sha256:d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54 \ + --hash=sha256:d9c275eaacd24aa73f94ffd6de08fc3f932424d8b6c376f4bed7cde376fe7bc3 \ + --hash=sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b \ + --hash=sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be \ + --hash=sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d \ + --hash=sha256:df423d40ee8654634421812bc3b196da3f9bd7d32929da813f8394c4348a5358 \ + --hash=sha256:df913725b79db7bcf03448f36b7bf8815363417d5b58deecf9305e3e30f0f21a \ + --hash=sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7 \ + --hash=sha256:e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc \ + --hash=sha256:e6e8cff14d6fb0be70a09c0bdc58096f501952d04624ebf867e0e56da2df8960 \ + --hash=sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125 \ + --hash=sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb \ + --hash=sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a \ + --hash=sha256:f5cfbc5fe74540d335175b656c725d74d90e3730c626d92575eea35029d9afaa \ + --hash=sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf \ + --hash=sha256:f8ec5e643a9a937f64e1999eb9f75d072263751912dc5cd06d3c85f8f44be7c3 \ + --hash=sha256:fb92203a88b3d3053034db775110081c49d28be6551923805e039924093761e4 \ + --hash=sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264 + # via argon2-cffi-bindings +click==8.5.0 \ + --hash=sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360 \ + --hash=sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34 + # via uvicorn +h11==0.16.0 \ + --hash=sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1 \ + --hash=sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86 + # via uvicorn +httptools==0.9.0 \ + --hash=sha256:02bc5b3dcb6394b9d825fd62a7bfa0b2943063a3c89abc4492ad45e334a20eb5 \ + --hash=sha256:050f7ab098121873c8f13e35857f97ab60a76185c8302bde9a384939bb7c3b96 \ + --hash=sha256:050f84b7ec46a6efe0e5f521cf8729e3397c1cef4384f62ed8d5d68ca0045776 \ + --hash=sha256:06bfe7fad972a417269d8a5fc53b87e4eca970354abf5e9e24336fd06d64292e \ + --hash=sha256:088de1738e1af624466a01c35d652dbe6fb825be887c76d68aa850621d81db88 \ + --hash=sha256:0adc974916efe1fbf89d0363a86dcb2c746727643e362ff398de1a4b50b6bc77 \ + --hash=sha256:0cc339a807c156d840b54f8bf050ba0fc265eb81692c24bca8535b52fbd797c6 \ + --hash=sha256:0fd73d0bbf700a30dd87e4412adf41cfa71542a533d6b390c7244bbb8a1152bb \ + --hash=sha256:130635fea6e611a6b2026120037965ddb88b3dafd11bb64e264b101a70a76630 \ + --hash=sha256:13873eb8aef5972fcfee614f63d47064312ad4efbfe65ade15b8a3b77f8c8659 \ + --hash=sha256:18d800aaa2d6bff7d889df810d1b19a5fde72b1f6c0ca96e8d9f28a692fe5460 \ + --hash=sha256:1a4050a651e1f2faf05eb028ce9f2168abbcee9e24b209f5c1f2eb96d8c569e4 \ + --hash=sha256:1a7f1df31829c258158be01bb04eb668c4fba7df1ddf2262131a972962e651b6 \ + --hash=sha256:1b01c0fcd6725a8d79a164ecdc4116866282479d68bb3d6d74a909bf994656c4 \ + --hash=sha256:1b95775f6292d72cb452c33e5c0f8b8551807c29a10e3c1671fef7f61361370a \ + --hash=sha256:1f6da814aeecbc6cb8872d6d3e85ed16e8ab1653f9557cea8658725ce212348a \ + --hash=sha256:2095207b75a83c9e947346da9c127fb7e4fb29f41589df2643764f06b750989c \ + --hash=sha256:22ab1b10b06d357f01092e60f5e6856a0d479ed79b0ec2166a339ea26c699be2 \ + --hash=sha256:2319858018eedd0c0b2f950a620413c0a9d1352607be4267eb28209eca8b1e3f \ + --hash=sha256:268d18601feb5367885c6ebf6f402c18fc25a324cee215784adafe0a1eef925f \ + --hash=sha256:26e1d9629f3bf70d23f0d22238152aec51c837a7c9e384cb74f356fdccad7eb3 \ + --hash=sha256:272db0c51e8b71e953c1f2ecbe63402b819680e4564be2ef285cfd4584ee8355 \ + --hash=sha256:289f213d2a3dde2e8312c415ffecec5a01698589ec6249ec4e8fb3b47c0444ba \ + --hash=sha256:29b0d823e3c1e7cd1093a5dc889245db693ef13ada624cd66e2262421ef38867 \ + --hash=sha256:310266a2db1377ffae3bdf6556ab4973f4f94508a8ce37b2f6bb096a89bcefa1 \ + --hash=sha256:3238e198429cb8909ec42951b82d6a33fe0fdfcf86371732f8f09311c5b8ac32 \ + --hash=sha256:34266cec8c1d4e3e91fcca7efe38971d6bdda64a7944f2a46ab576da15173680 \ + --hash=sha256:36fac804b8cfd6b935ae64f71349f833d2b6298404626d017a2c57bb942bc643 \ + --hash=sha256:3af4e45ff455fce5511fdf2653c1ce428ef09c56fe37a83eb4d924c2d474f31e \ + --hash=sha256:3e3201fe4d46e0d15d7ff9fafc94a605da9eb82d2c5b9837f0368acb325481f1 \ + --hash=sha256:45b3002392948dcf578029c89f6318e1289a993a1a5ec38a4161560fab60f811 \ + --hash=sha256:465bc1526debf53a3be92022a16ca0c38f891ea3b5c1587af4f52e44020f8a07 \ + --hash=sha256:48c705bd0b1afb6253ed71eca9f9ba7ac7d47838e5fed1ef7891d67f21ecd4de \ + --hash=sha256:4a4d8c2c7e73ba5967be74d7c3a5ff81fde815ee1b48d9c5c0f14de8463a847b \ + --hash=sha256:4a85401b0c3f893cf5695c1199e8679fbf673f7f78c2f6c11d6b1850f8c7e358 \ + --hash=sha256:4c58dc91aefb31adad500aa68054334f429b840b36dd29e34e834101044cb2ef \ + --hash=sha256:4efbee349138a3fee7a4cc3a95abd2d499fae70dd5bff9fed9138d6f570f4283 \ + --hash=sha256:4fb995082fe41ec410b33c48b54fb1d44abb8a6ee762c31e8c42519e8c3a30a9 \ + --hash=sha256:5042aa1c7e2b1a24c17dab31d8770b63a5101c9abc25f832c6aef6b201e1ca4f \ + --hash=sha256:52fe0176682a25b15370f23f5b0f1366a84771df89144fb0cd979cb72a94b5ca \ + --hash=sha256:5332a020a60bbe32ede4bda1a62b3d56c4831d309cdf0932842c0fca8ad6aaa3 \ + --hash=sha256:563e4568217dc907a91843f38c737be865222c0400a38cdcd0d26ce92b3db271 \ + --hash=sha256:581b27663c6e9f4df68068f32fe6d1cd7647b31fac90237221a66f8821c342eb \ + --hash=sha256:58a1b0ec4cbb930e69669f9771715b2c7898d3cdf064d9811f7a66afef96b544 \ + --hash=sha256:5cc5d3a29f9ec86ce406e5ec09c241dd8dc4d30e838f74f68d728b89131a3acf \ + --hash=sha256:63d38e9a9a10a20fb57593742e63c6b1e78dd7f6ef5472de8e0b1e4cf4f3db26 \ + --hash=sha256:6b1ac7f1bc6c0dbf90684b77571a51a21b2463909fd916ce0ac9bfc4d566dc75 \ + --hash=sha256:6b900073e7b8481ef1aaf4f6c1789d210a1db01a9da8789821578cfeb4c2d540 \ + --hash=sha256:6c12d0393a903b58bc5f5a7406d6c5290acfb8284290d68547ce620c06f7d133 \ + --hash=sha256:6e2780e33a58a93f27cc3bb74a55bae6f9a8278a1dbabdff392940d30d381671 \ + --hash=sha256:6ebd39ee26db460cfe5ab8b71a15d1149b289139a0d3981522757d6af620887e \ + --hash=sha256:6f8b41299b203ce8f627db670cfea82067d9638853dbeaf86dccd93878879b85 \ + --hash=sha256:6f9549ca354a1d6d6167c458a1f1b12147726b968f02dd64b6a5801dba91ae0f \ + --hash=sha256:6ff0145b34610e57c9fae20df4e133c8d54266447387de6fcc0bdabfe4db4569 \ + --hash=sha256:6ff5f0ed70783dcb9562dbd20edca51c3d4d277f128223709e3da6b75986d1d4 \ + --hash=sha256:714bf348f468532d86bed670837e7d5ddff3834dd7f5d3c08066da400c86f088 \ + --hash=sha256:757e3f79cb865a7db94e0db5f4d0ed3284a69e39d53568f433982ea13c60cac1 \ + --hash=sha256:7e32b83bd8c2f8b6fa726ef34e63e21c4d7eddc277d40d4ef7245ea3ed28e5b6 \ + --hash=sha256:805b0f2618e5d4c3e28f45b731eb1a0539691ae4a2f97b4ce014de0bf96a1ff5 \ + --hash=sha256:80eae881cfb69383303e9a4d7961a478025b89c24f38f2e69b30c516fa0d57f2 \ + --hash=sha256:813a32f94991b9627795528053c73a57d2ce3eb98ede89f0e1c7a31095938e81 \ + --hash=sha256:8463b34ebde3f000627e9dbd8a545f995ad49fbf7ff9dd5abc0cd507da98a603 \ + --hash=sha256:8a59c749a73fbdbc8e63b895a3079825fa085d752e75bc0a500042cb8a801e48 \ + --hash=sha256:8d90d10e9b6594c28f27896a68fab97fd784c43804e9fe419dab8e8dcfcf4b02 \ + --hash=sha256:8e1e037bb57dbc549c6fe20370b763ea74bdb09413cdcf857e4f14d9e4e2fb13 \ + --hash=sha256:931f45f84e15daafec5f82cc92e6710569e1f50933f3253d206eab4132bec678 \ + --hash=sha256:995b52f7c260ac7023640221f27472303968753cb6fc6fce1ddfb0e9db59a398 \ + --hash=sha256:9b4da5789d7cf576c7e81f0088c632f6ee3786d87d17f08e90e703c22ce15633 \ + --hash=sha256:a3ed60ea9a7c352c590182c67404599e6b5a0c901e75ae4cceee9a9fd6bfa455 \ + --hash=sha256:a4d1ecad62e83cc65b411ea0125972cf3af98821e8117129947fd1e3a113f8d2 \ + --hash=sha256:ae9bb62a7902e2ab65782447cd3eeb753510feace4e3ea03937a85489b01b16b \ + --hash=sha256:b2ab3aad55d75d0b8df8d8a1b5920baaec9b161112cd5e95984848b4d2cd3dfe \ + --hash=sha256:b2cc6991f16f6d666d48e4b57318104e7b29109e32e2f6b86e9d44c4e6a27f4e \ + --hash=sha256:b5a3f5f70967a1aa2bc47fec42a1e19d2fb38c61700e3ee62b63a4af4f4fd001 \ + --hash=sha256:b68fb053b37c258a473ab67f4965c3b439500dc160fe364667035a6833eaf50a \ + --hash=sha256:b6ee42112d785a913dd63ec0335435a3dddbea5040c151252db815b0095cf066 \ + --hash=sha256:b928ab0ecaa664e8caecc529dcb8bc881b6b35bb2b74bf9a39ae25f982ee8812 \ + --hash=sha256:b9430f65db521db7962ad951571d446171213686f96c998a54dc18ed574821e2 \ + --hash=sha256:b9cd15cb7cf0d5cc41f649fd789aae12c56c3b83eff593f8e095c1d4555ad5c3 \ + --hash=sha256:bb1533541c729ad422f870a780d8b4af924f9817d45b5f580390418cda72eaa2 \ + --hash=sha256:bbf7377fbd41b7c87d47820e25b9876724963681c2a1d6f6ff2adb4db46ac174 \ + --hash=sha256:bca180cbe84e4fba7807eb408a8655295f697928512324517e30a091ede522a8 \ + --hash=sha256:beb2c8a34cc90fb4d862b7284eafdb322030d6a8b2ee5eb6a744f84205beedc3 \ + --hash=sha256:bfdabac0c6d3d6a5be8c2a100a001c92c14a39bbafd5999545a675c493626e64 \ + --hash=sha256:c0e45def4d9ce7073e2226535572442d9d6efb4047c7a5fd8960807e877ce70a \ + --hash=sha256:c0f537e5e8152e8d9cae82804024790cb973061abd3b7ef8f66f46e2b5c7bb51 \ + --hash=sha256:c195a69df0ab2541252ab5b1d76e3c182e5688ac2a9b708e5e6f66aaeda91e9a \ + --hash=sha256:c271bfb832be5c5c020b4e2fcbc1e70a0b990adba6de874b0bba1184b89cdea3 \ + --hash=sha256:c42424213c28804f8d0e20f5692106cfb57bf72e1dbc4092b8481fb2f9e4c707 \ + --hash=sha256:c4fa57d3c31889722f64bfa785545a5e603a893b6f29ac1a41bfa830abeaefd5 \ + --hash=sha256:cb2bb3ac0af7fdab2311b895c9eb95442b45deb14cc949b9e65545e74aa0be69 \ + --hash=sha256:cb3e7a4fd0168e362673a980380bf4fd6ae3b1555150e60c5390b4b10d9c50c4 \ + --hash=sha256:cbbfcd5d15056fbd1edd5e725cf3feeb47c7cbccbe205927ebab422cc229f417 \ + --hash=sha256:cd3e55223a77d6e08d5730ebacb4930ecca5d2ce7c57e7ba10833be7e52903f1 \ + --hash=sha256:ce8e723b4637034b76f5382a30a6b725518c332273e8d62a6c7d46e90837c947 \ + --hash=sha256:d1e329a1866981efe0201d05a374617f6c6cf14434a501d78ab22793d1ab1fa6 \ + --hash=sha256:d20ba5c84cf0592afb2713336f07e2b6ced082e4ae803ceada153a85613efc9f \ + --hash=sha256:d2b095129b9a98eb46a271ee9631089529c4e40354576b4aa74e24de9d2bf2f7 \ + --hash=sha256:d3906b5c549ff2ad2473cb711e1fc65d76715c2726a402108fbf55eab6c6b49d \ + --hash=sha256:d484ebb7e3a3f3597b0f645fbd1b85633674ca808c1f5ba11c2caf7c66f5c8b6 \ + --hash=sha256:db735a23ecb0f0450d2b24e0a05fb00a8a35c9db172919c4d3e023e7c7ee4c9b \ + --hash=sha256:dbc9fd1521e573045d71b6afab7398439c5cc259e8cb9d416fe62d485c4899c6 \ + --hash=sha256:df3867518b205be3648e2fbd522bf380c851b5c2500588047505afdd786b6669 \ + --hash=sha256:e0acbd474d0af4afacc6e66c4273f8a19e25f8af4379fc816388095ea6b01371 \ + --hash=sha256:eacf0f45ca3ff84c01481c60c15da9ee56711f7292f66663df0f57af61e011c2 \ + --hash=sha256:ead1a40543a033a6732a9e1e515944979a19db3737ce77363fc0660e38554344 \ + --hash=sha256:eae4e9c7a0785a1a715de0a74fb822ab40084c060f444f18f075d05e322aa7ef \ + --hash=sha256:ecf7037e491c220cd73987838c1ac3958d787bb098c3be0bfaf7f04204a6162c \ + --hash=sha256:ecfeee649184ffd800955068be9a6b579a0f33fc3c98535d685d5779cb59347f \ + --hash=sha256:edd5aa045fa3cc57143db018dd32ce7962bd5b525d05230709015d7e570100aa \ + --hash=sha256:f0ef48ce353f6b6a52232ba23d0983d4c2c84c84a778899404e34b4718509bf2 \ + --hash=sha256:f1734bd6f588975ffc246211e8b96c11933344087ca280d2cbcbf35cf835d7a9 \ + --hash=sha256:f67db0ba2bedafec15b8e5330d40da1e1c7921559fa715af021252bfef81a6f8 \ + --hash=sha256:f6ac1414556b910a879c108d79736f77e797871f9919ed0d2c3cf8cf3ecca986 \ + --hash=sha256:f78f7ae1c2e5aabf29583fc0d302d8081a663776f84578025662eb6f5d63a921 \ + --hash=sha256:f9489c1d87160c126f73b004742fe8654fa1ce37ed89e9e01330a1c10aaecde4 \ + --hash=sha256:f9ccc9884241efceb4547a92955d128574c864681f11b7ea3ecbde295fafbe8b \ + --hash=sha256:fc1a4f9d18d32a6e0a0a0a382986a60a2126f5144dd08715be7adb8df18e8a46 + # via -r requirements.in +idna==3.20 \ + --hash=sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44 \ + --hash=sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c + # via anyio +psycopg==3.3.6 \ + --hash=sha256:a1db9f7148b06a28606767efaca51fa6f9398c5c0a3810519be69d7000bdb631 \ + --hash=sha256:c081f2250df751a943036e42db6df4571c66cd0aabe8291a7a506512b12007d2 + # via -r requirements.in +psycopg-binary==3.3.6 \ + --hash=sha256:05a83ac9fd52b9bca7cb5ab04b3691163170bd16f53defa27216ea3aa07ee781 \ + --hash=sha256:0a52991594ac4db888c7d39bccef331797e30cb31a95cae02cf2607f83a42dc2 \ + --hash=sha256:0bf08b749cc144f33b44a91b78e3f71c60eb07963746a0df5a100b36ce3d7475 \ + --hash=sha256:0ebfad5d131de9f892ae9e70cc7616207768b6714b66a52d4612b8ceaf78b372 \ + --hash=sha256:1679a1cb93fbe5a6d1fd58d82cbddcc6fcb8c61446ba7cae6eb2a7b19bc585de \ + --hash=sha256:198a48e68cc99ccac03ba95ac857e73aa66f3bf6be77019fafb0832a05f7ad03 \ + --hash=sha256:1fbd30e537dab22cafdf080608f10148fe2a5f3a61294ddb5113caac8a623840 \ + --hash=sha256:289aadd6a00e151203c081f708348ec89f1e483c9b510ef4ac3981f847f01f79 \ + --hash=sha256:2f122603f36050937982abf9668d8bc4769a79f7c93a65013b1c49f1cab7b56b \ + --hash=sha256:303732e798fe6729f8e12021b9c96107df8e95ecec4dd487c67b98ec2a59435e \ + --hash=sha256:31cd942c23f613276b81a6e6598cefa12960058b0f46e1e874b540c793f6aca5 \ + --hash=sha256:366db6e97e66b37211475f20c4c1324a2dc0dd825e46d4e87f9d599304d276f9 \ + --hash=sha256:373704aea331d3f3e3402c125a1543f5875e2986ebb54f97d1647942161f803f \ + --hash=sha256:37d40450659401600e6d043ff586c89a71a69f33cbb8bcdba6cdb2569beecdbe \ + --hash=sha256:37e517c146b185f9c0c6e8d0a0ebbdeeeb67896af28466e032bc810d0c7dc7a7 \ + --hash=sha256:3af90f92769d8cc10f94515ee7a0aef36ea85ca733a0ce22858f6e0953f41138 \ + --hash=sha256:3c9e663b2e800e3218994cf948c11bcc2844e6491b34aa80d089baf6531827bf \ + --hash=sha256:3f84dab25e0385692ee13274c68678377e0b1a70ab9d14e56264cbf61f60c62d \ + --hash=sha256:4690cf67738f0e0e49a32aeec99bf0e4595cc2b4f1af984a4345394b1dcff91a \ + --hash=sha256:566dd827f17728efdf7d88a5b066f815170f6fdad13967ae952842d90e6aaa9f \ + --hash=sha256:5927b7ba63153cd8e9862987290a2b783a5c590daf2a4ef981700cc3569166d4 \ + --hash=sha256:5ad8f35e67cc16d1fad1fa8c88972dc9b3a3141ea67897399904edab96a301b6 \ + --hash=sha256:5ea8beeb5541780b4b50b462eeacbc4f594ce3b911dc20c81c75f267876f71d2 \ + --hash=sha256:5f598f19fa9a91540b5cee17932ffd227b7b53a481605bcc4573c0eafa647300 \ + --hash=sha256:612382ac3ed13651c7fa44b5fee9fbf7baaa2ddbc6f500391672682c5f1df9e0 \ + --hash=sha256:6ff05561e4a067d35507dc5c90f1deb2ec1c9703ac5cccc1bc26e08a197f9c5a \ + --hash=sha256:7308c93cf0b19bbaf8e6ff0a6ad50d3c442385739245fe15a8d593bf841734a6 \ + --hash=sha256:79a2a1c3449f6c3409427078ed1cec10de79f3023cb5f2504f0597d350ad46c7 \ + --hash=sha256:7beb3e41c9a1e509f3ed85263386588cbe3e975aa67be21f79f44fd35ffaeefc \ + --hash=sha256:86147cb5d140341c3363fb5bacce31f8d5543902a46699d3c536b101bbceaf9e \ + --hash=sha256:889e42acec10450185e0cdfb396f375e2c1a8d7737c114830a7fde4654f59e30 \ + --hash=sha256:910ace140e3e7b7596898d083f37a8fe90c5c40684252ad4e682364b2cd3deba \ + --hash=sha256:955e3dd94da361e052d2e49acf591017158dc8f8ed2c8a42c2e3943403c39dc2 \ + --hash=sha256:9892188bb15e5803beb51afe8a25add6b56be391a53058e8bca03b74e1e6bf22 \ + --hash=sha256:98c02090d88f2ebc0ec1e8da538f77d225ce0fffecf372aa39262e62a1b054ef \ + --hash=sha256:9b2f11794e017ce340934e35de46181c46ef71ec75ea3d85dd75cd836761c01e \ + --hash=sha256:a2e44a342d2aee40508e28a563d8961c39d9bbd8cae36d8578f0a3c6658aab0f \ + --hash=sha256:a4ee3bdd5468a725f2a4d9aab8a74b6d0279f768c8b5d3aeb102c5307ff3d59c \ + --hash=sha256:a5165300324efd5a772c48a88ab3a928513ab3979fca76553e62ee815f7b2b9c \ + --hash=sha256:a9348c5b43a3bb5ef8c2e89d5237c9c87eeafb01d338c84a7aebbc5cd0313299 \ + --hash=sha256:aa73160077345ec21b3f51e8e24b3de2e99586217e497629326eb9b2ea88c52e \ + --hash=sha256:ad1c785e784cfd87e8436c6b7702f2d321fc39601bbaf29bc63a41a867091638 \ + --hash=sha256:b3f75dee0f9afafabe4edc52c4842f1e1878ed2069bd05b22d6fe961e97e4dba \ + --hash=sha256:b599defe9190b17e9907c8b4d114c181e702c87efcd1b8a0ad40971cdcc4634a \ + --hash=sha256:b82491019b884d62318b5f30706c3d7e6d4e5a6cb7eabcb3edc0c1b0fdaceae9 \ + --hash=sha256:b8ece331509f7a975b90501f41e83ad905e4141753fedf3f2711b2bc70a8efbc \ + --hash=sha256:b979a42815410432420275412633960807178b1ce26591a16ce06e78a5bd4bb2 \ + --hash=sha256:be4f9b3c9338ac5dd217c5847e21521b396c8117f78dc420d495a5c49bbef874 \ + --hash=sha256:bf8c8481d026b85dd70c5fa7dde85b2333aed0b32a2602bcd38a900cbd78a49c \ + --hash=sha256:c61617eaae0112ca154da87ffb99b73af2c74067acac28dfb9a4455b019dff2e \ + --hash=sha256:c6d19cb4999d03231e8730a5f66c8f5068bc3b532677eb39dab0f600bff3e312 \ + --hash=sha256:c7753871eb57e6a5f4646f6168590c6653073dea5e9e720b201c8875332df4c8 \ + --hash=sha256:c7f92daa0d2a1c76f07264abddf8cbabd30152a2f09c3270e50f0c7efdf5dcac \ + --hash=sha256:cbd5f73073ed19c378d4c35499db1e3e703a5b1a324e521204065967bfaa7a18 \ + --hash=sha256:cec5ea900390897d0b46130f60bc2883bf19c314f9044235217c8be88b0ef269 \ + --hash=sha256:d636338c8f21b0df2f84657b00bc34f9313f826ef93f1155bc743607e4a0c5eb \ + --hash=sha256:dc75da5a20951049f7b773145f998f69d181adad9c58a0ff36e0cf1d73c10e10 \ + --hash=sha256:e23a66a763fbe83fcc210bc77c27e5a5ea380ebf091c06f34d8561b695e5a40f \ + --hash=sha256:e8cbb54454dbf1bbf2ff08dd7693e8d94ac94b1a20f70f4b3b813d52ecb5cbc1 \ + --hash=sha256:ee2c4728c691245e24501fcd7a97b5b381236b9985bc445bba88cdce7d1b5784 \ + --hash=sha256:f0535693ce476a722b718b002d5d2c27d47e71ca945276ac194409c98e74c492 \ + --hash=sha256:f19cc87343eaa55255e76b31259a570072ac95d6ae82c92dd34b97691f5e49dc \ + --hash=sha256:f21d057f3e5f5491067e5b292498073b73847d48799b099803fef100775fcc52 \ + --hash=sha256:f87dbdc42e78ee0f7ea180c03f8c78e80a949e373066629bd90fefff10552dff \ + --hash=sha256:fa34eb47969297471db7b7f193622c7e3ee839ec05abd05f1fe104d5b1b1dcf4 \ + --hash=sha256:fdccb3a0e184b03e9baa673b15a809cf36c339c85dbda0ebc25a698846dfbee8 + # via -r requirements.in +psycopg-pool==3.3.3 \ + --hash=sha256:9b9cd6a4fcec47a410f7e82d408540e7f77b478509e91b44c1a5457a13e5ff37 \ + --hash=sha256:df87b5d9d0ad7db37f6cdad4fa8ce113d250f5997f6db38e9a99192fb67f9e1d + # via -r requirements.in +pycparser==3.11 \ + --hash=sha256:51d5a8ba2be0bbe440b99d2112604c95bbbc3c2748a64260186c541e1729cd80 \ + --hash=sha256:d875f09c3507d00e1aba0eecc6dcadc1352f30fff09dc6bff2f1c2935e97c2bc + # via cffi +redis==8.1.0 \ + --hash=sha256:6e1a19beef9225c83efd689c7e6b7da2d5215b1f42cd13b7fc3714d0a09c7b25 \ + --hash=sha256:a4fe1aac3d3b3cc791d4b3d5931c5a956045dc951ee74d1c913ee3ac4d2ee9fb + # via -r requirements.in +starlette==1.7.0 \ + --hash=sha256:67f8e99895493dd2911a03f11314af6ceebeae4e704bb9f43dfc6a9db151c93e \ + --hash=sha256:c79f74ea63cff761804fbbfb182f1e0b440c2d07b164d24700c5a1bab5d6ff5d + # via -r requirements.in +typing-extensions==4.16.0 \ + --hash=sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8 \ + --hash=sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5 + # via + # anyio + # psycopg-pool +uvicorn==0.54.0 \ + --hash=sha256:505bdb0f318731d45f1f712071fc781a8981f6847a31c902c9f5e652d4f67faf \ + --hash=sha256:a2e33cbfaa0306f8e6b0c13e0cb89d7d7a2da3e62b90c66e18c33d9807b28620 + # via -r requirements.in +uvloop==0.23.0 ; sys_platform != "win32" \ + --hash=sha256:0305871ac712f54b62af73f943dbf21ae3ce80a44bc0f0151424484affa85645 \ + --hash=sha256:090865d8ce7a03986755a3ce711b7dd0d4b44eb14ab74368b717f3fad1180208 \ + --hash=sha256:098a85e1393ef5202767b7e5fb41a32cd8bd81e6ee4af364c179801c4aa3f6d4 \ + --hash=sha256:0efdd55bddbd36bb2fcb842d64c0d5f6407c6958c68088cc25df8c09edc5b5fd \ + --hash=sha256:12634f15e6625f78b3f2922f91404c4d7173487eba11746764153f556e9852dc \ + --hash=sha256:1748321e3c59a14a75404b1ae8d5a8d81c4e201803ea0e14c1b6fd84421024b5 \ + --hash=sha256:19c64108b507cd0bc140e400e3396bacebd9d504956aa7726272bf6de7d9aabb \ + --hash=sha256:1e84575f11873c109cf3962ad0bdf679094466184125f4cadcc41a73febff41f \ + --hash=sha256:24c58ae4a83e93a04c504bcc678125e36a0bfc44af928ad69444880c60f187a5 \ + --hash=sha256:28d160f51ab4da3b187063652e643dea6831072add4adc1e6d62afbe73b6be27 \ + --hash=sha256:2dcff2d69be43e6559e5dad2c5a7a2dbfb60e05a77311b6c4b7a4a8123d86c65 \ + --hash=sha256:31e0cf90bc8fd88784f6802cdba968a51fb1aec1cc3feec74d862b2d371d1330 \ + --hash=sha256:378188efbb1524f2219d05246a3e1e5907217848d2882144dff59585f1b81d55 \ + --hash=sha256:42feced24b9b44b856c633eafb5cc5dec354972da55ce77598db6844c054bc7c \ + --hash=sha256:4448e9124537620f9c25d004c227bb5104440b58955c19bbd312d910af919a63 \ + --hash=sha256:4a08875543bbd4519faf30497506c9cda8a48470467ffdf967c7313c7a5981a8 \ + --hash=sha256:4b8e207c67d207a8608fec57e116511030af3495dc0109b8c333cf9cb412b16f \ + --hash=sha256:4bb7f5d0b62b5afaaaea2b7b60d508921c24b0fe39c22c1438bec1811ffe10ec \ + --hash=sha256:4f1798f56c6f4ba5ac11fa2869e5717926e4470d97a1dd42b4f59219d43b5027 \ + --hash=sha256:514698d3683189031dcbfdc31e87115992e5ce9e1b19fe5359941323f2df800c \ + --hash=sha256:53c2c5d7e2024e46776c2d90e6c637d01102126b61aaf5faa5edaf05f8b5722a \ + --hash=sha256:55d6f4135d914305929fe9e9c44d8b5383a9b3fa1bee3bfcf60ee97e01af07ea \ + --hash=sha256:5a2bbad3a63007f7e9524d4903ba04fee252557c2acd86f9a3d4f91786695254 \ + --hash=sha256:5a3e0f56ec19bfd9ad1605572878dd6ff7f01b325f4fc154812ae70d615c3aff \ + --hash=sha256:5bb9be71d9ee39b4359b832f9569518ec9bc08704194034e79e4958e6bc4d46d \ + --hash=sha256:60ec798c40a1810d282ee046f61ecac1c5675cb898763d9f08d97d53a5e00a81 \ + --hash=sha256:6b3cbc4f96ddfa1fb88a78a69dd851369825b7816d9702eee8c4461505ba172e \ + --hash=sha256:6c7ef4701a96553514b2688e342ef1bf2beae6cfd172d89a76c768292aabf405 \ + --hash=sha256:7337b06a9f9ed9ea3049f04b76f65819db9b19bb832ee598e97b388eadf25e5f \ + --hash=sha256:76345f51367fb1f23e08605c6efb18374f669be5b223658fbab6b17627950507 \ + --hash=sha256:7e35c9bc977760981693e1a7a51493b58ee5a501f9ebb1e547565ee40b6c6208 \ + --hash=sha256:80cac5cb90ed7b9b72a217a1d6982b15b829cdbd0ee6bc19b93e3a9e47fb0ac9 \ + --hash=sha256:8af88fe5c7dd68fe1fec6dea8155caa1a47155d219a750ff34049541cf536a5e \ + --hash=sha256:8fcd721113260ffb5e38bf14a8725b17d431f34209f7d1c7005b667946e630b3 \ + --hash=sha256:93087a845cdfb35753e539354ac9551bdd2ff528c202a98df0ae46e852bcf021 \ + --hash=sha256:93935ab27b6eaef4c3e5489aebc84284f0644592f7ab516df60ee1b27eaf5eb3 \ + --hash=sha256:9bf08e4b6362dd1c08623bbfa2d061e8bac0f1da8fc2007062cfe1dc360a49fa \ + --hash=sha256:a6ac96da66c35bf789bdcde78a88dc7d56b7907d8379648c54adc1c61594575d \ + --hash=sha256:ab17b3a8aa754be0de0e397f7b95f13b14e56f077a4c6ae295e3d4afd199b325 \ + --hash=sha256:b0d106d9314546d69b3df1b5352639aa628530ec3ecef8a98a21942d2a2a64f5 \ + --hash=sha256:b90397a50ad6332ed3e459c648ac20d182cce24a557354363ad85fc9ea4a17cd \ + --hash=sha256:bbbdb8fcd5e7062e546eec1ac78c28bb21ae7df54c18f8e4b06e15a18d661a49 \ + --hash=sha256:bd6f2f81c7b9da99d301c0b16b82044e76fe887086e42e1590ecf520b94dbdac \ + --hash=sha256:be53e1d5f83de43dc175c87612ecc128d444b38e5c56cb3f807f5a73d6887476 \ + --hash=sha256:c3f23f403a273900d57de6ee5ca0614c650f7f58563065dad1a4744498960e53 \ + --hash=sha256:cbe8d03d4efcccdb7fcedecbaa1e1fa02913eaf3a74cb933634a6bc6d2ea9e2a \ + --hash=sha256:ce17bc317d089f361b33521654c13e30eacfd3d2034fd34e613ca9c51c969686 \ + --hash=sha256:d918d6f304a309222a784bbd140b85ec5594d97e4dc0e79f590549d28970663a \ + --hash=sha256:dc61e4f9e37b507069dc7e659ae28bca7adcb04c993c3508214315d12c63f848 \ + --hash=sha256:e095f9e105af76593b4c183bb0bcbdae64bd913a59ec595732dc108b48730ab5 \ + --hash=sha256:e2cba180d6451822763eda8364f342435a873bcfb3849cbd82fdeca248ca65eb \ + --hash=sha256:e49eba8f1e28e7c03648b7a476e1ba05309e087ccdea859fc6dd659564aa8d7e \ + --hash=sha256:f1341c6abcee1c31277cfe28d34e46196f2143ec3d755e6efe7452126e1f626d \ + --hash=sha256:f3fbfe82829d8e381426a289b87e59e585278728361db9ce975b88b51f64f410 \ + --hash=sha256:f50b580fad005a092ed87c5a3a4683459b21d1620497d6a5bccad203bee4c071 \ + --hash=sha256:f5576e8ae1723ece60d8f93c6710abf784714e99388bcf023ba9ca800bc587f6 \ + --hash=sha256:f673d835bdb1a60229cc3609a113fd2c9ce3f4a3c75ad4eaed111180c00199d2 \ + --hash=sha256:f7548ede3ee908cfabc0d068106e303a9a2d811af959cdf6ab85676344cedcda \ + --hash=sha256:fa8ed556fcc87a4091cf61587ef172fa104323dc89ecc085a618ba7ff8629a8f \ + --hash=sha256:fefea5cf8cdda9053b962ca8a90216fb0b1d40907dcb6819382b42e483e6e9f6 \ + --hash=sha256:ff7144d8167e513fe39fbb46bffb4f6f192dfb1f4b0b4e9102e1fd4f212e4747 + # via -r requirements.in diff --git a/scripts/init_secrets.py b/scripts/init_secrets.py new file mode 100755 index 0000000..b02f635 --- /dev/null +++ b/scripts/init_secrets.py @@ -0,0 +1,47 @@ +#!/usr/bin/env python3 +"""Create local synthetic credentials for the stand in ./secrets (ignored by Git). + + python scripts/init_secrets.py + +Idempotent: existing files are kept, so re-running never changes passwords of a +database that already has data. Prints only file names, never values. +Delete ./secrets together with the volumes (`docker compose down -v`) to start over. +""" +from __future__ import annotations + +import os +import secrets +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +SECRETS = ROOT / "secrets" + + +def write(name: str, value: str) -> None: + path = SECRETS / name + if path.exists(): + print(f"keep secrets/{name}") + return + path.write_text(value + "\n", encoding="utf-8", newline="\n") + # Readable by the container users (postgres, valkey, app uid 10001) through the + # compose bind mount. Local synthetic lab credentials only. + os.chmod(path, 0o644) + print(f"created secrets/{name}") + + +def read(name: str) -> str: + return (SECRETS / name).read_text(encoding="utf-8").strip() + + +def main() -> int: + SECRETS.mkdir(exist_ok=True) + write("postgres_password", secrets.token_urlsafe(24)) # [A-Za-z0-9_-]: safe inside URLs + write("valkey_password", secrets.token_urlsafe(24)) + write("database_url", f"postgresql://messenger:{read('postgres_password')}@postgres:5432/messenger") + write("cache_url", f"redis://:{read('valkey_password')}@valkey:6379/0") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 0000000..f8a4ff9 --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,6 @@ +@echo off +rem Windows wrapper: tests/resilience.py starts the hook as a program, and Windows +rem cannot execute a .sh file directly. Runs the same scripts\restart.sh with Git Bash. +rem python tests/resilience.py --mode persistence --action-script scripts/restart.cmd +"%ProgramFiles%\Git\bin\bash.exe" "%~dp0restart.sh" +exit /b %ERRORLEVEL% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 0000000..973048a --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,15 @@ +#!/bin/sh +# Restart hook for `make test-persistence ACTION_SCRIPT=scripts/restart.sh`. +# Restarts the API and ALL state stores (PostgreSQL, Valkey) of compose.yaml. +# Volumes, schema and data are preserved: no `down -v`, no FLUSH, no re-seed. +# Output is suppressed by the test; run it by hand to see the steps. +set -eu +cd "$(dirname "$0")/.." + +# 1. API first: no request is served while the stores restart underneath it. +docker compose stop api +# 2. Stores: clean shutdown (PostgreSQL checkpoint, Valkey AOF fsync), then start again. +docker compose restart postgres valkey +# 3. API again; it waits for healthy stores via depends_on and reconnects its pool. +docker compose start api +echo "restart.sh: api, postgres and valkey restarted with volumes preserved" diff --git a/src/messenger/__main__.py b/src/messenger/__main__.py index 6a410d4..331a1fd 100644 --- a/src/messenger/__main__.py +++ b/src/messenger/__main__.py @@ -4,7 +4,8 @@ Shutdown sequence on SIGTERM/SIGINT: 1. readiness flips to 503 (`app.state.draining = True`); 2. uvicorn closes the listening socket, so new connections are refused; 3. in-flight requests get up to SHUTDOWN_TIMEOUT_SECONDS (default 8 s < Docker's 10 s) to finish; -4. the process exits with code 0. In-memory data is lost by design. +4. the lifespan closes the DB pool and the Valkey client; the process exits with code 0. + Data stays in PostgreSQL and Valkey volumes. """ from __future__ import annotations @@ -47,16 +48,16 @@ def main() -> int: access_log=False, server_header=False, proxy_headers=False, - lifespan="off", + lifespan="on", timeout_graceful_shutdown=settings.shutdown_timeout, ) server = GracefulServer(config) log.info("starting", extra={"fields": { "version": __version__, "env": settings.env, "host": settings.host, "port": settings.port, - "python": sys.version.split()[0], "storage": "in-memory (single process)", + "python": sys.version.split()[0], "storage": "postgresql", }}) server.run() - log.info("stopped", extra={"fields": {"state": app.state.store.counts(), "note": "in-memory data discarded"}}) + log.info("stopped") return 0 diff --git a/src/messenger/app.py b/src/messenger/app.py index 9073cda..9d0bf79 100644 --- a/src/messenger/app.py +++ b/src/messenger/app.py @@ -2,6 +2,7 @@ from __future__ import annotations import asyncio +import contextlib import logging import re import time @@ -11,14 +12,16 @@ from typing import Any from starlette.applications import Starlette from starlette.exceptions import HTTPException from starlette.requests import Request -from starlette.responses import JSONResponse +from starlette.responses import JSONResponse, Response from starlette.routing import Route from starlette.types import ASGIApp, Message as AsgiMessage, Receive, Scope, Send -from . import cursor, docs, validation +from . import authhdr, cursor, docs, passwords, repo, validation from .config import Settings -from .errors import ApiError, InvalidRequest, PayloadTooLarge, Unauthorized, Unavailable -from .store import Store, User +from .db import Database +from .errors import BASIC_CHALLENGE, ApiError, InvalidRequest, PayloadTooLarge, Unauthorized, Unavailable +from .sessions import SessionStore, build_store +from .timefmt import rfc3339 log = logging.getLogger("messenger") access_log = logging.getLogger("messenger.access") @@ -36,7 +39,7 @@ def error_response(request_id: str, status: int, code: str, message: str, header async def api_error_handler(request: Request, exc: Exception) -> JSONResponse: assert isinstance(exc, ApiError) - return error_response(request.state.request_id, exc.status, exc.code, exc.message) + return error_response(request.state.request_id, exc.status, exc.code, exc.message, exc.headers) async def http_exception_handler(request: Request, exc: Exception) -> JSONResponse: @@ -108,19 +111,24 @@ class RequestContextMiddleware: # -------------------------------------------------------------------------- # Request helpers # -------------------------------------------------------------------------- -def store_of(request: Request) -> Store: - return request.app.state.store +def db_of(request: Request) -> Database: + return request.app.state.db -def current_user(request: Request) -> User: - """Lab 1 identification: X-User-Id must be the UUID of an existing user, otherwise 401.""" - raw = request.headers.get("x-user-id") - if raw is None or validation.UUID_RE.fullmatch(raw) is None: - raise Unauthorized() - user = store_of(request).get_user(raw.lower()) - if user is None: - raise Unauthorized() - return user +def sessions_of(request: Request) -> SessionStore: + return request.app.state.sessions + + +async def authenticate(request: Request) -> str: + """User id of a valid Bearer session, otherwise 401. X-User-Id is ignored since lab 2. + + Store failures are 503 (Unavailable), never 401 and never anonymous access. + """ + token = authhdr.parse_bearer(request.headers.get("authorization")) + user_id = await sessions_of(request).user_id_for(token) + if user_id is None: + raise Unauthorized("Сессия недействительна, истекла или отозвана") + return user_id def path_uuid(request: Request, name: str) -> str: @@ -170,85 +178,136 @@ async def live(request: Request) -> JSONResponse: async def ready(request: Request) -> JSONResponse: - # The only critical dependency is process memory; while draining after - # SIGTERM the instance reports 503 so no new traffic is routed to it. + """200 only if the mandatory synchronous path can be served: PostgreSQL and, + with SESSION_STORE=valkey, Valkey answer. 503 while draining after SIGTERM.""" if request.app.state.draining: raise Unavailable("Сервер завершает работу") + db_ok, store_ok = await asyncio.gather(db_of(request).ping(), sessions_of(request).ping()) + if not db_ok: + raise Unavailable("PostgreSQL недоступен") + if not store_ok: + raise Unavailable("Хранилище сессий недоступно") return ok({"status": "ok"}) async def register_user(request: Request) -> JSONResponse: data = await read_json(request) - validation.check_fields(data, {"username", "display_name"}) + validation.check_fields(data, {"username", "display_name", "password"}) username = validation.username_field(data) display_name = validation.text_field(data, "display_name", 100) - user = store_of(request).create_user(username, display_name) + password = validation.password_field(data) + password_hash = await passwords.hash_password(password) + user = await repo.create_user(db_of(request), username, display_name, password_hash) log.info("user_created", extra={"fields": {"request_id": request.state.request_id, "user_id": user.id}}) return ok(user.to_json(), 201) +async def create_session(request: Request) -> JSONResponse: + """Login: only `Authorization: Basic`; wrong user and wrong password give the same 401.""" + username, password = authhdr.parse_basic(request.headers.get("authorization")) + found = await repo.get_credentials(db_of(request), username) + user, stored_hash = found if found else (None, None) + if not await passwords.verify_password(stored_hash, password) or user is None: + log.info("login_failed", extra={"fields": {"request_id": request.state.request_id}}) + raise Unauthorized("Неверное имя пользователя или пароль", challenge=BASIC_CHALLENGE) + ttl = request.app.state.settings.session_ttl_seconds + token, expires_at = await sessions_of(request).create(user.id, ttl) + log.info("session_created", extra={"fields": {"request_id": request.state.request_id, "user_id": user.id}}) + return ok({"token": token, "token_type": "Bearer", "expires_at": rfc3339(expires_at), "user": user.to_json()}, 201) + + +async def revoke_session(request: Request) -> Response: + token = authhdr.parse_bearer(request.headers.get("authorization")) + if not await sessions_of(request).revoke(token): + raise Unauthorized("Сессия недействительна, истекла или отозвана") + log.info("session_revoked", extra={"fields": {"request_id": request.state.request_id}}) + return Response(status_code=204) + + async def me(request: Request) -> JSONResponse: - return ok(current_user(request).to_json()) + user_id = await authenticate(request) + user = await repo.get_user(db_of(request), user_id) + if user is None: + raise Unauthorized("Сессия недействительна, истекла или отозвана") + return ok(user.to_json()) async def create_chat(request: Request) -> JSONResponse: - user = current_user(request) + user_id = await authenticate(request) data = await read_json(request) validation.check_fields(data, {"title", "member_ids"}) title = validation.text_field(data, "title", 100) member_ids = validation.member_ids_field(data) - chat = store_of(request).create_chat(user.id, title, member_ids) + chat = await repo.create_chat(db_of(request), user_id, title, member_ids) log.info("chat_created", extra={"fields": {"request_id": request.state.request_id, "chat_id": chat.id, "members": len(member_ids)}}) return ok(chat.to_json(), 201) async def list_chats(request: Request) -> JSONResponse: - user = current_user(request) + user_id = await authenticate(request) limit, raw_cursor = page_params(request) - after = cursor.decode(raw_cursor, cursor.CHATS, user.id) if raw_cursor else None - items, has_more = store_of(request).list_chats(user.id, after, limit) - next_cursor = cursor.encode(cursor.CHATS, user.id, items[-1].key) if has_more else None + after = cursor.decode(raw_cursor, cursor.CHATS, user_id) if raw_cursor else None + items, has_more = await repo.list_chats(db_of(request), user_id, after, limit) + next_cursor = cursor.encode(cursor.CHATS, user_id, items[-1].key) if has_more else None return ok({"items": [c.to_json() for c in items], "next_cursor": next_cursor}) async def get_chat(request: Request) -> JSONResponse: - user = current_user(request) + user_id = await authenticate(request) chat_id = path_uuid(request, "chat_id") - return ok(store_of(request).get_chat(user.id, chat_id).to_json()) + return ok((await repo.get_chat(db_of(request), user_id, chat_id)).to_json()) async def create_message(request: Request) -> JSONResponse: - user = current_user(request) + user_id = await authenticate(request) chat_id = path_uuid(request, "chat_id") - store = store_of(request) - store.get_chat(user.id, chat_id) # access check before reading the body: outsiders get 404 + db = db_of(request) + await repo.ensure_member(db, user_id, chat_id) # outsiders get 404 before the body is read data = await read_json(request) validation.check_fields(data, {"text"}) text = validation.text_field(data, "text", 4000) - # sender_id is derived from the identification, never taken from the body. - message = store.add_message(user.id, chat_id, text) + # sender_id is derived from the session, never taken from the body. + message = await repo.add_message(db, user_id, chat_id, text) return ok(message.to_json(), 201) async def list_messages(request: Request) -> JSONResponse: - user = current_user(request) + user_id = await authenticate(request) chat_id = path_uuid(request, "chat_id") - store = store_of(request) - store.get_chat(user.id, chat_id) # 404 for outsiders before any cursor details leak + db = db_of(request) + await repo.ensure_member(db, user_id, chat_id) # 404 for outsiders before cursor details leak limit, raw_cursor = page_params(request) after = cursor.decode(raw_cursor, cursor.MESSAGES, chat_id) if raw_cursor else None - items, has_more = store.list_messages(user.id, chat_id, after, limit) + items, has_more = await repo.list_messages(db, chat_id, after, limit) next_cursor = cursor.encode(cursor.MESSAGES, chat_id, items[-1].key) if has_more else None return ok({"items": [m.to_json() for m in items], "next_cursor": next_cursor}) -def create_app(settings: Settings | None = None, store: Store | None = None) -> Starlette: +def create_app(settings: Settings | None = None) -> Starlette: settings = settings or Settings.from_env() + db = Database(settings) + sessions = build_store(settings, db) + + @contextlib.asynccontextmanager + async def lifespan(app: Starlette): + passwords.configure(settings.hash_concurrency) + await db.open() + log.info("dependencies_configured", extra={"fields": { + "session_store": sessions.name, "session_ttl_s": settings.session_ttl_seconds, + "db_pool_max": settings.db_pool_max, "db_timeout_s": settings.db_timeout_seconds}}) + try: + yield + finally: + await sessions.close() + await db.close() + routes = [ Route("/health/live", live, methods=["GET"]), Route("/health/ready", ready, methods=["GET"]), Route("/api/v1/users", register_user, methods=["POST"]), Route("/api/v1/users/me", me, methods=["GET"]), + Route("/api/v1/auth/sessions", create_session, methods=["POST"]), + Route("/api/v1/auth/sessions/current", revoke_session, methods=["DELETE"]), Route("/api/v1/chats", create_chat, methods=["POST"]), Route("/api/v1/chats", list_chats, methods=["GET"]), Route("/api/v1/chats/{chat_id}", get_chat, methods=["GET"]), @@ -263,9 +322,11 @@ def create_app(settings: Settings | None = None, store: Store | None = None) -> app = Starlette( routes=routes, exception_handlers={ApiError: api_error_handler, HTTPException: http_exception_handler}, + lifespan=lifespan, ) app.add_middleware(RequestContextMiddleware) app.state.settings = settings - app.state.store = store or Store() + app.state.db = db + app.state.sessions = sessions app.state.draining = False return app diff --git a/src/messenger/authhdr.py b/src/messenger/authhdr.py new file mode 100644 index 0000000..f849b02 --- /dev/null +++ b/src/messenger/authhdr.py @@ -0,0 +1,48 @@ +"""Parsing of the Authorization header. Any malformed value is 401, never 500. + +Basic (RFC 7617) is accepted only by POST /auth/sessions; everything else needs +Bearer. Basic is an encoding, not encryption: plain HTTP is acceptable only for the +local synthetic lab stand (lab 7 adds TLS). +""" +from __future__ import annotations + +import base64 +import binascii +import re + +from .errors import BASIC_CHALLENGE, BEARER_CHALLENGE, Unauthorized +from .validation import USERNAME_RE + +B64_RE = re.compile(r"[A-Za-z0-9+/]+={0,2}") +TOKEN_RE = re.compile(r"[A-Za-z0-9_-]{32,128}") # token_urlsafe(32) gives 43 characters + + +def _split(header: str | None) -> tuple[str, str]: + if not header: + return "", "" + scheme, _, value = header.strip().partition(" ") + return scheme.lower(), value.strip() + + +def parse_basic(header: str | None) -> tuple[str, str]: + """(username, password) from `Basic base64(username:password)`; the password may contain ':'.""" + invalid = Unauthorized("Неверное имя пользователя или пароль", challenge=BASIC_CHALLENGE) + scheme, value = _split(header) + if scheme != "basic" or B64_RE.fullmatch(value) is None or len(value) > 1024: + raise invalid + try: + decoded = base64.b64decode(value, validate=True).decode("utf-8") + except (binascii.Error, ValueError, UnicodeDecodeError): + raise invalid from None + username, sep, password = decoded.partition(":") # split at the FIRST colon + if not sep or USERNAME_RE.fullmatch(username) is None or not password: + raise invalid + return username, password + + +def parse_bearer(header: str | None) -> str: + scheme, value = _split(header) + if scheme != "bearer" or TOKEN_RE.fullmatch(value) is None: + # Missing header, Basic on a business endpoint, garbage token: one answer. + raise Unauthorized("Требуется действительная Bearer-сессия", challenge=BEARER_CHALLENGE) + return value diff --git a/src/messenger/config.py b/src/messenger/config.py index 25f4c51..4cecbcd 100644 --- a/src/messenger/config.py +++ b/src/messenger/config.py @@ -1,13 +1,15 @@ """Runtime configuration read from environment variables (12-factor style). -Every variable has a safe default, so `docker run` works from a clean clone -even without an .env file. Invalid values stop the process at startup with a -clear message instead of failing later under traffic. +Non-secret settings have safe defaults. Connection strings with passwords are +read from files (`DATABASE_URL_FILE`, `CACHE_URL_FILE` → Docker secrets in +/run/secrets), so they never appear in `docker inspect`, compose files or logs. +Invalid values stop the process at startup with a clear message. """ from __future__ import annotations import os from dataclasses import dataclass +from pathlib import Path class ConfigError(ValueError): @@ -49,6 +51,22 @@ def _bool(name: str, default: bool) -> bool: return raw in {"true", "1"} +def _secret(name: str, required: bool) -> str: + """Value of _FILE (preferred, Docker secret) or (local runs/tests).""" + path = os.environ.get(f"{name}_FILE", "").strip() + if path: + try: + value = Path(path).read_text(encoding="utf-8").strip() + except OSError as exc: + # The message names the file, never its content. + raise ConfigError(f"{name}_FILE={path} cannot be read: {exc.strerror}") from None + else: + value = os.environ.get(name, "").strip() + if required and not value: + raise ConfigError(f"{name}_FILE (or {name}) must be set") + return value + + @dataclass(frozen=True) class Settings: host: str @@ -58,12 +76,35 @@ class Settings: shutdown_timeout: float max_body_bytes: int docs_enabled: bool = True + database_url: str = "" + session_store: str = "postgres" + cache_url: str = "" + session_ttl_seconds: int = 3600 + db_pool_min: int = 1 + db_pool_max: int = 10 + db_timeout_seconds: float = 3.0 + cache_timeout_seconds: float = 0.5 + hash_concurrency: int = 2 + + @property + def db_statement_timeout_ms(self) -> int: + # The server stops a statement a bit before the client-side deadline fires. + return max(100, int(self.db_timeout_seconds * 1000) - 500) @classmethod def from_env(cls) -> "Settings": log_level = os.environ.get("LOG_LEVEL", "info").strip().lower() or "info" if log_level not in {"debug", "info", "warning", "error"}: raise ConfigError(f"LOG_LEVEL must be debug/info/warning/error, got {log_level!r}") + session_store = os.environ.get("SESSION_STORE", "postgres").strip().lower() or "postgres" + if session_store == "redis": + session_store = "valkey" # same protocol; the course allows Redis OR Valkey + if session_store not in {"postgres", "valkey"}: + raise ConfigError(f"SESSION_STORE must be postgres or valkey, got {session_store!r}") + db_pool_min = _int("DB_POOL_MIN", 1, 0, 50) + db_pool_max = _int("DB_POOL_MAX", 10, 1, 100) + if db_pool_min > db_pool_max: + raise ConfigError("DB_POOL_MIN must not exceed DB_POOL_MAX") return cls( host=os.environ.get("APP_HOST", "0.0.0.0").strip() or "0.0.0.0", port=_int("APP_PORT", 8080, 1, 65535), @@ -73,4 +114,14 @@ class Settings: shutdown_timeout=_float("SHUTDOWN_TIMEOUT_SECONDS", 8.0, 0.0, 9.0), max_body_bytes=_int("MAX_BODY_BYTES", 64 * 1024, 1024, 1024 * 1024), docs_enabled=_bool("DOCS_ENABLED", True), + database_url=_secret("DATABASE_URL", required=True), + session_store=session_store, + cache_url=_secret("CACHE_URL", required=session_store == "valkey"), + # Contract name. Minimum 1 s so the expiry test can use 2 s. + session_ttl_seconds=_int("SESSION_TTL_SECONDS", 3600, 1, 30 * 24 * 3600), + db_pool_min=db_pool_min, + db_pool_max=db_pool_max, + db_timeout_seconds=_float("DB_TIMEOUT_SECONDS", 3.0, 0.5, 30.0), + cache_timeout_seconds=_float("CACHE_TIMEOUT_SECONDS", 0.5, 0.05, 10.0), + hash_concurrency=_int("PASSWORD_HASH_CONCURRENCY", 2, 1, 16), ) diff --git a/src/messenger/cursor.py b/src/messenger/cursor.py index bb77604..8e2d5ee 100644 --- a/src/messenger/cursor.py +++ b/src/messenger/cursor.py @@ -16,6 +16,9 @@ from .validation import UUID_RE B64_RE = re.compile(r"[A-Za-z0-9_-]{1,512}") TS_RE = re.compile(r"[0-9]{1,19}") +# Latest instant both Python datetime and PostgreSQL accept: 9999-12-31T23:59:59.999999Z. +MAX_TS_US = 253402300799999999 + MESSAGES = "m" CHATS = "c" @@ -44,6 +47,8 @@ def decode(cursor: str, scope: str, owner_id: str) -> SortKey: if TS_RE.fullmatch(ts) is None or UUID_RE.fullmatch(item_id) is None or item_id != item_id.lower(): raise bad key = (int(ts), item_id) + if key[0] > MAX_TS_US: + raise bad # out-of-range time must be 400, not an overflow (500) in datetime/SQL if encode(got_scope, got_owner, key) != cursor: raise bad # only the canonical form produced by the server is accepted if got_scope != scope or got_owner != owner_id: diff --git a/src/messenger/db.py b/src/messenger/db.py new file mode 100644 index 0000000..6c753a6 --- /dev/null +++ b/src/messenger/db.py @@ -0,0 +1,109 @@ +"""PostgreSQL access: a bounded connection pool and a hard deadline for every unit of work. + +Three independent limits keep a request from hanging when the database misbehaves: + +* pool `timeout` — waiting for a free connection (pool exhausted); +* server `statement_timeout` / `lock_timeout` — PostgreSQL itself cancels a slow + statement or a statement stuck behind a lock; +* client deadline — covers what the server cannot report, e.g. a + paused/frozen PostgreSQL container or a dead network. + +The client deadline needs care: when a psycopg query is cancelled, psycopg sends a +cancel request to the server and waits for it (up to 5 s + 5 s) before giving up. +With a frozen server that would stretch a 3 s deadline to 13 s. Therefore every unit +of work runs as its own task: at the deadline the request stops waiting and gets 503 +at once, while the task finishes its cleanup (cancel, close, return to the pool) in +the background. Any failure becomes 503 `unavailable` — never 401, never a hang. +""" +from __future__ import annotations + +import asyncio +import logging +from collections.abc import Awaitable, Callable +from typing import TypeVar + +import psycopg +from psycopg_pool import AsyncConnectionPool, PoolTimeout + +from .config import Settings +from .errors import Unavailable + +log = logging.getLogger("messenger.db") + +T = TypeVar("T") +Work = Callable[[psycopg.AsyncConnection], Awaitable[T]] + +# Errors that mean "the database is unavailable right now", not "the request is wrong". +# QueryCanceled (statement_timeout), LockNotAvailable (lock_timeout) and AdminShutdown +# (server restart) are subclasses of OperationalError. +UNAVAILABLE_ERRORS = (psycopg.OperationalError, psycopg.InterfaceError, PoolTimeout, TimeoutError) + + +def _forget(task: asyncio.Task) -> None: + """Done-callback for abandoned tasks: retrieve the result so nothing is logged as 'never retrieved'.""" + if not task.cancelled(): + task.exception() + + +class Database: + def __init__(self, settings: Settings): + self.deadline = settings.db_timeout_seconds + options = ( + f"-c statement_timeout={settings.db_statement_timeout_ms} " + f"-c lock_timeout={max(100, settings.db_statement_timeout_ms // 2)} " + "-c idle_in_transaction_session_timeout=10000" + ) + self.pool = AsyncConnectionPool( + conninfo=settings.database_url, + min_size=settings.db_pool_min, + max_size=settings.db_pool_max, + timeout=settings.db_timeout_seconds, # max wait for a free connection + open=False, + name="messenger", + check=AsyncConnectionPool.check_connection, # drop connections broken by a DB restart + kwargs={ + "options": options, + "connect_timeout": max(1, int(settings.db_timeout_seconds)), + "application_name": "messenger-api", + }, + ) + + async def open(self) -> None: + # wait=False: the API starts (liveness 200) even if PostgreSQL is not up yet; + # readiness stays 503 until the database answers. + await self.pool.open(wait=False) + + async def close(self) -> None: + await self.pool.close(timeout=2) + + async def run(self, work: Work[T], deadline: float | None = None) -> T: + """Run `work(conn)` in one transaction (COMMIT on success, ROLLBACK on any exception). + + Domain errors raised by `work` (NotFound, Conflict, ...) propagate unchanged; + database unavailability and the deadline become Unavailable (503). + """ + async def unit() -> T: + async with self.pool.connection() as conn: + async with conn.transaction(): + return await work(conn) + + task = asyncio.ensure_future(unit()) + try: + return await asyncio.wait_for(asyncio.shield(task), deadline or self.deadline) + except UNAVAILABLE_ERRORS as exc: + log.warning("database_unavailable", extra={"fields": {"error": type(exc).__name__}}) + raise Unavailable("База данных временно недоступна") from None + finally: + if not task.done(): + # Deadline or cancelled request: stop waiting now, let psycopg clean up later. + task.cancel() + task.add_done_callback(_forget) + + async def ping(self, timeout: float = 1.0) -> bool: + async def select_one(conn: psycopg.AsyncConnection) -> None: + await conn.execute("SELECT 1") + try: + await self.run(select_one, deadline=timeout) + return True + except Unavailable: + return False diff --git a/src/messenger/errors.py b/src/messenger/errors.py index c1fe309..22dbe74 100644 --- a/src/messenger/errors.py +++ b/src/messenger/errors.py @@ -1,6 +1,9 @@ """Domain errors mapped 1:1 to the contract error codes (contracts/README.md).""" from __future__ import annotations +BEARER_CHALLENGE = 'Bearer realm="messenger"' +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' + class ApiError(Exception): status = 500 @@ -11,6 +14,10 @@ class ApiError(Exception): self.message = message or self.default_message super().__init__(self.message) + @property + def headers(self) -> dict[str, str]: + return {} + class InvalidRequest(ApiError): status = 400 @@ -19,9 +26,19 @@ class InvalidRequest(ApiError): class Unauthorized(ApiError): + """401 with the challenge of the scheme the endpoint expects (RFC 7235).""" + status = 401 code = "unauthorized" - default_message = "Требуется X-User-Id существующего пользователя" + default_message = "Требуется действительная сессия" + + def __init__(self, message: str | None = None, challenge: str = BEARER_CHALLENGE): + super().__init__(message) + self.challenge = challenge + + @property + def headers(self) -> dict[str, str]: + return {"WWW-Authenticate": self.challenge} class NotFound(ApiError): diff --git a/src/messenger/migrate.py b/src/messenger/migrate.py new file mode 100644 index 0000000..10b18e9 --- /dev/null +++ b/src/messenger/migrate.py @@ -0,0 +1,76 @@ +"""Versioned SQL migrations: `python -m messenger.migrate` (compose service `migrate`). + +* Files `migrations/NNNN_name.sql` are applied in name order, each in its own + transaction together with its row in `schema_migrations` (DDL is transactional + in PostgreSQL, so a failed migration leaves nothing behind). +* Re-running is safe: applied versions are skipped, so data is never duplicated. +* The SHA-256 of every applied file is stored; if an applied file was edited later, + the run stops instead of silently diverging from the real schema. +* `pg_advisory_lock` serialises concurrent runs (two API replicas starting at once). +""" +from __future__ import annotations + +import hashlib +import sys +import time +from pathlib import Path + +import psycopg + +from .config import ConfigError, _secret + +MIGRATIONS_DIR = Path(__file__).resolve().parents[2] / "migrations" +LOCK_ID = 2026_02 # arbitrary application-wide advisory lock id + + +def say(text: str) -> None: + print(f"migrate: {text}", flush=True) + + +def connect(url: str, wait_seconds: float = 60) -> psycopg.Connection: + deadline = time.monotonic() + wait_seconds + while True: + try: + return psycopg.connect(url, autocommit=True, connect_timeout=3, application_name="messenger-migrate") + except psycopg.OperationalError as exc: + if time.monotonic() > deadline: + raise SystemExit(f"migrate: database is not reachable: {type(exc).__name__}") from None + time.sleep(1) + + +def main() -> int: + try: + url = _secret("DATABASE_URL", required=True) + except ConfigError as exc: + print(f"configuration error: {exc}", file=sys.stderr) + return 2 + files = sorted(MIGRATIONS_DIR.glob("*.sql")) + with connect(url) as conn: + conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,)) + try: + conn.execute( + "CREATE TABLE IF NOT EXISTS schema_migrations (" + " version text PRIMARY KEY, checksum text NOT NULL," + " applied_at timestamptz NOT NULL DEFAULT now())") + applied = dict(conn.execute("SELECT version, checksum FROM schema_migrations").fetchall()) + for path in files: + version, sql = path.stem, path.read_bytes() + checksum = hashlib.sha256(sql).hexdigest() + if version in applied: + if applied[version] != checksum: + say(f"{version}: file changed after it was applied; create a new migration instead") + return 1 + say(f"{version}: already applied, skipped") + continue + with conn.transaction(): + conn.execute(sql.decode("utf-8")) + conn.execute("INSERT INTO schema_migrations (version, checksum) VALUES (%s, %s)", (version, checksum)) + say(f"{version}: applied") + finally: + conn.execute("SELECT pg_advisory_unlock(%s)", (LOCK_ID,)) + say(f"done, {len(files)} migration file(s) checked") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/src/messenger/passwords.py b/src/messenger/passwords.py new file mode 100644 index 0000000..a1fc35a --- /dev/null +++ b/src/messenger/passwords.py @@ -0,0 +1,53 @@ +"""Password hashing with Argon2id (memory-hard password KDF; also mandatory in lab 7). + +* Parameters follow the OWASP minimum for Argon2id: m=19 MiB, t=2, p=1. Unlike bcrypt + there is no 72-byte limit, so any 12-128 code point UTF-8 password is hashed whole. +* Hashing takes tens of milliseconds of CPU and 19 MiB of RAM. It runs in a worker + thread (argon2-cffi releases the GIL), so the event loop keeps serving other + requests, and a semaphore caps parallel hashes (memory/CPU DoS protection). +* An unknown username is checked against a dummy hash, so "no such user" and + "wrong password" take the same time and return the same 401. +""" +from __future__ import annotations + +import asyncio + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError + +_hasher = PasswordHasher(time_cost=2, memory_cost=19 * 1024, parallelism=1, hash_len=32, salt_len=16) +_semaphore: asyncio.Semaphore | None = None +_dummy_hash: str | None = None + + +def configure(concurrency: int) -> None: + global _semaphore + _semaphore = asyncio.Semaphore(concurrency) + + +async def _run(func, *args): + if _semaphore is None: + configure(2) + async with _semaphore: + return await asyncio.to_thread(func, *args) + + +async def hash_password(password: str) -> str: + return await _run(_hasher.hash, password) + + +def _verify(stored_hash: str, password: str) -> bool: + try: + return _hasher.verify(stored_hash, password) + except (VerifyMismatchError, VerificationError, InvalidHashError): + return False + + +async def verify_password(stored_hash: str | None, password: str) -> bool: + global _dummy_hash + if stored_hash is None: + if _dummy_hash is None: + _dummy_hash = await hash_password("dummy-password-for-timing") + await _run(_verify, _dummy_hash, password) + return False + return await _run(_verify, stored_hash, password) diff --git a/src/messenger/repo.py b/src/messenger/repo.py new file mode 100644 index 0000000..4ae4d95 --- /dev/null +++ b/src/messenger/repo.py @@ -0,0 +1,244 @@ +"""SQL for users, chats and messages. All statements are parameterised (%s placeholders): +values travel separately from the SQL text, so input can never change the query. + +Free text is stored as UTF-8 BYTEA (PostgreSQL TEXT cannot hold U+0000), so it is +encoded on the way in and decoded on the way out. See docs/DATA_MODEL.md. +""" +from __future__ import annotations + +import datetime as dt +import uuid +from dataclasses import dataclass + +import psycopg +from psycopg import errors as pg_errors + +from .cursor import SortKey +from .db import Database +from .errors import Conflict, InvalidRequest, NotFound +from .timefmt import from_us, rfc3339, to_us + + +def _b(text: str) -> bytes: + return text.encode("utf-8") + + +def _s(raw: bytes | memoryview) -> str: + return bytes(raw).decode("utf-8") + + +@dataclass(slots=True, frozen=True) +class User: + id: str + username: str + display_name: str + created_at: dt.datetime + + def to_json(self) -> dict: + return {"id": self.id, "username": self.username, "display_name": self.display_name, + "created_at": rfc3339(self.created_at)} + + +@dataclass(slots=True, frozen=True) +class Chat: + id: str + title: str + member_ids: tuple[str, ...] + created_at: dt.datetime + + @property + def key(self) -> SortKey: + return (to_us(self.created_at), self.id) + + def to_json(self) -> dict: + return {"id": self.id, "title": self.title, "member_ids": list(self.member_ids), + "created_at": rfc3339(self.created_at)} + + +@dataclass(slots=True, frozen=True) +class Message: + id: str + chat_id: str + sender_id: str + text: str + created_at: dt.datetime + + @property + def key(self) -> SortKey: + return (to_us(self.created_at), self.id) + + def to_json(self) -> dict: + return {"id": self.id, "chat_id": self.chat_id, "sender_id": self.sender_id, "text": self.text, + "created_at": rfc3339(self.created_at)} + + +def _user(row) -> User: + return User(str(row[0]), row[1], _s(row[2]), row[3]) + + +# ------------------------------------------------------------------ users +async def create_user(db: Database, username: str, display_name: str, password_hash: str) -> User: + async def work(conn: psycopg.AsyncConnection) -> User: + cur = await conn.execute( + "INSERT INTO users (id, username, display_name, password_hash) VALUES (%s, %s, %s, %s) " + "RETURNING id, username, display_name, created_at", + (uuid.uuid4(), username, _b(display_name), password_hash)) + return _user(await cur.fetchone()) + try: + return await db.run(work) + except pg_errors.UniqueViolation: + # Two concurrent registrations: the unique index lets exactly one INSERT commit. + raise Conflict("Имя пользователя уже занято") from None + + +async def get_user(db: Database, user_id: str) -> User | None: + async def work(conn: psycopg.AsyncConnection) -> User | None: + cur = await conn.execute( + "SELECT id, username, display_name, created_at FROM users WHERE id = %s", (user_id,)) + row = await cur.fetchone() + return _user(row) if row else None + return await db.run(work) + + +async def get_credentials(db: Database, username: str) -> tuple[User, str] | None: + async def work(conn: psycopg.AsyncConnection) -> tuple[User, str] | None: + cur = await conn.execute( + "SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s", + (username,)) + row = await cur.fetchone() + return (_user(row), row[4]) if row else None + return await db.run(work) + + +# ------------------------------------------------------------------ chats +async def create_chat(db: Database, creator_id: str, title: str, member_ids: list[str]) -> Chat: + """Atomic: the chat row and all memberships commit together or not at all. + + The chat is inserted FIRST; an unknown member then fails the membership INSERT + with a foreign-key violation and the whole transaction (chat row included) is + rolled back. student-tests check that nothing is left behind. + """ + if creator_id not in member_ids: + raise InvalidRequest("member_ids должен включать текущего пользователя") + chat_id = uuid.uuid4() + + async def work(conn: psycopg.AsyncConnection) -> dt.datetime: + cur = await conn.execute( + "INSERT INTO chats (id, title, created_by) VALUES (%s, %s, %s) RETURNING created_at", + (chat_id, _b(title), creator_id)) + (created_at,) = await cur.fetchone() + await conn.execute( + "INSERT INTO chat_members (chat_id, user_id, position, chat_created_at) " + "SELECT %s, m.user_id, m.ord - 1, %s " + "FROM unnest(%s::uuid[]) WITH ORDINALITY AS m(user_id, ord)", + (chat_id, created_at, member_ids)) + return created_at + try: + created_at = await db.run(work) + except pg_errors.ForeignKeyViolation: + raise InvalidRequest("member_ids содержит несуществующих пользователей") from None + return Chat(str(chat_id), title, tuple(member_ids), created_at) + + +async def _load_chats(conn: psycopg.AsyncConnection, rows) -> list[Chat]: + if not rows: + return [] + ids = [r[0] for r in rows] + cur = await conn.execute( + "SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY(%s) ORDER BY chat_id, position", (ids,)) + members: dict[uuid.UUID, list[str]] = {i: [] for i in ids} + for chat_id, user_id in await cur.fetchall(): + members[chat_id].append(str(user_id)) + return [Chat(str(r[0]), _s(r[1]), tuple(members[r[0]]), r[2]) for r in rows] + + +async def get_chat(db: Database, user_id: str, chat_id: str) -> Chat: + """The chat if the user is a member; a missing chat and a foreign chat are both 404.""" + async def work(conn: psycopg.AsyncConnection) -> Chat: + cur = await conn.execute( + "SELECT c.id, c.title, c.created_at FROM chats c " + "JOIN chat_members m ON m.chat_id = c.id AND m.user_id = %s WHERE c.id = %s", + (user_id, chat_id)) + row = await cur.fetchone() + if row is None: + raise NotFound("Чат не найден") + return (await _load_chats(conn, [row]))[0] + return await db.run(work) + + +async def _check_member(conn: psycopg.AsyncConnection, user_id: str, chat_id: str) -> None: + cur = await conn.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user_id)) + if await cur.fetchone() is None: + raise NotFound("Чат не найден") + + +async def ensure_member(db: Database, user_id: str, chat_id: str) -> None: + async def work(conn: psycopg.AsyncConnection) -> None: + await _check_member(conn, user_id, chat_id) + await db.run(work) + + +async def list_chats(db: Database, user_id: str, after: SortKey | None, limit: int) -> tuple[list[Chat], bool]: + async def work(conn: psycopg.AsyncConnection) -> tuple[list[Chat], bool]: + if after is None: + cur = await conn.execute( + "SELECT c.id, c.title, c.created_at FROM chat_members m JOIN chats c ON c.id = m.chat_id " + "WHERE m.user_id = %s ORDER BY m.chat_created_at, m.chat_id LIMIT %s", + (user_id, limit + 1)) + else: + cur = await conn.execute( + "SELECT c.id, c.title, c.created_at FROM chat_members m JOIN chats c ON c.id = m.chat_id " + "WHERE m.user_id = %s AND (m.chat_created_at, m.chat_id) > (%s, %s) " + "ORDER BY m.chat_created_at, m.chat_id LIMIT %s", + (user_id, from_us(after[0]), after[1], limit + 1)) + rows = await cur.fetchall() + return await _load_chats(conn, rows[:limit]), len(rows) > limit + return await db.run(work) + + +# ------------------------------------------------------------------ messages +async def add_message(db: Database, user_id: str, chat_id: str, text: str) -> Message: + """Insert with a per-chat strictly increasing timestamp. + + `UPDATE chats ... RETURNING` locks the chat row until COMMIT, so writers of one + chat are serialised: a message with a smaller created_at can never commit after + a message with a bigger one, and a reader paging by cursor cannot skip it. + """ + message_id = uuid.uuid4() + + async def work(conn: psycopg.AsyncConnection) -> dt.datetime: + await _check_member(conn, user_id, chat_id) + cur = await conn.execute( + "UPDATE chats SET last_message_at = greatest(clock_timestamp(), " + "last_message_at + interval '1 microsecond') WHERE id = %s RETURNING last_message_at", + (chat_id,)) + (created_at,) = await cur.fetchone() + await conn.execute( + "INSERT INTO messages (id, chat_id, sender_id, text, created_at) VALUES (%s, %s, %s, %s, %s)", + (message_id, chat_id, user_id, _b(text), created_at)) + return created_at + created_at = await db.run(work) + return Message(str(message_id), chat_id, user_id, text, created_at) + + +# Two statements instead of one with "(%s IS NULL OR ...)": with a generic plan the OR +# would push the cursor into a Filter and late pages would scan the whole prefix. +HISTORY_FIRST = ( + "SELECT id, sender_id, text, created_at FROM messages " + "WHERE chat_id = %s ORDER BY created_at, id LIMIT %s") +HISTORY_AFTER = ( + "SELECT id, sender_id, text, created_at FROM messages " + "WHERE chat_id = %s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s") + + +async def list_messages(db: Database, chat_id: str, after: SortKey | None, limit: int) -> tuple[list[Message], bool]: + async def work(conn: psycopg.AsyncConnection) -> list: + if after is None: + cur = await conn.execute(HISTORY_FIRST, (chat_id, limit + 1)) + else: + cur = await conn.execute(HISTORY_AFTER, (chat_id, from_us(after[0]), after[1], limit + 1)) + return await cur.fetchall() + rows = await db.run(work) + items = [Message(str(r[0]), chat_id, str(r[1]), _s(r[2]), r[3]) for r in rows[:limit]] + return items, len(rows) > limit diff --git a/src/messenger/sessions.py b/src/messenger/sessions.py new file mode 100644 index 0000000..53736e4 --- /dev/null +++ b/src/messenger/sessions.py @@ -0,0 +1,160 @@ +"""Server-side sessions behind an opaque Bearer token. + +* Token: `secrets.token_urlsafe(32)` = 256 random bits. Only SHA-256(token) is + stored, so a leaked database/AOF does not contain usable tokens. A fast hash is + enough for a 256-bit random value; passwords need a slow KDF (passwords.py). +* Expiry is absolute: `expires_at = login time + SESSION_TTL_SECONDS`. Every lookup + compares it with the current time, and a restart never extends it. + +Two interchangeable stores (SESSION_STORE): + +* `valkey` (compose default): the ONLY copy of a session is a Valkey key with + `PXAT expires_at`, persisted by AOF with `appendfsync always`. There is no second + copy (no cache over PostgreSQL), so a logout cannot be "forgotten" and a revoked + token cannot come back after Valkey fails and recovers. If Valkey is unreachable + a session cannot be checked: protected requests and logout get 503, never access. +* `postgres`: table `sessions` (migrations/0001_init.sql). +""" +from __future__ import annotations + +import asyncio +import datetime as dt +import hashlib +import json +import logging +import secrets +from typing import Protocol + +from redis import exceptions as redis_errors +from redis.asyncio import Redis +from redis.backoff import NoBackoff +from redis.retry import Retry + +from .config import Settings +from .db import Database +from .errors import Unavailable +from .timefmt import UTC, from_us, to_us + +log = logging.getLogger("messenger.sessions") + + +def new_token() -> str: + return secrets.token_urlsafe(32) + + +def token_hash(token: str) -> bytes: + return hashlib.sha256(token.encode("ascii")).digest() + + +def now() -> dt.datetime: + return dt.datetime.now(UTC) + + +class SessionStore(Protocol): + name: str + + async def create(self, user_id: str, ttl_seconds: int) -> tuple[str, dt.datetime]: ... + async def user_id_for(self, token: str) -> str | None: ... + async def revoke(self, token: str) -> bool: ... + async def ping(self) -> bool: ... + async def close(self) -> None: ... + + +class PostgresSessionStore: + name = "postgres" + + def __init__(self, db: Database): + self.db = db + + async def create(self, user_id: str, ttl_seconds: int) -> tuple[str, dt.datetime]: + token = new_token() + expires_at = now() + dt.timedelta(seconds=ttl_seconds) + + async def work(conn) -> None: + await conn.execute( + "INSERT INTO sessions (token_hash, user_id, expires_at) VALUES (%s, %s, %s)", + (token_hash(token), user_id, expires_at)) + # Housekeeping: drop this user's expired sessions (bounded by the user's own rows). + await conn.execute("DELETE FROM sessions WHERE user_id = %s AND expires_at <= %s", (user_id, now())) + await self.db.run(work) + return token, expires_at + + async def user_id_for(self, token: str) -> str | None: + async def work(conn): + cur = await conn.execute( + "SELECT user_id FROM sessions WHERE token_hash = %s AND expires_at > %s", (token_hash(token), now())) + return await cur.fetchone() + row = await self.db.run(work) + return str(row[0]) if row else None + + async def revoke(self, token: str) -> bool: + async def work(conn) -> bool: + cur = await conn.execute( + "DELETE FROM sessions WHERE token_hash = %s AND expires_at > %s", (token_hash(token), now())) + return cur.rowcount == 1 + return await self.db.run(work) + + async def ping(self) -> bool: + return True # covered by the database readiness check + + async def close(self) -> None: + return None + + +class ValkeySessionStore: + name = "valkey" + PREFIX = "session:" + + def __init__(self, settings: Settings): + self.timeout = settings.cache_timeout_seconds + self.client = Redis.from_url( + settings.cache_url, + socket_timeout=self.timeout, + socket_connect_timeout=self.timeout, + retry=Retry(NoBackoff(), 0), # no hidden retries: a failure is reported at once + decode_responses=False, + ) + + def _key(self, token: str) -> str: + return self.PREFIX + token_hash(token).hex() + + async def _call(self, coro): + try: + async with asyncio.timeout(self.timeout * 2): + return await coro + except (redis_errors.ConnectionError, redis_errors.TimeoutError, TimeoutError, OSError) as exc: + log.warning("session_store_unavailable", extra={"fields": {"error": type(exc).__name__}}) + raise Unavailable("Хранилище сессий временно недоступно") from None + + async def create(self, user_id: str, ttl_seconds: int) -> tuple[str, dt.datetime]: + token = new_token() + expires_at = now() + dt.timedelta(seconds=ttl_seconds) + value = json.dumps({"user_id": user_id, "expires_at_us": to_us(expires_at)}).encode() + # PXAT = absolute expiry time: survives restarts (AOF) without being extended. + await self._call(self.client.set(self._key(token), value, pxat=to_us(expires_at) // 1000)) + return token, expires_at + + async def user_id_for(self, token: str) -> str | None: + raw = await self._call(self.client.get(self._key(token))) + if raw is None: + return None + data = json.loads(raw) + if from_us(data["expires_at_us"]) <= now(): + return None # do not rely only on Valkey's lazy expiry + return data["user_id"] + + async def revoke(self, token: str) -> bool: + return await self._call(self.client.delete(self._key(token))) == 1 + + async def ping(self) -> bool: + try: + return bool(await self._call(self.client.ping())) + except Unavailable: + return False + + async def close(self) -> None: + await self.client.aclose() + + +def build_store(settings: Settings, db: Database) -> SessionStore: + return ValkeySessionStore(settings) if settings.session_store == "valkey" else PostgresSessionStore(db) diff --git a/src/messenger/store.py b/src/messenger/store.py deleted file mode 100644 index 881a8c8..0000000 --- a/src/messenger/store.py +++ /dev/null @@ -1,191 +0,0 @@ -"""In-memory state of the messenger: the single source of truth for lab 1. - -Concurrency model ------------------ -All data lives in ordinary dicts/lists of ONE process. Every public method -takes `self._lock` for its whole critical section, so each operation is atomic -and readers never see a half-built chat or message. - -The server runs coroutines on one asyncio event loop, and store methods never -`await`, so on the event loop they are already atomic. The lock additionally -protects the store when it is used from several threads (student-tests start -10 threads that write concurrently) and documents the invariant explicitly. - -Ordering invariant ------------------- -`created_at` is assigned INSIDE the same critical section that appends the -object, from a strictly increasing clock (`_next_ts`). Therefore the append -order of every list equals the contract order `(created_at, id)` even under -concurrent writes and even if the wall clock jumps backwards. -""" -from __future__ import annotations - -import bisect -import datetime as dt -import operator -import threading -import time -import uuid -from dataclasses import dataclass -from typing import Callable - -from .cursor import SortKey -from .errors import Conflict, InvalidRequest, NotFound - -_EPOCH = dt.datetime(1970, 1, 1, tzinfo=dt.timezone.utc) -# (created_at, id) of a Chat/Message as a C-level getter: cheap to call inside bisect. -_sort_key = operator.attrgetter("ts", "id") - - -def format_ts(ts_us: int) -> str: - """RFC 3339 UTC with fixed microsecond precision, e.g. 2026-09-25T12:00:00.000001Z.""" - return (_EPOCH + dt.timedelta(microseconds=ts_us)).strftime("%Y-%m-%dT%H:%M:%S.%fZ") - - -@dataclass(slots=True, frozen=True) -class User: - id: str - username: str - display_name: str - ts: int - created_at: str - - def to_json(self) -> dict: - return {"id": self.id, "username": self.username, "display_name": self.display_name, "created_at": self.created_at} - - -@dataclass(slots=True, frozen=True) -class Chat: - id: str - title: str - member_ids: tuple[str, ...] - members: frozenset[str] - ts: int - created_at: str - - @property - def key(self) -> SortKey: - return (self.ts, self.id) - - def to_json(self) -> dict: - return {"id": self.id, "title": self.title, "member_ids": list(self.member_ids), "created_at": self.created_at} - - -@dataclass(slots=True, frozen=True) -class Message: - id: str - chat_id: str - sender_id: str - text: str - ts: int - created_at: str - - @property - def key(self) -> SortKey: - return (self.ts, self.id) - - def to_json(self) -> dict: - return {"id": self.id, "chat_id": self.chat_id, "sender_id": self.sender_id, "text": self.text, "created_at": self.created_at} - - -def _page_after(items: list, after: SortKey | None, limit: int) -> tuple[list, bool]: - """Keyset page: up to `limit` items strictly after `after`, plus "has more". - - `items` is always sorted by (created_at, id) (see the ordering invariant), so - the page start is found by binary search in O(log n) instead of scanning the - history from the beginning (O(n)); only the page itself is copied. - """ - start = 0 if after is None else bisect.bisect_right(items, after, key=_sort_key) - page = items[start:start + limit + 1] - return page[:limit], len(page) > limit - - -class Store: - def __init__(self, clock_ns: Callable[[], int] = time.time_ns): - self._lock = threading.Lock() - self._clock_ns = clock_ns - self._last_ts = 0 - self._users: dict[str, User] = {} - self._user_ids_by_name: dict[str, str] = {} - self._chats: dict[str, Chat] = {} - self._chats_by_user: dict[str, list[Chat]] = {} - self._messages: dict[str, list[Message]] = {} - - # -- helpers (caller holds the lock) --------------------------------- - def _next_ts(self) -> tuple[int, str]: - """Strictly increasing server time in microseconds; must be called under the lock.""" - ts = max(self._clock_ns() // 1000, self._last_ts + 1) - self._last_ts = ts - return ts, format_ts(ts) - - def _chat_for_member(self, user_id: str, chat_id: str) -> Chat: - chat = self._chats.get(chat_id) - # A missing chat and a foreign chat are indistinguishable: both 404. - if chat is None or user_id not in chat.members: - raise NotFound("Чат не найден") - return chat - - # -- users ----------------------------------------------------------- - def create_user(self, username: str, display_name: str) -> User: - with self._lock: - if username in self._user_ids_by_name: - raise Conflict("Имя пользователя уже занято") - ts, created_at = self._next_ts() - user = User(str(uuid.uuid4()), username, display_name, ts, created_at) - self._users[user.id] = user - self._user_ids_by_name[username] = user.id - self._chats_by_user[user.id] = [] - return user - - def get_user(self, user_id: str) -> User | None: - with self._lock: - return self._users.get(user_id) - - # -- chats ----------------------------------------------------------- - def create_chat(self, creator_id: str, title: str, member_ids: list[str]) -> Chat: - with self._lock: - if creator_id not in member_ids: - raise InvalidRequest("member_ids должен включать текущего пользователя") - if any(member not in self._users for member in member_ids): - raise InvalidRequest("member_ids содержит несуществующих пользователей") - ts, created_at = self._next_ts() - chat = Chat(str(uuid.uuid4()), title, tuple(member_ids), frozenset(member_ids), ts, created_at) - # All indexes are updated in one critical section: the chat is created atomically. - self._chats[chat.id] = chat - self._messages[chat.id] = [] - for member in member_ids: - self._chats_by_user[member].append(chat) - return chat - - def get_chat(self, user_id: str, chat_id: str) -> Chat: - with self._lock: - return self._chat_for_member(user_id, chat_id) - - def list_chats(self, user_id: str, after: SortKey | None, limit: int) -> tuple[list[Chat], bool]: - """Page of the user's chats ordered by (created_at, id); returns (items, has_more).""" - with self._lock: - return _page_after(self._chats_by_user[user_id], after, limit) - - # -- messages -------------------------------------------------------- - def add_message(self, user_id: str, chat_id: str, text: str) -> Message: - with self._lock: - chat = self._chat_for_member(user_id, chat_id) - ts, created_at = self._next_ts() - message = Message(str(uuid.uuid4()), chat.id, user_id, text, ts, created_at) - self._messages[chat.id].append(message) - return message - - def list_messages(self, user_id: str, chat_id: str, after: SortKey | None, limit: int) -> tuple[list[Message], bool]: - """Page of history strictly after `after` in (created_at, id) order; returns (items, has_more).""" - with self._lock: - chat = self._chat_for_member(user_id, chat_id) - return _page_after(self._messages[chat.id], after, limit) - - # -- diagnostics ----------------------------------------------------- - def counts(self) -> dict[str, int]: - with self._lock: - return { - "users": len(self._users), - "chats": len(self._chats), - "messages": sum(len(h) for h in self._messages.values()), - } diff --git a/src/messenger/timefmt.py b/src/messenger/timefmt.py new file mode 100644 index 0000000..9c33b12 --- /dev/null +++ b/src/messenger/timefmt.py @@ -0,0 +1,22 @@ +"""Conversions between PostgreSQL timestamptz values, cursor integers and RFC 3339 strings.""" +from __future__ import annotations + +import datetime as dt + +UTC = dt.timezone.utc +_EPOCH = dt.datetime(1970, 1, 1, tzinfo=UTC) + + +def to_us(value: dt.datetime) -> int: + """Microseconds since the Unix epoch (exact: timestamptz has microsecond precision).""" + delta = value - _EPOCH + return (delta.days * 86_400 + delta.seconds) * 1_000_000 + delta.microseconds + + +def from_us(us: int) -> dt.datetime: + return _EPOCH + dt.timedelta(microseconds=us) + + +def rfc3339(value: dt.datetime) -> str: + """RFC 3339 UTC with fixed microsecond precision, e.g. 2026-10-12T12:00:00.000001Z.""" + return value.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%S.%fZ") diff --git a/src/messenger/validation.py b/src/messenger/validation.py index 6619324..8767095 100644 --- a/src/messenger/validation.py +++ b/src/messenger/validation.py @@ -70,6 +70,20 @@ def username_field(data: dict[str, Any]) -> str: return value +def password_field(data: dict[str, Any]) -> str: + """12-128 Unicode code points, not whitespace-only; any other character (':' too) is allowed.""" + value = data["password"] + if not isinstance(value, str): + raise InvalidRequest("Поле password должно быть строкой") + if SURROGATES_RE.search(value): + raise InvalidRequest("Поле password содержит недопустимые символы") + if not 12 <= len(value) <= 128: + raise InvalidRequest("Длина пароля должна быть от 12 до 128 символов") + if value.strip() == "": + raise InvalidRequest("Пароль не может состоять только из пробелов") + return value + + def parse_uuid(value: Any, what: str = "UUID") -> str: if not isinstance(value, str) or UUID_RE.fullmatch(value) is None: raise InvalidRequest(f"Неверный {what}")