From de44fc87c713439c7515e053b26394324a3cc829 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9?= Date: Thu, 8 Oct 2026 16:50:41 +0300 Subject: [PATCH 1/6] add base from lab 1 --- Dockerfile | 23 ++++ pyproject.toml | 10 ++ src/__init__.py | 1 + src/config.py | 48 +++++++++ src/cursor.py | 69 ++++++++++++ src/errors.py | 10 ++ src/main.py | 111 +++++++++++++++++++ src/models.py | 81 ++++++++++++++ src/routes.py | 154 +++++++++++++++++++++++++++ src/storage/__init__.py | 2 + src/storage/memory.py | 149 ++++++++++++++++++++++++++ uv.lock | 229 ++++++++++++++++++++++++++++++++++++++++ 12 files changed, 887 insertions(+) create mode 100644 Dockerfile create mode 100644 pyproject.toml create mode 100644 src/__init__.py create mode 100644 src/config.py create mode 100644 src/cursor.py create mode 100644 src/errors.py create mode 100644 src/main.py create mode 100644 src/models.py create mode 100644 src/routes.py create mode 100644 src/storage/__init__.py create mode 100644 src/storage/memory.py create mode 100644 uv.lock diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..371e47ba --- /dev/null +++ b/Dockerfile @@ -0,0 +1,23 @@ +FROM python:3.12.12-slim + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 + +WORKDIR /app + +RUN pip install --no-cache-dir uv==0.11.28 + +COPY pyproject.toml uv.lock ./ +RUN uv sync --frozen --no-dev --no-install-project + +COPY src ./src + +USER 65534:65534 + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ + CMD ["/app/.venv/bin/python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).read()"] + +CMD ["/app/.venv/bin/python", "-m", "src.main"] + diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..43a1dc9c --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,10 @@ +[project] +name = "mtusi2026lab2" +version = "0.1.0" +description = "MTUSI high-load messenger, laboratory 2" +readme = "README.md" +requires-python = ">=3.12" +dependencies = [ + "fastapi>=0.141.1", + "uvicorn>=0.53.0", +] diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/src/__init__.py @@ -0,0 +1 @@ + diff --git a/src/config.py b/src/config.py new file mode 100644 index 00000000..3b5a4519 --- /dev/null +++ b/src/config.py @@ -0,0 +1,48 @@ +from dataclasses import dataclass +import os +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[1] +_CONFIGURATION_KEYS = {"APP_HOST", "APP_PORT", "APP_ENV"} + + +@dataclass(frozen=True, slots=True) +class Settings: + """Проверенная конфигурация запуска HTTP-сервера.""" + + host: str + port: int + environment: str + + +def load_settings(env_file: Path = ROOT / ".env") -> Settings: + """Читает разрешённые ключи .env, не заменяя явно переданное окружение.""" + + if env_file.is_file(): + for raw_line in env_file.read_text(encoding="utf-8").splitlines(): + line = raw_line.strip() + if not line or line.startswith("#"): + continue + key, separator, value = line.partition("=") + if not separator or key not in _CONFIGURATION_KEYS: + continue + value = value.strip() + if len(value) >= 2 and value[0] == value[-1] and value[0] in {"'", '"'}: + value = value[1:-1] + os.environ.setdefault(key, value) + + host = os.environ.get("APP_HOST", "0.0.0.0").strip() + environment = os.environ.get("APP_ENV", "lab").strip() + if not host: + raise ValueError("APP_HOST не может быть пустым") + if not environment: + raise ValueError("APP_ENV не может быть пустым") + try: + port = int(os.environ.get("APP_PORT", "8080")) + except ValueError as error: + raise ValueError("APP_PORT должен быть целым числом") from error + if not 1 <= port <= 65535: + raise ValueError("APP_PORT должен находиться в диапазоне 1..65535") + return Settings(host=host, port=port, environment=environment) + diff --git a/src/cursor.py b/src/cursor.py new file mode 100644 index 00000000..1938bfc6 --- /dev/null +++ b/src/cursor.py @@ -0,0 +1,69 @@ +import base64 +from datetime import UTC, datetime +import hashlib +import hmac +import json +from secrets import token_bytes +from uuid import UUID + + +_secret = token_bytes(32) + + +class CursorError(ValueError): + """Недопустимый, повреждённый или применённый не к тому ресурсу курсор.""" + + +def _encode_bytes(value: bytes) -> str: + return base64.urlsafe_b64encode(value).decode().rstrip("=") + + +def _decode_bytes(value: str) -> bytes: + try: + return base64.urlsafe_b64decode(value + "=" * (-len(value) % 4)) + except (ValueError, UnicodeEncodeError) as error: + raise CursorError from error + + +def encode_cursor(scope: str, created_at: datetime, item_id: str) -> str: + payload = json.dumps( + { + "scope": scope, + "created_at": created_at.astimezone(UTC) + .isoformat() + .replace("+00:00", "Z"), + "id": item_id, + }, + separators=(",", ":"), + sort_keys=True, + ).encode() + signature = hmac.new(_secret, payload, hashlib.sha256).digest() + return _encode_bytes(payload) + "." + _encode_bytes(signature) + + +def decode_cursor(cursor: str, expected_scope: str) -> tuple[datetime, str]: + try: + encoded_payload, encoded_signature = cursor.split(".") + payload = _decode_bytes(encoded_payload) + signature = _decode_bytes(encoded_signature) + except ValueError as error: + raise CursorError from error + + expected_signature = hmac.new(_secret, payload, hashlib.sha256).digest() + if not hmac.compare_digest(signature, expected_signature): + raise CursorError + + try: + data = json.loads(payload) + if set(data) != {"scope", "created_at", "id"}: + raise CursorError + if data["scope"] != expected_scope: + raise CursorError + item_id = str(UUID(data["id"])) + created_at = datetime.fromisoformat(data["created_at"].replace("Z", "+00:00")) + if created_at.tzinfo is None: + raise CursorError + return created_at.astimezone(UTC), item_id + except (TypeError, ValueError, KeyError) as error: + raise CursorError from error + diff --git a/src/errors.py b/src/errors.py new file mode 100644 index 00000000..4b67c7a7 --- /dev/null +++ b/src/errors.py @@ -0,0 +1,10 @@ +"""Ошибки, которые преобразуются в контрактные HTTP-ответы.""" + + +class ApiError(Exception): + + def __init__(self, status_code: int, code: str, message: str) -> None: + self.status_code = status_code + self.code = code + self.message = message + diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..9d0bb575 --- /dev/null +++ b/src/main.py @@ -0,0 +1,111 @@ +import logging +import sys +import time +from uuid import uuid4 + +from fastapi import FastAPI, Request +from fastapi.exceptions import RequestValidationError +import uvicorn +from starlette.responses import JSONResponse, Response + +from .errors import ApiError +from .models import ErrorDetails, ErrorResponse +from .config import load_settings +from .routes import router + + +access_logger = logging.getLogger("messenger.access") +if not access_logger.handlers: + handler = logging.StreamHandler(sys.stdout) + handler.setFormatter( + logging.Formatter("%(asctime)s %(levelname)s %(name)s %(message)s") + ) + access_logger.addHandler(handler) +access_logger.setLevel(logging.INFO) +access_logger.propagate = False + + +app = FastAPI( + title="MTUSI Messenger", + version="1.1.0", + redoc_url=None, +) + + +@app.middleware("http") +async def add_request_id(request: Request, call_next) -> Response: + """Добавляет ID запроса и пишет безопасную строку access-лога.""" + + request.state.request_id = str(uuid4()) + started_at = time.monotonic() + status_code = 500 + try: + response = await call_next(request) + status_code = response.status_code + response.headers["X-Request-Id"] = request.state.request_id + return response + finally: + access_logger.info( + "request_id=%s method=%s path=%s status=%s elapsed_ms=%.3f", + request.state.request_id, + request.method, + request.url.path, + status_code, + (time.monotonic() - started_at) * 1000, + ) + + +def error_response(request: Request, status_code: int, code: str, message: str) -> JSONResponse: + request_id = request.state.request_id + body = ErrorResponse( + error=ErrorDetails(code=code, message=message, request_id=request_id) + ) + # Неожиданная ошибка обрабатывается за пределами HTTP-middleware. + # Поэтому её ответ тоже должен сам получить заголовок из контракта. + return JSONResponse( + status_code=status_code, + content=body.model_dump(), + headers={"X-Request-Id": request_id}, + ) + + +@app.exception_handler(ApiError) +async def handle_api_error(request: Request, error: ApiError) -> JSONResponse: + """Преобразует контролируемую ошибку API в стандартный JSON-ответ.""" + + return error_response(request, error.status_code, error.code, error.message) + + +@app.exception_handler(RequestValidationError) +async def handle_validation_error( + request: Request, error: RequestValidationError +) -> JSONResponse: + """Преобразует ошибки JSON и Pydantic в обязательный ответ 400.""" + + return error_response(request, 400, "invalid_request", "Некорректный запрос") + + +@app.exception_handler(Exception) +async def handle_unexpected_error(request: Request, error: Exception) -> JSONResponse: + """Не раскрывает внутренние детали при непредвиденной ошибке приложения.""" + + return error_response(request, 500, "internal_error", "Внутренняя ошибка сервера") + + +app.include_router(router) + + +def main() -> None: + settings = load_settings() + uvicorn.run( + app, + host=settings.host, + port=settings.port, + access_log=False, + timeout_graceful_shutdown=8, + ) + + +if __name__ == "__main__": + main() + diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..c9772466 --- /dev/null +++ b/src/models.py @@ -0,0 +1,81 @@ +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field, field_validator + +from .storage.memory import Chat, Message + + +class CreateUserRequest(BaseModel): + model_config = ConfigDict(extra="forbid", strict=True) + + username: str = Field(min_length=3, max_length=32, pattern=r"^[a-z0-9_]{3,32}$") + display_name: str = Field(min_length=1, max_length=100) + + @field_validator("display_name") + @classmethod + def display_name_must_not_be_whitespace(cls, value: str) -> str: + """Не допускает обязательное имя, состоящее только из пробелов.""" + + if not value.strip(): + raise ValueError("display_name не может состоять только из пробелов") + return value + + +class CreateChatRequest(BaseModel): + model_config = ConfigDict(extra="forbid") + + title: str = Field(min_length=1, max_length=100) + member_ids: list[UUID] = Field(min_length=1, max_length=100) + + @field_validator("title") + @classmethod + def title_must_not_be_whitespace(cls, value: str) -> str: + """Не допускает обязательное название, состоящее только из пробелов.""" + + if not value.strip(): + raise ValueError("title не может состоять только из пробелов") + return value + + +class ChatPageResponse(BaseModel): + model_config = ConfigDict(extra="forbid") + + items: list[Chat] + next_cursor: str | None + + +class CreateMessageRequest(BaseModel): + model_config = ConfigDict(extra="forbid", strict=True) + + text: str = Field(min_length=1, max_length=4000) + + @field_validator("text") + @classmethod + def text_must_not_be_whitespace(cls, value: str) -> str: + """Не допускает сообщение, состоящее только из пробельных символов.""" + + if not value.strip(): + raise ValueError("text не может состоять только из пробелов") + return value + + +class MessagePageResponse(BaseModel): + model_config = ConfigDict(extra="forbid") + + items: list[Message] + next_cursor: str | None + + +class ErrorDetails(BaseModel): + model_config = ConfigDict(extra="forbid") + + code: str + message: str + request_id: str + + +class ErrorResponse(BaseModel): + model_config = ConfigDict(extra="forbid") + + error: ErrorDetails + diff --git a/src/routes.py b/src/routes.py new file mode 100644 index 00000000..ad515930 --- /dev/null +++ b/src/routes.py @@ -0,0 +1,154 @@ +from uuid import UUID + +from fastapi import APIRouter, Depends, Header, Query + +from .cursor import CursorError, decode_cursor, encode_cursor +from .errors import ApiError +from .models import ( + ChatPageResponse, + CreateChatRequest, + CreateMessageRequest, + CreateUserRequest, + MessagePageResponse, +) +from .storage.memory import Chat, MemoryStore, Message, User + + +router = APIRouter() +store = MemoryStore() + + +@router.get("/health/live") +async def liveness() -> dict[str, str]: + return {"status": "ok"} + + +@router.get("/health/ready") +async def readiness() -> dict[str, str]: + return {"status": "ok"} + + +def get_current_user( + user_id_header: str | None = Header(default=None, alias="X-User-Id"), +) -> User: + """Определяет текущего пользователя по X-User-Id.""" + + if user_id_header is None: + raise ApiError(401, "unauthorized", "Требуется заголовок X-User-Id") + + try: + user_id = str(UUID(user_id_header)) + except ValueError as error: + raise ApiError(401, "unauthorized", "Некорректный X-User-Id") from error + + user = store.get_user(user_id) + if user is None: + raise ApiError(401, "unauthorized", "Пользователь не найден") + return user + + +@router.post("/api/v1/users", response_model=User, status_code=201) +def register_user(payload: CreateUserRequest) -> User: + return store.create_user(payload.username, payload.display_name) + + +@router.get("/api/v1/users/me", response_model=User) +def current_user(user: User = Depends(get_current_user)) -> User: + return user + + +@router.post("/api/v1/chats", response_model=Chat, status_code=201) +def create_chat( + payload: CreateChatRequest, + user: User = Depends(get_current_user), +) -> Chat: + return store.create_chat( + creator_id=user.id, + title=payload.title, + member_ids=[str(member_id) for member_id in payload.member_ids], + ) + + +@router.get("/api/v1/chats", response_model=ChatPageResponse) +def list_chats( + user: User = Depends(get_current_user), + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = Query(default=None, min_length=1), +) -> ChatPageResponse: + chats = store.list_chats_for_member(user.id) + scope = "chats:" + user.id + if cursor is not None: + try: + cursor_key = decode_cursor(cursor, scope) + except CursorError as error: + raise ApiError(400, "invalid_request", "Некорректный cursor") from error + chats = tuple( + chat for chat in chats if (chat.created_at, chat.id) > cursor_key + ) + + page = chats[:limit] + next_cursor = None + if len(chats) > len(page): + last_chat = page[-1] + next_cursor = encode_cursor(scope, last_chat.created_at, last_chat.id) + return ChatPageResponse( + items=list(page), + next_cursor=next_cursor, + ) + + +@router.get("/api/v1/chats/{chat_id}", response_model=Chat) +def get_chat( + chat_id: UUID, + user: User = Depends(get_current_user), +) -> Chat: + return store.get_chat_for_member(str(chat_id), user.id) + + +@router.post( + "/api/v1/chats/{chat_id}/messages", + response_model=Message, + status_code=201, +) +def create_message( + chat_id: UUID, + payload: CreateMessageRequest, + user: User = Depends(get_current_user), +) -> Message: + return store.create_message(str(chat_id), user.id, payload.text) + + +@router.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePageResponse) +def list_messages( + chat_id: UUID, + user: User = Depends(get_current_user), + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = Query(default=None, min_length=1), +) -> MessagePageResponse: + chat_id_text = str(chat_id) + messages = store.list_messages_for_member(chat_id_text, user.id) + + scope = "messages:" + chat_id_text + if cursor is not None: + try: + cursor_key = decode_cursor(cursor, scope) + except CursorError as error: + raise ApiError(400, "invalid_request", "Некорректный cursor") from error + messages = tuple( + message + for message in messages + if (message.created_at, message.id) > cursor_key + ) + + page = messages[:limit] + next_cursor = None + if len(messages) > len(page): + last_message = page[-1] + next_cursor = encode_cursor( + scope, last_message.created_at, last_message.id + ) + return MessagePageResponse( + items=list(page), + next_cursor=next_cursor, + ) + diff --git a/src/storage/__init__.py b/src/storage/__init__.py new file mode 100644 index 00000000..569ca90f --- /dev/null +++ b/src/storage/__init__.py @@ -0,0 +1,2 @@ +"""Слой in-memory хранения для приложения первой лабораторной работы.""" + diff --git a/src/storage/memory.py b/src/storage/memory.py new file mode 100644 index 00000000..4a7d480c --- /dev/null +++ b/src/storage/memory.py @@ -0,0 +1,149 @@ +from dataclasses import dataclass +from datetime import UTC, datetime +from threading import RLock +from uuid import uuid4 + +from ..errors import ApiError + + +@dataclass(frozen=True, slots=True) +class User: + id: str + username: str + display_name: str + created_at: datetime + + +@dataclass(frozen=True, slots=True) +class Chat: + id: str + title: str + member_ids: tuple[str, ...] + created_at: datetime + + +@dataclass(frozen=True, slots=True) +class Message: + id: str + chat_id: str + sender_id: str + text: str + created_at: datetime + + +class MemoryStore: + def __init__(self) -> None: + self._users_by_id: dict[str, User] = {} + self._user_ids_by_username: dict[str, str] = {} + self._chats_by_id: dict[str, Chat] = {} + self._messages_by_chat_id: dict[str, list[Message]] = {} + self._lock = RLock() + + @staticmethod + def _now() -> datetime: + return datetime.now(UTC) + + @staticmethod + def _message_sort_key(message: Message) -> tuple[datetime, str]: + """Возвращает ключ порядка сообщений, заданный API-контрактом.""" + + return message.created_at, message.id + + @classmethod + def _insert_message_in_order( + cls, messages: list[Message], message: Message + ) -> None: + """Вставляет сообщение в отсортированную историю без сортировки при чтении.""" + + message_key = cls._message_sort_key(message) + left, right = 0, len(messages) + while left < right: + middle = (left + right) // 2 + if cls._message_sort_key(messages[middle]) <= message_key: + left = middle + 1 + else: + right = middle + messages.insert(left, message) + + def create_user(self, username: str, display_name: str) -> User: + with self._lock: + if username in self._user_ids_by_username: + raise ApiError(409, "conflict", "Username уже занят") + + user = User( + id=str(uuid4()), + username=username, + display_name=display_name, + created_at=self._now(), + ) + self._users_by_id[user.id] = user + self._user_ids_by_username[user.username] = user.id + return user + + def get_user(self, user_id: str) -> User | None: + """Возвращает пользователя по ID, если он существует.""" + + with self._lock: + return self._users_by_id.get(user_id) + + def create_chat( + self, creator_id: str, title: str, member_ids: list[str] | tuple[str, ...] + ) -> Chat: + members = tuple(member_ids) + with self._lock: + if len(members) != len(set(members)): + raise ApiError(400, "invalid_request", "Список участников содержит повторяющиеся ID") + if creator_id not in members: + raise ApiError(400, "invalid_request", "Создатель должен входить в список участников") + if any(member_id not in self._users_by_id for member_id in members): + raise ApiError(400, "invalid_request", "Один или несколько участников не существуют") + + chat = Chat( + id=str(uuid4()), + title=title, + member_ids=members, + created_at=self._now(), + ) + self._chats_by_id[chat.id] = chat + self._messages_by_chat_id[chat.id] = [] + return chat + + def get_chat_for_member(self, chat_id: str, user_id: str) -> Chat: + with self._lock: + chat = self._chats_by_id.get(chat_id) + if chat is None or user_id not in chat.member_ids: + raise ApiError(404, "not_found", "Чат не найден") + return chat + + def list_chats_for_member(self, user_id: str) -> tuple[Chat, ...]: + with self._lock: + chats = ( + chat for chat in self._chats_by_id.values() if user_id in chat.member_ids + ) + return tuple(sorted(chats, key=lambda chat: (chat.created_at, chat.id))) + + def create_message(self, chat_id: str, sender_id: str, text: str) -> Message: + with self._lock: + chat = self._chats_by_id.get(chat_id) + if chat is None or sender_id not in chat.member_ids: + raise ApiError(404, "not_found", "Чат не найден") + + message = Message( + id=str(uuid4()), + chat_id=chat_id, + sender_id=sender_id, + text=text, + created_at=self._now(), + ) + self._insert_message_in_order(self._messages_by_chat_id[chat_id], message) + return message + + def list_messages_for_member( + self, chat_id: str, user_id: str + ) -> tuple[Message, ...]: + with self._lock: + chat = self._chats_by_id.get(chat_id) + if chat is None or user_id not in chat.member_ids: + raise ApiError(404, "not_found", "Чат не найден") + return tuple(self._messages_by_chat_id[chat_id]) + diff --git a/uv.lock b/uv.lock new file mode 100644 index 00000000..e5d679eb --- /dev/null +++ b/uv.lock @@ -0,0 +1,229 @@ +version = 1 +revision = 3 +requires-python = ">=3.12" + +[[package]] +name = "annotated-doc" +version = "0.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" }, +] + +[[package]] +name = "anyio" +version = "4.15.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.15'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" }, +] + +[[package]] +name = "click" +version = "8.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/0e/7fa0ef50764b67090eca4114772a2abf8b6148198475e54c660b97caeee6/click-8.5.0.tar.gz", hash = "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34", size = 382235, upload-time = "2026-08-26T13:33:14.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", hash = "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", size = 125251, upload-time = "2026-08-26T13:33:12.928Z" }, +] + +[[package]] +name = "fastapi" +version = "0.141.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/02/91e3416a8fdd715abb903a952a6bec7cdd8d14eed55d415fc8595524c319/fastapi-0.141.1.tar.gz", hash = "sha256:e8822fc40db1e1858054d7a949a888695bc9bdce70139178e33bd2871a453ca1", size = 425799, upload-time = "2026-07-29T17:18:05.568Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/03/10388a42375ee7e4ac9b94eb2c5c569c8b5795e377e701c9ac3ad63de890/fastapi-0.141.1-py3-none-any.whl", hash = "sha256:bfb91aa2d334c61cb35ba9a116fc123b3d3df31640b801cf57a7a78ec3f603b3", size = 131954, upload-time = "2026-07-29T17:18:04.364Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "idna" +version = "3.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" }, +] + +[[package]] +name = "mtusi2026lab2" +version = "0.1.0" +source = { virtual = "." } +dependencies = [ + { name = "fastapi" }, + { name = "uvicorn" }, +] + +[package.metadata] +requires-dist = [ + { name = "fastapi", specifier = ">=0.141.1" }, + { name = "uvicorn", specifier = ">=0.53.0" }, +] + +[[package]] +name = "pydantic" +version = "2.13.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/53/ef/fc4f868f4e2cee79f863883abffceff107875f569b848507319842d2a681/pydantic-2.13.5.tar.gz", hash = "sha256:51a9c5f7b2f8e636f04c6cada605d9b6a3bf1348fdf945a3d8869b19bba0ee08", size = 845750, upload-time = "2026-08-28T14:04:00.916Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/47/c95ffc2009878c7aac0c5e08528022dcb885933252a88b5f170058014464/pydantic-2.13.5-py3-none-any.whl", hash = "sha256:346a034f080da3755d8e9cb5e00e8b07de1d39e4f6e2c87d8ab7cafa0b269a73", size = 472589, upload-time = "2026-08-28T14:03:59.136Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.46.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/f9/8a06bea35ef8daf588f707784c973a7046e0034c8d8cfb08828eeffb8b75/pydantic_core-2.46.5.tar.gz", hash = "sha256:10416c15b8839ecc4ef4d0885da76da6fd0f67333a0eb8aff6d93c4b8f2910fc", size = 472262, upload-time = "2026-08-28T10:01:31.677Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3f/76358795aa7a8c6d4f36e2cb828ad1c90ee118e1393a9281664f5aade9d4/pydantic_core-2.46.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:b9fe6fb92520e3fd61f2e49000b6911b188824f089b75973ea06d6267f0b476d", size = 2076516, upload-time = "2026-08-28T09:58:21.576Z" }, + { url = "https://files.pythonhosted.org/packages/db/50/26b091836076ce4cb2fac264186936acc069e0595772cfd02a563bc4761a/pydantic_core-2.46.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a39ac25a9a2fa4072efdb429833c4a4c8009a51ff9eea3eeae131713cd27991e", size = 1922874, upload-time = "2026-08-28T09:58:23.766Z" }, + { url = "https://files.pythonhosted.org/packages/09/f0/2a8ce3849e299d44e2d2c196b6082643a3235565a735cb51db7a6261f614/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4fdc8b93a41521988916eeaa271173fcca7fa0803d62f87675aac8dcec1c8e29", size = 1951772, upload-time = "2026-08-28T09:58:25.435Z" }, + { url = "https://files.pythonhosted.org/packages/87/46/ac0dc8bdd9e6048183a14eb127764e7ad9240021c17513074a4711b0e31e/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b98134087d9de723658d17a42c7d0da8d6e2ef08015dee7dc93889047315f5e4", size = 2031832, upload-time = "2026-08-28T09:58:27.102Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c2/339de5bef7be36301a2231eaa52e62163742c2281f11b5f4892bc79785cd/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e652ab17569c94bff5475520f907b7148b8c24036a8ebbe5cf7cf7493d28579a", size = 2208645, upload-time = "2026-08-28T09:58:28.948Z" }, + { url = "https://files.pythonhosted.org/packages/7b/a0/9ff22b797724262da14427abaed4dd1d864a139693fc5e7809114376a716/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d925f3d9afd05a8c0fb3a1031463a8d59ebe5e2afad297e29c78be19e13b4e62", size = 2265935, upload-time = "2026-08-28T09:58:30.625Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a4/eb9409ec0736e50aa70a412f16c204ed149516846912f7e6724d4c73ee53/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0fc5be0abd4a407e200d844b404e33639a554e7bd0d448e7b9ae181be4789ac2", size = 2066284, upload-time = "2026-08-28T09:58:32.289Z" }, + { url = "https://files.pythonhosted.org/packages/c0/02/7f6156ffc926857f1c37c07d9a388682865a81830ab6a1b637082c25e399/pydantic_core-2.46.5-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:816ff0a6550ffc06c098ccd2e0698600f9aa7da192a79eaa6f9af504a35db869", size = 2105889, upload-time = "2026-08-28T09:58:33.986Z" }, + { url = "https://files.pythonhosted.org/packages/92/b1/e781d357ebe09fc929f995700f1b3503e8897f1cece183ecb1300d4d67e9/pydantic_core-2.46.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c7ea57fc63aa7da93a1bd2d644e6577befae10c52c4e36377635eea1056a74f5", size = 2158006, upload-time = "2026-08-28T09:58:35.647Z" }, + { url = "https://files.pythonhosted.org/packages/70/0a/644597d84ab400e50609c192120b85c9681c22d3a20461b9060a79be0a7a/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:efd62a42486f1bda5d24cb4f63d15a3c7768375fe83d36f9417b4ad7a2fb20b3", size = 2158408, upload-time = "2026-08-28T09:58:37.38Z" }, + { url = "https://files.pythonhosted.org/packages/1e/ee/ca3b7b3a4b3769ffe9ce9432a7c9be755de9593a46d3b0d54d0409323e44/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:2bc9419666990c06d7397831f2126a1ecc3594aaa3ff7de5bf2d066802f4e07b", size = 2309609, upload-time = "2026-08-28T09:58:39.22Z" }, + { url = "https://files.pythonhosted.org/packages/ce/52/39fa1f451486019524ca685020390e7ca351832fd874530ba30c8628e6dc/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:18a09e1e1011b462f2e32774f25859ef1223d5c2b0546a633cf56654710721e0", size = 2342618, upload-time = "2026-08-28T09:58:40.89Z" }, + { url = "https://files.pythonhosted.org/packages/81/5e/468fc630568c61dcef3cd47ad32ffbeed9af643f49208d1ea86ab4f890c4/pydantic_core-2.46.5-cp312-cp312-win32.whl", hash = "sha256:5cb482e9e84c851f4e623fe4acc1ced89168cf1fe18f7089db4548c8f5bbb65b", size = 1939475, upload-time = "2026-08-28T09:58:42.591Z" }, + { url = "https://files.pythonhosted.org/packages/cf/c9/4c19f41b84cf6b622a72fbeed7665b25d47a187d68d47d0d430c07f23268/pydantic_core-2.46.5-cp312-cp312-win_amd64.whl", hash = "sha256:5e81740c09e310f5aa5cbd3e434a01c154d4bef93241c7877b39f211d2b78ba8", size = 2043140, upload-time = "2026-08-28T09:58:44.272Z" }, + { url = "https://files.pythonhosted.org/packages/af/dd/0c1a050299147c746e5256db16d645ab5efd4f78c59937d581a0524e74a2/pydantic_core-2.46.5-cp312-cp312-win_arm64.whl", hash = "sha256:f7b0ec93a2893de856652154d73b7ba622f26fa97726487dcac373de5f4c6084", size = 1997729, upload-time = "2026-08-28T09:58:46.13Z" }, + { url = "https://files.pythonhosted.org/packages/f5/37/5abe39a8372a61d3dc3c1338fc504281c01b32fdb3169cd7187153b56d3e/pydantic_core-2.46.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:b7ca9034437b6022f941f4857459562ee00a560b97e7cce8a0ec5a74fc6766e0", size = 2075885, upload-time = "2026-08-28T09:58:47.856Z" }, + { url = "https://files.pythonhosted.org/packages/21/43/6323b1f8b217780454c61304bcd2b38ae4762f50754414124603ccc90bb2/pydantic_core-2.46.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f332f0e72a5a0400141f830744e141bf9f97917878dbe968669e8a7fefea78ff", size = 1922768, upload-time = "2026-08-28T09:58:49.58Z" }, + { url = "https://files.pythonhosted.org/packages/0f/a3/c05ca796e1197618a774b01e596aeedfefc2f7d8c01ae3054e910b120e8a/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:193375f3548919d3f0b60936ca113ada3e38f264f91b9b8e0508efaad57be931", size = 1951241, upload-time = "2026-08-28T09:58:51.511Z" }, + { url = "https://files.pythonhosted.org/packages/68/32/33bc39ac705c52cffc908e8389f9754fdb208aea5c69cceddf4eb3ce99af/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:79bdfa52f843137045b2d081cc05c120ba6665d29b7559c2c47690906f39279f", size = 2031975, upload-time = "2026-08-28T09:58:53.166Z" }, + { url = "https://files.pythonhosted.org/packages/b0/70/2333e885c0f6a67bc105c5916965dac9b57f2718ee20d81d1a06a4ebdc13/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:24922243639cbdac66c75fcb6fd6495a9cb52b213d62f9a0d16f0310b1ff8038", size = 2208542, upload-time = "2026-08-28T09:58:55.017Z" }, + { url = "https://files.pythonhosted.org/packages/f7/ea/296debfb4264207bbda5936133892e027c0a58875ad53ebd512fba8ec3a2/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c76fe65e607be28c7fd4d56fc3c42b1583aa058ce3408b7ad0fd540171d31f9f", size = 2264692, upload-time = "2026-08-28T09:58:56.767Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f2/9e4de77a6271e07a76d2d58b11c091a979c191ed2939bf80067568b369d2/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f7b393a8b3da82f5c1fc0751e6d01ac6c55b93c18226a60bdfba4a724efafd1", size = 2066633, upload-time = "2026-08-28T09:58:58.531Z" }, + { url = "https://files.pythonhosted.org/packages/8d/db/f9e9d0c97445987b2084823d5c240de88087338f04fc2cfaa2df186b8049/pydantic_core-2.46.5-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:7ac031912d54f3d83ef3b3eb98dfabc1608802e2202263d25957eeed40b94761", size = 2105235, upload-time = "2026-08-28T09:59:00.421Z" }, + { url = "https://files.pythonhosted.org/packages/07/c5/79169b047b3b2c3e99e04bc76372af9637e0bf6db638274fa927df96369e/pydantic_core-2.46.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:837b396ca3d7b74091ca623f6cbd8351bd42d670a79c2683e79fb089f06a2de5", size = 2157367, upload-time = "2026-08-28T09:59:02.442Z" }, + { url = "https://files.pythonhosted.org/packages/26/b5/ba6057afb7c291bd449f51b867f95aef2072941c4ce4e5c31d6ffd132d3b/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:5ee239d575f80b08eca11f6e20f90c4c695de7825c67eefe6091fbf20dda648e", size = 2158420, upload-time = "2026-08-28T09:59:04.2Z" }, + { url = "https://files.pythonhosted.org/packages/6e/28/2057abecaafdc22912afa819603a51f0a62d40643b7c4871c51721fea9be/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:e80675d75ae2cd14372cb65cad5400d9347a3d3f6c13000183f22dfd027283ed", size = 2309588, upload-time = "2026-08-28T09:59:06.048Z" }, + { url = "https://files.pythonhosted.org/packages/71/9d/881156dc404e27479c4246128d73538464cab4a239bec61995e227644c30/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:9c4b71f10dd532fb7a5cbc8f58707779e64f03a258c2bf8bfbaecfcd9970b519", size = 2341866, upload-time = "2026-08-28T09:59:08.539Z" }, + { url = "https://files.pythonhosted.org/packages/5a/38/d66f443a259f84d13babdceae568e572b0ed26da17ca5d0a649ebb110a67/pydantic_core-2.46.5-cp313-cp313-win32.whl", hash = "sha256:97bf8de4d541598c94a59344eeb988a94c08ff76b5723c41f6567ec18c7892ea", size = 1938580, upload-time = "2026-08-28T09:59:10.402Z" }, + { url = "https://files.pythonhosted.org/packages/2c/1e/1d5371213f4cc9a7ed70c0bfcc7911de22311ee99a662a56077d7292d2ac/pydantic_core-2.46.5-cp313-cp313-win_amd64.whl", hash = "sha256:15f4a94963c95accac15b7b657bb177d3ad82bb90b0d0526d9a9b85079925db5", size = 2041980, upload-time = "2026-08-28T09:59:12.396Z" }, + { url = "https://files.pythonhosted.org/packages/5a/48/4222d90b1c67568bace4dec6dca6271449c66de3595d72b6d098f5fde597/pydantic_core-2.46.5-cp313-cp313-win_arm64.whl", hash = "sha256:d22a945598fb91236b4dd793a6e42e4f3dd7740bb5aace5ebd7d4c08d13bb575", size = 1997213, upload-time = "2026-08-28T09:59:14.245Z" }, + { url = "https://files.pythonhosted.org/packages/8e/8a/14596f2a8367da50cf7cbac48169ee5d9c8e11d486a3b527082384630c72/pydantic_core-2.46.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:c1c43ad4339643d70ebb8124e1305a7dab423001eff58bb41a0f731adbc98355", size = 2074081, upload-time = "2026-08-28T09:59:16.141Z" }, + { url = "https://files.pythonhosted.org/packages/ae/d5/d8a4eb6d6c7f66b91dd37c576d76e9e60fba900caf5372c17bcf949febc2/pydantic_core-2.46.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1a353f84de772f423b5ffb11d7ae352fbbef0f446f3c0b0af0f8236d7233606e", size = 1920497, upload-time = "2026-08-28T09:59:18.065Z" }, + { url = "https://files.pythonhosted.org/packages/8e/26/092079428f86e927e030b2c0ced87df69dbb1c875cdeaa67bf42ea2be746/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5086029a57366b8cf81b130a43908738095c270c21a8d7f0e8bdfdb89718e2f3", size = 1952130, upload-time = "2026-08-28T09:59:20.476Z" }, + { url = "https://files.pythonhosted.org/packages/08/c3/8ec0e290a9ebaebd64047bf5fda94be835c6b1551b02437e4b76778fbcd7/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:46c25dda9d092a06c08db76ffe0a197107904d0dfac653f7d5306bbcd6d6119c", size = 2026371, upload-time = "2026-08-28T09:59:22.227Z" }, + { url = "https://files.pythonhosted.org/packages/01/72/4fd20ad520fb8da0157f95b27a7eb05a72790ef08138e7701ac972c342ea/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:37ea7b83c935e5b0d68c9449b82651accf78a10828b2c02b2f2d9e9496446c21", size = 2202822, upload-time = "2026-08-28T09:59:24.277Z" }, + { url = "https://files.pythonhosted.org/packages/31/b0/d16e0771206b29314f0d52198b720be21e8a99ab2bf11e3bc0d7c9cebdff/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e64e88d5585bea9ce95861079de72006c7fa6d3df4e3a3b65ba31eb979c15c9f", size = 2262756, upload-time = "2026-08-28T09:59:26.608Z" }, + { url = "https://files.pythonhosted.org/packages/2c/9b/59634b7ac631c63b2a37760eb6943af3e29573d6b59a4abc5e7f019d4cee/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54d510bac3ee52247af28ed4bb18a1e799f040ac60fd2bf5ccd4c92f1fbe786f", size = 2068352, upload-time = "2026-08-28T09:59:29.044Z" }, + { url = "https://files.pythonhosted.org/packages/08/7c/570abb1ad2155348dc754ea91be22e5aaa18eb6d69a6068f7c6f2679a6ed/pydantic_core-2.46.5-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:a2a5e1d0ff29adddc9f6d6821a66302e4493f8ca898b715b6b1182c2c201ea0a", size = 2104777, upload-time = "2026-08-28T09:59:30.95Z" }, + { url = "https://files.pythonhosted.org/packages/8e/25/5bf74adc65a1ac5b7be3f6cb0bcb5433615c1598a801c19d830d84c98ded/pydantic_core-2.46.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:03b9666e41e35d8909852ba191a0607520f81b74eaf12ccf8737005dbb313821", size = 2156312, upload-time = "2026-08-28T09:59:32.604Z" }, + { url = "https://files.pythonhosted.org/packages/90/6a/2ef38830675e050121040618135564ed56b860b45433b02d9b4ebece46f3/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:a91c17edf6eea2402cb5457b4c89e99bc5ed1004aa34c4adf1d4258c1a5c22c2", size = 2150067, upload-time = "2026-08-28T09:59:34.453Z" }, + { url = "https://files.pythonhosted.org/packages/90/ef/a7dbb03a14a64c2a4621f989c615ed9a892535a6cad938fc27079f919d80/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b49924c73a235e969511bf2aabdff3beebf9820931f646c80274d5d780010c47", size = 2304516, upload-time = "2026-08-28T09:59:36.194Z" }, + { url = "https://files.pythonhosted.org/packages/68/f8/6bb4c4b80e8a6fde1904c64a51c62a1d04fcdfa3ea521a66b2ddefa1d885/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:2cbd9a5eff05e51c447c34dfa4632145b26b09120cf04bd0c871e44c1a5e1c9a", size = 2335223, upload-time = "2026-08-28T09:59:37.931Z" }, + { url = "https://files.pythonhosted.org/packages/2a/80/f46b8c681195190b2c1f1c7c0a81abce60663e987613e09ef64d433dd96b/pydantic_core-2.46.5-cp314-cp314-win32.whl", hash = "sha256:2d5d76654becf5efd62c9e51c3756c67b49498b0c9a40884934c40807adbd074", size = 1934827, upload-time = "2026-08-28T09:59:39.836Z" }, + { url = "https://files.pythonhosted.org/packages/f7/3c/60674207246bc0a4009d2391b7c7251c7159f279c8d2ab8aae8ef46f3dee/pydantic_core-2.46.5-cp314-cp314-win_amd64.whl", hash = "sha256:fa10ef4112775900e7a0661068635eb67b2ab824fbde764de6e0e21982a93db0", size = 2042648, upload-time = "2026-08-28T09:59:41.792Z" }, + { url = "https://files.pythonhosted.org/packages/69/0c/117c562c7c1babdf44576b72a5e496906506c93690387ecfbca7c729ae2e/pydantic_core-2.46.5-cp314-cp314-win_arm64.whl", hash = "sha256:045ab3b6d308439e32b81cc173bba5b9018bc6ed896afd0c65b3b009b1699af5", size = 1989652, upload-time = "2026-08-28T09:59:43.702Z" }, + { url = "https://files.pythonhosted.org/packages/e8/66/9336ae58f9eb68c41d121894e52c4c89eccb07eb8f602a04ee9c3f37736a/pydantic_core-2.46.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8816f3d218beb4b787de5c9759c259b8fa61f9dec42dc7811f320a33771778b7", size = 2065829, upload-time = "2026-08-28T09:59:45.364Z" }, + { url = "https://files.pythonhosted.org/packages/c5/02/bc19b47a96c2d3109760711acf22369e56bd7e405ca52f7ade164d2ead57/pydantic_core-2.46.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:bce57638e08ac148e5778cce7feb968307a727d66f8e2274a543d0cf0c9ad6a3", size = 1905716, upload-time = "2026-08-28T09:59:47.18Z" }, + { url = "https://files.pythonhosted.org/packages/52/a4/70b47c0509923dd98ccfed04fb3e32ea3849c82a0ff2205bb41009b43c00/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:976e1128455aa595ea04c79ccfedff1aaeab96ee013fcc916bed120c4f0ad94f", size = 1934216, upload-time = "2026-08-28T09:59:49.241Z" }, + { url = "https://files.pythonhosted.org/packages/52/ab/aa03b65f7bb198585edf806b906c3223ecf1795543e39e23aec4cce27ad2/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b891faeedeafba41b2983e5001a81b6a915b69544c7e7570d1989ce1c36ac7", size = 2010635, upload-time = "2026-08-28T09:59:51.692Z" }, + { url = "https://files.pythonhosted.org/packages/3c/8b/0da06343f30b84ec549aafd309c6456223d5dc8bd36af504c573faad561d/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f194189415698233dd1114a093a9b56e61e2c57e11b469be3b0506f46f0771c", size = 2209369, upload-time = "2026-08-28T09:59:53.582Z" }, + { url = "https://files.pythonhosted.org/packages/d6/5b/844c4defaa34a3df66eb9257087d121d70c201298b96abdf9f492fc2f1bf/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:82a36973cf8a2ef5406f4fe2edbf8ed0c99629535d959e0b100c76a32535a111", size = 2253238, upload-time = "2026-08-28T09:59:55.484Z" }, + { url = "https://files.pythonhosted.org/packages/f4/64/a4e536cb16d7f61a7fd3120b46c577fc7fa7325992f69c4f52bc786d77d8/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdbb78909f52b981d3b2d56b97328d71eb0b974c36bd77c920123a7ebb192829", size = 2065740, upload-time = "2026-08-28T09:59:58.038Z" }, + { url = "https://files.pythonhosted.org/packages/5f/75/aaa38c6bc2d085f6605b34eabdc6a8a4e0b2e61fc9c8e6e52b28e97b3125/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:52e24eacdb536cade636aa90fb851835222becff8484b7001fdc78cb0290f2aa", size = 2087425, upload-time = "2026-08-28T09:59:59.898Z" }, + { url = "https://files.pythonhosted.org/packages/55/ae/fcab4cfc39aba3689e1d20c8b5250ad280957022c09af2ed9cd585602a5e/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:37ae34309d7bd8c0d61ab839668058f2a7962ea1fc51d105d2db228fe0618034", size = 2139306, upload-time = "2026-08-28T10:00:03.057Z" }, + { url = "https://files.pythonhosted.org/packages/2d/f4/f1d03a4bc9d9acbc62f4d742b8a319af52f71885079868b2ff8e48a651ee/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:0cdbada856a1c69a7624a64d3d9aefe79300bd6ef827b43a4f265010b9b55184", size = 2144589, upload-time = "2026-08-28T10:00:05.645Z" }, + { url = "https://files.pythonhosted.org/packages/83/f3/7a53bb1356de514a4cd295f25b6ac39237895620c0462d2592b76c16e114/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:545f26c504b27c3758439a5e6d9349931f0a04f855668d5fe323c89e82300a38", size = 2288882, upload-time = "2026-08-28T10:00:07.931Z" }, + { url = "https://files.pythonhosted.org/packages/cd/94/5a81583660c175c59d49ffb09f4b3a44debeaf86a19fca664ae1cdd9ee32/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:ff218293c9c806138dca139765e3b067621be52bcd93cdc14c7711be7ddc90a9", size = 2335210, upload-time = "2026-08-28T10:00:10.177Z" }, + { url = "https://files.pythonhosted.org/packages/5a/9f/5d685c2693b972d1a59c998586e8823712b66603aeff47ee60a4bdaafd37/pydantic_core-2.46.5-cp314-cp314t-win32.whl", hash = "sha256:97cf3eb53a8cccacf9d46686a0926186c9bfb5574f2ed66d3639d5fe117cd3a9", size = 1921180, upload-time = "2026-08-28T10:00:12.35Z" }, + { url = "https://files.pythonhosted.org/packages/70/12/5c94ee16d65a37a15f9e869f5e6256df111154491173801a4c5e800ab548/pydantic_core-2.46.5-cp314-cp314t-win_amd64.whl", hash = "sha256:d2f9fc07a8042a8f95925b35c4f04f469707c981fc33245b6ca187cf5d2dd290", size = 2020515, upload-time = "2026-08-28T10:00:14.774Z" }, + { url = "https://files.pythonhosted.org/packages/63/19/67830dda664e6bdf9285ee2e40f355d0d7d6b92aa0c42e8d217bb8d33d36/pydantic_core-2.46.5-cp314-cp314t-win_arm64.whl", hash = "sha256:acf8a67ba51f4ca9ddbd0e6b3000a65ac51ab734661778b3e7ba64d99a710f2f", size = 1989276, upload-time = "2026-08-28T10:00:16.984Z" }, + { url = "https://files.pythonhosted.org/packages/df/dd/053c2e4303f791f3b8f8a14ab0b22008e8eb21d868c0c90b4f9be705b76a/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:013d6f3483d81e02e7c328831808f336c8596ee33b4bd4026b9ffb1e960b8942", size = 2062540, upload-time = "2026-08-28T10:01:00.318Z" }, + { url = "https://files.pythonhosted.org/packages/d7/dd/a18df751a5e37dd51bfad7f68e766999125bebe68c9e1d10a493ad01bd63/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:e9c134bb666dd54b778b9fc0d2b50cbb7f979b9e3716f26a88c9ab3b6fc1dd0f", size = 1902040, upload-time = "2026-08-28T10:01:02.529Z" }, + { url = "https://files.pythonhosted.org/packages/b7/13/01d40f9d07ce8a779fd6e0bd8ad4fba91309500dd67b869e2e219d261a6d/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:347ec774390c87326a2e4929d58d3f7e8763a104d5d35f4cd595a4c952366433", size = 1967479, upload-time = "2026-08-28T10:01:05.004Z" }, + { url = "https://files.pythonhosted.org/packages/fa/04/c81d4841331c2178b6fb09ae225425e110ed72d990c9fe556c4ec03d1013/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e24d8f05fa2d28513d94e877e9c75ad66175376209b3977f916e240e623193c", size = 2111034, upload-time = "2026-08-28T10:01:07.345Z" }, +] + +[[package]] +name = "starlette" +version = "1.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7b/2b/3850dc6bf7ef71b088962eba31dafc6cffd2f96e577ebb0bb316df96da3e/starlette-1.7.0.tar.gz", hash = "sha256:c79f74ea63cff761804fbbfb182f1e0b440c2d07b164d24700c5a1bab5d6ff5d", size = 2736246, upload-time = "2026-09-23T07:30:26.35Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/d6/1ec1b290f9e0fb067899b61e1d37a30c923068bad260b216dbe37a7d2967/starlette-1.7.0-py3-none-any.whl", hash = "sha256:67f8e99895493dd2911a03f11314af6ceebeae4e704bb9f43dfc6a9db151c93e", size = 78980, upload-time = "2026-09-23T07:30:24.567Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/26/b09b8010994eccc3c09092e6b34058f36a460eea2d4c3e8b910c695975a0/typing_inspection-0.4.4.tar.gz", hash = "sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47", size = 76928, upload-time = "2026-08-12T12:37:25.997Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/81/4add07e5172b7ac40d8ed5ff580409a7801a4fe26d529bdd915401dabfbe/typing_inspection-0.4.4-py3-none-any.whl", hash = "sha256:65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147", size = 14750, upload-time = "2026-08-12T12:37:24.648Z" }, +] + +[[package]] +name = "uvicorn" +version = "0.53.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5d/ad/04bbb797c84fc1f26cb171f7394716f4865ffb8d8c5e1eef42565c2dfa6b/uvicorn-0.53.0.tar.gz", hash = "sha256:a9356f0cb89b3b8621529c5d5eebd69bfe154f4c3f68b4cf2de47e45fa855c2e", size = 110881, upload-time = "2026-09-14T07:44:23.815Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/18/0eea75741ee812e9f598b687619ce2454f6c3a1c5cd21ea990ec6bd26f45/uvicorn-0.53.0-py3-none-any.whl", hash = "sha256:e8dca71ec86dce5f04e333f0d56cdedf942446e6643b9cea1af0d6d3a02cb03e", size = 87081, upload-time = "2026-09-14T07:44:22.179Z" }, +] -- 2.54.0 From b158c880870498f1b2ea03a20a0fcca83daffa07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9?= Date: Thu, 8 Oct 2026 17:04:26 +0300 Subject: [PATCH 2/6] add code for level 3 --- Dockerfile | 2 +- REPORT.md | 86 +++++++--- compose.yaml | 49 ++++++ evidence/persistence-2026-10-08.txt | 5 + evidence/smoke-2026-10-08.txt | 4 + migrations/001_initial.sql | 37 ++++ pyproject.toml | 6 +- scripts/restart.sh | 4 + src/config.py | 35 +++- src/errors.py | 6 +- src/main.py | 26 ++- src/models.py | 45 ++++- src/routes.py | 199 +++++++++------------- src/storage/__init__.py | 2 +- src/storage/memory.py | 149 ---------------- src/storage/postgres.py | 252 ++++++++++++++++++++++++++++ uv.lock | 207 ++++++++++++++++++++++- 17 files changed, 804 insertions(+), 310 deletions(-) create mode 100644 compose.yaml create mode 100644 evidence/persistence-2026-10-08.txt create mode 100644 evidence/smoke-2026-10-08.txt create mode 100644 migrations/001_initial.sql create mode 100755 scripts/restart.sh delete mode 100644 src/storage/memory.py create mode 100644 src/storage/postgres.py diff --git a/Dockerfile b/Dockerfile index 371e47ba..ab272d34 100644 --- a/Dockerfile +++ b/Dockerfile @@ -11,6 +11,7 @@ COPY pyproject.toml uv.lock ./ RUN uv sync --frozen --no-dev --no-install-project COPY src ./src +COPY migrations ./migrations USER 65534:65534 @@ -20,4 +21,3 @@ HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ CMD ["/app/.venv/bin/python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).read()"] CMD ["/app/.venv/bin/python", "-m", "src.main"] - diff --git a/REPORT.md b/REPORT.md index e42f2b05..d39a6daa 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,83 @@ # Отчёт — лабораторная 2 - Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Целевая оценка: 3 - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные библиотеки: FastAPI 0.141.1, Uvicorn 0.40.0, asyncpg 0.31.0, argon2-cffi 25.1.0; зафиксированы в `pyproject.toml` и `uv.lock`. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker Engine с Docker Compose v2 и OpenSSL. Создайте только локальные +секреты — они исключены из Git: + +```sh +mkdir -p secrets +openssl rand -hex 32 -out secrets/postgres_password +awk '{printf "postgresql://messenger:%s@postgres:5432/messenger\\n", $0}' \ + secrets/postgres_password > secrets/database_url +chmod 700 secrets +chmod 600 secrets/postgres_password secrets/database_url +docker compose --env-file .env.example config --quiet +docker compose --env-file .env.example up -d --build +``` + +API публикуется на `http://localhost:8080`. Миграции запускаются API при +старте; таблица `schema_migrations` не применяет уже записанную миграцию +повторно. Проверка готовности: + +```sh +curl -fsS http://localhost:8080/health/ready +make test +chmod +x scripts/restart.sh +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` + +Обычная остановка сохраняет учебные данные: + +```sh +docker compose down +``` + +Намеренно удалить учебные данные можно только отдельной командой +`docker compose down -v`; она не входит в restart hook. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```text +HTTP-клиент → FastAPI API → asyncpg pool (1..10 соединений) → PostgreSQL + └→ миграции SQL при старте +``` + +PostgreSQL — источник истины для `users`, `chats`, `chat_members`, +`messages` и `sessions`. Named volume `postgres_data` хранит каталог БД. +Токен сессии создаётся через `secrets.token_urlsafe(32)`; в БД лежит только +SHA-256 токена и время истечения. Пароли хешируются Argon2 через +`argon2-cffi`; plaintext и hash не попадают в API-ответы. + +`POST /api/v1/users` требует `password`. `POST /api/v1/auth/sessions` +принимает только Basic и выдаёт opaque Bearer token. Все бизнес-endpoint +определяют пользователя только по Bearer; `X-User-Id` игнорируется. +Logout удаляет текущую серверную сессию. Срок действия фиксируется при +создании и задаётся `SESSION_TTL_SECONDS` (3600 по умолчанию). + +Создание чата — одна транзакция: проверка состава пользователей, запись чата и +всех участников. Внешние ключи и уникальность username заданы миграцией. +История выбирается keyset-запросом по `(created_at, id)`; индекс +`messages_chat_created_id_idx` соответствует этому запросу. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| Критерий | Команда | Наблюдаемый результат | Статус | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. - -## Эксперименты и отказы - -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. - -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Контракт и синтаксис | `make check` | PASS | выполнено | +| Импорт приложения и Basic parser | `uv run --frozen python …` | PASS | выполнено | +| Согласованность lock-файла | `uv lock --check` | PASS | выполнено | +| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/smoke-2026-10-08.txt` | +| Persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` | `evidence/persistence-2026-10-08.txt` | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Redis/Valkey не используется: он относится к уровню 4 этой лабораторной. +Публичные smoke и persistence выполнены на локальном Compose-стенде 2026-10-08. +При фиксации работы в PR сохраните их stdout в `evidence/` без токенов и +паролей. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..4c1eafe4 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,49 @@ +services: + postgres: + image: postgres:17.6-alpine + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 12 + start_period: 5s + + api: + build: + context: . + environment: + APP_HOST: 0.0.0.0 + APP_PORT: 8080 + APP_ENV: lab2 + DATABASE_URL_FILE: /run/secrets/database_url + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + secrets: + - database_url + depends_on: + postgres: + condition: service_healthy + ports: + - "8080:8080" + healthcheck: + test: ["CMD", "/app/.venv/bin/python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).read()"] + interval: 5s + timeout: 3s + retries: 12 + start_period: 10s + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + +volumes: + postgres_data: diff --git a/evidence/persistence-2026-10-08.txt b/evidence/persistence-2026-10-08.txt new file mode 100644 index 00000000..db025a7c --- /dev/null +++ b/evidence/persistence-2026-10-08.txt @@ -0,0 +1,5 @@ +Date: 2026-10-08 +Command: make test-persistence ACTION_SCRIPT=scripts/restart.sh +Result: +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/smoke-2026-10-08.txt b/evidence/smoke-2026-10-08.txt new file mode 100644 index 00000000..47fef3d7 --- /dev/null +++ b/evidence/smoke-2026-10-08.txt @@ -0,0 +1,4 @@ +Date: 2026-10-08 +Command: make test +Result: +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..c03d5fd9 --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,37 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, + username varchar(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name varchar(100) NOT NULL CHECK (char_length(btrim(display_name)) > 0), + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title varchar(100) NOT NULL CHECK (char_length(btrim(title)) > 0), + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT, + PRIMARY KEY (chat_id, user_id) +); +CREATE INDEX chat_members_user_chat_idx ON chat_members (user_id, chat_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT, + text varchar(4000) NOT NULL CHECK (char_length(btrim(text)) > 0), + created_at timestamptz NOT NULL DEFAULT now() +); +CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); + +CREATE TABLE sessions ( + token_hash char(64) PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at timestamptz NOT NULL, + created_at timestamptz NOT NULL DEFAULT now() +); +CREATE INDEX sessions_expiry_idx ON sessions (expires_at); diff --git a/pyproject.toml b/pyproject.toml index 43a1dc9c..2eb0b29d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,6 +5,8 @@ description = "MTUSI high-load messenger, laboratory 2" readme = "README.md" requires-python = ">=3.12" dependencies = [ - "fastapi>=0.141.1", - "uvicorn>=0.53.0", + "argon2-cffi==25.1.0", + "asyncpg==0.31.0", + "fastapi==0.141.1", + "uvicorn==0.40.0", ] diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..5d062916 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose restart api postgres diff --git a/src/config.py b/src/config.py index 3b5a4519..80aa98f0 100644 --- a/src/config.py +++ b/src/config.py @@ -4,7 +4,14 @@ from pathlib import Path ROOT = Path(__file__).resolve().parents[1] -_CONFIGURATION_KEYS = {"APP_HOST", "APP_PORT", "APP_ENV"} +_CONFIGURATION_KEYS = { + "APP_HOST", + "APP_PORT", + "APP_ENV", + "DATABASE_URL", + "DATABASE_URL_FILE", + "SESSION_TTL_SECONDS", +} @dataclass(frozen=True, slots=True) @@ -14,6 +21,8 @@ class Settings: host: str port: int environment: str + database_url: str + session_ttl_seconds: int def load_settings(env_file: Path = ROOT / ".env") -> Settings: @@ -44,5 +53,25 @@ def load_settings(env_file: Path = ROOT / ".env") -> Settings: raise ValueError("APP_PORT должен быть целым числом") from error if not 1 <= port <= 65535: raise ValueError("APP_PORT должен находиться в диапазоне 1..65535") - return Settings(host=host, port=port, environment=environment) - + database_url_file = os.environ.get("DATABASE_URL_FILE", "").strip() + database_url = os.environ.get("DATABASE_URL", "").strip() + if database_url_file: + try: + database_url = Path(database_url_file).read_text(encoding="utf-8").strip() + except OSError as error: + raise ValueError("DATABASE_URL_FILE недоступен") from error + if not database_url.startswith(("postgresql://", "postgres://")): + raise ValueError("Нужен PostgreSQL DATABASE_URL или DATABASE_URL_FILE") + try: + session_ttl_seconds = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + except ValueError as error: + raise ValueError("SESSION_TTL_SECONDS должен быть целым числом") from error + if session_ttl_seconds < 1: + raise ValueError("SESSION_TTL_SECONDS должен быть положительным") + return Settings( + host=host, + port=port, + environment=environment, + database_url=database_url, + session_ttl_seconds=session_ttl_seconds, + ) diff --git a/src/errors.py b/src/errors.py index 4b67c7a7..258d6996 100644 --- a/src/errors.py +++ b/src/errors.py @@ -3,8 +3,10 @@ class ApiError(Exception): - def __init__(self, status_code: int, code: str, message: str) -> None: + def __init__( + self, status_code: int, code: str, message: str, headers: dict[str, str] | None = None + ) -> None: self.status_code = status_code self.code = code self.message = message - + self.headers = headers or {} diff --git a/src/main.py b/src/main.py index 9d0bb575..46fb8e87 100644 --- a/src/main.py +++ b/src/main.py @@ -1,6 +1,7 @@ import logging import sys import time +from contextlib import asynccontextmanager from uuid import uuid4 from fastapi import FastAPI, Request @@ -12,6 +13,7 @@ from .errors import ApiError from .models import ErrorDetails, ErrorResponse from .config import load_settings from .routes import router +from .storage.postgres import PostgresStore access_logger = logging.getLogger("messenger.access") @@ -25,10 +27,25 @@ access_logger.setLevel(logging.INFO) access_logger.propagate = False +@asynccontextmanager +async def lifespan(application: FastAPI): + settings = load_settings() + store = PostgresStore(settings.database_url) + await store.connect() + await store.migrate() + application.state.store = store + application.state.settings = settings + try: + yield + finally: + await store.close() + + app = FastAPI( title="MTUSI Messenger", version="1.1.0", redoc_url=None, + lifespan=lifespan, ) @@ -55,7 +72,9 @@ async def add_request_id(request: Request, call_next) -> Response: ) -def error_response(request: Request, status_code: int, code: str, message: str) -> JSONResponse: +def error_response( + request: Request, status_code: int, code: str, message: str, headers: dict[str, str] | None = None +) -> JSONResponse: request_id = request.state.request_id body = ErrorResponse( error=ErrorDetails(code=code, message=message, request_id=request_id) @@ -65,7 +84,7 @@ def error_response(request: Request, status_code: int, code: str, message: str) return JSONResponse( status_code=status_code, content=body.model_dump(), - headers={"X-Request-Id": request_id}, + headers={"X-Request-Id": request_id, **(headers or {})}, ) @@ -73,7 +92,7 @@ def error_response(request: Request, status_code: int, code: str, message: str) async def handle_api_error(request: Request, error: ApiError) -> JSONResponse: """Преобразует контролируемую ошибку API в стандартный JSON-ответ.""" - return error_response(request, error.status_code, error.code, error.message) + return error_response(request, error.status_code, error.code, error.message, error.headers) @app.exception_handler(RequestValidationError) @@ -108,4 +127,3 @@ def main() -> None: if __name__ == "__main__": main() - diff --git a/src/models.py b/src/models.py index c9772466..095ec1a2 100644 --- a/src/models.py +++ b/src/models.py @@ -1,15 +1,14 @@ +from datetime import datetime from uuid import UUID from pydantic import BaseModel, ConfigDict, Field, field_validator -from .storage.memory import Chat, Message - - class CreateUserRequest(BaseModel): model_config = ConfigDict(extra="forbid", strict=True) username: str = Field(min_length=3, max_length=32, pattern=r"^[a-z0-9_]{3,32}$") display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) @field_validator("display_name") @classmethod @@ -40,7 +39,7 @@ class CreateChatRequest(BaseModel): class ChatPageResponse(BaseModel): model_config = ConfigDict(extra="forbid") - items: list[Chat] + items: list["Chat"] next_cursor: str | None @@ -62,7 +61,7 @@ class CreateMessageRequest(BaseModel): class MessagePageResponse(BaseModel): model_config = ConfigDict(extra="forbid") - items: list[Message] + items: list["Message"] next_cursor: str | None @@ -79,3 +78,39 @@ class ErrorResponse(BaseModel): error: ErrorDetails + +class User(BaseModel): + model_config = ConfigDict(extra="forbid") + + id: UUID + username: str + display_name: str + created_at: datetime + + +class Chat(BaseModel): + model_config = ConfigDict(extra="forbid") + + id: UUID + title: str + member_ids: list[UUID] + created_at: datetime + + +class Message(BaseModel): + model_config = ConfigDict(extra="forbid") + + id: UUID + chat_id: UUID + sender_id: UUID + text: str + created_at: datetime + + +class Session(BaseModel): + model_config = ConfigDict(extra="forbid") + + token: str = Field(min_length=32) + token_type: str = "Bearer" + expires_at: datetime + user: User diff --git a/src/routes.py b/src/routes.py index ad515930..c2062e9c 100644 --- a/src/routes.py +++ b/src/routes.py @@ -1,154 +1,117 @@ +import base64 +from datetime import datetime from uuid import UUID -from fastapi import APIRouter, Depends, Header, Query +from fastapi import APIRouter, Depends, Header, Query, Request, Response from .cursor import CursorError, decode_cursor, encode_cursor from .errors import ApiError -from .models import ( - ChatPageResponse, - CreateChatRequest, - CreateMessageRequest, - CreateUserRequest, - MessagePageResponse, -) -from .storage.memory import Chat, MemoryStore, Message, User - +from .models import Chat, ChatPageResponse, CreateChatRequest, CreateMessageRequest, CreateUserRequest, Message, MessagePageResponse, Session, User +from .storage.postgres import PostgresStore router = APIRouter() -store = MemoryStore() +BEARER_CHALLENGE = {'WWW-Authenticate': 'Bearer realm="messenger"'} +BASIC_CHALLENGE = {'WWW-Authenticate': 'Basic realm="messenger", charset="UTF-8"'} +def get_store(request: Request) -> PostgresStore: + return request.app.state.store + +async def get_current_user(authorization: str | None = Header(default=None), store: PostgresStore = Depends(get_store)) -> dict: + if authorization is None or not authorization.startswith("Bearer "): + raise ApiError(401, "unauthorized", "Требуется Bearer-сессия", BEARER_CHALLENGE) + token = authorization[7:] + if not token or token.strip() != token: + raise ApiError(401, "unauthorized", "Требуется Bearer-сессия", BEARER_CHALLENGE) + user = await store.user_for_token(token) + if user is None: + raise ApiError(401, "unauthorized", "Недействительная сессия", BEARER_CHALLENGE) + return user + +def parse_basic(authorization: str | None) -> tuple[str, str]: + if authorization is None or not authorization.startswith("Basic "): + raise ApiError(401, "unauthorized", "Неверные учётные данные", BASIC_CHALLENGE) + try: + decoded = base64.b64decode(authorization[6:], validate=True) + username_bytes, password_bytes = decoded.split(b":", 1) + username = username_bytes.decode("ascii") + password = password_bytes.decode("utf-8") + except (UnicodeDecodeError, ValueError) as error: + raise ApiError(401, "unauthorized", "Неверные учётные данные", BASIC_CHALLENGE) from error + if not username or not (12 <= len(password) <= 128): + raise ApiError(401, "unauthorized", "Неверные учётные данные", BASIC_CHALLENGE) + return username, password @router.get("/health/live") async def liveness() -> dict[str, str]: return {"status": "ok"} - @router.get("/health/ready") -async def readiness() -> dict[str, str]: +async def readiness(store: PostgresStore = Depends(get_store)) -> dict[str, str]: + await store.ready() return {"status": "ok"} - -def get_current_user( - user_id_header: str | None = Header(default=None, alias="X-User-Id"), -) -> User: - """Определяет текущего пользователя по X-User-Id.""" - - if user_id_header is None: - raise ApiError(401, "unauthorized", "Требуется заголовок X-User-Id") - - try: - user_id = str(UUID(user_id_header)) - except ValueError as error: - raise ApiError(401, "unauthorized", "Некорректный X-User-Id") from error - - user = store.get_user(user_id) - if user is None: - raise ApiError(401, "unauthorized", "Пользователь не найден") - return user - - @router.post("/api/v1/users", response_model=User, status_code=201) -def register_user(payload: CreateUserRequest) -> User: - return store.create_user(payload.username, payload.display_name) +async def register_user(payload: CreateUserRequest, store: PostgresStore = Depends(get_store)) -> dict: + return await store.create_user(payload.username, payload.display_name, payload.password) +@router.post("/api/v1/auth/sessions", response_model=Session, status_code=201) +async def create_session(request: Request, authorization: str | None = Header(default=None), store: PostgresStore = Depends(get_store)) -> dict: + if await request.body(): + raise ApiError(400, "invalid_request", "Тело запроса не требуется") + username, password = parse_basic(authorization) + user = await store.authenticate(username, password) + if user is None: + raise ApiError(401, "unauthorized", "Неверные учётные данные", BASIC_CHALLENGE) + return await store.create_session(user, request.app.state.settings.session_ttl_seconds) + +@router.delete("/api/v1/auth/sessions/current", status_code=204) +async def revoke_session(authorization: str | None = Header(default=None), store: PostgresStore = Depends(get_store), user: dict = Depends(get_current_user)) -> Response: + del user + await store.revoke_session(authorization[7:]) + return Response(status_code=204) @router.get("/api/v1/users/me", response_model=User) -def current_user(user: User = Depends(get_current_user)) -> User: +async def current_user(user: dict = Depends(get_current_user)) -> dict: return user - @router.post("/api/v1/chats", response_model=Chat, status_code=201) -def create_chat( - payload: CreateChatRequest, - user: User = Depends(get_current_user), -) -> Chat: - return store.create_chat( - creator_id=user.id, - title=payload.title, - member_ids=[str(member_id) for member_id in payload.member_ids], - ) - +async def create_chat(payload: CreateChatRequest, user: dict = Depends(get_current_user), store: PostgresStore = Depends(get_store)) -> dict: + return await store.create_chat(user["id"], payload.title, payload.member_ids) @router.get("/api/v1/chats", response_model=ChatPageResponse) -def list_chats( - user: User = Depends(get_current_user), - limit: int = Query(default=50, ge=1, le=100), - cursor: str | None = Query(default=None, min_length=1), -) -> ChatPageResponse: - chats = store.list_chats_for_member(user.id) - scope = "chats:" + user.id +async def list_chats(user: dict = Depends(get_current_user), store: PostgresStore = Depends(get_store), limit: int = Query(default=50, ge=1, le=100), cursor: str | None = Query(default=None, min_length=1)) -> ChatPageResponse: + after: tuple[datetime, UUID] | None = None + scope = "chats:" + str(user["id"]) if cursor is not None: try: - cursor_key = decode_cursor(cursor, scope) - except CursorError as error: + created_at, item_id = decode_cursor(cursor, scope) + after = created_at, UUID(item_id) + except (CursorError, ValueError) as error: raise ApiError(400, "invalid_request", "Некорректный cursor") from error - chats = tuple( - chat for chat in chats if (chat.created_at, chat.id) > cursor_key - ) - - page = chats[:limit] - next_cursor = None - if len(chats) > len(page): - last_chat = page[-1] - next_cursor = encode_cursor(scope, last_chat.created_at, last_chat.id) - return ChatPageResponse( - items=list(page), - next_cursor=next_cursor, - ) - + rows = await store.list_chats_for_member(user["id"], after, limit) + page = rows[:limit] + next_cursor = encode_cursor(scope, page[-1]["created_at"], str(page[-1]["id"])) if len(rows) > limit else None + return ChatPageResponse(items=page, next_cursor=next_cursor) @router.get("/api/v1/chats/{chat_id}", response_model=Chat) -def get_chat( - chat_id: UUID, - user: User = Depends(get_current_user), -) -> Chat: - return store.get_chat_for_member(str(chat_id), user.id) - - -@router.post( - "/api/v1/chats/{chat_id}/messages", - response_model=Message, - status_code=201, -) -def create_message( - chat_id: UUID, - payload: CreateMessageRequest, - user: User = Depends(get_current_user), -) -> Message: - return store.create_message(str(chat_id), user.id, payload.text) +async def get_chat(chat_id: UUID, user: dict = Depends(get_current_user), store: PostgresStore = Depends(get_store)) -> dict: + return await store.get_chat_for_member(chat_id, user["id"]) +@router.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201) +async def create_message(chat_id: UUID, payload: CreateMessageRequest, user: dict = Depends(get_current_user), store: PostgresStore = Depends(get_store)) -> dict: + return await store.create_message(chat_id, user["id"], payload.text) @router.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePageResponse) -def list_messages( - chat_id: UUID, - user: User = Depends(get_current_user), - limit: int = Query(default=50, ge=1, le=100), - cursor: str | None = Query(default=None, min_length=1), -) -> MessagePageResponse: - chat_id_text = str(chat_id) - messages = store.list_messages_for_member(chat_id_text, user.id) - - scope = "messages:" + chat_id_text +async def list_messages(chat_id: UUID, user: dict = Depends(get_current_user), store: PostgresStore = Depends(get_store), limit: int = Query(default=50, ge=1, le=100), cursor: str | None = Query(default=None, min_length=1)) -> MessagePageResponse: + after: tuple[datetime, UUID] | None = None + scope = "messages:" + str(chat_id) if cursor is not None: try: - cursor_key = decode_cursor(cursor, scope) - except CursorError as error: + created_at, item_id = decode_cursor(cursor, scope) + after = created_at, UUID(item_id) + except (CursorError, ValueError) as error: raise ApiError(400, "invalid_request", "Некорректный cursor") from error - messages = tuple( - message - for message in messages - if (message.created_at, message.id) > cursor_key - ) - - page = messages[:limit] - next_cursor = None - if len(messages) > len(page): - last_message = page[-1] - next_cursor = encode_cursor( - scope, last_message.created_at, last_message.id - ) - return MessagePageResponse( - items=list(page), - next_cursor=next_cursor, - ) - + rows = await store.list_messages_for_member(chat_id, user["id"], after, limit) + page = rows[:limit] + next_cursor = encode_cursor(scope, page[-1]["created_at"], str(page[-1]["id"])) if len(rows) > limit else None + return MessagePageResponse(items=page, next_cursor=next_cursor) diff --git a/src/storage/__init__.py b/src/storage/__init__.py index 569ca90f..e2e04193 100644 --- a/src/storage/__init__.py +++ b/src/storage/__init__.py @@ -1,2 +1,2 @@ """Слой in-memory хранения для приложения первой лабораторной работы.""" - +"""Persistent storage adapters.""" diff --git a/src/storage/memory.py b/src/storage/memory.py deleted file mode 100644 index 4a7d480c..00000000 --- a/src/storage/memory.py +++ /dev/null @@ -1,149 +0,0 @@ -from dataclasses import dataclass -from datetime import UTC, datetime -from threading import RLock -from uuid import uuid4 - -from ..errors import ApiError - - -@dataclass(frozen=True, slots=True) -class User: - id: str - username: str - display_name: str - created_at: datetime - - -@dataclass(frozen=True, slots=True) -class Chat: - id: str - title: str - member_ids: tuple[str, ...] - created_at: datetime - - -@dataclass(frozen=True, slots=True) -class Message: - id: str - chat_id: str - sender_id: str - text: str - created_at: datetime - - -class MemoryStore: - def __init__(self) -> None: - self._users_by_id: dict[str, User] = {} - self._user_ids_by_username: dict[str, str] = {} - self._chats_by_id: dict[str, Chat] = {} - self._messages_by_chat_id: dict[str, list[Message]] = {} - self._lock = RLock() - - @staticmethod - def _now() -> datetime: - return datetime.now(UTC) - - @staticmethod - def _message_sort_key(message: Message) -> tuple[datetime, str]: - """Возвращает ключ порядка сообщений, заданный API-контрактом.""" - - return message.created_at, message.id - - @classmethod - def _insert_message_in_order( - cls, messages: list[Message], message: Message - ) -> None: - """Вставляет сообщение в отсортированную историю без сортировки при чтении.""" - - message_key = cls._message_sort_key(message) - left, right = 0, len(messages) - while left < right: - middle = (left + right) // 2 - if cls._message_sort_key(messages[middle]) <= message_key: - left = middle + 1 - else: - right = middle - messages.insert(left, message) - - def create_user(self, username: str, display_name: str) -> User: - with self._lock: - if username in self._user_ids_by_username: - raise ApiError(409, "conflict", "Username уже занят") - - user = User( - id=str(uuid4()), - username=username, - display_name=display_name, - created_at=self._now(), - ) - self._users_by_id[user.id] = user - self._user_ids_by_username[user.username] = user.id - return user - - def get_user(self, user_id: str) -> User | None: - """Возвращает пользователя по ID, если он существует.""" - - with self._lock: - return self._users_by_id.get(user_id) - - def create_chat( - self, creator_id: str, title: str, member_ids: list[str] | tuple[str, ...] - ) -> Chat: - members = tuple(member_ids) - with self._lock: - if len(members) != len(set(members)): - raise ApiError(400, "invalid_request", "Список участников содержит повторяющиеся ID") - if creator_id not in members: - raise ApiError(400, "invalid_request", "Создатель должен входить в список участников") - if any(member_id not in self._users_by_id for member_id in members): - raise ApiError(400, "invalid_request", "Один или несколько участников не существуют") - - chat = Chat( - id=str(uuid4()), - title=title, - member_ids=members, - created_at=self._now(), - ) - self._chats_by_id[chat.id] = chat - self._messages_by_chat_id[chat.id] = [] - return chat - - def get_chat_for_member(self, chat_id: str, user_id: str) -> Chat: - with self._lock: - chat = self._chats_by_id.get(chat_id) - if chat is None or user_id not in chat.member_ids: - raise ApiError(404, "not_found", "Чат не найден") - return chat - - def list_chats_for_member(self, user_id: str) -> tuple[Chat, ...]: - with self._lock: - chats = ( - chat for chat in self._chats_by_id.values() if user_id in chat.member_ids - ) - return tuple(sorted(chats, key=lambda chat: (chat.created_at, chat.id))) - - def create_message(self, chat_id: str, sender_id: str, text: str) -> Message: - with self._lock: - chat = self._chats_by_id.get(chat_id) - if chat is None or sender_id not in chat.member_ids: - raise ApiError(404, "not_found", "Чат не найден") - - message = Message( - id=str(uuid4()), - chat_id=chat_id, - sender_id=sender_id, - text=text, - created_at=self._now(), - ) - self._insert_message_in_order(self._messages_by_chat_id[chat_id], message) - return message - - def list_messages_for_member( - self, chat_id: str, user_id: str - ) -> tuple[Message, ...]: - with self._lock: - chat = self._chats_by_id.get(chat_id) - if chat is None or user_id not in chat.member_ids: - raise ApiError(404, "not_found", "Чат не найден") - return tuple(self._messages_by_chat_id[chat_id]) - diff --git a/src/storage/postgres.py b/src/storage/postgres.py new file mode 100644 index 00000000..ad3367e5 --- /dev/null +++ b/src/storage/postgres.py @@ -0,0 +1,252 @@ +from datetime import datetime +from hashlib import sha256 +from pathlib import Path +from secrets import token_urlsafe +from uuid import UUID, uuid4 + +import asyncpg +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError + +from ..errors import ApiError + + +ROOT = Path(__file__).resolve().parents[2] +MIGRATIONS = ROOT / "migrations" +PASSWORD_HASHER = PasswordHasher() + + +class PostgresStore: + def __init__(self, database_url: str) -> None: + self._database_url = database_url + self._pool: asyncpg.Pool | None = None + + async def connect(self) -> None: + try: + self._pool = await asyncpg.create_pool( + self._database_url, min_size=1, max_size=10, command_timeout=5 + ) + except asyncpg.PostgresError as error: + raise RuntimeError("PostgreSQL is unavailable") from error + + async def close(self) -> None: + if self._pool is not None: + await self._pool.close() + + @property + def pool(self) -> asyncpg.Pool: + if self._pool is None: + raise RuntimeError("PostgreSQL pool has not been initialized") + return self._pool + + async def migrate(self) -> None: + async with self.pool.acquire() as connection: + await connection.execute( + "CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())" + ) + for migration in sorted(MIGRATIONS.glob("*.sql")): + applied = await connection.fetchval( + "SELECT 1 FROM schema_migrations WHERE version = $1", migration.name + ) + if applied: + continue + async with connection.transaction(): + await connection.execute(migration.read_text(encoding="utf-8")) + await connection.execute( + "INSERT INTO schema_migrations (version) VALUES ($1)", migration.name + ) + + @staticmethod + def _user(row: asyncpg.Record) -> dict: + return { + "id": row["id"], + "username": row["username"], + "display_name": row["display_name"], + "created_at": row["created_at"], + } + + @staticmethod + def _chat(row: asyncpg.Record) -> dict: + return { + "id": row["id"], + "title": row["title"], + "member_ids": row["member_ids"], + "created_at": row["created_at"], + } + + @staticmethod + def _message(row: asyncpg.Record) -> dict: + return { + "id": row["id"], + "chat_id": row["chat_id"], + "sender_id": row["sender_id"], + "text": row["text"], + "created_at": row["created_at"], + } + + async def ready(self) -> None: + try: + await self.pool.fetchval("SELECT 1") + except asyncpg.PostgresError as error: + raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error + + async def create_user(self, username: str, display_name: str, password: str) -> dict: + try: + row = await self.pool.fetchrow( + "INSERT INTO users (id, username, display_name, password_hash) VALUES ($1, $2, $3, $4) RETURNING id, username, display_name, created_at", + uuid4(), + username, + display_name, + PASSWORD_HASHER.hash(password), + ) + except asyncpg.UniqueViolationError as error: + raise ApiError(409, "conflict", "Username уже занят") from error + except asyncpg.PostgresError as error: + raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error + return self._user(row) + + async def get_user(self, user_id: UUID) -> dict | None: + try: + row = await self.pool.fetchrow( + "SELECT id, username, display_name, created_at FROM users WHERE id = $1", user_id + ) + except asyncpg.PostgresError as error: + raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error + return self._user(row) if row else None + + async def authenticate(self, username: str, password: str) -> dict | None: + try: + row = await self.pool.fetchrow( + "SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = $1", + username, + ) + except asyncpg.PostgresError as error: + raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error + if row is None: + return None + try: + valid = PASSWORD_HASHER.verify(row["password_hash"], password) + except (InvalidHashError, VerificationError): + valid = False + return self._user(row) if valid else None + + async def create_session(self, user: dict, ttl_seconds: int) -> dict: + token = token_urlsafe(32) + token_hash = sha256(token.encode("ascii")).hexdigest() + try: + row = await self.pool.fetchrow( + "INSERT INTO sessions (token_hash, user_id, expires_at) VALUES ($1, $2, now() + $3 * interval '1 second') RETURNING expires_at", + token_hash, + user["id"], + ttl_seconds, + ) + except asyncpg.PostgresError as error: + raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error + return {"token": token, "token_type": "Bearer", "expires_at": row["expires_at"], "user": user} + + async def user_for_token(self, token: str) -> dict | None: + token_hash = sha256(token.encode("ascii")).hexdigest() + try: + row = await self.pool.fetchrow( + "SELECT u.id, u.username, u.display_name, u.created_at FROM sessions s JOIN users u ON u.id = s.user_id WHERE s.token_hash = $1 AND s.expires_at > now()", + token_hash, + ) + except asyncpg.PostgresError as error: + raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error + return self._user(row) if row else None + + async def revoke_session(self, token: str) -> None: + try: + await self.pool.execute( + "DELETE FROM sessions WHERE token_hash = $1", sha256(token.encode("ascii")).hexdigest() + ) + except asyncpg.PostgresError as error: + raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error + + async def create_chat(self, creator_id: UUID, title: str, member_ids: list[UUID]) -> dict: + if len(member_ids) != len(set(member_ids)) or creator_id not in member_ids: + raise ApiError(400, "invalid_request", "Некорректный список участников") + try: + async with self.pool.acquire() as connection, connection.transaction(): + existing = await connection.fetchval( + "SELECT count(*) FROM users WHERE id = ANY($1::uuid[])", member_ids + ) + if existing != len(member_ids): + raise ApiError(400, "invalid_request", "Один или несколько участников не существуют") + row = await connection.fetchrow( + "INSERT INTO chats (id, title) VALUES ($1, $2) RETURNING id, title, created_at", + uuid4(), + title, + ) + await connection.executemany( + "INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)", + [(row["id"], member_id) for member_id in member_ids], + ) + except asyncpg.PostgresError as error: + raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error + return { + "id": row["id"], + "title": row["title"], + "member_ids": member_ids, + "created_at": row["created_at"], + } + + async def get_chat_for_member(self, chat_id: UUID, user_id: UUID) -> dict: + try: + row = await self.pool.fetchrow( + "SELECT c.id, c.title, c.created_at, array_agg(cm_all.user_id ORDER BY cm_all.user_id) AS member_ids FROM chats c JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = $2 JOIN chat_members cm_all ON cm_all.chat_id = c.id WHERE c.id = $1 GROUP BY c.id", + chat_id, + user_id, + ) + except asyncpg.PostgresError as error: + raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error + if row is None: + raise ApiError(404, "not_found", "Чат не найден") + return self._chat(row) + + async def list_chats_for_member( + self, user_id: UUID, after: tuple[datetime, UUID] | None, limit: int + ) -> list[dict]: + query = "SELECT c.id, c.title, c.created_at, array_agg(cm_all.user_id ORDER BY cm_all.user_id) AS member_ids FROM chats c JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = $1 JOIN chat_members cm_all ON cm_all.chat_id = c.id" + args: list = [user_id] + if after is not None: + query += " WHERE (c.created_at, c.id) > ($2, $3)" + args.extend(after) + query += " GROUP BY c.id ORDER BY c.created_at, c.id LIMIT $" + str(len(args) + 1) + args.append(limit + 1) + try: + rows = await self.pool.fetch(query, *args) + except asyncpg.PostgresError as error: + raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error + return [self._chat(row) for row in rows] + + async def create_message(self, chat_id: UUID, sender_id: UUID, text: str) -> dict: + await self.get_chat_for_member(chat_id, sender_id) + try: + row = await self.pool.fetchrow( + "INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1, $2, $3, $4) RETURNING id, chat_id, sender_id, text, created_at", + uuid4(), + chat_id, + sender_id, + text, + ) + except asyncpg.PostgresError as error: + raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error + return self._message(row) + + async def list_messages_for_member( + self, chat_id: UUID, user_id: UUID, after: tuple[datetime, UUID] | None, limit: int + ) -> list[dict]: + await self.get_chat_for_member(chat_id, user_id) + query = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1" + args: list = [chat_id] + if after is not None: + query += " AND (created_at, id) > ($2, $3)" + args.extend(after) + query += " ORDER BY created_at, id LIMIT $" + str(len(args) + 1) + args.append(limit + 1) + try: + rows = await self.pool.fetch(query, *args) + except asyncpg.PostgresError as error: + raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error + return [self._message(row) for row in rows] diff --git a/uv.lock b/uv.lock index e5d679eb..c5c450d3 100644 --- a/uv.lock +++ b/uv.lock @@ -1,6 +1,10 @@ version = 1 revision = 3 requires-python = ">=3.12" +resolution-markers = [ + "python_full_version >= '3.14'", + "python_full_version < '3.14'", +] [[package]] name = "annotated-doc" @@ -33,6 +37,186 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" }, ] +[[package]] +name = "argon2-cffi" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0b/43/bb8b6e8708d49a5ab36781333af092d9f483b198a2710d01281204640055/argon2_cffi_bindings-26.1.0.tar.gz", hash = "sha256:63505c71542a44b68b1e38060450fb006404170da375feb31af153e7f9c6205d", size = 1790807, upload-time = "2026-08-20T07:44:22.492Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/d2/0ae991f1b2181e5be49007c574710a800ad36c2978683addb3e67c474e55/argon2_cffi_bindings-26.1.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:21ca0396fe5ec995dd54431c32698189666f9224810acfa752e50d2bd94d9df2", size = 25521, upload-time = "2026-08-20T07:32:43.019Z" }, + { url = "https://files.pythonhosted.org/packages/7e/e4/ad91d8297638aa2258aad4501c306aca99480dfe76ccd638173fa3702db9/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78de2d65e0b9ea7ce9d1b1c3e87297b2d7305a02c266ee2a2d6910daddd7ee69", size = 27177, upload-time = "2026-08-20T07:32:44.158Z" }, + { url = "https://files.pythonhosted.org/packages/6f/86/5363df11b86d02cf3662208e7406496327649cc90eb365bf6f4e8a54a41f/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:27f1821903e2ceadcb88ec2b45ef190897b7682449c772f4d9b53e42c520cf29", size = 26597, upload-time = "2026-08-20T07:32:45.172Z" }, + { url = "https://files.pythonhosted.org/packages/f4/b5/a14dcc592652347dad23ee93b278a4da5d2a25c9ed3ebd10d68eea823a4f/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d88e5f7e60f28ae0b0cc6b2f16c43e87cd642a196a86f85e0d8bb6fe016fc16d", size = 27403, upload-time = "2026-08-20T07:32:46.13Z" }, + { url = "https://files.pythonhosted.org/packages/b3/81/b4a20d4902af7f796390bf9245ff83c5217dfa7367efa1d14986956c482b/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:34b7d9c24a4165a2c61cc8ae11d44d48c9ce2830fb536cb7914e11fdd9962728", size = 27132, upload-time = "2026-08-20T07:32:47.13Z" }, + { url = "https://files.pythonhosted.org/packages/7e/1b/c8de358af07b1c490e0fcb863ef98e46ddb486e45567aca5a60bd68d9daa/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:224865cbbcb7a2bd1356741dff12b0134df726b6d44bb7b500df8e303cbd9e81", size = 27588, upload-time = "2026-08-20T07:32:48.087Z" }, + { url = "https://files.pythonhosted.org/packages/48/2f/7ee62a6e79f9309f9d9982d301b22a00010adb580c05c8109b94d7b33de0/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ffff613aaa9ce6236766e2fc6dc560bb5abde7a2e2416e3db1f9ae395a2b4dd4", size = 26785, upload-time = "2026-08-20T07:32:48.977Z" }, + { url = "https://files.pythonhosted.org/packages/e9/10/960d0ee93d4897741bcaf4799c697dae2d81499f66fd1ed042a7dd54c1f4/argon2_cffi_bindings-26.1.0-cp310-abi3-win32.whl", hash = "sha256:a86c069c91a747a2c4e5c51473590aeb48172fff9b2130d23729a42d98665ecb", size = 23898, upload-time = "2026-08-20T07:32:50.114Z" }, + { url = "https://files.pythonhosted.org/packages/6d/3a/0cc14a05810e6add9bce5e87693334baa2222de5f647fa31781885b6573f/argon2_cffi_bindings-26.1.0-cp310-abi3-win_amd64.whl", hash = "sha256:2c36ff87b5dfaa477d0bd51e9d7f6abdae7c8955d2983c97419085d842154b3e", size = 25730, upload-time = "2026-08-20T07:32:51.091Z" }, + { url = "https://files.pythonhosted.org/packages/4e/db/d83cf2af140547f0b9cdaece05b2dc2dcbf991be4667331d073eff771435/argon2_cffi_bindings-26.1.0-cp310-abi3-win_arm64.whl", hash = "sha256:f9c4420a7a864fe1b86ce35befc95b8e39fb852493b81cf798671ddc265de638", size = 24478, upload-time = "2026-08-20T07:32:52.111Z" }, + { url = "https://files.pythonhosted.org/packages/bb/5f/f652055e18d2627e2eed94c7f31a792127cfe38df786635395d742321674/argon2_cffi_bindings-26.1.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:af11ac37a7c53dc16cb7950a6190851b0870fe218b6c60c0bb7ac355234e3083", size = 15434, upload-time = "2026-08-20T07:32:53.143Z" }, + { url = "https://files.pythonhosted.org/packages/76/38/de696045960f5b846d428c0fb6c130ed3da87aac2af209b05c193815404c/argon2_cffi_bindings-26.1.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:db0fcd827ca61622a01b220aadfbece01939acf53888f2cb98cd93e9b1e2c97e", size = 15449, upload-time = "2026-08-20T07:32:54.075Z" }, + { url = "https://files.pythonhosted.org/packages/91/0a/c25af768f6b75a5a71e31207f87c540656b2808c015260444a22763221ad/argon2_cffi_bindings-26.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:28524438cd3e723f25412f63d4fd516ff5bae9ae5aa56acbe2a1404398a0cf31", size = 25683, upload-time = "2026-08-20T07:32:55.05Z" }, + { url = "https://files.pythonhosted.org/packages/a8/7e/be212c751ab0bcea7f646615f933bf262e8e50b3f7bef32f861d0a2d066b/argon2_cffi_bindings-26.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac82fc756a446b6ccd7139ce70efa9d8bbe541e7ad579a12dcb52764b7175c5f", size = 27311, upload-time = "2026-08-20T07:32:56.166Z" }, + { url = "https://files.pythonhosted.org/packages/a6/ee/f84b28e4afd13d3cac36c1d8fa8c239d2dc2c51cd978d02ee5d5ad98d9bb/argon2_cffi_bindings-26.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6a4e68eed961a8de6928d1c17ff3dc2a547e0e923c17f8f1cd79fb7bc9502f98", size = 26771, upload-time = "2026-08-20T07:32:57.206Z" }, + { url = "https://files.pythonhosted.org/packages/21/c3/95c07a023691ecd529da9cb6a8f0779e13ebc1bdfaa86d145fdc1c6e7e79/argon2_cffi_bindings-26.1.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:151dfaad9de753f4af2a7854e707e4784f2acc434340ade64239c5b104b2d605", size = 27568, upload-time = "2026-08-20T07:32:58.361Z" }, + { url = "https://files.pythonhosted.org/packages/e6/31/3a18e31406d8694b4d6a31573c3e572fff6bed318bb744453eb653766d22/argon2_cffi_bindings-26.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:061a6919145bbf282ebf1f9c59d3135d4833c25313c8595c0d68cf7712ddfce2", size = 27280, upload-time = "2026-08-20T07:32:59.343Z" }, + { url = "https://files.pythonhosted.org/packages/0b/39/d4be4577e178b2397aa5b5575c8a309bf0da2afe05fe0c72c8f398662d63/argon2_cffi_bindings-26.1.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:62ff20cd130c956c7c9144d5fe35228f98b51c579b2439e988b27ef93e16c02a", size = 27776, upload-time = "2026-08-20T07:33:00.325Z" }, + { url = "https://files.pythonhosted.org/packages/71/47/78f4dd96f7411339f723b96fe24039c1bd5835102b8a5ba71ac4ec712ac7/argon2_cffi_bindings-26.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:19423e5d7ac1cc354baab59eaabf18db2ec04ef6593b5abe5a34f323c4a8f87a", size = 26932, upload-time = "2026-08-20T07:33:01.272Z" }, + { url = "https://files.pythonhosted.org/packages/3b/cd/96bfd37434cc0a848a9066c291d84b28846c4c9ea289ed9866b1164d622b/argon2_cffi_bindings-26.1.0-cp314-cp314t-win32.whl", hash = "sha256:4f84cdd868978d7b7350a566c254042d44216d9e37f241f3a6d3b1dfebeede35", size = 24878, upload-time = "2026-08-20T07:33:02.189Z" }, + { url = "https://files.pythonhosted.org/packages/f1/42/d8b6810abd9b1bd2f47ebbccf460da59c9f32e94888bea4f7b137d998797/argon2_cffi_bindings-26.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2b741888c93147444fdfc851abd81cc207f37f7f7da42062a00deb3888e57da8", size = 26656, upload-time = "2026-08-20T07:33:03.222Z" }, + { url = "https://files.pythonhosted.org/packages/a9/d1/095d95eaf2ed1d9f77268cf3291bde148c6cd56121f8db2c74c1ba618a0e/argon2_cffi_bindings-26.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:6ab674f668d5962a3a4136ae0812519b0f1586874263723a32181d60d64137e1", size = 25378, upload-time = "2026-08-20T07:33:04.332Z" }, + { url = "https://files.pythonhosted.org/packages/66/cb/214092c39c4dbcb72cf98b12234ddac2221f8fe2c0acf29c6a70fa83be53/argon2_cffi_bindings-26.1.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:1d98e33bd8bd67d7206c124e200bf2229c4cfa8c9c19f7b44a897f0fc71837eb", size = 25683, upload-time = "2026-08-20T07:33:05.337Z" }, + { url = "https://files.pythonhosted.org/packages/83/e5/02015b83e9b05ccb85ff2ced424cf6e83a12d3810bc7f66d679a92b69ffb/argon2_cffi_bindings-26.1.0-cp315-cp315t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ccaf0a46cbb380f1fd102a874e32aa629fd3cb0c0e94f4943fa1f6d5edc5dac6", size = 27310, upload-time = "2026-08-20T07:33:06.344Z" }, + { url = "https://files.pythonhosted.org/packages/c3/4a/85e612787d0796878b3b4f6bd53dcd5484b6fe7b64cc6fc7b6e6a04cf835/argon2_cffi_bindings-26.1.0-cp315-cp315t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f0c3103fcff20183e593459cfea6e012281c0e76ae3ed8b5565ad1b92eac3990", size = 26771, upload-time = "2026-08-20T07:33:07.429Z" }, + { url = "https://files.pythonhosted.org/packages/f6/84/ccb003b6f9969820e87656398f4d49c857def71a85ca1588a0e809afd7ce/argon2_cffi_bindings-26.1.0-cp315-cp315t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c49e853a3bef9dd10329f31f702e7fa9b5c58229ff9c2ff6d069efaf09177c08", size = 27569, upload-time = "2026-08-20T07:33:08.598Z" }, + { url = "https://files.pythonhosted.org/packages/88/07/c26b76debf0998ee08fbe947ab2058ac5de37d4b9d46b06c17abaa6c4ce9/argon2_cffi_bindings-26.1.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:6376d4b3aca039375ca8bf92f770da0ec424a1ce3a37077a8d3c557411aa56ca", size = 27279, upload-time = "2026-08-20T07:33:09.518Z" }, + { url = "https://files.pythonhosted.org/packages/ee/0d/ead6ddc029f91bc9b9390686dad3c808ab08100d348f6266b5f93f8970ee/argon2_cffi_bindings-26.1.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:9bacedc04b0402837586a17f0919e3dfdd95291f441f1f56bd80ec274c2840a1", size = 27774, upload-time = "2026-08-20T07:33:10.728Z" }, + { url = "https://files.pythonhosted.org/packages/7d/47/c108530d9eb86036b78d3af4de28b83b4a2d9a70512bd10ff8e59966aab4/argon2_cffi_bindings-26.1.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:76ae29acace5d33355344612844d588e19deaaba4639d8bb01601e4b1418ef36", size = 26933, upload-time = "2026-08-20T07:33:11.661Z" }, + { url = "https://files.pythonhosted.org/packages/a9/02/0bfc59e781c89acf64c31c388aade9d9d1c1ea38aa1ba1292fe07f607fe9/argon2_cffi_bindings-26.1.0-cp315-cp315t-win32.whl", hash = "sha256:df612391feca41c44d20118f3b88d1b86419465cd1f5496859f715ca60ec2210", size = 24875, upload-time = "2026-08-20T07:33:12.616Z" }, + { url = "https://files.pythonhosted.org/packages/61/c7/c3e46068cddffccecb8ad94d71135e9bf62bbc789589e7dfadc7c6f59214/argon2_cffi_bindings-26.1.0-cp315-cp315t-win_amd64.whl", hash = "sha256:1a0a29ed86960e44eaace7e081bdfab4f08b012fd96ec8edba71e2ad020939e4", size = 26655, upload-time = "2026-08-20T07:33:13.521Z" }, + { url = "https://files.pythonhosted.org/packages/f4/ca/18b9c8c45fecf34b9100ec6d7946057f14a158f2eaa20ea123a3e82351cb/argon2_cffi_bindings-26.1.0-cp315-cp315t-win_arm64.whl", hash = "sha256:d157ddfab1e8b21f2f1dedda9c09645d98b5ed0b667b0626be600a345d426440", size = 25376, upload-time = "2026-08-20T07:33:14.491Z" }, +] + +[[package]] +name = "asyncpg" +version = "0.31.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/cc/d18065ce2380d80b1bcce927c24a2642efd38918e33fd724bc4bca904877/asyncpg-0.31.0.tar.gz", hash = "sha256:c989386c83940bfbd787180f2b1519415e2d3d6277a70d9d0f0145ac73500735", size = 993667, upload-time = "2025-11-24T23:27:00.812Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/a6/59d0a146e61d20e18db7396583242e32e0f120693b67a8de43f1557033e2/asyncpg-0.31.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b44c31e1efc1c15188ef183f287c728e2046abb1d26af4d20858215d50d91fad", size = 662042, upload-time = "2025-11-24T23:25:49.578Z" }, + { url = "https://files.pythonhosted.org/packages/36/01/ffaa189dcb63a2471720615e60185c3f6327716fdc0fc04334436fbb7c65/asyncpg-0.31.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0c89ccf741c067614c9b5fc7f1fc6f3b61ab05ae4aaa966e6fd6b93097c7d20d", size = 638504, upload-time = "2025-11-24T23:25:51.501Z" }, + { url = "https://files.pythonhosted.org/packages/9f/62/3f699ba45d8bd24c5d65392190d19656d74ff0185f42e19d0bbd973bb371/asyncpg-0.31.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:12b3b2e39dc5470abd5e98c8d3373e4b1d1234d9fbdedf538798b2c13c64460a", size = 3426241, upload-time = "2025-11-24T23:25:53.278Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d1/a867c2150f9c6e7af6462637f613ba67f78a314b00db220cd26ff559d532/asyncpg-0.31.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:aad7a33913fb8bcb5454313377cc330fbb19a0cd5faa7272407d8a0c4257b671", size = 3520321, upload-time = "2025-11-24T23:25:54.982Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1a/cce4c3f246805ecd285a3591222a2611141f1669d002163abef999b60f98/asyncpg-0.31.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3df118d94f46d85b2e434fd62c84cb66d5834d5a890725fe625f498e72e4d5ec", size = 3316685, upload-time = "2025-11-24T23:25:57.43Z" }, + { url = "https://files.pythonhosted.org/packages/40/ae/0fc961179e78cc579e138fad6eb580448ecae64908f95b8cb8ee2f241f67/asyncpg-0.31.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bd5b6efff3c17c3202d4b37189969acf8927438a238c6257f66be3c426beba20", size = 3471858, upload-time = "2025-11-24T23:25:59.636Z" }, + { url = "https://files.pythonhosted.org/packages/52/b2/b20e09670be031afa4cbfabd645caece7f85ec62d69c312239de568e058e/asyncpg-0.31.0-cp312-cp312-win32.whl", hash = "sha256:027eaa61361ec735926566f995d959ade4796f6a49d3bde17e5134b9964f9ba8", size = 527852, upload-time = "2025-11-24T23:26:01.084Z" }, + { url = "https://files.pythonhosted.org/packages/b5/f0/f2ed1de154e15b107dc692262395b3c17fc34eafe2a78fc2115931561730/asyncpg-0.31.0-cp312-cp312-win_amd64.whl", hash = "sha256:72d6bdcbc93d608a1158f17932de2321f68b1a967a13e014998db87a72ed3186", size = 597175, upload-time = "2025-11-24T23:26:02.564Z" }, + { url = "https://files.pythonhosted.org/packages/95/11/97b5c2af72a5d0b9bc3fa30cd4b9ce22284a9a943a150fdc768763caf035/asyncpg-0.31.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c204fab1b91e08b0f47e90a75d1b3c62174dab21f670ad6c5d0f243a228f015b", size = 661111, upload-time = "2025-11-24T23:26:04.467Z" }, + { url = "https://files.pythonhosted.org/packages/1b/71/157d611c791a5e2d0423f09f027bd499935f0906e0c2a416ce712ba51ef3/asyncpg-0.31.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:54a64f91839ba59008eccf7aad2e93d6e3de688d796f35803235ea1c4898ae1e", size = 636928, upload-time = "2025-11-24T23:26:05.944Z" }, + { url = "https://files.pythonhosted.org/packages/2e/fc/9e3486fb2bbe69d4a867c0b76d68542650a7ff1574ca40e84c3111bb0c6e/asyncpg-0.31.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0e0822b1038dc7253b337b0f3f676cadc4ac31b126c5d42691c39691962e403", size = 3424067, upload-time = "2025-11-24T23:26:07.957Z" }, + { url = "https://files.pythonhosted.org/packages/12/c6/8c9d076f73f07f995013c791e018a1cd5f31823c2a3187fc8581706aa00f/asyncpg-0.31.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bef056aa502ee34204c161c72ca1f3c274917596877f825968368b2c33f585f4", size = 3518156, upload-time = "2025-11-24T23:26:09.591Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3b/60683a0baf50fbc546499cfb53132cb6835b92b529a05f6a81471ab60d0c/asyncpg-0.31.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0bfbcc5b7ffcd9b75ab1558f00db2ae07db9c80637ad1b2469c43df79d7a5ae2", size = 3319636, upload-time = "2025-11-24T23:26:11.168Z" }, + { url = "https://files.pythonhosted.org/packages/50/dc/8487df0f69bd398a61e1792b3cba0e47477f214eff085ba0efa7eac9ce87/asyncpg-0.31.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:22bc525ebbdc24d1261ecbf6f504998244d4e3be1721784b5f64664d61fbe602", size = 3472079, upload-time = "2025-11-24T23:26:13.164Z" }, + { url = "https://files.pythonhosted.org/packages/13/a1/c5bbeeb8531c05c89135cb8b28575ac2fac618bcb60119ee9696c3faf71c/asyncpg-0.31.0-cp313-cp313-win32.whl", hash = "sha256:f890de5e1e4f7e14023619399a471ce4b71f5418cd67a51853b9910fdfa73696", size = 527606, upload-time = "2025-11-24T23:26:14.78Z" }, + { url = "https://files.pythonhosted.org/packages/91/66/b25ccb84a246b470eb943b0107c07edcae51804912b824054b3413995a10/asyncpg-0.31.0-cp313-cp313-win_amd64.whl", hash = "sha256:dc5f2fa9916f292e5c5c8b2ac2813763bcd7f58e130055b4ad8a0531314201ab", size = 596569, upload-time = "2025-11-24T23:26:16.189Z" }, + { url = "https://files.pythonhosted.org/packages/3c/36/e9450d62e84a13aea6580c83a47a437f26c7ca6fa0f0fd40b6670793ea30/asyncpg-0.31.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:f6b56b91bb0ffc328c4e3ed113136cddd9deefdf5f79ab448598b9772831df44", size = 660867, upload-time = "2025-11-24T23:26:17.631Z" }, + { url = "https://files.pythonhosted.org/packages/82/4b/1d0a2b33b3102d210439338e1beea616a6122267c0df459ff0265cd5807a/asyncpg-0.31.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:334dec28cf20d7f5bb9e45b39546ddf247f8042a690bff9b9573d00086e69cb5", size = 638349, upload-time = "2025-11-24T23:26:19.689Z" }, + { url = "https://files.pythonhosted.org/packages/41/aa/e7f7ac9a7974f08eff9183e392b2d62516f90412686532d27e196c0f0eeb/asyncpg-0.31.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:98cc158c53f46de7bb677fd20c417e264fc02b36d901cc2a43bd6cb0dc6dbfd2", size = 3410428, upload-time = "2025-11-24T23:26:21.275Z" }, + { url = "https://files.pythonhosted.org/packages/6f/de/bf1b60de3dede5c2731e6788617a512bc0ebd9693eac297ee74086f101d7/asyncpg-0.31.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9322b563e2661a52e3cdbc93eed3be7748b289f792e0011cb2720d278b366ce2", size = 3471678, upload-time = "2025-11-24T23:26:23.627Z" }, + { url = "https://files.pythonhosted.org/packages/46/78/fc3ade003e22d8bd53aaf8f75f4be48f0b460fa73738f0391b9c856a9147/asyncpg-0.31.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19857a358fc811d82227449b7ca40afb46e75b33eb8897240c3839dd8b744218", size = 3313505, upload-time = "2025-11-24T23:26:25.235Z" }, + { url = "https://files.pythonhosted.org/packages/bf/e9/73eb8a6789e927816f4705291be21f2225687bfa97321e40cd23055e903a/asyncpg-0.31.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ba5f8886e850882ff2c2ace5732300e99193823e8107e2c53ef01c1ebfa1e85d", size = 3434744, upload-time = "2025-11-24T23:26:26.944Z" }, + { url = "https://files.pythonhosted.org/packages/08/4b/f10b880534413c65c5b5862f79b8e81553a8f364e5238832ad4c0af71b7f/asyncpg-0.31.0-cp314-cp314-win32.whl", hash = "sha256:cea3a0b2a14f95834cee29432e4ddc399b95700eb1d51bbc5bfee8f31fa07b2b", size = 532251, upload-time = "2025-11-24T23:26:28.404Z" }, + { url = "https://files.pythonhosted.org/packages/d3/2d/7aa40750b7a19efa5d66e67fc06008ca0f27ba1bd082e457ad82f59aba49/asyncpg-0.31.0-cp314-cp314-win_amd64.whl", hash = "sha256:04d19392716af6b029411a0264d92093b6e5e8285ae97a39957b9a9c14ea72be", size = 604901, upload-time = "2025-11-24T23:26:30.34Z" }, + { url = "https://files.pythonhosted.org/packages/ce/fe/b9dfe349b83b9dee28cc42360d2c86b2cdce4cb551a2c2d27e156bcac84d/asyncpg-0.31.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bdb957706da132e982cc6856bb2f7b740603472b54c3ebc77fe60ea3e57e1bd2", size = 702280, upload-time = "2025-11-24T23:26:32Z" }, + { url = "https://files.pythonhosted.org/packages/6a/81/e6be6e37e560bd91e6c23ea8a6138a04fd057b08cf63d3c5055c98e81c1d/asyncpg-0.31.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6d11b198111a72f47154fa03b85799f9be63701e068b43f84ac25da0bda9cb31", size = 682931, upload-time = "2025-11-24T23:26:33.572Z" }, + { url = "https://files.pythonhosted.org/packages/a6/45/6009040da85a1648dd5bc75b3b0a062081c483e75a1a29041ae63a0bf0dc/asyncpg-0.31.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:18c83b03bc0d1b23e6230f5bf8d4f217dc9bc08644ce0502a9d91dc9e634a9c7", size = 3581608, upload-time = "2025-11-24T23:26:35.638Z" }, + { url = "https://files.pythonhosted.org/packages/7e/06/2e3d4d7608b0b2b3adbee0d0bd6a2d29ca0fc4d8a78f8277df04e2d1fd7b/asyncpg-0.31.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e009abc333464ff18b8f6fd146addffd9aaf63e79aa3bb40ab7a4c332d0c5e9e", size = 3498738, upload-time = "2025-11-24T23:26:37.275Z" }, + { url = "https://files.pythonhosted.org/packages/7d/aa/7d75ede780033141c51d83577ea23236ba7d3a23593929b32b49db8ed36e/asyncpg-0.31.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3b1fbcb0e396a5ca435a8826a87e5c2c2cc0c8c68eb6fadf82168056b0e53a8c", size = 3401026, upload-time = "2025-11-24T23:26:39.423Z" }, + { url = "https://files.pythonhosted.org/packages/ba/7a/15e37d45e7f7c94facc1e9148c0e455e8f33c08f0b8a0b1deb2c5171771b/asyncpg-0.31.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8df714dba348efcc162d2adf02d213e5fab1bd9f557e1305633e851a61814a7a", size = 3429426, upload-time = "2025-11-24T23:26:41.032Z" }, + { url = "https://files.pythonhosted.org/packages/13/d5/71437c5f6ae5f307828710efbe62163974e71237d5d46ebd2869ea052d10/asyncpg-0.31.0-cp314-cp314t-win32.whl", hash = "sha256:1b41f1afb1033f2b44f3234993b15096ddc9cd71b21a42dbd87fc6a57b43d65d", size = 614495, upload-time = "2025-11-24T23:26:42.659Z" }, + { url = "https://files.pythonhosted.org/packages/3c/d7/8fb3044eaef08a310acfe23dae9a8e2e07d305edc29a53497e52bc76eca7/asyncpg-0.31.0-cp314-cp314t-win_amd64.whl", hash = "sha256:bd4107bb7cdd0e9e65fae66a62afd3a249663b844fa34d479f6d5b3bef9c04c3", size = 706062, upload-time = "2025-11-24T23:26:44.086Z" }, +] + +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/69/43965eccfdead3b9220015fd1320e117be8c6ed01a62ffab76eeb752f5d5/cffi-2.1.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0", size = 184821, upload-time = "2026-08-03T21:19:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/54/7d/16e5a096677b5e313ca80cd5e5170efa3ea44624a82bb111925522da64b1/cffi-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf", size = 184719, upload-time = "2026-08-03T21:19:46.129Z" }, + { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" }, + { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" }, + { url = "https://files.pythonhosted.org/packages/6a/5b/717f1526b9957b34456313c31645c5b82b8fb5c3fe9e4752999be7128bfc/cffi-2.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50", size = 210249, upload-time = "2026-08-03T21:19:49.543Z" }, + { url = "https://files.pythonhosted.org/packages/64/b3/f8aa4f3e34986c7e4ec45072d1b1b9dd295b6b18007b45518d79726dd725/cffi-2.1.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e", size = 208775, upload-time = "2026-08-03T21:19:50.918Z" }, + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" }, + { url = "https://files.pythonhosted.org/packages/80/fb/0bb75b7039588c074b37ae99f40d9bfddf990ecb2fbc346ebccd2e56b9be/cffi-2.1.1-cp312-cp312-win32.whl", hash = "sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e", size = 175292, upload-time = "2026-08-03T21:19:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/d9/79/615cc094e2fb508cade7de88d3b4f6c4ec2bab695c97bce9153dc65aadf5/cffi-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a", size = 185919, upload-time = "2026-08-03T21:19:56.89Z" }, + { url = "https://files.pythonhosted.org/packages/70/c6/d0ea84713fe46b243a436a18fcd47d639732747e21635c8a27191b06dc30/cffi-2.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80", size = 180093, upload-time = "2026-08-03T21:19:58.155Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", size = 194248, upload-time = "2026-08-03T21:19:59.399Z" }, + { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", size = 196908, upload-time = "2026-08-03T21:20:00.746Z" }, + { url = "https://files.pythonhosted.org/packages/a7/46/2e5fdde8555706dd98139a910ca11be02809f3f605ce956f655d0214e100/cffi-2.1.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6", size = 184805, upload-time = "2026-08-03T21:20:02.02Z" }, + { url = "https://files.pythonhosted.org/packages/55/41/4c7042f317b9217502988f0873af87e16ad606dc20f84e546e3e6ce9764c/cffi-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971", size = 184764, upload-time = "2026-08-03T21:20:03.141Z" }, + { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", size = 214722, upload-time = "2026-08-03T21:20:04.377Z" }, + { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", size = 222369, upload-time = "2026-08-03T21:20:05.544Z" }, + { url = "https://files.pythonhosted.org/packages/02/10/4b3c75dde3d9663c9e02ba05c2668b954f671d4bbe346413ca8c696b295a/cffi-2.1.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264", size = 210175, upload-time = "2026-08-03T21:20:06.75Z" }, + { url = "https://files.pythonhosted.org/packages/df/62/14f74b9543e605d17701dc797b815958b8bb70b7624ce1b832ddad48ed6c/cffi-2.1.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3", size = 208670, upload-time = "2026-08-03T21:20:08.04Z" }, + { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", size = 221824, upload-time = "2026-08-03T21:20:09.274Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", size = 225148, upload-time = "2026-08-03T21:20:10.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", size = 223564, upload-time = "2026-08-03T21:20:12.165Z" }, + { url = "https://files.pythonhosted.org/packages/70/ea/839b50531021a647fb5e929f72cf97bc1ff702b5472166164b5b6e76b851/cffi-2.1.1-cp313-cp313-win32.whl", hash = "sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac", size = 175263, upload-time = "2026-08-03T21:20:13.559Z" }, + { url = "https://files.pythonhosted.org/packages/60/a6/8b149b2c3f2e11aaa1618ef64500b45f50f22c57a977a4dff1aff1f91042/cffi-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d", size = 185688, upload-time = "2026-08-03T21:20:14.69Z" }, + { url = "https://files.pythonhosted.org/packages/01/9a/11f687cb39d6a3504060d5242f04f48c735afb4d3d533958a20594890cb2/cffi-2.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973", size = 180078, upload-time = "2026-08-03T21:20:15.917Z" }, + { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", size = 194064, upload-time = "2026-08-03T21:20:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", size = 196720, upload-time = "2026-08-03T21:20:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/d9/99/c4b0c17cacdc9c3b8f280026286a9826d6a208c0f047591a3c3ce99b91fd/cffi-2.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54", size = 184964, upload-time = "2026-08-03T21:20:19.708Z" }, + { url = "https://files.pythonhosted.org/packages/b3/a9/9db617d05d7367c1ad0ab00b3aa6e6f9281edd689b4ee9ea0e5a84e89c97/cffi-2.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72", size = 184962, upload-time = "2026-08-03T21:20:20.833Z" }, + { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", size = 222328, upload-time = "2026-08-03T21:20:22.118Z" }, + { url = "https://files.pythonhosted.org/packages/80/10/c5c0cbf0a657aecf59ef511409734230bf556f05a0d6c9eed7aa5c0a0166/cffi-2.1.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062", size = 209985, upload-time = "2026-08-03T21:20:23.401Z" }, + { url = "https://files.pythonhosted.org/packages/d5/6c/bfa0b87b03b9238148beca990292843c9396ba069b54496596594173de7b/cffi-2.1.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03", size = 208530, upload-time = "2026-08-03T21:20:24.628Z" }, + { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", size = 221525, upload-time = "2026-08-03T21:20:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", size = 225053, upload-time = "2026-08-03T21:20:26.985Z" }, + { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", size = 223213, upload-time = "2026-08-03T21:20:28.277Z" }, + { url = "https://files.pythonhosted.org/packages/0b/e9/d0061c364cde06ee43168a0d076ac1da512cbc380d44767b844ba34fe2b6/cffi-2.1.1-cp314-cp314-win32.whl", hash = "sha256:1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c", size = 177682, upload-time = "2026-08-03T21:20:44.288Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1c3e01e3ba14c39f6d10bfbac52753b7e22259e38088e5cfe1d704918690/cffi-2.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48", size = 187949, upload-time = "2026-08-03T21:20:45.623Z" }, + { url = "https://files.pythonhosted.org/packages/87/5b/da4e39efe18eeb89cf580ea9cfc66b6a7c3eadb808fc0cc1d3a295cb5a5d/cffi-2.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836", size = 182947, upload-time = "2026-08-03T21:20:46.955Z" }, + { url = "https://files.pythonhosted.org/packages/23/59/40338bf421c5accea1d45158170c87006ef1cd371b05c077e76476949728/cffi-2.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3", size = 188504, upload-time = "2026-08-03T21:20:29.495Z" }, + { url = "https://files.pythonhosted.org/packages/7d/47/5ecf1023850036e674c77ec4de86182d309ae344e39e7cba984b7df5d647/cffi-2.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2", size = 188259, upload-time = "2026-08-03T21:20:31.291Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", size = 223864, upload-time = "2026-08-03T21:20:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/4d/45/ba4c93527bc38616a8bd36488acb69a2212d60486794f0c1f318949bbb76/cffi-2.1.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc", size = 211538, upload-time = "2026-08-03T21:20:33.808Z" }, + { url = "https://files.pythonhosted.org/packages/80/e9/b6ef565e452acb932fb0cb5443f44a78efbd1233e566f02b5a83855e9115/cffi-2.1.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29", size = 210688, upload-time = "2026-08-03T21:20:34.974Z" }, + { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", size = 223803, upload-time = "2026-08-03T21:20:36.564Z" }, + { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", size = 226763, upload-time = "2026-08-03T21:20:37.816Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", size = 225688, upload-time = "2026-08-03T21:20:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d2/3b7176cb570a1d3e27faf67b72f591af508036e0d8b2be2ef9af9e8c84bb/cffi-2.1.1-cp314-cp314t-win32.whl", hash = "sha256:8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4", size = 182868, upload-time = "2026-08-03T21:20:40.388Z" }, + { url = "https://files.pythonhosted.org/packages/56/78/31f00c1bcd97c9bbf55f1bfdf5bc809a5de8887473e90bb9960dca825e80/cffi-2.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e", size = 194104, upload-time = "2026-08-03T21:20:41.725Z" }, + { url = "https://files.pythonhosted.org/packages/7b/1b/58496f2ed0a35de575250c02a43ab3cc2c04d494a88fed31c1cabc0fd176/cffi-2.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5", size = 186402, upload-time = "2026-08-03T21:20:43.042Z" }, + { url = "https://files.pythonhosted.org/packages/c1/8f/9ebe220eab48a093d1a5a5e339ab0dc7316eef3bb04d63c42f0251b61f50/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d", size = 194043, upload-time = "2026-08-03T21:20:48.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/69/844bad3ece306c4782c2ecb93597035b6690d48704b803914c199da1e8b3/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b", size = 196737, upload-time = "2026-08-03T21:20:49.457Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8a/af668013284634733f02d683458a0728739c7d6ddb5e14cb0c20832266fe/cffi-2.1.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:fb92203a88b3d3053034db775110081c49d28be6551923805e039924093761e4", size = 184933, upload-time = "2026-08-03T21:20:50.639Z" }, + { url = "https://files.pythonhosted.org/packages/0c/75/2f5207ff6d1a613133b23a5203cc0c2a628313b5eb3974d7956ae3c57950/cffi-2.1.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2ae64be792b8966f2c69538199728b290e34726562896df1e5dc8ffd8d8188e8", size = 185002, upload-time = "2026-08-03T21:20:52.173Z" }, + { url = "https://files.pythonhosted.org/packages/e2/31/9e1313b0a6e30e91b3b3d3fff51ae99c857c07738e3afcce1f7334e1b7ab/cffi-2.1.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6", size = 222271, upload-time = "2026-08-03T21:20:53.462Z" }, + { url = "https://files.pythonhosted.org/packages/50/e3/f6234a833e6e08c7007003074723c406559eecf9b48dfc97471e5a8eb7a0/cffi-2.1.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:246fa40ce8645a614ff682e0b70f37134e460eaf93a775e0cbe3cca585a67a80", size = 209919, upload-time = "2026-08-03T21:20:54.783Z" }, + { url = "https://files.pythonhosted.org/packages/0d/fc/5f74e293fced6edb51af3a46c4ccf6c23c9943774ecb375ddbd522c76add/cffi-2.1.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:471cee653ae88de62096552e6d24ccb4a5adb8c8c9f10b5054d0122c15bf2779", size = 208529, upload-time = "2026-08-03T21:20:56.066Z" }, + { url = "https://files.pythonhosted.org/packages/44/16/29e6d01b388bef055ecd6ca8244b3f4d336bd09e92d5d892187b9601084e/cffi-2.1.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399", size = 221630, upload-time = "2026-08-03T21:20:57.336Z" }, + { url = "https://files.pythonhosted.org/packages/a4/18/fa7f1f6857d5eb88a4ca99ffcbfb7c387a287ccc154c64a73e86314745d7/cffi-2.1.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688", size = 225134, upload-time = "2026-08-03T21:20:58.675Z" }, + { url = "https://files.pythonhosted.org/packages/e0/9f/e8e3dfa04a1b4c241f8c91faacad872b4d4efd051d49764ad4e2fd4b9fea/cffi-2.1.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7", size = 223197, upload-time = "2026-08-03T21:20:59.968Z" }, + { url = "https://files.pythonhosted.org/packages/f8/7e/8debeb04f1ab9fe2a6963964cd6f1aaf7192627b83926586a6a4e089c9fa/cffi-2.1.1-cp315-cp315-win32.whl", hash = "sha256:4f42141fc14250de6dde5ee7ea4432be017252d91f19c5ad043c084cea629cac", size = 177683, upload-time = "2026-08-03T21:21:14.901Z" }, + { url = "https://files.pythonhosted.org/packages/e0/31/5158704cc474ab65c1647932e88be78dc0873f47130e253be38bcaf13d01/cffi-2.1.1-cp315-cp315-win_amd64.whl", hash = "sha256:e6e8cff14d6fb0be70a09c0bdc58096f501952d04624ebf867e0e56da2df8960", size = 187897, upload-time = "2026-08-03T21:21:16.108Z" }, + { url = "https://files.pythonhosted.org/packages/cc/4b/b3a2da8570c704ffc0f9762cdc3ec0f02c8573798e0b5cf7f11c82bbb70f/cffi-2.1.1-cp315-cp315-win_arm64.whl", hash = "sha256:27350daa11d4f10c540e6e89dada4c54feb7256ad03e9a4dc075ebad7ba360d1", size = 182935, upload-time = "2026-08-03T21:21:17.271Z" }, + { url = "https://files.pythonhosted.org/packages/d0/ef/5443574510a1207e6f6bc38ba6e1f1de36cb48fef07b2728bb896a21f430/cffi-2.1.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:c26608d2222fb1e94487e4a387d85f13eb55d5ed725cb25a0c589ac4ee60e7bc", size = 188464, upload-time = "2026-08-03T21:21:01.163Z" }, + { url = "https://files.pythonhosted.org/packages/7e/ae/a56fa8c4686ad50e148fcbc8d3ae0d03915ff5c30d795058988c24118cef/cffi-2.1.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:4be96343e422f2dfcd12ab5c9f5aebe03f82f737c6bffeca6830b3875cb44aab", size = 188262, upload-time = "2026-08-03T21:21:02.382Z" }, + { url = "https://files.pythonhosted.org/packages/53/b2/6187f46f2912276a3ae284076109cc5c8680482f11f766ccf26db4a86427/cffi-2.1.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e", size = 223779, upload-time = "2026-08-03T21:21:03.553Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f6/c3ad28bd19f77047a03084424fbd4cbe997303267c14423737324be0385d/cffi-2.1.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:df423d40ee8654634421812bc3b196da3f9bd7d32929da813f8394c4348a5358", size = 211520, upload-time = "2026-08-03T21:21:04.863Z" }, + { url = "https://files.pythonhosted.org/packages/a0/cd/ccac9013a5bd9fd764de118674ab9c805b5ca10c19270d90ee273f8b2240/cffi-2.1.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a730a083190634c65cca36ba5f489531576ebd79bcd5c8e172130f6453127231", size = 210673, upload-time = "2026-08-03T21:21:06.223Z" }, + { url = "https://files.pythonhosted.org/packages/52/86/2976131c639aead931c5bee5aba67e4b09fbeb8018b6f282f70803f923a7/cffi-2.1.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6", size = 223835, upload-time = "2026-08-03T21:21:07.539Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0c/33a7aeab2f9c76918c52e084beb39c570db3588133412929e8ec06fab90b/cffi-2.1.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94", size = 226705, upload-time = "2026-08-03T21:21:08.774Z" }, + { url = "https://files.pythonhosted.org/packages/e3/26/2cde30fdde421130bfc18f70395731a6e6b2053c6a1978a5258ff04e72fa/cffi-2.1.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5", size = 225539, upload-time = "2026-08-03T21:21:09.911Z" }, + { url = "https://files.pythonhosted.org/packages/6d/cd/a361394c94b2129d604bb846f624a8e88255a3ee33129c434a00d715e64f/cffi-2.1.1-cp315-cp315t-win32.whl", hash = "sha256:06c72bb76605a4b0cd0aad6930b69d4baf7dd5d806cfc409b824191099700e66", size = 182707, upload-time = "2026-08-03T21:21:11.226Z" }, + { url = "https://files.pythonhosted.org/packages/9b/b5/ba2b299993c26577d529b6ae29841f9e15b9fcf004d65f423f4fcf94ade9/cffi-2.1.1-cp315-cp315t-win_amd64.whl", hash = "sha256:d9c275eaacd24aa73f94ffd6de08fc3f932424d8b6c376f4bed7cde376fe7bc3", size = 193772, upload-time = "2026-08-03T21:21:12.39Z" }, + { url = "https://files.pythonhosted.org/packages/aa/29/35e016098c814cd93de9cd320c66b5bfba14dc6ecedd3cb518fa7c408c69/cffi-2.1.1-cp315-cp315t-win_arm64.whl", hash = "sha256:d18e5ac0f2f03f4f518d3e23db0f0cad7faa1da8620e9c09461d443bbf6e6692", size = 186360, upload-time = "2026-08-03T21:21:13.636Z" }, +] + [[package]] name = "click" version = "8.5.0" @@ -81,14 +265,27 @@ name = "mtusi2026lab2" version = "0.1.0" source = { virtual = "." } dependencies = [ + { name = "argon2-cffi" }, + { name = "asyncpg" }, { name = "fastapi" }, { name = "uvicorn" }, ] [package.metadata] requires-dist = [ - { name = "fastapi", specifier = ">=0.141.1" }, - { name = "uvicorn", specifier = ">=0.53.0" }, + { name = "argon2-cffi", specifier = "==25.1.0" }, + { name = "asyncpg", specifier = "==0.31.0" }, + { name = "fastapi", specifier = "==0.141.1" }, + { name = "uvicorn", specifier = "==0.40.0" }, +] + +[[package]] +name = "pycparser" +version = "3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ac/d3/eb1d3bc30dda12f7e69640ae2ac8cb10240b71fb73024ad528b7d2ae73da/pycparser-3.1.tar.gz", hash = "sha256:b3fc6dec06a8b2fefa0ed4ff92285306a5e3be9987bc5603c9edbdc4e492418f", size = 105946, upload-time = "2026-10-08T12:26:34.349Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/ce/b3ae9ee0324d991c860187be2a6ee436d27a3d02397eaddbb101ec901f3d/pycparser-3.1-py3-none-any.whl", hash = "sha256:f09d358c840bd147b79e55f2bc494f18ea869dc897f5852a8f5766b74f787882", size = 48709, upload-time = "2026-10-08T12:26:32.97Z" }, ] [[package]] @@ -217,13 +414,13 @@ wheels = [ [[package]] name = "uvicorn" -version = "0.53.0" +version = "0.40.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, { name = "h11" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/5d/ad/04bbb797c84fc1f26cb171f7394716f4865ffb8d8c5e1eef42565c2dfa6b/uvicorn-0.53.0.tar.gz", hash = "sha256:a9356f0cb89b3b8621529c5d5eebd69bfe154f4c3f68b4cf2de47e45fa855c2e", size = 110881, upload-time = "2026-09-14T07:44:23.815Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/d1/8f3c683c9561a4e6689dd3b1d345c815f10f86acd044ee1fb9a4dcd0b8c5/uvicorn-0.40.0.tar.gz", hash = "sha256:839676675e87e73694518b5574fd0f24c9d97b46bea16df7b8c05ea1a51071ea", size = 81761, upload-time = "2025-12-21T14:16:22.45Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/76/18/0eea75741ee812e9f598b687619ce2454f6c3a1c5cd21ea990ec6bd26f45/uvicorn-0.53.0-py3-none-any.whl", hash = "sha256:e8dca71ec86dce5f04e333f0d56cdedf942446e6643b9cea1af0d6d3a02cb03e", size = 87081, upload-time = "2026-09-14T07:44:22.179Z" }, + { url = "https://files.pythonhosted.org/packages/3d/d8/2083a1daa7439a66f3a48589a57d576aa117726762618f6bb09fe3798796/uvicorn-0.40.0-py3-none-any.whl", hash = "sha256:c6c8f55bc8bf13eb6fa9ff87ad62308bbbc33d0b67f84293151efe87e0d5f2ee", size = 68502, upload-time = "2025-12-21T14:16:21.041Z" }, ] -- 2.54.0 From 13fa322ca29a28731a1233075c49536ef9722c47 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9?= Date: Thu, 8 Oct 2026 19:08:55 +0300 Subject: [PATCH 3/6] add code for level 4 --- .env.example | 1 + Makefile | 6 ++- REPORT.md | 20 +++++++ compose.yaml | 18 +++++++ evidence/explain-history-2026-10-08.txt | 14 +++++ evidence/grade4-checks-2026-10-08.txt | 11 ++++ evidence/redis-cache-2026-10-08.txt | 6 +++ migrations/002_history_cache_version.sql | 1 + pyproject.toml | 1 + scripts/explain_history.sh | 35 ++++++++++++ scripts/restart.sh | 2 +- scripts/test_dependencies.sh | 16 ++++++ src/config.py | 22 ++++++++ src/main.py | 5 ++ src/routes.py | 18 +++++-- src/storage/history_cache.py | 60 +++++++++++++++++++++ src/storage/postgres.py | 68 ++++++++++++++++-------- student-tests/lab4_checks.py | 66 +++++++++++++++++++++++ student-tests/readiness_unavailable.py | 16 ++++++ student-tests/session_expiry.py | 20 +++++++ uv.lock | 11 ++++ 21 files changed, 390 insertions(+), 27 deletions(-) create mode 100644 evidence/explain-history-2026-10-08.txt create mode 100644 evidence/grade4-checks-2026-10-08.txt create mode 100644 evidence/redis-cache-2026-10-08.txt create mode 100644 migrations/002_history_cache_version.sql create mode 100755 scripts/explain_history.sh create mode 100755 scripts/test_dependencies.sh create mode 100644 src/storage/history_cache.py create mode 100644 student-tests/lab4_checks.py create mode 100644 student-tests/readiness_unavailable.py create mode 100644 student-tests/session_expiry.py diff --git a/.env.example b/.env.example index 714c8076..f4266ba1 100644 --- a/.env.example +++ b/.env.example @@ -4,6 +4,7 @@ APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab SESSION_TTL_SECONDS=3600 +CACHE_TTL_SECONDS=60 # Choose credentials locally. File paths contain no secret values. DATABASE_URL_FILE=/run/secrets/database_url # Optional on 3, required use on 4 in lab2; Redis OR Valkey: diff --git a/Makefile b/Makefile index 9ecb223e..ffc955ca 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +.PHONY: help check validate test load test-persistence test-grade4 help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -24,3 +24,7 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +test-grade4: + $(PYTHON) student-tests/lab4_checks.py + ./scripts/test_dependencies.sh diff --git a/REPORT.md b/REPORT.md index d39a6daa..9ae87dda 100644 --- a/REPORT.md +++ b/REPORT.md @@ -30,6 +30,22 @@ curl -fsS http://localhost:8080/health/ready make test chmod +x scripts/restart.sh make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-grade4 +``` + +Для проверки короткого TTL временно пересоздайте только API: + +```sh +SESSION_TTL_SECONDS=2 docker compose --env-file .env.example up -d --force-recreate api +docker compose --env-file .env.example up -d --wait api +python3 student-tests/session_expiry.py +SESSION_TTL_SECONDS=3600 docker compose --env-file .env.example up -d --force-recreate api +``` + +План запроса истории создаётся на 10 000 синтетических сообщениях: + +```sh +./scripts/explain_history.sh | tee evidence/explain-history-local.txt ``` Обычная остановка сохраняет учебные данные: @@ -74,6 +90,10 @@ Logout удаляет текущую серверную сессию. Срок | Согласованность lock-файла | `uv lock --check` | PASS | выполнено | | Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/smoke-2026-10-08.txt` | | Persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` | `evidence/persistence-2026-10-08.txt` | +| Redis cache | `make test-grade4`; `redis-cli --scan` | read-after-write без stale read; создан ключ `history:first:…` | `evidence/redis-cache-2026-10-08.txt` | +| Гонка и rollback | `make test-grade4` | Ровно одна регистрация успешна; неуспешный чат не виден | `evidence/grade4-checks-2026-10-08.txt` | +| TTL и зависимости | `make test-grade4`; TTL=2 | Expired session → 401; Redis fallback проходит smoke; DB readiness → 503 | `evidence/grade4-checks-2026-10-08.txt` | +| Индекс истории | `./scripts/explain_history.sh` | Index Scan, 50 строк, shared hit=3 | `evidence/explain-history-2026-10-08.txt` | ## Ограничения и следующие шаги diff --git a/compose.yaml b/compose.yaml index 4c1eafe4..432240f6 100644 --- a/compose.yaml +++ b/compose.yaml @@ -24,9 +24,12 @@ services: APP_PORT: 8080 APP_ENV: lab2 DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + CACHE_TTL_SECONDS: ${CACHE_TTL_SECONDS:-60} SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} secrets: - database_url + - cache_url depends_on: postgres: condition: service_healthy @@ -39,11 +42,26 @@ services: retries: 12 start_period: 10s + redis: + image: redis:7.4.2-alpine + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"] + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 12 + start_period: 5s + secrets: postgres_password: file: ./secrets/postgres_password database_url: file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url volumes: postgres_data: + redis_data: diff --git a/evidence/explain-history-2026-10-08.txt b/evidence/explain-history-2026-10-08.txt new file mode 100644 index 00000000..c4fd493f --- /dev/null +++ b/evidence/explain-history-2026-10-08.txt @@ -0,0 +1,14 @@ +Date: 2026-10-08 +Command: ./scripts/explain_history.sh + +Dataset: 10,000 synthetic messages in one chat. +Query plan: +Limit (cost=0.29..4.20 rows=50 width=73) (actual time=0.006..0.010 rows=50 loops=1) + Buffers: shared hit=3 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..783.39 rows=10000 width=73) (actual time=0.006..0.008 rows=50 loops=1) + Index Cond: (chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb'::uuid) + Buffers: shared hit=3 +Planning: + Buffers: shared hit=39 +Planning Time: 0.099 ms +Execution Time: 0.016 ms diff --git a/evidence/grade4-checks-2026-10-08.txt b/evidence/grade4-checks-2026-10-08.txt new file mode 100644 index 00000000..31162fd3 --- /dev/null +++ b/evidence/grade4-checks-2026-10-08.txt @@ -0,0 +1,11 @@ +Date: 2026-10-08 +Commands: + make test-grade4 + SESSION_TTL_SECONDS=2 docker compose --env-file .env.example up -d --force-recreate api + python3 student-tests/session_expiry.py + +Results: +PASS: registration race, chat rollback and cache read-after-write +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. +PASS: readiness rejects unavailable PostgreSQL +PASS: expired Bearer session was rejected diff --git a/evidence/redis-cache-2026-10-08.txt b/evidence/redis-cache-2026-10-08.txt new file mode 100644 index 00000000..e2301e0e --- /dev/null +++ b/evidence/redis-cache-2026-10-08.txt @@ -0,0 +1,6 @@ +Date: 2026-10-08 +Command: + docker compose exec -T redis redis-cli --scan --pattern 'history:first:*' + +Observed key after public smoke: +history:first:b1805682-25ab-4339-b2f1-6c61ccffbec4:v2:l1 diff --git a/migrations/002_history_cache_version.sql b/migrations/002_history_cache_version.sql new file mode 100644 index 00000000..7b7972c1 --- /dev/null +++ b/migrations/002_history_cache_version.sql @@ -0,0 +1 @@ +ALTER TABLE chats ADD COLUMN history_version bigint NOT NULL DEFAULT 0; diff --git a/pyproject.toml b/pyproject.toml index 2eb0b29d..9de26558 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -8,5 +8,6 @@ dependencies = [ "argon2-cffi==25.1.0", "asyncpg==0.31.0", "fastapi==0.141.1", + "redis==5.0.8", "uvicorn==0.40.0", ] diff --git a/scripts/explain_history.sh b/scripts/explain_history.sh new file mode 100755 index 00000000..cec693a3 --- /dev/null +++ b/scripts/explain_history.sh @@ -0,0 +1,35 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." + +docker compose exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 <<'SQL' +INSERT INTO users (id, username, display_name, password_hash) +VALUES ('aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', 'plan_user', 'Plan user', 'not-used') +ON CONFLICT (id) DO NOTHING; + +INSERT INTO chats (id, title) +VALUES ('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb', 'Plan history') +ON CONFLICT (id) DO NOTHING; + +INSERT INTO chat_members (chat_id, user_id) +VALUES ('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb', 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa') +ON CONFLICT DO NOTHING; + +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT + ('00000000-0000-4000-8000-' || lpad(item::text, 12, '0'))::uuid, + 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb', + 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', + 'plan message ' || item, + '2026-01-01T00:00:00Z'::timestamptz + item * interval '1 microsecond' +FROM generate_series(1, 10000) AS item +ON CONFLICT (id) DO NOTHING; + +ANALYZE messages; +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb' +ORDER BY created_at, id +LIMIT 50; +SQL diff --git a/scripts/restart.sh b/scripts/restart.sh index 5d062916..d29bed84 100755 --- a/scripts/restart.sh +++ b/scripts/restart.sh @@ -1,4 +1,4 @@ #!/bin/sh set -eu cd "$(dirname "$0")/.." -docker compose restart api postgres +docker compose restart api postgres redis diff --git a/scripts/test_dependencies.sh b/scripts/test_dependencies.sh new file mode 100755 index 00000000..41c6936c --- /dev/null +++ b/scripts/test_dependencies.sh @@ -0,0 +1,16 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." + +restore() { + docker compose start postgres redis >/dev/null 2>&1 || true + docker compose up -d --wait api >/dev/null 2>&1 || true +} +trap restore EXIT + +docker compose stop redis +make test +docker compose start redis +docker compose up -d --wait api +docker compose stop postgres +python3 student-tests/readiness_unavailable.py diff --git a/src/config.py b/src/config.py index 80aa98f0..61d26192 100644 --- a/src/config.py +++ b/src/config.py @@ -10,6 +10,9 @@ _CONFIGURATION_KEYS = { "APP_ENV", "DATABASE_URL", "DATABASE_URL_FILE", + "CACHE_URL", + "CACHE_URL_FILE", + "CACHE_TTL_SECONDS", "SESSION_TTL_SECONDS", } @@ -23,6 +26,8 @@ class Settings: environment: str database_url: str session_ttl_seconds: int + cache_url: str | None + cache_ttl_seconds: int def load_settings(env_file: Path = ROOT / ".env") -> Settings: @@ -68,10 +73,27 @@ def load_settings(env_file: Path = ROOT / ".env") -> Settings: raise ValueError("SESSION_TTL_SECONDS должен быть целым числом") from error if session_ttl_seconds < 1: raise ValueError("SESSION_TTL_SECONDS должен быть положительным") + cache_url_file = os.environ.get("CACHE_URL_FILE", "").strip() + cache_url = os.environ.get("CACHE_URL", "").strip() + if cache_url_file: + try: + cache_url = Path(cache_url_file).read_text(encoding="utf-8").strip() + except OSError as error: + raise ValueError("CACHE_URL_FILE недоступен") from error + if cache_url and not cache_url.startswith(("redis://", "rediss://")): + raise ValueError("CACHE_URL должен содержать Redis URL") + try: + cache_ttl_seconds = int(os.environ.get("CACHE_TTL_SECONDS", "60")) + except ValueError as error: + raise ValueError("CACHE_TTL_SECONDS должен быть целым числом") from error + if cache_ttl_seconds < 1: + raise ValueError("CACHE_TTL_SECONDS должен быть положительным") return Settings( host=host, port=port, environment=environment, database_url=database_url, session_ttl_seconds=session_ttl_seconds, + cache_url=cache_url or None, + cache_ttl_seconds=cache_ttl_seconds, ) diff --git a/src/main.py b/src/main.py index 46fb8e87..3e60da5b 100644 --- a/src/main.py +++ b/src/main.py @@ -13,6 +13,7 @@ from .errors import ApiError from .models import ErrorDetails, ErrorResponse from .config import load_settings from .routes import router +from .storage.history_cache import HistoryCache from .storage.postgres import PostgresStore @@ -35,9 +36,13 @@ async def lifespan(application: FastAPI): await store.migrate() application.state.store = store application.state.settings = settings + cache = HistoryCache(settings.cache_url, settings.cache_ttl_seconds) + await cache.connect() + application.state.history_cache = cache try: yield finally: + await cache.close() await store.close() diff --git a/src/routes.py b/src/routes.py index c2062e9c..e0378ca8 100644 --- a/src/routes.py +++ b/src/routes.py @@ -8,6 +8,7 @@ from .cursor import CursorError, decode_cursor, encode_cursor from .errors import ApiError from .models import Chat, ChatPageResponse, CreateChatRequest, CreateMessageRequest, CreateUserRequest, Message, MessagePageResponse, Session, User from .storage.postgres import PostgresStore +from .storage.history_cache import HistoryCache router = APIRouter() BEARER_CHALLENGE = {'WWW-Authenticate': 'Bearer realm="messenger"'} @@ -16,6 +17,9 @@ BASIC_CHALLENGE = {'WWW-Authenticate': 'Basic realm="messenger", charset="UTF-8" def get_store(request: Request) -> PostgresStore: return request.app.state.store +def get_history_cache(request: Request) -> HistoryCache: + return request.app.state.history_cache + async def get_current_user(authorization: str | None = Header(default=None), store: PostgresStore = Depends(get_store)) -> dict: if authorization is None or not authorization.startswith("Bearer "): raise ApiError(401, "unauthorized", "Требуется Bearer-сессия", BEARER_CHALLENGE) @@ -99,10 +103,11 @@ async def get_chat(chat_id: UUID, user: dict = Depends(get_current_user), store: @router.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201) async def create_message(chat_id: UUID, payload: CreateMessageRequest, user: dict = Depends(get_current_user), store: PostgresStore = Depends(get_store)) -> dict: - return await store.create_message(chat_id, user["id"], payload.text) + message, _version = await store.create_message(chat_id, user["id"], payload.text) + return message @router.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePageResponse) -async def list_messages(chat_id: UUID, user: dict = Depends(get_current_user), store: PostgresStore = Depends(get_store), limit: int = Query(default=50, ge=1, le=100), cursor: str | None = Query(default=None, min_length=1)) -> MessagePageResponse: +async def list_messages(chat_id: UUID, user: dict = Depends(get_current_user), store: PostgresStore = Depends(get_store), cache: HistoryCache = Depends(get_history_cache), limit: int = Query(default=50, ge=1, le=100), cursor: str | None = Query(default=None, min_length=1)) -> MessagePageResponse: after: tuple[datetime, UUID] | None = None scope = "messages:" + str(chat_id) if cursor is not None: @@ -111,7 +116,14 @@ async def list_messages(chat_id: UUID, user: dict = Depends(get_current_user), s after = created_at, UUID(item_id) except (CursorError, ValueError) as error: raise ApiError(400, "invalid_request", "Некорректный cursor") from error - rows = await store.list_messages_for_member(chat_id, user["id"], after, limit) + if cursor is None: + version = await store.history_version_for_member(chat_id, user["id"]) + rows = await cache.get(chat_id, version, limit) + if rows is None: + rows = await store.list_messages_for_member(chat_id, user["id"], after, limit) + await cache.set(chat_id, version, limit, rows) + else: + rows = await store.list_messages_for_member(chat_id, user["id"], after, limit) page = rows[:limit] next_cursor = encode_cursor(scope, page[-1]["created_at"], str(page[-1]["id"])) if len(rows) > limit else None return MessagePageResponse(items=page, next_cursor=next_cursor) diff --git a/src/storage/history_cache.py b/src/storage/history_cache.py new file mode 100644 index 00000000..b3803f43 --- /dev/null +++ b/src/storage/history_cache.py @@ -0,0 +1,60 @@ +import json +from uuid import UUID + +from redis.asyncio import Redis +from redis.exceptions import RedisError + + +class HistoryCache: + """Кэш только первой страницы истории; PostgreSQL остаётся источником истины.""" + + def __init__(self, url: str | None, ttl_seconds: int) -> None: + self._url = url + self._ttl_seconds = ttl_seconds + self._client: Redis | None = None + self._disabled = not bool(url) + + async def connect(self) -> None: + if self._disabled: + return + try: + client = Redis.from_url( + self._url, + decode_responses=True, + socket_connect_timeout=1, + socket_timeout=1, + max_connections=10, + ) + await client.ping() + self._client = client + except RedisError: + self._disabled = True + + async def close(self) -> None: + if self._client is not None: + await self._client.aclose() + + @staticmethod + def _key(chat_id: UUID, version: int, limit: int) -> str: + return f"history:first:{chat_id}:v{version}:l{limit}" + + async def get(self, chat_id: UUID, version: int, limit: int) -> list[dict] | None: + if self._disabled or self._client is None: + return None + try: + value = await self._client.get(self._key(chat_id, version, limit)) + return json.loads(value) if value else None + except (RedisError, ValueError, TypeError): + self._disabled = True + return None + + async def set(self, chat_id: UUID, version: int, limit: int, items: list[dict]) -> None: + if self._disabled or self._client is None: + return + try: + encoded = json.dumps(items, default=str, separators=(",", ":")) + await self._client.set( + self._key(chat_id, version, limit), encoded, ex=self._ttl_seconds + ) + except RedisError: + self._disabled = True diff --git a/src/storage/postgres.py b/src/storage/postgres.py index ad3367e5..435c2f05 100644 --- a/src/storage/postgres.py +++ b/src/storage/postgres.py @@ -26,7 +26,7 @@ class PostgresStore: self._pool = await asyncpg.create_pool( self._database_url, min_size=1, max_size=10, command_timeout=5 ) - except asyncpg.PostgresError as error: + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: raise RuntimeError("PostgreSQL is unavailable") from error async def close(self) -> None: @@ -87,7 +87,7 @@ class PostgresStore: async def ready(self) -> None: try: await self.pool.fetchval("SELECT 1") - except asyncpg.PostgresError as error: + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error async def create_user(self, username: str, display_name: str, password: str) -> dict: @@ -101,7 +101,7 @@ class PostgresStore: ) except asyncpg.UniqueViolationError as error: raise ApiError(409, "conflict", "Username уже занят") from error - except asyncpg.PostgresError as error: + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error return self._user(row) @@ -110,7 +110,7 @@ class PostgresStore: row = await self.pool.fetchrow( "SELECT id, username, display_name, created_at FROM users WHERE id = $1", user_id ) - except asyncpg.PostgresError as error: + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error return self._user(row) if row else None @@ -120,7 +120,7 @@ class PostgresStore: "SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = $1", username, ) - except asyncpg.PostgresError as error: + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error if row is None: return None @@ -140,7 +140,7 @@ class PostgresStore: user["id"], ttl_seconds, ) - except asyncpg.PostgresError as error: + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error return {"token": token, "token_type": "Bearer", "expires_at": row["expires_at"], "user": user} @@ -151,7 +151,7 @@ class PostgresStore: "SELECT u.id, u.username, u.display_name, u.created_at FROM sessions s JOIN users u ON u.id = s.user_id WHERE s.token_hash = $1 AND s.expires_at > now()", token_hash, ) - except asyncpg.PostgresError as error: + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error return self._user(row) if row else None @@ -160,7 +160,7 @@ class PostgresStore: await self.pool.execute( "DELETE FROM sessions WHERE token_hash = $1", sha256(token.encode("ascii")).hexdigest() ) - except asyncpg.PostgresError as error: + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error async def create_chat(self, creator_id: UUID, title: str, member_ids: list[UUID]) -> dict: @@ -182,7 +182,7 @@ class PostgresStore: "INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)", [(row["id"], member_id) for member_id in member_ids], ) - except asyncpg.PostgresError as error: + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error return { "id": row["id"], @@ -198,7 +198,7 @@ class PostgresStore: chat_id, user_id, ) - except asyncpg.PostgresError as error: + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error if row is None: raise ApiError(404, "not_found", "Чат не найден") @@ -216,23 +216,47 @@ class PostgresStore: args.append(limit + 1) try: rows = await self.pool.fetch(query, *args) - except asyncpg.PostgresError as error: + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error return [self._chat(row) for row in rows] async def create_message(self, chat_id: UUID, sender_id: UUID, text: str) -> dict: - await self.get_chat_for_member(chat_id, sender_id) try: - row = await self.pool.fetchrow( - "INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1, $2, $3, $4) RETURNING id, chat_id, sender_id, text, created_at", - uuid4(), - chat_id, - sender_id, - text, - ) - except asyncpg.PostgresError as error: + async with self.pool.acquire() as connection, connection.transaction(): + member = await connection.fetchval( + "SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2", + chat_id, + sender_id, + ) + if member is None: + raise ApiError(404, "not_found", "Чат не найден") + row = await connection.fetchrow( + "INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1, $2, $3, $4) RETURNING id, chat_id, sender_id, text, created_at", + uuid4(), + chat_id, + sender_id, + text, + ) + version = await connection.fetchval( + "UPDATE chats SET history_version = history_version + 1 WHERE id = $1 RETURNING history_version", + chat_id, + ) + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error - return self._message(row) + return self._message(row), version + + async def history_version_for_member(self, chat_id: UUID, user_id: UUID) -> int: + try: + version = await self.pool.fetchval( + "SELECT c.history_version FROM chats c JOIN chat_members cm ON cm.chat_id = c.id WHERE c.id = $1 AND cm.user_id = $2", + chat_id, + user_id, + ) + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error + if version is None: + raise ApiError(404, "not_found", "Чат не найден") + return version async def list_messages_for_member( self, chat_id: UUID, user_id: UUID, after: tuple[datetime, UUID] | None, limit: int @@ -247,6 +271,6 @@ class PostgresStore: args.append(limit + 1) try: rows = await self.pool.fetch(query, *args) - except asyncpg.PostgresError as error: + except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error return [self._message(row) for row in rows] diff --git a/student-tests/lab4_checks.py b/student-tests/lab4_checks.py new file mode 100644 index 00000000..0df37ed8 --- /dev/null +++ b/student-tests/lab4_checks.py @@ -0,0 +1,66 @@ +#!/usr/bin/env python3 +"""Проверки гонки регистрации и rollback создания чата.""" +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path +import sys +import uuid + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests")) +from client import Client, check, run # noqa: E402 + + +def main() -> None: + client = Client() + alice, bob, _eve, chat = client.bootstrap() + + username = "race_" + uuid.uuid4().hex[:12] + body = { + "username": username, + "display_name": "Гонка регистрации", + "password": "Race-password-" + uuid.uuid4().hex, + } + + def register_once() -> int: + local = Client() + return local.call("POST", "/api/v1/users", expected=[201, 409], body=body)["status"] + + with ThreadPoolExecutor(max_workers=8) as pool: + statuses = list(pool.map(lambda _unused: register_once(), range(8))) + check(statuses.count(201) == 1 and statuses.count(409) == 7, "username race was not serialized") + + title = "rollback-" + uuid.uuid4().hex + client.call( + "POST", + "/api/v1/chats", + 400, + actor=alice, + body={"title": title, "member_ids": [alice["id"], str(uuid.uuid4())]}, + ) + chats = client.call( + "GET", "/api/v1/chats?limit=100", actor=alice, schema="ChatPage" + )["json"]["items"] + check(all(chat["title"] != title for chat in chats), "failed chat creation left a chat") + + first = client.message(alice, chat, "before cached read")["json"] + client.call( + "GET", + "/api/v1/chats/" + chat["id"] + "/messages?limit=100", + actor=alice, + schema="MessagePage", + ) + second = client.message(bob, chat, "after cached read")["json"] + history = client.call( + "GET", + "/api/v1/chats/" + chat["id"] + "/messages?limit=100", + actor=alice, + schema="MessagePage", + )["json"]["items"] + check( + {message["id"] for message in history} == {first["id"], second["id"]}, + "history cache returned stale data after write", + ) + print("PASS: registration race, chat rollback and cache read-after-write") + + +if __name__ == "__main__": + run(main) diff --git a/student-tests/readiness_unavailable.py b/student-tests/readiness_unavailable.py new file mode 100644 index 00000000..cf4bffa1 --- /dev/null +++ b/student-tests/readiness_unavailable.py @@ -0,0 +1,16 @@ +#!/usr/bin/env python3 +"""Проверка 503 readiness при остановленном PostgreSQL.""" +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests")) +from client import Client, run # noqa: E402 + + +def main() -> None: + Client().call("GET", "/health/ready", 503) + print("PASS: readiness rejects unavailable PostgreSQL") + + +if __name__ == "__main__": + run(main) diff --git a/student-tests/session_expiry.py b/student-tests/session_expiry.py new file mode 100644 index 00000000..37e29fb8 --- /dev/null +++ b/student-tests/session_expiry.py @@ -0,0 +1,20 @@ +#!/usr/bin/env python3 +"""Проверка expiry; запускается при SESSION_TTL_SECONDS=2.""" +from pathlib import Path +import sys +import time + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests")) +from client import Client, check, run # noqa: E402 + + +def main() -> None: + client = Client() + actor = client.user("expiry") + time.sleep(3) + client.call("GET", "/api/v1/users/me", 401, actor=actor) + print("PASS: expired Bearer session was rejected") + + +if __name__ == "__main__": + run(main) diff --git a/uv.lock b/uv.lock index c5c450d3..d45c8ed1 100644 --- a/uv.lock +++ b/uv.lock @@ -268,6 +268,7 @@ dependencies = [ { name = "argon2-cffi" }, { name = "asyncpg" }, { name = "fastapi" }, + { name = "redis" }, { name = "uvicorn" }, ] @@ -276,6 +277,7 @@ requires-dist = [ { name = "argon2-cffi", specifier = "==25.1.0" }, { name = "asyncpg", specifier = "==0.31.0" }, { name = "fastapi", specifier = "==0.141.1" }, + { name = "redis", specifier = "==5.0.8" }, { name = "uvicorn", specifier = "==0.40.0" }, ] @@ -378,6 +380,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fa/04/c81d4841331c2178b6fb09ae225425e110ed72d990c9fe556c4ec03d1013/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e24d8f05fa2d28513d94e877e9c75ad66175376209b3977f916e240e623193c", size = 2111034, upload-time = "2026-08-28T10:01:07.345Z" }, ] +[[package]] +name = "redis" +version = "5.0.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/48/10/defc227d65ea9c2ff5244645870859865cba34da7373477c8376629746ec/redis-5.0.8.tar.gz", hash = "sha256:0c5b10d387568dfe0698c6fad6615750c24170e548ca2deac10c649d463e9870", size = 4595651, upload-time = "2024-07-30T14:11:52.137Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/d1/19a9c76811757684a0f74adc25765c8a901d67f9f6472ac9d57c844a23c8/redis-5.0.8-py3-none-any.whl", hash = "sha256:56134ee08ea909106090934adc36f65c9bcbbaecea5b21ba704ba6fb561f8eb4", size = 255608, upload-time = "2024-07-30T14:11:49.541Z" }, +] + [[package]] name = "starlette" version = "1.7.0" -- 2.54.0 From 744e941d552e4be1fc37005369155f0db21ecba3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9?= Date: Thu, 8 Oct 2026 19:48:18 +0300 Subject: [PATCH 4/6] add code for level 5 --- .env.example | 1 + REPORT.md | 51 ++++++- compose.yaml | 3 + evidence/track1-cache-stampede-2026-10-08.txt | 25 ++++ src/config.py | 79 +++++----- src/main.py | 27 ++-- src/routes.py | 138 +++++++++++++----- src/storage/history_cache.py | 51 ++++++- src/storage/postgres.py | 42 +++--- student-tests/cache_recovery.py | 30 ++++ student-tests/cache_stampede.py | 51 +++++++ 11 files changed, 384 insertions(+), 114 deletions(-) create mode 100644 evidence/track1-cache-stampede-2026-10-08.txt create mode 100644 student-tests/cache_recovery.py create mode 100644 student-tests/cache_stampede.py diff --git a/.env.example b/.env.example index f4266ba1..ca880991 100644 --- a/.env.example +++ b/.env.example @@ -5,6 +5,7 @@ APP_PORT=8080 APP_ENV=lab SESSION_TTL_SECONDS=3600 CACHE_TTL_SECONDS=60 +CACHE_STAMPEDE_PROTECTION=true # Choose credentials locally. File paths contain no secret values. DATABASE_URL_FILE=/run/secrets/database_url # Optional on 3, required use on 4 in lab2; Redis OR Valkey: diff --git a/REPORT.md b/REPORT.md index 9ae87dda..901791a9 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,9 +1,9 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка: 3 +- Автор, группа: Козырев Матвей БВТ2301 +- Целевая оценка: 5; трек 1 — согласованность кэша - Commit/PR: TODO после публикации -- Использованные библиотеки: FastAPI 0.141.1, Uvicorn 0.40.0, asyncpg 0.31.0, argon2-cffi 25.1.0; зафиксированы в `pyproject.toml` и `uv.lock`. +- Использованные библиотеки: FastAPI 0.141.1, Uvicorn 0.40.0, asyncpg 0.31.0, argon2-cffi 25.1.0, redis 5.0.8; зафиксированы в `pyproject.toml` и `uv.lock`. ## Запуск из чистого clone @@ -62,6 +62,7 @@ docker compose down ```text HTTP-клиент → FastAPI API → asyncpg pool (1..10 соединений) → PostgreSQL └→ миграции SQL при старте + └→ Redis cache истории (pool до 50 соединений) ``` PostgreSQL — источник истины для `users`, `chats`, `chat_members`, @@ -81,6 +82,13 @@ Logout удаляет текущую серверную сессию. Срок История выбирается keyset-запросом по `(created_at, id)`; индекс `messages_chat_created_id_idx` соответствует этому запросу. +Redis кэширует только первую страницу истории. Ключ включает `chat_id`, +`limit` и `history_version` из PostgreSQL. В той же транзакции, что и +вставка сообщения, PostgreSQL увеличивает `history_version`; старый ключ +поэтому больше не читается. Redis не источник истины: при его отказе кэш +отключается в процессе API, а чтение продолжает PostgreSQL. Redis использует +AOF и named volume `redis_data`. + ## Доказательства критериев | Критерий | Команда | Наблюдаемый результат | Статус | @@ -94,10 +102,45 @@ Logout удаляет текущую серверную сессию. Срок | Гонка и rollback | `make test-grade4` | Ровно одна регистрация успешна; неуспешный чат не виден | `evidence/grade4-checks-2026-10-08.txt` | | TTL и зависимости | `make test-grade4`; TTL=2 | Expired session → 401; Redis fallback проходит smoke; DB readiness → 503 | `evidence/grade4-checks-2026-10-08.txt` | | Индекс истории | `./scripts/explain_history.sh` | Index Scan, 50 строк, shared hit=3 | `evidence/explain-history-2026-10-08.txt` | +| Трек 5: stampede | `student-tests/cache_stampede.py` | 20 SQL-загрузок → 1 при 20 читателях | `evidence/track1-cache-stampede-2026-10-08.txt` | +| Трек 5: restart cache | `student-tests/cache_recovery.py` | История не изменилась после restart Redis | `evidence/track1-cache-stampede-2026-10-08.txt` | + +## Трек 5 — согласованность кэша + +**Гипотеза.** При холодном ключе 20 одновременных запросов первой страницы +истории создают 20 SQL-загрузок без координации. Redis-lock `SET NX EX 2` +оставит одну загрузку; остальные запросы ждут заполнения ключа до 1 секунды. + +**Методика.** Для каждой точки API запускался с одним и тем же Compose-стендом: +PostgreSQL 17.6, Redis 7.4.2, Python 3.12.12, Docker Engine 29.8.0, 10 CPU и +16 GiB RAM. `student-tests/cache_stampede.py` создаёт новый чат с одним +сообщением и одновременно запускает 20 GET первой страницы. SQL-загрузка +считается по записи `history_sql_page_load` в журнале API. Baseline запускает +API с `CACHE_STAMPEDE_PROTECTION=false`; затем тот же сценарий повторяется с +`true`. Данные, чат и ключ каждый раз новые. + +| Точка | Успешных чтений | SQL-загрузок | p50 / p95 / max latency | +| --- | ---: | ---: | --- | +| Без координации | 20 | 20 | 111.620 / 113.364 / 113.603 ms | +| Redis-lock | 20 | 1 | 157.831 / 159.477 / 159.549 ms | + +Число SQL-загрузок уменьшилось на `(20 − 1) / 20 × 100 = 95%`. В этой +единственной точке p50 вырос на `157.831 − 111.620 = 46.211 ms`, поскольку +ожидающие запросы опрашивают кэш с интервалом 50 ms. Это не оценка +производительности системы в целом: измерение одноразовое, closed-loop, +включает HTTP-клиент и не отделяет влияние Docker Desktop. + +read-after-write проверяет `student-tests/lab4_checks.py`: страница сначала +кэшируется, затем создаётся сообщение, и следующий GET содержит оба сообщения. +`student-tests/cache_recovery.py` заполняет кэш, перезапускает Redis и +проверяет неизменность ответа. Raw results и команды сохранены в evidence. ## Ограничения и следующие шаги -Redis/Valkey не используется: он относится к уровню 4 этой лабораторной. +Результат трека относится к одному локальному прогону с 20 читателями; для +обобщения нужны повторы, нагрузка других размеров и измерение CPU/RAM +контейнеров. Redis-lock не заменяет PostgreSQL: при недоступности Redis API +безопасно обходит кэш, а при недоступности PostgreSQL readiness возвращает 503. Публичные smoke и persistence выполнены на локальном Compose-стенде 2026-10-08. При фиксации работы в PR сохраните их stdout в `evidence/` без токенов и паролей. diff --git a/compose.yaml b/compose.yaml index 432240f6..6699cd52 100644 --- a/compose.yaml +++ b/compose.yaml @@ -26,6 +26,7 @@ services: DATABASE_URL_FILE: /run/secrets/database_url CACHE_URL_FILE: /run/secrets/cache_url CACHE_TTL_SECONDS: ${CACHE_TTL_SECONDS:-60} + CACHE_STAMPEDE_PROTECTION: ${CACHE_STAMPEDE_PROTECTION:-true} SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} secrets: - database_url @@ -33,6 +34,8 @@ services: depends_on: postgres: condition: service_healthy + redis: + condition: service_healthy ports: - "8080:8080" healthcheck: diff --git a/evidence/track1-cache-stampede-2026-10-08.txt b/evidence/track1-cache-stampede-2026-10-08.txt new file mode 100644 index 00000000..3c2c4cd7 --- /dev/null +++ b/evidence/track1-cache-stampede-2026-10-08.txt @@ -0,0 +1,25 @@ +Date: 2026-10-08 +Track: 1 — cache consistency +Environment: Docker Engine 29.8.0; PostgreSQL 17.6; Redis 7.4.2; +Python 3.12.12; 10 CPU; 16 GiB RAM. + +Method: +student-tests/cache_stampede.py creates a new chat with one message and +launches 20 concurrent GET requests for its cold first history page. +The API logs one history_sql_page_load per PostgreSQL page query. + +Baseline: CACHE_STAMPEDE_PROTECTION=false +{"chat_id":"5aa10886-61e0-47f2-82d2-c09a05bbd45f","concurrency":20,"successful_reads":20,"latency_ms":{"p50":111.620,"p95":113.364,"max":113.603},"sql_page_loads":20} + +After: CACHE_STAMPEDE_PROTECTION=true +{"chat_id":"96fd0c67-907f-4681-8ec5-6fcbfc4d8fc7","concurrency":20,"successful_reads":20,"latency_ms":{"p50":157.831,"p95":159.477,"max":159.549},"sql_page_loads":1} + +Reduction: (20 - 1) / 20 * 100 = 95%. + +Cache restart: +Command: python3 student-tests/cache_recovery.py +PASS: history remains correct after Redis restart + +Read-after-write: +Command: python3 student-tests/lab4_checks.py +PASS: registration race, chat rollback and cache read-after-write diff --git a/src/config.py b/src/config.py index 61d26192..2bd85801 100644 --- a/src/config.py +++ b/src/config.py @@ -13,6 +13,7 @@ _CONFIGURATION_KEYS = { "CACHE_URL", "CACHE_URL_FILE", "CACHE_TTL_SECONDS", + "CACHE_STAMPEDE_PROTECTION", "SESSION_TTL_SECONDS", } @@ -28,6 +29,7 @@ class Settings: session_ttl_seconds: int cache_url: str | None cache_ttl_seconds: int + cache_stampede_protection: bool def load_settings(env_file: Path = ROOT / ".env") -> Settings: @@ -46,54 +48,55 @@ def load_settings(env_file: Path = ROOT / ".env") -> Settings: value = value[1:-1] os.environ.setdefault(key, value) - host = os.environ.get("APP_HOST", "0.0.0.0").strip() - environment = os.environ.get("APP_ENV", "lab").strip() + def value(name: str, default: str = "") -> str: + return os.environ.get(name, default).strip() + + def number(name: str, default: int) -> int: + try: + result = int(value(name, str(default))) + except ValueError as error: + raise ValueError(f"{name} должен быть целым числом") from error + if result < 1: + raise ValueError(f"{name} должен быть положительным") + return result + + def url(name: str, file_name: str, prefixes: tuple[str, ...]) -> str: + result = value(name) + path = value(file_name) + if path: + try: + result = Path(path).read_text(encoding="utf-8").strip() + except OSError as error: + raise ValueError(f"{file_name} недоступен") from error + if result and not result.startswith(prefixes): + raise ValueError(f"{name} содержит неверный URL") + return result + + host = value("APP_HOST", "0.0.0.0") + environment = value("APP_ENV", "lab") if not host: raise ValueError("APP_HOST не может быть пустым") if not environment: raise ValueError("APP_ENV не может быть пустым") - try: - port = int(os.environ.get("APP_PORT", "8080")) - except ValueError as error: - raise ValueError("APP_PORT должен быть целым числом") from error - if not 1 <= port <= 65535: + port = number("APP_PORT", 8080) + if port > 65535: raise ValueError("APP_PORT должен находиться в диапазоне 1..65535") - database_url_file = os.environ.get("DATABASE_URL_FILE", "").strip() - database_url = os.environ.get("DATABASE_URL", "").strip() - if database_url_file: - try: - database_url = Path(database_url_file).read_text(encoding="utf-8").strip() - except OSError as error: - raise ValueError("DATABASE_URL_FILE недоступен") from error - if not database_url.startswith(("postgresql://", "postgres://")): + database_url = url( + "DATABASE_URL", "DATABASE_URL_FILE", ("postgresql://", "postgres://") + ) + if not database_url: raise ValueError("Нужен PostgreSQL DATABASE_URL или DATABASE_URL_FILE") - try: - session_ttl_seconds = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) - except ValueError as error: - raise ValueError("SESSION_TTL_SECONDS должен быть целым числом") from error - if session_ttl_seconds < 1: - raise ValueError("SESSION_TTL_SECONDS должен быть положительным") - cache_url_file = os.environ.get("CACHE_URL_FILE", "").strip() - cache_url = os.environ.get("CACHE_URL", "").strip() - if cache_url_file: - try: - cache_url = Path(cache_url_file).read_text(encoding="utf-8").strip() - except OSError as error: - raise ValueError("CACHE_URL_FILE недоступен") from error - if cache_url and not cache_url.startswith(("redis://", "rediss://")): - raise ValueError("CACHE_URL должен содержать Redis URL") - try: - cache_ttl_seconds = int(os.environ.get("CACHE_TTL_SECONDS", "60")) - except ValueError as error: - raise ValueError("CACHE_TTL_SECONDS должен быть целым числом") from error - if cache_ttl_seconds < 1: - raise ValueError("CACHE_TTL_SECONDS должен быть положительным") + cache_url = url("CACHE_URL", "CACHE_URL_FILE", ("redis://", "rediss://")) + raw_protection = value("CACHE_STAMPEDE_PROTECTION", "true").lower() + if raw_protection not in {"true", "false"}: + raise ValueError("CACHE_STAMPEDE_PROTECTION должен быть true или false") return Settings( host=host, port=port, environment=environment, database_url=database_url, - session_ttl_seconds=session_ttl_seconds, + session_ttl_seconds=number("SESSION_TTL_SECONDS", 3600), cache_url=cache_url or None, - cache_ttl_seconds=cache_ttl_seconds, + cache_ttl_seconds=number("CACHE_TTL_SECONDS", 60), + cache_stampede_protection=raw_protection == "true", ) diff --git a/src/main.py b/src/main.py index 3e60da5b..adb5f3d2 100644 --- a/src/main.py +++ b/src/main.py @@ -17,15 +17,20 @@ from .storage.history_cache import HistoryCache from .storage.postgres import PostgresStore -access_logger = logging.getLogger("messenger.access") -if not access_logger.handlers: +def logger(name: str) -> logging.Logger: + result = logging.getLogger(name) + if result.handlers: + return result handler = logging.StreamHandler(sys.stdout) - handler.setFormatter( - logging.Formatter("%(asctime)s %(levelname)s %(name)s %(message)s") - ) - access_logger.addHandler(handler) -access_logger.setLevel(logging.INFO) -access_logger.propagate = False + handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s %(message)s")) + result.addHandler(handler) + result.setLevel(logging.INFO) + result.propagate = False + return result + + +access_logger = logger("messenger.access") +logger("messenger.cache") @asynccontextmanager @@ -36,7 +41,11 @@ async def lifespan(application: FastAPI): await store.migrate() application.state.store = store application.state.settings = settings - cache = HistoryCache(settings.cache_url, settings.cache_ttl_seconds) + cache = HistoryCache( + settings.cache_url, + settings.cache_ttl_seconds, + settings.cache_stampede_protection, + ) await cache.connect() application.state.history_cache = cache try: diff --git a/src/routes.py b/src/routes.py index e0378ca8..514f2f21 100644 --- a/src/routes.py +++ b/src/routes.py @@ -1,4 +1,5 @@ import base64 +import logging from datetime import datetime from uuid import UUID @@ -6,13 +7,24 @@ from fastapi import APIRouter, Depends, Header, Query, Request, Response from .cursor import CursorError, decode_cursor, encode_cursor from .errors import ApiError -from .models import Chat, ChatPageResponse, CreateChatRequest, CreateMessageRequest, CreateUserRequest, Message, MessagePageResponse, Session, User -from .storage.postgres import PostgresStore from .storage.history_cache import HistoryCache +from .storage.postgres import PostgresStore +from .models import ( + Chat, + ChatPageResponse, + CreateChatRequest, + CreateMessageRequest, + CreateUserRequest, + Message, + MessagePageResponse, + Session, + User, +) router = APIRouter() -BEARER_CHALLENGE = {'WWW-Authenticate': 'Bearer realm="messenger"'} -BASIC_CHALLENGE = {'WWW-Authenticate': 'Basic realm="messenger", charset="UTF-8"'} +cache_logger = logging.getLogger("messenger.cache") +BEARER_CHALLENGE = {"WWW-Authenticate": 'Bearer realm="messenger"'} +BASIC_CHALLENGE = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} def get_store(request: Request) -> PostgresStore: return request.app.state.store @@ -20,7 +32,11 @@ def get_store(request: Request) -> PostgresStore: def get_history_cache(request: Request) -> HistoryCache: return request.app.state.history_cache -async def get_current_user(authorization: str | None = Header(default=None), store: PostgresStore = Depends(get_store)) -> dict: + +async def get_current_user( + authorization: str | None = Header(default=None), + store: PostgresStore = Depends(get_store), +) -> dict: if authorization is None or not authorization.startswith("Bearer "): raise ApiError(401, "unauthorized", "Требуется Bearer-сессия", BEARER_CHALLENGE) token = authorization[7:] @@ -45,6 +61,23 @@ def parse_basic(authorization: str | None) -> tuple[str, str]: raise ApiError(401, "unauthorized", "Неверные учётные данные", BASIC_CHALLENGE) return username, password + +def cursor_position(cursor: str | None, scope: str) -> tuple[datetime, UUID] | None: + if cursor is None: + return None + try: + created_at, item_id = decode_cursor(cursor, scope) + return created_at, UUID(item_id) + except (CursorError, ValueError) as error: + raise ApiError(400, "invalid_request", "Некорректный cursor") from error + + +def next_page_cursor(rows: list[dict], limit: int, scope: str) -> str | None: + if len(rows) <= limit: + return None + last = rows[limit - 1] + return encode_cursor(scope, last["created_at"], str(last["id"])) + @router.get("/health/live") async def liveness() -> dict[str, str]: return {"status": "ok"} @@ -55,11 +88,17 @@ async def readiness(store: PostgresStore = Depends(get_store)) -> dict[str, str] return {"status": "ok"} @router.post("/api/v1/users", response_model=User, status_code=201) -async def register_user(payload: CreateUserRequest, store: PostgresStore = Depends(get_store)) -> dict: +async def register_user( + payload: CreateUserRequest, store: PostgresStore = Depends(get_store) +) -> dict: return await store.create_user(payload.username, payload.display_name, payload.password) @router.post("/api/v1/auth/sessions", response_model=Session, status_code=201) -async def create_session(request: Request, authorization: str | None = Header(default=None), store: PostgresStore = Depends(get_store)) -> dict: +async def create_session( + request: Request, + authorization: str | None = Header(default=None), + store: PostgresStore = Depends(get_store), +) -> dict: if await request.body(): raise ApiError(400, "invalid_request", "Тело запроса не требуется") username, password = parse_basic(authorization) @@ -69,7 +108,11 @@ async def create_session(request: Request, authorization: str | None = Header(de return await store.create_session(user, request.app.state.settings.session_ttl_seconds) @router.delete("/api/v1/auth/sessions/current", status_code=204) -async def revoke_session(authorization: str | None = Header(default=None), store: PostgresStore = Depends(get_store), user: dict = Depends(get_current_user)) -> Response: +async def revoke_session( + authorization: str | None = Header(default=None), + store: PostgresStore = Depends(get_store), + user: dict = Depends(get_current_user), +) -> Response: del user await store.revoke_session(authorization[7:]) return Response(status_code=204) @@ -79,51 +122,74 @@ async def current_user(user: dict = Depends(get_current_user)) -> dict: return user @router.post("/api/v1/chats", response_model=Chat, status_code=201) -async def create_chat(payload: CreateChatRequest, user: dict = Depends(get_current_user), store: PostgresStore = Depends(get_store)) -> dict: +async def create_chat( + payload: CreateChatRequest, + user: dict = Depends(get_current_user), + store: PostgresStore = Depends(get_store), +) -> dict: return await store.create_chat(user["id"], payload.title, payload.member_ids) @router.get("/api/v1/chats", response_model=ChatPageResponse) -async def list_chats(user: dict = Depends(get_current_user), store: PostgresStore = Depends(get_store), limit: int = Query(default=50, ge=1, le=100), cursor: str | None = Query(default=None, min_length=1)) -> ChatPageResponse: - after: tuple[datetime, UUID] | None = None +async def list_chats( + user: dict = Depends(get_current_user), + store: PostgresStore = Depends(get_store), + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = Query(default=None, min_length=1), +) -> ChatPageResponse: scope = "chats:" + str(user["id"]) - if cursor is not None: - try: - created_at, item_id = decode_cursor(cursor, scope) - after = created_at, UUID(item_id) - except (CursorError, ValueError) as error: - raise ApiError(400, "invalid_request", "Некорректный cursor") from error - rows = await store.list_chats_for_member(user["id"], after, limit) + rows = await store.list_chats_for_member(user["id"], cursor_position(cursor, scope), limit) page = rows[:limit] - next_cursor = encode_cursor(scope, page[-1]["created_at"], str(page[-1]["id"])) if len(rows) > limit else None - return ChatPageResponse(items=page, next_cursor=next_cursor) + return ChatPageResponse(items=page, next_cursor=next_page_cursor(rows, limit, scope)) @router.get("/api/v1/chats/{chat_id}", response_model=Chat) -async def get_chat(chat_id: UUID, user: dict = Depends(get_current_user), store: PostgresStore = Depends(get_store)) -> dict: +async def get_chat( + chat_id: UUID, + user: dict = Depends(get_current_user), + store: PostgresStore = Depends(get_store), +) -> dict: return await store.get_chat_for_member(chat_id, user["id"]) @router.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201) -async def create_message(chat_id: UUID, payload: CreateMessageRequest, user: dict = Depends(get_current_user), store: PostgresStore = Depends(get_store)) -> dict: - message, _version = await store.create_message(chat_id, user["id"], payload.text) - return message +async def create_message( + chat_id: UUID, + payload: CreateMessageRequest, + user: dict = Depends(get_current_user), + store: PostgresStore = Depends(get_store), +) -> dict: + return await store.create_message(chat_id, user["id"], payload.text) @router.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePageResponse) -async def list_messages(chat_id: UUID, user: dict = Depends(get_current_user), store: PostgresStore = Depends(get_store), cache: HistoryCache = Depends(get_history_cache), limit: int = Query(default=50, ge=1, le=100), cursor: str | None = Query(default=None, min_length=1)) -> MessagePageResponse: - after: tuple[datetime, UUID] | None = None +async def list_messages( + chat_id: UUID, + user: dict = Depends(get_current_user), + store: PostgresStore = Depends(get_store), + cache: HistoryCache = Depends(get_history_cache), + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = Query(default=None, min_length=1), +) -> MessagePageResponse: scope = "messages:" + str(chat_id) - if cursor is not None: - try: - created_at, item_id = decode_cursor(cursor, scope) - after = created_at, UUID(item_id) - except (CursorError, ValueError) as error: - raise ApiError(400, "invalid_request", "Некорректный cursor") from error + after = cursor_position(cursor, scope) if cursor is None: version = await store.history_version_for_member(chat_id, user["id"]) rows = await cache.get(chat_id, version, limit) if rows is None: - rows = await store.list_messages_for_member(chat_id, user["id"], after, limit) - await cache.set(chat_id, version, limit, rows) + lock_token = await cache.acquire_load_lock(chat_id, version, limit) + if lock_token == "": + rows = await cache.wait_for_fill(chat_id, version, limit) + if rows is None: + cache_logger.info( + "history_sql_page_load chat_id=%s version=%s limit=%s", + chat_id, + version, + limit, + ) + try: + rows = await store.list_messages_for_member(chat_id, user["id"], None, limit) + await cache.set(chat_id, version, limit, rows) + finally: + if lock_token: + await cache.release_load_lock(chat_id, version, limit, lock_token) else: rows = await store.list_messages_for_member(chat_id, user["id"], after, limit) page = rows[:limit] - next_cursor = encode_cursor(scope, page[-1]["created_at"], str(page[-1]["id"])) if len(rows) > limit else None - return MessagePageResponse(items=page, next_cursor=next_cursor) + return MessagePageResponse(items=page, next_cursor=next_page_cursor(rows, limit, scope)) diff --git a/src/storage/history_cache.py b/src/storage/history_cache.py index b3803f43..6e36c16f 100644 --- a/src/storage/history_cache.py +++ b/src/storage/history_cache.py @@ -1,4 +1,6 @@ import json +from asyncio import sleep +from secrets import token_urlsafe from uuid import UUID from redis.asyncio import Redis @@ -8,11 +10,12 @@ from redis.exceptions import RedisError class HistoryCache: """Кэш только первой страницы истории; PostgreSQL остаётся источником истины.""" - def __init__(self, url: str | None, ttl_seconds: int) -> None: + def __init__(self, url: str | None, ttl_seconds: int, stampede_protection: bool) -> None: self._url = url self._ttl_seconds = ttl_seconds self._client: Redis | None = None self._disabled = not bool(url) + self._stampede_protection = stampede_protection async def connect(self) -> None: if self._disabled: @@ -23,7 +26,7 @@ class HistoryCache: decode_responses=True, socket_connect_timeout=1, socket_timeout=1, - max_connections=10, + max_connections=50, ) await client.ping() self._client = client @@ -38,6 +41,10 @@ class HistoryCache: def _key(chat_id: UUID, version: int, limit: int) -> str: return f"history:first:{chat_id}:v{version}:l{limit}" + @classmethod + def _lock_key(cls, chat_id: UUID, version: int, limit: int) -> str: + return cls._key(chat_id, version, limit) + ":lock" + async def get(self, chat_id: UUID, version: int, limit: int) -> list[dict] | None: if self._disabled or self._client is None: return None @@ -58,3 +65,43 @@ class HistoryCache: ) except RedisError: self._disabled = True + + async def acquire_load_lock( + self, chat_id: UUID, version: int, limit: int + ) -> str | None: + if self._disabled or self._client is None or not self._stampede_protection: + return None + token = token_urlsafe(16) + try: + locked = await self._client.set( + self._lock_key(chat_id, version, limit), token, nx=True, ex=2 + ) + return token if locked else "" + except RedisError: + self._disabled = True + return None + + async def wait_for_fill( + self, chat_id: UUID, version: int, limit: int + ) -> list[dict] | None: + for _ in range(20): + await sleep(0.05) + cached = await self.get(chat_id, version, limit) + if cached is not None or self._disabled: + return cached + return None + + async def release_load_lock( + self, chat_id: UUID, version: int, limit: int, token: str + ) -> None: + if self._disabled or self._client is None: + return + try: + await self._client.eval( + "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) end return 0", + 1, + self._lock_key(chat_id, version, limit), + token, + ) + except RedisError: + self._disabled = True diff --git a/src/storage/postgres.py b/src/storage/postgres.py index 435c2f05..dc9ec47f 100644 --- a/src/storage/postgres.py +++ b/src/storage/postgres.py @@ -14,6 +14,7 @@ from ..errors import ApiError ROOT = Path(__file__).resolve().parents[2] MIGRATIONS = ROOT / "migrations" PASSWORD_HASHER = PasswordHasher() +DB_ERRORS = (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) class PostgresStore: @@ -26,7 +27,7 @@ class PostgresStore: self._pool = await asyncpg.create_pool( self._database_url, min_size=1, max_size=10, command_timeout=5 ) - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + except DB_ERRORS as error: raise RuntimeError("PostgreSQL is unavailable") from error async def close(self) -> None: @@ -87,7 +88,7 @@ class PostgresStore: async def ready(self) -> None: try: await self.pool.fetchval("SELECT 1") - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + except DB_ERRORS as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error async def create_user(self, username: str, display_name: str, password: str) -> dict: @@ -101,26 +102,17 @@ class PostgresStore: ) except asyncpg.UniqueViolationError as error: raise ApiError(409, "conflict", "Username уже занят") from error - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + except DB_ERRORS as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error return self._user(row) - async def get_user(self, user_id: UUID) -> dict | None: - try: - row = await self.pool.fetchrow( - "SELECT id, username, display_name, created_at FROM users WHERE id = $1", user_id - ) - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: - raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error - return self._user(row) if row else None - async def authenticate(self, username: str, password: str) -> dict | None: try: row = await self.pool.fetchrow( "SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = $1", username, ) - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + except DB_ERRORS as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error if row is None: return None @@ -140,7 +132,7 @@ class PostgresStore: user["id"], ttl_seconds, ) - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + except DB_ERRORS as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error return {"token": token, "token_type": "Bearer", "expires_at": row["expires_at"], "user": user} @@ -151,7 +143,7 @@ class PostgresStore: "SELECT u.id, u.username, u.display_name, u.created_at FROM sessions s JOIN users u ON u.id = s.user_id WHERE s.token_hash = $1 AND s.expires_at > now()", token_hash, ) - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + except DB_ERRORS as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error return self._user(row) if row else None @@ -160,7 +152,7 @@ class PostgresStore: await self.pool.execute( "DELETE FROM sessions WHERE token_hash = $1", sha256(token.encode("ascii")).hexdigest() ) - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + except DB_ERRORS as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error async def create_chat(self, creator_id: UUID, title: str, member_ids: list[UUID]) -> dict: @@ -182,7 +174,7 @@ class PostgresStore: "INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)", [(row["id"], member_id) for member_id in member_ids], ) - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + except DB_ERRORS as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error return { "id": row["id"], @@ -198,7 +190,7 @@ class PostgresStore: chat_id, user_id, ) - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + except DB_ERRORS as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error if row is None: raise ApiError(404, "not_found", "Чат не найден") @@ -216,7 +208,7 @@ class PostgresStore: args.append(limit + 1) try: rows = await self.pool.fetch(query, *args) - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + except DB_ERRORS as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error return [self._chat(row) for row in rows] @@ -237,13 +229,13 @@ class PostgresStore: sender_id, text, ) - version = await connection.fetchval( - "UPDATE chats SET history_version = history_version + 1 WHERE id = $1 RETURNING history_version", + await connection.execute( + "UPDATE chats SET history_version = history_version + 1 WHERE id = $1", chat_id, ) - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + except DB_ERRORS as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error - return self._message(row), version + return self._message(row) async def history_version_for_member(self, chat_id: UUID, user_id: UUID) -> int: try: @@ -252,7 +244,7 @@ class PostgresStore: chat_id, user_id, ) - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + except DB_ERRORS as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error if version is None: raise ApiError(404, "not_found", "Чат не найден") @@ -271,6 +263,6 @@ class PostgresStore: args.append(limit + 1) try: rows = await self.pool.fetch(query, *args) - except (asyncpg.PostgresError, asyncpg.InterfaceError, OSError) as error: + except DB_ERRORS as error: raise ApiError(503, "unavailable", "PostgreSQL недоступен") from error return [self._message(row) for row in rows] diff --git a/student-tests/cache_recovery.py b/student-tests/cache_recovery.py new file mode 100644 index 00000000..e5dbd86e --- /dev/null +++ b/student-tests/cache_recovery.py @@ -0,0 +1,30 @@ +#!/usr/bin/env python3 +"""Доказывает корректное чтение после restart Redis.""" +from pathlib import Path +import subprocess +import sys +import time + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests")) +from client import Client, check, run # noqa: E402 + + +ROOT = Path(__file__).resolve().parents[1] + + +def main() -> None: + client = Client() + alice, _bob, _eve, chat = client.bootstrap() + message = client.message(alice, chat, "survives Redis restart")["json"] + path = "/api/v1/chats/" + chat["id"] + "/messages?limit=100" + before = client.call("GET", path, actor=alice, schema="MessagePage")["json"] + check(before["items"] == [message], "initial cache fill failed") + subprocess.run(["docker", "compose", "restart", "redis"], cwd=ROOT, check=True) + time.sleep(1) + after = client.call("GET", path, actor=alice, schema="MessagePage")["json"] + check(after["items"] == [message], "history changed after Redis restart") + print("PASS: history remains correct after Redis restart") + + +if __name__ == "__main__": + run(main) diff --git a/student-tests/cache_stampede.py b/student-tests/cache_stampede.py new file mode 100644 index 00000000..c057be26 --- /dev/null +++ b/student-tests/cache_stampede.py @@ -0,0 +1,51 @@ +#!/usr/bin/env python3 +"""Одновременное чтение холодной первой страницы истории.""" +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path +import json +import sys +import threading +import time + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests")) +from client import Client, check, run # noqa: E402 + + +def main() -> None: + concurrency = 20 + client = Client() + alice, _bob, _eve, chat = client.bootstrap() + created = client.message(alice, chat, "cold-cache message")["json"] + path = "/api/v1/chats/" + chat["id"] + "/messages?limit=1" + barrier = threading.Barrier(concurrency) + + def read_page(_worker: int) -> float: + local = Client() + barrier.wait() + started = time.monotonic() + response = local.call("GET", path, actor=alice, schema="MessagePage")["json"] + check(response["items"] == [created], "cold-page response differs") + return time.monotonic() - started + + with ThreadPoolExecutor(max_workers=concurrency) as pool: + latencies = list(pool.map(read_page, range(concurrency))) + ordered = sorted(latencies) + print( + json.dumps( + { + "chat_id": chat["id"], + "concurrency": concurrency, + "successful_reads": len(latencies), + "latency_ms": { + "p50": round(1000 * ordered[(concurrency - 1) // 2], 3), + "p95": round(1000 * ordered[18], 3), + "max": round(1000 * ordered[-1], 3), + }, + }, + ensure_ascii=False, + ) + ) + + +if __name__ == "__main__": + run(main) -- 2.54.0 From 7cda43308574ae05d42ea16c4e71f699c9627c11 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9?= Date: Fri, 9 Oct 2026 20:38:43 +0300 Subject: [PATCH 5/6] restore Redis cache after outage --- REPORT.md | 13 ++-- evidence/redis-recovery-2026-10-09.txt | 1 + src/storage/history_cache.py | 98 +++++++++++++++++--------- student-tests/cache_recovery.py | 47 ++++++++++-- 4 files changed, 119 insertions(+), 40 deletions(-) create mode 100644 evidence/redis-recovery-2026-10-09.txt diff --git a/REPORT.md b/REPORT.md index 901791a9..8673f3df 100644 --- a/REPORT.md +++ b/REPORT.md @@ -86,7 +86,9 @@ Redis кэширует только первую страницу истории `limit` и `history_version` из PostgreSQL. В той же транзакции, что и вставка сообщения, PostgreSQL увеличивает `history_version`; старый ключ поэтому больше не читается. Redis не источник истины: при его отказе кэш -отключается в процессе API, а чтение продолжает PostgreSQL. Redis использует +временно обходится, а чтение продолжает PostgreSQL. API повторно проверяет +Redis не чаще одного раза в секунду; после успешного `PING` заново создаёт +клиент, и кэш с Redis-lock снова используются без restart API. Redis использует AOF и named volume `redis_data`. ## Доказательства критериев @@ -103,7 +105,7 @@ AOF и named volume `redis_data`. | TTL и зависимости | `make test-grade4`; TTL=2 | Expired session → 401; Redis fallback проходит smoke; DB readiness → 503 | `evidence/grade4-checks-2026-10-08.txt` | | Индекс истории | `./scripts/explain_history.sh` | Index Scan, 50 строк, shared hit=3 | `evidence/explain-history-2026-10-08.txt` | | Трек 5: stampede | `student-tests/cache_stampede.py` | 20 SQL-загрузок → 1 при 20 читателях | `evidence/track1-cache-stampede-2026-10-08.txt` | -| Трек 5: restart cache | `student-tests/cache_recovery.py` | История не изменилась после restart Redis | `evidence/track1-cache-stampede-2026-10-08.txt` | +| Трек 5: отказ и восстановление cache | `student-tests/cache_recovery.py` | PostgreSQL fallback, затем кэш и lock восстановлены без restart API | `evidence/redis-recovery-2026-10-09.txt` | ## Трек 5 — согласованность кэша @@ -132,8 +134,11 @@ API с `CACHE_STAMPEDE_PROTECTION=false`; затем тот же сценари read-after-write проверяет `student-tests/lab4_checks.py`: страница сначала кэшируется, затем создаётся сообщение, и следующий GET содержит оба сообщения. -`student-tests/cache_recovery.py` заполняет кэш, перезапускает Redis и -проверяет неизменность ответа. Raw results и команды сохранены в evidence. +`student-tests/cache_recovery.py` сначала останавливает Redis и подтверждает +корректный PostgreSQL fallback. Затем Redis запускается обратно без restart API: +тест проверяет создание нового ключа кэша и ровно одну SQL-загрузку для 20 +одновременных запросов новой версии истории. Raw results и команды сохранены в +evidence. ## Ограничения и следующие шаги diff --git a/evidence/redis-recovery-2026-10-09.txt b/evidence/redis-recovery-2026-10-09.txt new file mode 100644 index 00000000..1d29fb20 --- /dev/null +++ b/evidence/redis-recovery-2026-10-09.txt @@ -0,0 +1 @@ +PASS: Redis cache and stampede lock recover without API restart diff --git a/src/storage/history_cache.py b/src/storage/history_cache.py index 6e36c16f..616444f0 100644 --- a/src/storage/history_cache.py +++ b/src/storage/history_cache.py @@ -1,5 +1,6 @@ import json -from asyncio import sleep +from asyncio import Lock, sleep +from time import monotonic from secrets import token_urlsafe from uuid import UUID @@ -14,28 +15,55 @@ class HistoryCache: self._url = url self._ttl_seconds = ttl_seconds self._client: Redis | None = None - self._disabled = not bool(url) + self._reconnect_lock = Lock() + self._next_reconnect_at = 0.0 self._stampede_protection = stampede_protection async def connect(self) -> None: - if self._disabled: - return - try: - client = Redis.from_url( - self._url, - decode_responses=True, - socket_connect_timeout=1, - socket_timeout=1, - max_connections=50, - ) - await client.ping() - self._client = client - except RedisError: - self._disabled = True + await self._client_or_none() + + async def _client_or_none(self) -> Redis | None: + """Возвращает рабочий клиент или временно обходит кэш при отказе Redis.""" + if not self._url: + return None + if self._client is not None: + return self._client + if monotonic() < self._next_reconnect_at: + return None + + async with self._reconnect_lock: + if self._client is not None: + return self._client + if monotonic() < self._next_reconnect_at: + return None + try: + client = Redis.from_url( + self._url, + decode_responses=True, + socket_connect_timeout=1, + socket_timeout=1, + max_connections=50, + ) + await client.ping() + self._client = client + return client + except RedisError: + self._next_reconnect_at = monotonic() + 1 + return None + + async def _mark_unavailable(self, client: Redis) -> None: + """Отбрасывает сломанное соединение и разрешает повторное подключение.""" + async with self._reconnect_lock: + if self._client is client: + self._client = None + self._next_reconnect_at = monotonic() + 1 + await client.aclose() async def close(self) -> None: - if self._client is not None: - await self._client.aclose() + if self._client is None: + return + await self._client.aclose() + self._client = None @staticmethod def _key(chat_id: UUID, version: int, limit: int) -> str: @@ -46,39 +74,44 @@ class HistoryCache: return cls._key(chat_id, version, limit) + ":lock" async def get(self, chat_id: UUID, version: int, limit: int) -> list[dict] | None: - if self._disabled or self._client is None: + client = await self._client_or_none() + if client is None: return None try: - value = await self._client.get(self._key(chat_id, version, limit)) + value = await client.get(self._key(chat_id, version, limit)) return json.loads(value) if value else None - except (RedisError, ValueError, TypeError): - self._disabled = True + except RedisError: + await self._mark_unavailable(client) + return None + except (ValueError, TypeError): return None async def set(self, chat_id: UUID, version: int, limit: int, items: list[dict]) -> None: - if self._disabled or self._client is None: + client = await self._client_or_none() + if client is None: return try: encoded = json.dumps(items, default=str, separators=(",", ":")) - await self._client.set( + await client.set( self._key(chat_id, version, limit), encoded, ex=self._ttl_seconds ) except RedisError: - self._disabled = True + await self._mark_unavailable(client) async def acquire_load_lock( self, chat_id: UUID, version: int, limit: int ) -> str | None: - if self._disabled or self._client is None or not self._stampede_protection: + client = await self._client_or_none() + if client is None or not self._stampede_protection: return None token = token_urlsafe(16) try: - locked = await self._client.set( + locked = await client.set( self._lock_key(chat_id, version, limit), token, nx=True, ex=2 ) return token if locked else "" except RedisError: - self._disabled = True + await self._mark_unavailable(client) return None async def wait_for_fill( @@ -87,21 +120,22 @@ class HistoryCache: for _ in range(20): await sleep(0.05) cached = await self.get(chat_id, version, limit) - if cached is not None or self._disabled: + if cached is not None or self._client is None: return cached return None async def release_load_lock( self, chat_id: UUID, version: int, limit: int, token: str ) -> None: - if self._disabled or self._client is None: + client = await self._client_or_none() + if client is None: return try: - await self._client.eval( + await client.eval( "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) end return 0", 1, self._lock_key(chat_id, version, limit), token, ) except RedisError: - self._disabled = True + await self._mark_unavailable(client) diff --git a/student-tests/cache_recovery.py b/student-tests/cache_recovery.py index e5dbd86e..7571d5e0 100644 --- a/student-tests/cache_recovery.py +++ b/student-tests/cache_recovery.py @@ -1,8 +1,11 @@ #!/usr/bin/env python3 -"""Доказывает корректное чтение после restart Redis.""" +"""Проверяет fallback и восстановление Redis-кэша без restart API.""" +from concurrent.futures import ThreadPoolExecutor +from datetime import datetime, timezone from pathlib import Path import subprocess import sys +import threading import time sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests")) @@ -19,11 +22,47 @@ def main() -> None: path = "/api/v1/chats/" + chat["id"] + "/messages?limit=100" before = client.call("GET", path, actor=alice, schema="MessagePage")["json"] check(before["items"] == [message], "initial cache fill failed") - subprocess.run(["docker", "compose", "restart", "redis"], cwd=ROOT, check=True) - time.sleep(1) + + subprocess.run(["docker", "compose", "stop", "redis"], cwd=ROOT, check=True) + fallback = client.call("GET", path, actor=alice, schema="MessagePage")["json"] + check(fallback["items"] == [message], "PostgreSQL fallback returned a different history") + + subprocess.run(["docker", "compose", "start", "redis"], cwd=ROOT, check=True) + time.sleep(1.1) # Интервал повторного подключения к Redis в приложении. after = client.call("GET", path, actor=alice, schema="MessagePage")["json"] check(after["items"] == [message], "history changed after Redis restart") - print("PASS: history remains correct after Redis restart") + + keys = subprocess.check_output( + [ + "docker", "compose", "exec", "-T", "redis", "redis-cli", "--scan", + "--pattern", "history:first:" + chat["id"] + ":*", + ], + cwd=ROOT, + text=True, + ) + check("history:first:" + chat["id"] in keys, "cache was not restored after Redis restart") + + second = client.message(alice, chat, "cold page after Redis recovery")["json"] + started_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") + workers = 20 + barrier = threading.Barrier(workers) + + def read_cold_page(_worker: int) -> None: + barrier.wait() + response = Client().call("GET", path, actor=alice, schema="MessagePage")["json"] + check(response["items"] == [message, second], "concurrent history differs") + + with ThreadPoolExecutor(max_workers=workers) as pool: + list(pool.map(read_cold_page, range(workers))) + + logs = subprocess.check_output( + ["docker", "compose", "logs", "--since", started_at, "api"], + cwd=ROOT, + text=True, + ) + marker = "history_sql_page_load chat_id=" + chat["id"] + " version=2 limit=100" + check(logs.count(marker) == 1, "Redis lock was not restored after Redis restart") + print("PASS: Redis cache and stampede lock recover without API restart") if __name__ == "__main__": -- 2.54.0 From b538b2db396f439f4436fc37a4dbfa7d172e2461 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9?= Date: Fri, 9 Oct 2026 21:06:31 +0300 Subject: [PATCH 6/6] fix cached history pagination and setup docs --- REPORT.md | 9 +++++---- evidence/cache-pagination-2026-10-09.txt | 1 + src/storage/history_cache.py | 12 +++++++++++- student-tests/lab4_checks.py | 16 ++++++++++++++++ 4 files changed, 33 insertions(+), 5 deletions(-) create mode 100644 evidence/cache-pagination-2026-10-09.txt diff --git a/REPORT.md b/REPORT.md index 8673f3df..3f208451 100644 --- a/REPORT.md +++ b/REPORT.md @@ -2,7 +2,7 @@ - Автор, группа: Козырев Матвей БВТ2301 - Целевая оценка: 5; трек 1 — согласованность кэша -- Commit/PR: TODO после публикации +- PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/22 - Использованные библиотеки: FastAPI 0.141.1, Uvicorn 0.40.0, asyncpg 0.31.0, argon2-cffi 25.1.0, redis 5.0.8; зафиксированы в `pyproject.toml` и `uv.lock`. ## Запуск из чистого clone @@ -13,10 +13,11 @@ ```sh mkdir -p secrets openssl rand -hex 32 -out secrets/postgres_password -awk '{printf "postgresql://messenger:%s@postgres:5432/messenger\\n", $0}' \ +awk '{printf "postgresql://messenger:%s@postgres:5432/messenger\n", $0}' \ secrets/postgres_password > secrets/database_url +printf '%s\n' 'redis://redis:6379/0' > secrets/cache_url chmod 700 secrets -chmod 600 secrets/postgres_password secrets/database_url +chmod 600 secrets/postgres_password secrets/database_url secrets/cache_url docker compose --env-file .env.example config --quiet docker compose --env-file .env.example up -d --build ``` @@ -100,7 +101,7 @@ AOF и named volume `redis_data`. | Согласованность lock-файла | `uv lock --check` | PASS | выполнено | | Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/smoke-2026-10-08.txt` | | Persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` | `evidence/persistence-2026-10-08.txt` | -| Redis cache | `make test-grade4`; `redis-cli --scan` | read-after-write без stale read; создан ключ `history:first:…` | `evidence/redis-cache-2026-10-08.txt` | +| Redis cache и курсор | `make test-grade4`; `redis-cli --scan` | read-after-write без stale read; повторный GET кэшированной страницы и её continuation возвращают 200 | `evidence/cache-pagination-2026-10-09.txt` | | Гонка и rollback | `make test-grade4` | Ровно одна регистрация успешна; неуспешный чат не виден | `evidence/grade4-checks-2026-10-08.txt` | | TTL и зависимости | `make test-grade4`; TTL=2 | Expired session → 401; Redis fallback проходит smoke; DB readiness → 503 | `evidence/grade4-checks-2026-10-08.txt` | | Индекс истории | `./scripts/explain_history.sh` | Index Scan, 50 строк, shared hit=3 | `evidence/explain-history-2026-10-08.txt` | diff --git a/evidence/cache-pagination-2026-10-09.txt b/evidence/cache-pagination-2026-10-09.txt new file mode 100644 index 00000000..32957fb7 --- /dev/null +++ b/evidence/cache-pagination-2026-10-09.txt @@ -0,0 +1 @@ +PASS: registration race, chat rollback and cache read-after-write diff --git a/src/storage/history_cache.py b/src/storage/history_cache.py index 616444f0..de4f88fa 100644 --- a/src/storage/history_cache.py +++ b/src/storage/history_cache.py @@ -1,5 +1,6 @@ import json from asyncio import Lock, sleep +from datetime import UTC, datetime from time import monotonic from secrets import token_urlsafe from uuid import UUID @@ -73,13 +74,22 @@ class HistoryCache: def _lock_key(cls, chat_id: UUID, version: int, limit: int) -> str: return cls._key(chat_id, version, limit) + ":lock" + @staticmethod + def _decode_rows(value: str) -> list[dict]: + rows = json.loads(value) + for row in rows: + created_at = row.get("created_at") + if isinstance(created_at, str): + row["created_at"] = datetime.fromisoformat(created_at).astimezone(UTC) + return rows + async def get(self, chat_id: UUID, version: int, limit: int) -> list[dict] | None: client = await self._client_or_none() if client is None: return None try: value = await client.get(self._key(chat_id, version, limit)) - return json.loads(value) if value else None + return self._decode_rows(value) if value else None except RedisError: await self._mark_unavailable(client) return None diff --git a/student-tests/lab4_checks.py b/student-tests/lab4_checks.py index 0df37ed8..cf429a88 100644 --- a/student-tests/lab4_checks.py +++ b/student-tests/lab4_checks.py @@ -59,6 +59,22 @@ def main() -> None: {message["id"] for message in history} == {first["id"], second["id"]}, "history cache returned stale data after write", ) + + first_page_path = "/api/v1/chats/" + chat["id"] + "/messages?limit=1" + first_page = client.call( + "GET", first_page_path, actor=alice, schema="MessagePage" + )["json"] + cached_page = client.call( + "GET", first_page_path, actor=alice, schema="MessagePage" + )["json"] + check(first_page == cached_page, "cached page differs from the first response") + check(first_page["next_cursor"], "first page has no continuation cursor") + client.call( + "GET", + first_page_path + "&cursor=" + first_page["next_cursor"], + actor=alice, + schema="MessagePage", + ) print("PASS: registration race, chat rollback and cache read-after-write") -- 2.54.0