Поправка по кэшу: по интервалу снова сверяем modified, всегда качает только кнопка

Как и просили: фоновое обновление по интервалу сначала смотрит на дату изменения файла и, если таблица не менялась, не скачивает её. Всегда перечитывать таблицу — только принудительное обновление из админки (force_reload, кнопка «Обновить сейчас»). Тесты: по интервалу — без скачивания при неизменном modified; кнопка — скачивает независимо от modified (test_force_refresh_ignores_ttl_and_modified).
Группы: ТОП-имена и порядок как в таблице
2026-10-06 15:01:07 +03:00 · 2026-09-30 09:42:27 +03:00 · 2026-09-29 15:32:47 +03:00 · 2026-09-29 15:27:01 +03:00 · 2026-09-29 13:50:17 +03:00 · 2026-09-28 13:56:32 +03:00
23 changed files with 560 additions and 1506 deletions
--- a/.env.example
+++ b/.env.example
@@ -1,30 +1,25 @@
-# --- расписание --------------------------------------------------------------
-# Публичная ссылка на Яндекс.Диск с таблицей расписания (обязательна)
+# --- расписание -------------------------------------------------------------
+# Публичная ссылка на Яндекс.Диск (обязательна)
 SCHEDULE_LINK=
-
-# Как часто перечитывать таблицу, минут
+# Интервал обновления в минутах (переживает перезапуск: правится в админке)
 SCHEDULE_INTERVAL_MINUTES=15
-# Устаревшее: интервал в секундах (используется, только если не задан предыдущий)
-SCHEDULE_CACHE_TTL=900
-# Пауза между повторными попытками, если источник недоступен, секунд
+# Пауза между повторными попытками при сбое источника, секунд
 SCHEDULE_RETRY_AFTER=60
+# Устаревшее: интервал в секундах (используется, только если не задан SCHEDULE_INTERVAL_MINUTES)
+SCHEDULE_CACHE_TTL=900

-# --- порты (только для docker) -------------------------------------------------
-# Оба порта публикуются на 127.0.0.1 (жёстко задано в docker-compose.yml):
-# снаружи сервисы отдаёт nginx, напрямую в интернет они не смотрят.
-API_PORT=8000
-FRONTEND_PORT=8080
-
-# --- админка (необязательно) ----------------------------------------------------
-# Пока эти переменные пустые, админка выключена и наружу ничего не торчит.
-# Секретный путь страницы админки: придумайте длинный, например /panel-8f3a91x7
+# --- админка (пусто = выключена) ---------------------------------------------
+# Секретный путь страницы админки, например /manage-7f3a91
 ADMIN_PATH=
 # Логин и пароль администратора
 ADMIN_LOGIN=
 ADMIN_PASSWORD=
-# Сколько неудачных попыток входа допускается и на сколько минут блокировать после них
-ADMIN_MAX_ATTEMPTS=3
-ADMIN_LOCKOUT_MINUTES=15
-# Где хранить настройки админки (ссылка, интервал, история входов).
-# Пусто = data/settings.json в корне проекта; в docker задаётся автоматически.
+# Где хранить настройки (ссылка/интервал).
+# В docker по умолчанию /data/settings.json (том schedule_data);
+# локально можно оставить пустым — тогда настройки живут в памяти.
 SETTINGS_FILE=
+
+# --- порты и адреса ----------------------------------------------------------
+API_PORT=8000
+FRONTEND_PORT=8080
+SCHEDULE_API=http://api:8000
--- a/.gitignore
+++ b/.gitignore
@@ -6,9 +6,3 @@ __pycache__/
 /.idea/
 **/*.env
 .env
-
-# локальные данные инструментов
-.kilo/
-
-# состояние админки (ссылка, интервал, история входов)
-/data/
--- a/68
+++ b/68
@@ -1,68 +1,32 @@
-PY := $(CURDIR)/.venv/bin/python
-PIP := $(CURDIR)/.venv/bin/pip
+.PHONY: build up down logs restart deploy ps dev test

-.PHONY: help venv run dev run-api run-front test build up down restart logs ps deploy nginx-print nginx-install
-
-help:  ## Показать этот список команд
-	@grep -hE '^[a-zA-Z_-]+:.*?## ' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-10s\033[0m %s\n", $$1, $$2}'
-
-# --- локальный запуск (без Docker) -------------------------------------------
-
-venv:  ## Создать .venv и установить зависимости
-	@test -x $(PY) || python3 -m venv .venv
-	@test -x $(PIP) || { echo "Не удалось создать .venv — см. README, раздел «Если установка не идёт» (на Debian/Ubuntu нужен пакет python3-venv)"; exit 1; }
-	@$(PIP) install -q --upgrade pip
-	@$(PIP) install -q -r requirements-dev.txt
-	@echo "Зависимости готовы (.venv). Дальше: make run"
-
-run: venv  ## Запустить API и сайт локально, без Docker
-	@echo "API:  http://127.0.0.1:8000/status"
-	@echo "Сайт: http://127.0.0.1:8080  (открыть в браузере)"
-	@echo "Остановить: Ctrl+C"
-	@trap 'kill 0' EXIT; \
-	  (cd src/backend && $(PY) -m uvicorn main:app --reload --port 8000) & \
-	  (cd src/frontend && $(PY) -m uvicorn main:app --reload --port 8080) & \
-	  wait
-
-dev: run  ## То же, что run
-
-run-api: venv  ## Запустить только API (http://127.0.0.1:8000)
-	cd src/backend && $(PY) -m uvicorn main:app --reload --port 8000
-
-run-front: venv  ## Запустить только сайт (http://127.0.0.1:8080)
-	cd src/frontend && $(PY) -m uvicorn main:app --reload --port 8080
-
-test: venv  ## Прогнать тесты
-	$(PY) -m pytest tests -q
-
-# --- Docker (продакшен) ------------------------------------------------------
-
-build:  ## Собрать образы
+build: ## Собрать образы микросервисов
 	docker compose build

-up:  ## Запустить сервисы в фоне
+up: ## Запустить все микросервисы одной командой
 	docker compose up -d

-down:  ## Остановить и удалить контейнеры
+down: ## Остановить и удалить контейнеры
 	docker compose down

-restart:  ## Перезапустить сервисы
+restart: ## Перезапустить микросервисы
 	docker compose restart

-logs:  ## Логи сервисов (Ctrl+C для выхода)
+logs: ## Логи всех микросервисов
 	docker compose logs -f

-ps:  ## Статус сервисов
+ps: ## Статус микросервисов
 	docker compose ps

-deploy:  ## Собрать и запустить (docker)
+deploy: ## Собрать и запустить (деплой на сервере)
 	./deploy.sh

-# --- nginx (на сервере) ------------------------------------------------------
+test: ## Прогнать тесты (локальный venv)
+	$(CURDIR)/.venv/bin/python -m pytest tests -q

-# DOMAIN=sched.example.ru make nginx-print / nginx-install
-nginx-print:  ## Показать конфиг nginx (DOMAIN=домен), ничего не меняя
-	deploy/nginx-site.sh --print --domain $(DOMAIN)
-
-nginx-install:  ## Сгенерировать, включить и перечитать конфиг nginx (DOMAIN=домен, с sudo)
-	sudo deploy/nginx-site.sh --domain $(DOMAIN)
+dev: ## Запустить локально без Docker (бэкенд + фронт)
+	@echo "Запуск бэкенда на :8000 и фронта на :8080..."
+	@trap 'kill 0' EXIT; \
+	cd src/backend && $(CURDIR)/.venv/bin/python -m uvicorn main:app --reload --port 8000 & \
+	cd src/frontend && $(CURDIR)/.venv/bin/python -m uvicorn main:app --reload --port 8080 & \
+	wait
--- a/README.md
+++ b/README.md
@@ -1,19 +1,8 @@
 # Расписание

-Публичное расписание учебных групп. Источник данных — Яндекс.Таблица (xlsx на
-Яндекс.Диске): файл скачивается по публичной ссылке, разбирается без сторонних
-библиотек и отдаётся как JSON API и как сайт, который можно «установить» на
-главный экран телефона (PWA).
-
-Умеет:
-
- расписание по группам, преподавателям и аудиториям с разделением
-  числитель/знаменатель и бейджем текущей недели;
- занятость всех аудиторий по дням и поиск свободных на конкретную пару;
- совпадающие недели показываются одним списком, различающиеся — двумя
-  колонками, пустая — «Окно»;
- примечания из таблицы (красный текст) — отдельной строкой в карточке;
- PWA: манифест, service worker, иконки — «на главный экран».
+Публичное расписание учебных групп факультета: источник данных — Яндекс.Таблица
+университета (файл xlsx), который скачивается, разбирается, превращается в JSON
+API и отображается на фронте. Деплой: `schedule.our-place.ru`.

 ## Архитектура

@@ -21,372 +10,20 @@
 Яндекс.Диск (xlsx)
      │  скачивание по публичной ссылке
      ▼
-api — FastAPI, порт 8000
-  • качает и разбирает xlsx стандартной библиотекой (zipfile + xml.etree)
+api (FastAPI), порт 8000, доступ только с localhost
+  • скачивает и разбирает xlsx без сторонних библиотек
  • кэш в памяти: TTL + проверка даты изменения файла + stale-while-error
  • один воркер, поэтому кэш общий
-      ▲  SCHEDULE_API=http://api:8000 (внутри docker-сети)
-      │
-frontend — FastAPI, порт из .env (по умолчанию 8080)
-  • отдаёт index.html / app.js / style.css / иконки
+      ▲  SCHEDULE_API=http://api:8000  (внутри docker-сети)
+      │  SCHEDULE_API=http://127.0.0.1:8000  (локальная разработка)
+frontend (FastAPI: статика + прокси), прод :8090, dev :8080
+  • отдаёт index.html / app.js / style.css / картинки
  • /api/* — тонкий прокси к api (браузер не знает адрес бэкенда)
      ▲
-nginx — порты 80/443, https://<домен сайта> → 127.0.0.1:<порт фронта>
+nginx (https://schedule.our-place.ru) → 127.0.0.1:8090
 ```

-Роли:
-
- **docker** изолирует оба сервиса, перезапускает их при падении
-  (`restart: unless-stopped`) и следит за здоровьем (healthcheck на
-  `/healthz`); frontend стартует, только когда api стал healthy.
- Оба порта публикуются **только на 127.0.0.1** (жёстко задано в
-  `docker-compose.yml`): из интернета контейнеры напрямую недоступны.
- **nginx** — единственная дверь из интернета: принимает https и проксирует на
-  фронт. Его конфиг генерирует `deploy/nginx-site.sh` (это делает установщик).
-
-## Установка на сервер
-
-Скачайте zip с проектом, распакуйте и запустите одну команду:
-
-```bash
-unzip schedule.zip && cd schedule
-bash install.sh
-```
-
-Установка требует root — скрипт сам перезапустится через sudo. До запуска DNS
-домена уже должен указывать на сервер, а порты 80/443 — быть открытыми:
-сертификат Let's Encrypt выпускается прямо в процессе установки.
-
-Скрипт спросит:
-
-| Вопрос | Что ответить |
-|---|---|
-| Как ставить: Docker или систему | Docker — рекомендуется (разница ниже) |
-| Публичная ссылка на таблицу | ссылка Я.Диска, единственная обязательная настройка |
-| Домен сайта | например `sched.example.ru`; пусто = без nginx, сайт на 127.0.0.1 |
-| Порт api и порт сайта | по умолчанию 8000 и 8080 |
-| Пользователь служб (только для «в систему») | от кого работают сервисы |
-| Почта (только если задан домен) | для уведомлений Let's Encrypt |
-
-Ответы можно передать и флагами: `--mode`, `--link`, `--domain`, `--api-port`,
-`--front-port`, `--user`, `--email`. `install.sh --dry-run` показывает план
-установки, ничего не меняя.
-
-### Docker или система — что выбрать
-
-**Docker** — рекомендуется: сервисы изолированы, автоматически перезапускаются,
-обновляются одной командой, не зависят от Python в системе. Установщик поставит
-Docker (если нет), запишет `.env`, соберёт образы, запустит контейнеры и
-дождётся их готовности.
-
-**Система (без Docker)** — если Docker не нужен: установщик проверит Python
-3.11+, создаст `.venv`, поставит зависимости и зарегистрирует две службы
-systemd — `schedule-api` и `schedule-frontend` (автозапуск после ребута,
-перезапуск при падении).
-
-В обоих случаях, если домен задан, установщик дополнительно поставит nginx и
-certbot, выпустит сертификат Let's Encrypt (webroot — продление автоматическое,
-сайт не останавливается) и настроит конфиг: http → https, прокси на порт
-фронта. Снаружи виден только nginx.
-
-### Ручная установка (без скрипта)
-
-Установщик делает ровно следующее — при желании те же шаги выполняются руками.
-
-**Docker:**
-
-```bash
-cp .env.example .env && nano .env            # SCHEDULE_LINK (+ порты при желании)
-sudo ./deploy.sh                             # собрать и запустить
-curl -s http://127.0.0.1:8080/api/status     # {"has_data":true} — работает
-```
-
-**Система:**
-
-```bash
-sudo apt install -y python3 python3-venv python3-pip   # Python 3.11+
-python3 -m venv .venv
-.venv/bin/pip install -r requirements.txt
-cp .env.example .env && nano .env            # SCHEDULE_LINK
-```
-
-Две службы systemd (`/etc/systemd/system/`), затем
-`sudo systemctl daemon-reload && sudo systemctl enable --now schedule-api schedule-frontend`:
-
-```ini
-# schedule-api.service
-[Unit]
-Description=Schedule API (FastAPI)
-After=network-online.target
-Wants=network-online.target
-[Service]
-User=www-data
-WorkingDirectory=/путь/к/проекту/src/backend
-ExecStart=/путь/к/проекту/.venv/bin/python -m uvicorn main:app --host 127.0.0.1 --port 8000
-Restart=always
-RestartSec=3
-[Install]
-WantedBy=multi-user.target
-
-# schedule-frontend.service
-[Unit]
-Description=Schedule frontend (FastAPI)
-After=network-online.target schedule-api.service
-Wants=network-online.target schedule-api.service
-[Service]
-User=www-data
-WorkingDirectory=/путь/к/проекту/src/frontend
-Environment=SCHEDULE_API=http://127.0.0.1:8000
-ExecStart=/путь/к/проекту/.venv/bin/python -m uvicorn main:app --host 127.0.0.1 --port 8080
-Restart=always
-RestartSec=3
-[Install]
-WantedBy=multi-user.target
-```
-
-**nginx + сертификат** (общий шаг для обоих способов; `.env` уже должен быть):
-
-```bash
-sudo apt install -y nginx certbot
-# временный http-конфиг домена с location /.well-known/acme-challenge/ → /var/www/html
-sudo certbot certonly --webroot -w /var/www/html -d sched.example.ru
-sudo deploy/nginx-site.sh --domain sched.example.ru --cert sched.example.ru --port 8080
-curl -sI https://sched.example.ru/ | head -3   # HTTP/2 200 — готово
-```
-
-`deploy/nginx-site.sh` генерирует финальный конфиг (http → https, прокси на
-`FRONTEND_PORT` из `.env`, таймауты под холодный кэш), включает его, проверяет
-`nginx -t` и перечитывает nginx. Посмотреть конфиг, ничего не меняя:
-`deploy/nginx-site.sh --print --domain sched.example.ru`.
-
-### Обслуживание
-
- **Обновление**: Docker — `cd <каталог проекта> && sudo ./deploy.sh`;
-  система — заменить файлы проекта и
-  `sudo systemctl restart schedule-api schedule-frontend`.
- **Диагностика**: Docker — `sudo docker compose ps` и
-  `sudo docker logs api --tail 50`; система — `systemctl status schedule-api`
-  и `journalctl -u schedule-api -u schedule-frontend`. Состояние кэша —
-  `/api/status` (смотреть поле `error`).
- **Ротация логов контейнеров** — настроить сразу: без лимита логи растут
-  вечно и однажды забивают диск. `/etc/docker/daemon.json`:
-
-  ```json
-  { "log-driver": "json-file", "log-opts": { "max-size": "10m", "max-file": "3" } }
-  ```
-
-  затем `sudo systemctl restart docker`.
- **Диск**: следить `df -h /`; раз в месяц
-  `sudo docker system prune -af && sudo journalctl --vacuum-size=200M`.
-
-## Локальная разработка
-
-Нужны Python 3.11+ и bash (Linux, macOS или WSL; на Windows без WSL — Docker).
-
-```bash
-python3 --version        # должен быть 3.11 или новее
-cp .env.example .env     # вписать SCHEDULE_LINK
-make run                 # создаст .venv, поставит зависимости, поднимет оба сервиса
-```
-
-Открыть <http://127.0.0.1:8080> (API — <http://127.0.0.1:8000>). Остановить —
-`Ctrl+C`; отвязать от терминала — `nohup make run &`.
-
-Данные скачиваются сразу на старте (несколько секунд) и дальше обновляются по
-интервалу.
-
-Полезные команды (`make help` — весь список):
-
-| Команда | Что делает |
-|---|---|
-| `make venv` | создать `.venv` и установить зависимости |
-| `make run` (или `make dev`) | запустить API и сайт |
-| `make run-api` / `make run-front` | запустить только один из сервисов |
-| `make test` | прогнать тесты |
-| `make nginx-print` / `make nginx-install` | показать / установить конфиг nginx |
-
-Без make — то же самое руками:
-
-```bash
-python3 -m venv .venv
-.venv/bin/pip install -r requirements-dev.txt
-.venv/bin/python -m uvicorn main:app --reload --port 8000   # в каталоге src/backend
-.venv/bin/python -m uvicorn main:app --reload --port 8080   # в каталоге src/frontend
-```
-
-### Тесты
-
-```bash
-make test                # 121 тест, сеть не нужна
-```
-
-## Зависимости
-
-**Системные требования**
-
-| Что | Зачем |
-|---|---|
-| Python 3.11+ | локальная разработка и режим «в систему» |
-| Docker + docker compose v2 | режим Docker (опционально) |
-
-**Python-пакеты** — закреплены в `requirements.txt` (рабочие) и
-`requirements-dev.txt` (тесты):
-
-| Пакет | Версия | Назначение |
-|---|---|---|
-| fastapi | 0.141.1 | веб-фреймворк обоих сервисов |
-| uvicorn | 0.52.4 | ASGI-сервер, которым запускаются сервисы |
-| python-dotenv | 1.2.3 | чтение `.env` |
-| requests | 2.34.2 | скачивание файла с Я.Диска и прокси к API |
-| pytest | 9.1.1 | тесты — только dev |
-| httpx2 | 2.12.0 | HTTP-клиент (наследник httpx) для `TestClient` — только dev |
-
-Больше ничего не нужно: xlsx разбирается стандартной библиотекой, базы данных
-нет, кэш — в памяти процесса. httpx2 в рабочем коде не используется и нужен
-только тестам; модуль импортируется как `httpx2` — httpx перешёл под опеку
-Pydantic и был переименован в августе 2026, `import httpx` больше не работает.
-
-### Если установка не идёт
-
- Проверьте `python3 --version`: нужен 3.11 или новее. Если под `python3`
-  скрывается старая версия, создайте окружение нужной явно:
-  `python3.12 -m venv .venv`.
- Debian/Ubuntu: если `make venv` падает на создании окружения, доставьте
-  пакет venv: `sudo apt install python3-venv` (для нестандартной версии —
-  например, `python3.12-venv`).
-
-### Если pip не находит пакеты: зеркала
-
-Если pip настроен на корпоративное/национальное зеркало, оно может отставать
-от PyPI — свежих пакетов там ещё нет. Диагностика и обход:
-
-```bash
-pip index versions httpx2                          # есть ли пакет на текущем индексе
-pip install -r requirements-dev.txt -i <зеркало>   # разово через другое зеркало
-pip config set global.index-url <зеркало>          # закрепить зеркало навсегда
-```
-
-Зеркала, проверенные 07.10.2026 (пакеты `httpx2`/`httpcore2` на месте;
-URL подставлять как есть в `-i` / `index-url`):
-
-| Зеркало | URL |
-|---|---|
-| PyPI, официальный | `https://pypi.org/simple` |
-| TUNA (Tsinghua) | `https://pypi.tuna.tsinghua.edu.cn/simple` |
-| Huawei Cloud | `https://mirrors.huaweicloud.com/repository/pypi/simple` |
-| BFSU | `https://mirrors.bfsu.edu.cn/pypi/web/simple` |
-| SJTU | `https://mirror.sjtu.edu.cn/pypi/web/simple` |
-| USTC | `https://mirrors.ustc.edu.cn/pypi/simple` |
-| SUSTech | `https://mirrors.sustech.edu.cn/pypi/simple` |
-
-Примечания: Alibaba Cloud (`https://mirrors.aliyun.com/pypi/simple`) обычно
-тоже свежий, но из части сетей недоступен; Яндекс-зеркало (`mirror.yandex.ru`)
-PyPI не раздаёт вовсе. Зеркала отстают по-разному, поэтому для свежих пакетов
-надёжнее разово ставить с официального индекса.
-
-## Переменные окружения
-
-| Переменная | По умолчанию | Где | Описание |
-|---|---|---|---|
-| `SCHEDULE_LINK` | — | api | публичная ссылка Я.Диска, **обязательна** |
-| `SCHEDULE_INTERVAL_MINUTES` | `15` | api | как часто перечитывать таблицу, минут |
-| `SCHEDULE_CACHE_TTL` | `900` | api | устаревшее: интервал в секундах (если не задан предыдущий) |
-| `SCHEDULE_RETRY_AFTER` | `60` | api | пауза между попытками при сбое источника |
-| `SCHEDULE_API` | `http://127.0.0.1:8000` | frontend | адрес бэкенда (в docker: `http://api:8000`) |
-| `SCHEDULE_PROXY_TIMEOUT` | `150` | frontend | таймаут прокси к бэкенду, сек |
-| `ADMIN_PATH` | — | api+frontend | секретный путь админки; пусто = админка выключена |
-| `ADMIN_LOGIN` / `ADMIN_PASSWORD` | — | api | логин и пароль администратора |
-| `ADMIN_MAX_ATTEMPTS` | `3` | api | сколько неудачных попыток входа допускается |
-| `ADMIN_LOCKOUT_MINUTES` | `15` | api | на сколько минут блокировать вход после них |
-| `SETTINGS_FILE` | `data/settings.json` | api | где хранить ссылку, интервал и историю входов |
-| `API_PORT` | `8000` | docker | внешний порт api (публикуется на 127.0.0.1) |
-| `FRONTEND_PORT` | `8080` | docker | внешний порт frontend (публикуется на 127.0.0.1) |
-
-`.env` ищется вверх от каталога модуля: и backend, и frontend находят общий
-`.env` в корне репозитория; `load_dotenv` не перезаписывает уже выставленные
-переменные окружения.
-
-## Админка
-
-Необязательная страница для управления источником данных. Отдельного входа на
-сайте нет: панель открывается по секретному пути `ADMIN_PATH`, а пока
-`ADMIN_LOGIN`/`ADMIN_PASSWORD` пусты, админка выключена и наружу ничего не
-торчит (маршруты `/api/admin/*` не регистрируются).
-
-Включить: заполнить в `.env` четыре переменные и перезапустить службу.
-
-```ini
-ADMIN_PATH=/panel-8f3a91x7     # придумайте длинный и неочевидный
-ADMIN_LOGIN=admin
-ADMIN_PASSWORD=<длинный пароль>
-```
-
-Что умеет:
-
- **посмотреть состояние**: сколько групп, когда обновлялось, дата файла на
-  Диске, изменился ли файл при последнем чтении (`sha256`), есть ли ошибки;
- **вставить новую ссылку** на таблицу: она проверяется скачиванием и разбором
-  до сохранения — нерабочая не применится, данные на сайте не пострадают;
- **задать интервал обновления** в минутах (`1…1440`);
- **обновить сейчас**: скачивает таблицу принудительно, не дожидаясь интервала
-  (по интервалу файл перечитывается, только если на Диске изменилась дата);
- **видеть входы**: последняя попытка (откуда, когда, успешна ли) и последний
-  успешный вход — и в панели, и в логе службы.
-
-Защита входа: после `ADMIN_MAX_ATTEMPTS` неудач (по умолчанию 3) вход с этого
-адреса блокируется на `ADMIN_LOCKOUT_MINUTES` минут (по умолчанию 15). Сессия —
-подписанная cookie на 12 часов.
-
-Настройки (ссылка, интервал, история входов) хранятся в `SETTINGS_FILE`
-(по умолчанию `data/settings.json` в корне проекта; в docker — в томе
-`schedule_data`). Если файл недоступен для записи, изменения живут в памяти до
-перезапуска, а панель предупредит об этом.
-
-## Структура кода
-
-```
-install.sh             интерактивная установка на сервер: Docker или systemd + nginx
-src/
-  backend/
-    main.py              FastAPI: маршруты, create_app(cache), /healthz
-    admin.py             админка: cookie-сессия, блокировка входа, ссылка, интервал, force
-    schedule/
-      xlsx.py            чтение xlsx: общие строки, объединённые ячейки,
-                         скрытые столбцы, красный текст, серийные даты
-      source.py          скачивание файла по публичной ссылке Я.Диска
-      lessons.py         разбор ячеек занятий (общий конвейер ролей)
-      parsing.py         лист → расписание, недели, индексы преподавателей/аудиторий
-      cache.py           ScheduleCache: блокировка, интервал, stale-while-error, force
-      settings.py        хранилище настроек админки (ссылка, интервал, история входов)
-      errors.py          ScheduleError
-  frontend/
-    main.py              FastAPI: статика + прокси /api/* (таймаут 150 c)
-    admin.html           страница админки (вне static: прямой доступ закрыт)
-    static/
-      index.html, app.js, style.css
-      manifest.json      PWA: имя, иконки, standalone-режим
-      sw.js              минимальный service worker (без кэша) для установки приложения
-      img/               логотипы и иконки приложения
-tools/
-  make_icons.py          генерация иконок приложения из логотипа (нужен rsvg-convert)
-deploy/
-  nginx-site.sh          генерация и включение конфига nginx (используется install.sh)
-tests/
-  conftest.py            общие фикстуры
-  xlsx_builder.py        генерация xlsx в памяти (без openpyxl)
-  fixtures.py            общая тестовая таблица
-  test_lessons.py        все форматы ячеек
-  test_xlsx.py           чтение книги
-  test_parsing.py        разбор листов, недели, индексы
-  test_api.py            API и поведение кэша (интервал/stale, 404/400/502)
-  test_admin.py          админка: вход, блокировка, история, ссылка/интервал/force
-  test_settings.py       хранилище настроек админки
-  test_deploy.py         проверка, что образы копируют все нужные файлы
-```
-
-Данные админки (`data/settings.json`) — рабочие, в git не попадают.
-
-## Как устроена таблица-источник
+## Как устроено расписание в таблице

 Лист «Бакалавры и магистры» — это сетка:

@@ -395,7 +32,9 @@ tests/
 столбцы 2–3   даты «знаменателя»
 столбец 4     день недели (указан один раз на блок дня)
 столбец 5     номер пары и время (ячейка объединена на две строки пары)
-столбцы 6+    группы — по одному столбцу на группу (скрытые столбцы пропускаются)
+столбцы 6+    группы — по одному столбцу на группу, порядок столбцов = порядок
+              групп на сайте (скрытые столбцы пропускаются; имена вида
+              «ИВТ-11БО», «ПИЭ-13МО», «ИВТ-ТОП-11БО»)
 ```

 Каждый день занимает блок строк, и строки идут парами: «числитель» /
@@ -430,10 +69,7 @@ tests/

 В одной ячейке может быть несколько занятий: они разделяются пустой строкой,
 новым маркером «к.в.» или началом нового предмета сразу после строки
-аудитории/преподавателя. Если пустой строкой (или красной заметкой, снятой с
-целой строки) от предмета оторвался только преподаватель и/или аудитория, этот
-кусок достраивает предыдущее занятие, а не создаёт занятие без предмета — иначе
-в расписании аудитории оставались бы одни группы.
+аудитории/преподавателя.

 Итог по паре: `{time, ч: {raw, lessons[]}, з: {raw, lessons[]}}`, где
 `lesson = {marker, subject, teacher, room, note}`.
@@ -452,13 +88,91 @@ tests/
 - Приложение можно «установить» на главный экран (манифест + service
  worker + иконки приложения); на iOS иконку берёт `apple-touch-icon`.

+## Админка
+
+Отдельного входа на сайте нет: панель открывается по секретному пути из
+`ADMIN_PATH` (например `/manage-7f3a91`), логин и пароль — `ADMIN_LOGIN` /
+`ADMIN_PASSWORD`. Если эти переменные пусты, админка полностью выключена и
+маршруты `/api/admin/*` не регистрируются (прод можно не трогать).
+
+Что умеет администратор:
+
+- **посмотреть текущую ссылку** и состояние кэша (обновлено, изменена,
+  ошибка, число групп);
+- **вставить новую ссылку**: она проверяется скачиванием и разбором таблицы
+  до сохранения — нерабочая не применится, данные на сайте не пострадают;
+- **принудительно обновить расписание** — вне интервала: кнопка перечитывает
+  таблицу всегда, не глядя на дату изменения файла;
+- **задать интервал обновления** в минутах (`1…1440`).
+
+Фоновое обновление по интервалу работает как раньше: сначала сверяется
+`modified` файла, и если таблица не менялась — скачивания не происходит.
+Принудительное обновление (кнопка) скачивает файл **всегда**, поэтому его и
+стоит нажимать сразу после правок в таблице. В панели и в логе при этом видно,
+изменилось ли содержимое файла: `sha256`, время последнего изменения и отметка
+«изменился / без изменений». Если вы поправили таблицу, а после обновления
+написано «без изменений» — значит публичная ссылка Яндекса отдаёт прежнюю
+версию файла (бывает с задержкой), стоит повторить обновление через минуту.
+
+Как это устроено:
+
+- вход — `POST /api/admin/login`, сессия в подписанной HMAC-cookie
+  (`HttpOnly`, `SameSite=Lax`, `Secure` при https), ключ — пароль админа,
+  срок 12 часов; неудачные попытки логируются;
+- все действия — под `/api/admin/*`, без cookie отвечают `401`;
+- ссылка и интервал хранятся в `SETTINGS_FILE` (в docker — том
+  `schedule_data`, `/data/settings.json`), поэтому переживают перезапуск;
+  если файл недоступен, настройки живут в памяти;
+- страница панели отдаётся фронтендом по `ADMIN_PATH` с заголовком
+  `X-Robots-Tag: noindex`; путь нигде не публикуется и не попадает в `/`.
+
+## Структура кода
+
+```
+src/
+  backend/
+    main.py            FastAPI: маршруты, create_app(cache), /healthz
+    admin.py           админка: cookie-сессия, ссылка, интервал, принудительное обновление
+    schedule/
+      xlsx.py          чтение xlsx: sharedStrings, мержи, скрытые столбцы,
+                       красный текст, серийные даты
+      source.py        загрузка файла по публичной ссылке Я.Диска
+      lessons.py       разбор ячеек занятий (общий конвейер ролей)
+      parsing.py       листы → расписание, недели, индексы преподавателей/аудиторий
+      cache.py         ScheduleCache: блокировка, интервал, stale-while-error
+      settings.py      хранилище настроек админки (ссылка, интервал) в JSON-файле
+      errors.py        ScheduleError
+  frontend/
+    main.py              FastAPI: статика + прокси /api/* (таймаут 150 c)
+    admin.html           страница админки (вне static: прямой доступ закрыт)
+    static/
+      index.html, app.js, style.css
+      manifest.json      PWA: имя, иконки, standalone-режим
+      sw.js              минимальный service worker (без кэша) для установки приложения
+      img/               логотипы (owl.svg, owl-white.svg), иконки приложения
+                         (app-icon.svg, icon-192/512.png, apple-touch-icon.png, favicon-32.png)
+deploy/
+  nginx-dev.conf         сайт тестового стенда (dev.schedule.our-place.ru)
+  README-dev.md          как поднять тестовый стенд рядом с продом
+tools/
+  make_icons.py          генерация иконок приложения из логотипа (нужен rsvg-convert)
+tests/
+  conftest.py            общие фикстуры
+  xlsx_builder.py        генерация xlsx в памяти (без openpyxl)
+  fixtures.py            общая тестовая таблица
+  test_lessons.py        все форматы ячеек
+  test_xlsx.py           чтение книги
+  test_parsing.py        разбор листов, недели, индексы
+  test_api.py            API и поведение кэша (интервал/stale, 404/400/502)
+```
+
 ## API

 Полный список методов отдаёт сам бэкенд: `GET /`.

 | Метод | Путь | Описание |
 |---|---|---|
-| GET | `/groups` | список групп (сначала БО, потом МО) |
+| GET | `/groups` | группы в том порядке, в каком идут столбцы в таблице |
 | GET | `/schedule/{group}` | расписание группы с разбором на занятия |
 | GET | `/schedule/{group}/{day}` | расписание группы на конкретный день |
 | GET | `/today?group={group}` | расписание группы на сегодня |
@@ -469,10 +183,93 @@ tests/
 | GET | `/rooms-day?day={день}` | занятость всех аудиторий за день |
 | GET | `/rooms-free?day={день}&period={N}` | свободные аудитории |
 | GET | `/week` | недели семестра и текущая чётность |
-| GET | `/status` | состояние кэша (`last_updated`, `table_modified`, `error`, …) |
+| GET | `/status` | состояние кэша (`cache_ttl_seconds`, `last_updated`, `table_modified`, `error`) |
 | GET | `/healthz` | живость процесса (не обращается к таблице) |

 Фронт проксирует только то, что использует, под префиксом `/api/...`:
 `groups`, `schedule/{group}`, `teachers`, `teacher/{name}`, `rooms`,
 `room/{label}`, `rooms-day`, `rooms-free`, `week`, `status`.
 Остальное (`today`, `schedule/{group}/{day}`) доступно только на бэкенде.
+
+## Переменные окружения
+
+| Переменная | По умолчанию | Где | Описание |
+|---|---|---|---|
+| `SCHEDULE_LINK` | — | api | публичная ссылка Я.Диска, **обязательна** |
+| `SCHEDULE_INTERVAL_MINUTES` | `15` | api | интервал обновления, мин (правится в админке) |
+| `SCHEDULE_CACHE_TTL` | `900` | api | устаревшее: интервал в секундах (если не задан предыдущий) |
+| `SCHEDULE_RETRY_AFTER` | `60` | api | пауза между попытками при сбое источника |
+| `ADMIN_PATH` | — | api+frontend | секретный путь панели (пусто = админка выключена) |
+| `ADMIN_LOGIN` / `ADMIN_PASSWORD` | — | api | учётные данные администратора |
+| `SETTINGS_FILE` | `/data/settings.json` | api | где хранить ссылку и интервал |
+| `SCHEDULE_API` | `http://127.0.0.1:8000` | frontend | адрес бэкенда (в docker: `http://api:8000`) |
+| `SCHEDULE_PROXY_TIMEOUT` | `150` | frontend | таймаут прокси к бэкенду, сек |
+| `API_PORT` | `8000` | docker | внешний порт api |
+| `FRONTEND_PORT` | `8080` | docker | внешний порт frontend (на проде: `127.0.0.1:8090`) |
+
+`.env` ищется вверх от каталога модуля (backend — до корня репозитория);
+`load_dotenv` не перезаписывает уже выставленные переменные окружения.
+
+## Запуск
+
+### Продакшен (Docker)
+
+```bash
+cp .env.example .env        # вписать SCHEDULE_LINK (и порты при необходимости)
+./deploy.sh                 # = docker compose build && up -d
+```
+
+У обоих сервисов есть healthcheck на `/healthz`; frontend стартует после того,
+как api стал healthy. Обновление: `git pull && docker compose up -d --build`.
+
+### Разработка
+
+```bash
+python3 -m venv .venv
+.venv/bin/pip install -r requirements-dev.txt
+make dev                    # api :8000 и фронт :8080, оба с --reload
+```
+
+### Тесты
+
+```bash
+make test                   # 104 теста, сеть не нужна
+```
+
+## Развёртывание на сервере
+
+Код хранится в Gitea (`git.our-place.ru`, web через nginx, git-ssh на порту
+2222) и живёт в `/opt/schedule`:
+
+```bash
+# первый запуск
+cd /opt/schedule
+# .env: SCHEDULE_LINK=... , API_PORT=127.0.0.1:8000, FRONTEND_PORT=127.0.0.1:8090
+sudo docker compose up -d --build
+
+# обновление
+cd /opt/schedule && git pull && sudo docker compose up -d --build
+```
+
+nginx-сайт `schedule.our-place.ru` проксирует 443 → 127.0.0.1:8090 (фронт),
+сертификат Let's Encrypt. Порты api и frontend слушаются только на loopback.
+
+### Тестовый стенд
+
+Новые штуки обкатываются на отдельном стенде `dev.schedule.our-place.ru`
+(ветка `admin-panel`), прод при этом не меняется: другой каталог
+(`/opt/schedule-dev`), другие порты (8001/8091), свой том настроек.
+Пошаговая инструкция — `deploy/README-dev.md`, конфиг nginx —
+`deploy/nginx-dev.conf`.
+
+## Замечания
+
+- Принудительное обновление и смена ссылки живут только в админке
+  (`/api/admin/*` под cookie-сессией): публичного `force` в API нет.
+- Кэш живёт в памяти единственного воркера: при горизонтальном масштабировании
+  api его придётся выносить в общее хранилище (настройки админки уже в файле).
+- `ADMIN_PATH` защищает только от «случайного» обнаружения панели; реальная
+  защита — логин и пароль. Стоит держать их длинными и не публиковать путь.
+- Строки внутри дня в таблице строго чередуются «числитель / знаменатель».
+  Если строку посреди блока вставят или удалят, бэкенд запишет предупреждение
+  «нечётное число строк, недели могли сдвинуться».
--- a/deploy/README-dev.md
+++ b/deploy/README-dev.md
@@ -0,0 +1,87 @@
+# Тестовый стенд (dev.schedule.our-place.ru)
+
+Отдельный стенд для обкатки админки: свой каталог, свои порты, своя база
+настроек. Прод (`/opt/schedule`, `schedule.our-place.ru`) не трогаем — он
+продолжает работать как раньше.
+
+Ветка: `admin-panel`.
+
+## 1. Код
+
+```bash
+sudo mkdir -p /opt/schedule-dev && sudo chown "$USER" /opt/schedule-dev
+git clone -b admin-panel <адрес репозитория> /opt/schedule-dev
+```
+
+Адрес — тот же, что у прода: если прод-клон забирает обновления по SSH,
+берите SSH-адрес (`ssh://git@git.our-place.ru:2222/Mermutef/schedule.git`),
+если по HTTPS — HTTPS-адрес с токеном:
+
+```bash
+git clone -b admin-panel https://Mermutef:<токен>@git.our-place.ru/Mermutef/schedule.git /opt/schedule-dev
+```
+
+## 2. .env
+
+Скопировать `.env.example` в `/opt/schedule-dev/.env` и заполнить:
+
+```ini
+SCHEDULE_LINK=https://disk.yandex.ru/i/...
+SCHEDULE_INTERVAL_MINUTES=15
+SCHEDULE_RETRY_AFTER=60
+ADMIN_PATH=/manage-<секретная-часть>
+ADMIN_LOGIN=<логин>
+ADMIN_PASSWORD=<пароль>
+API_PORT=127.0.0.1:8001
+FRONTEND_PORT=127.0.0.1:8091
+SCHEDULE_API=http://api:8000
+SETTINGS_FILE=/data/settings.json
+```
+
+Порты 8001/8091 выбраны, чтобы не пересечься с продом (8000/8090).
+`ADMIN_PATH` — секретный путь страницы админки: его нужно знать, чтобы
+попасть в панель; на сайте ссылки на него нет.
+
+## 3. Запуск
+
+```bash
+cd /opt/schedule-dev
+sudo docker compose up -d --build
+sudo docker compose ps
+```
+
+Настройки админки лежат в томе `schedule-dev_schedule_data` и переживают
+пересборку; посмотреть можно так:
+
+```bash
+sudo docker run --rm -v schedule-dev_schedule_data:/data alpine cat /data/settings.json
+```
+
+## 4. nginx и сертификат
+
+В `deploy/nginx-dev.conf` порт `proxy_pass` должен совпадать с `FRONTEND_PORT`
+из `.env` (по умолчанию 8091; если порт меняли — поправьте и в конфиге).
+
+```bash
+sudo cp /opt/schedule-dev/deploy/nginx-dev.conf /etc/nginx/sites-available/dev.schedule.our-place.ru
+sudo ln -sf /etc/nginx/sites-available/dev.schedule.our-place.ru /etc/nginx/sites-enabled/dev.schedule.our-place.ru
+sudo nginx -t && sudo systemctl reload nginx
+sudo certbot --nginx -d dev.schedule.our-place.ru
+```
+
+## 5. Проверка
+
+```bash
+curl -sI https://dev.schedule.our-place.ru/ | head -3          # 200
+curl -s -o /dev/null -w '%{http_code}\n' https://dev.schedule.our-place.ru/api/admin/state   # 401 (нужен вход)
+```
+
+Дальше — открыть `https://dev.schedule.our-place.ru/<ADMIN_PATH>` в браузере,
+войти логином/паролем из `.env` и проверить: смена ссылки, интервал,
+«Обновить сейчас».
+
+## Обновление стенда
+
+```bash
+cd /opt/schedule-dev && git pull && sudo docker compose up -d --build
+```
--- a/deploy/nginx-dev.conf
+++ b/deploy/nginx-dev.conf
@@ -0,0 +1,47 @@
+# Тестовый стенд dev.schedule.our-place.ru
+#
+# Ставится рядом с прод-сайтом schedule.our-place.ru (тот не трогаем):
+# отдельный каталог /opt/schedule-dev, отдельные порты, отдельная база настроек.
+#
+# sudo cp ~/schedule-dev/deploy/nginx-dev.conf /etc/nginx/sites-available/dev.schedule.our-place.ru
+# sudo ln -sf /etc/nginx/sites-available/dev.schedule.our-place.ru /etc/nginx/sites-enabled/
+# sudo certbot --nginx -d dev.schedule.our-place.ru
+# sudo nginx -t && sudo systemctl reload nginx
+
+server {
+    listen 80;
+    listen [::]:80;
+    server_name dev.schedule.our-place.ru;
+
+    location /.well-known/acme-challenge/ {
+        root /var/www/html;
+    }
+
+    location / {
+        return 301 https://$host$request_uri;
+    }
+}
+
+server {
+    listen 443 ssl http2;
+    listen [::]:443 ssl http2;
+    server_name dev.schedule.our-place.ru;
+
+    ssl_certificate /etc/letsencrypt/live/dev.schedule.our-place.ru/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/dev.schedule.our-place.ru/privkey.pem;
+    ssl_protocols TLSv1.2 TLSv1.3;
+
+    client_max_body_size 8m;
+
+    location / {
+        # порт должен совпадать с FRONTEND_PORT из .env стенда
+        proxy_pass http://127.0.0.1:8091;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto https;
+        # принудительное обновление расписания из админки — до ~2 минут
+        proxy_read_timeout 300s;
+        proxy_send_timeout 300s;
+    }
+}
--- a/deploy/nginx-site.sh
+++ b/deploy/nginx-site.sh
@@ -1,123 +0,0 @@
-#!/usr/bin/env bash
-# Генерирует и включает конфиг nginx для сайта расписания.
-#
-# SSL обеспечивает сертификат родительского домена (обычно wildcard *.example.ru):
-# отдельный certbot для поддомена не нужен — достаточно имени сертификата.
-# Список имён: sudo ls /etc/letsencrypt/live/
-#
-# Имя сертификата берётся из --cert, иначе — родительский домен от --domain
-# (sched.example.ru -> example.ru). Порт фронта берётся из --port, иначе из
-# FRONTEND_PORT файла .env в корне проекта, иначе 8080.
-#
-# Примеры:
-#   deploy/nginx-site.sh --print --domain sched.example.ru    # показать конфиг
-#   sudo deploy/nginx-site.sh --domain sched.example.ru       # поставить и перечитать nginx
-#   sudo deploy/nginx-site.sh --domain sched.example.ru --cert example.ru
-set -euo pipefail
-
-usage() {
-  grep '^#' "$0" | sed 's/^# \{0,1\}//' | tail -n +2
-}
-
-die() { echo "Ошибка: $*" >&2; exit 2; }
-
-DOMAIN=""
-CERT_NAME=""
-FRONTEND_PORT=""
-PRINT=0
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --domain) DOMAIN="$2"; shift 2 ;;
-    --cert)   CERT_NAME="$2"; shift 2 ;;
-    --port)   FRONTEND_PORT="$2"; shift 2 ;;
-    --print)  PRINT=1; shift ;;
-    -h|--help) usage; exit 0 ;;
-    *) echo "Неизвестный аргумент: $1 (см. --help)" >&2; exit 2 ;;
-  esac
-done
-
-[[ -n $DOMAIN ]] || die "Укажите домен: --domain sched.example.ru (см. --help)"
-[[ $DOMAIN =~ ^[a-zA-Z0-9.-]+$ ]] || die "Кривое имя домена: $DOMAIN"
-if [[ -z $CERT_NAME ]]; then
-  CERT_NAME="${DOMAIN#*.}"  # sched.example.ru -> example.ru (wildcard родителя)
-fi
-[[ $CERT_NAME =~ ^[a-zA-Z0-9.-]+$ ]] || { echo "Кривое имя сертификата: $CERT_NAME" >&2; exit 2; }
-
-if [[ -z $FRONTEND_PORT ]]; then
-  # FRONTEND_PORT из .env; значение вида «127.0.0.1:8090» трактуем как «порт после двоеточия»
-  FRONTEND_PORT=$(
-    grep -E '^FRONTEND_PORT=' .env 2>/dev/null | tail -1 | cut -d= -f2- \
-      | tr -d ' "' | awk -F: '{print $NF}'
-  ) || FRONTEND_PORT=""
-fi
-FRONTEND_PORT=${FRONTEND_PORT:-8080}
-[[ $FRONTEND_PORT =~ ^[0-9]+$ ]] || { echo "Не разобрал FRONTEND_PORT из .env, задайте --port" >&2; exit 2; }
-
-read -r -d '' CONFIG <<'TEMPLATE' || true
-# Сгенерировано deploy/nginx-site.sh — правки вносить в скрипт, не сюда.
-server {
-    listen 80;
-    listen [::]:80;
-    server_name __DOMAIN__;
-
-    location /.well-known/acme-challenge/ {
-        root /var/www/html;
-    }
-
-    location / {
-        return 301 https://$host$request_uri;
-    }
-}
-
-server {
-    listen 443 ssl http2;
-    listen [::]:443 ssl http2;
-    server_name __DOMAIN__;
-
-    # сертификат родительского домена (обычно wildcard), обновляет certbot родителя
-    ssl_certificate /etc/letsencrypt/live/__CERT__/fullchain.pem;
-    ssl_certificate_key /etc/letsencrypt/live/__CERT__/privkey.pem;
-    ssl_protocols TLSv1.2 TLSv1.3;
-
-    client_max_body_size 8m;
-
-    location / {
-        # порт FRONTEND_PORT из .env стенда
-        proxy_pass http://127.0.0.1:__PORT__;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto https;
-        # холодный кэш: бэкенд качает таблицу, до ~2 минут
-        proxy_read_timeout 300s;
-        proxy_send_timeout 300s;
-    }
-}
-TEMPLATE
-
-CONFIG=${CONFIG//__DOMAIN__/$DOMAIN}
-CONFIG=${CONFIG//__CERT__/$CERT_NAME}
-CONFIG=${CONFIG//__PORT__/$FRONTEND_PORT}
-
-if [[ $PRINT == 1 ]]; then
-  printf '%s\n' "$CONFIG"
-  exit 0
-fi
-
-if [[ $EUID -ne 0 ]]; then
-  echo "Установка требует root: sudo deploy/nginx-site.sh (посмотреть конфиг — deploy/nginx-site.sh --print)" >&2
-  exit 1
-fi
-
-DEST="/etc/nginx/sites-available/${DOMAIN}"
-printf '%s\n' "$CONFIG" > "$DEST"
-ln -sf "$DEST" "/etc/nginx/sites-enabled/${DOMAIN}"
-
-if nginx -t 2>&1; then
-  systemctl reload nginx
-  echo "Готово: https://${DOMAIN} -> 127.0.0.1:${FRONTEND_PORT} (сертификат ${CERT_NAME})"
-else
-  echo "nginx -t не прошёл: конфиг записан в ${DEST} и включён, но nginx НЕ перечитан. Разберитесь и выполните: sudo nginx -t && sudo systemctl reload nginx" >&2
-  exit 1
-fi
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -5,22 +5,19 @@ services:
      target: api
    environment:
      SCHEDULE_LINK: ${SCHEDULE_LINK}
-      SCHEDULE_INTERVAL_MINUTES: ${SCHEDULE_INTERVAL_MINUTES:-15}
      SCHEDULE_CACHE_TTL: ${SCHEDULE_CACHE_TTL:-900}
      SCHEDULE_RETRY_AFTER: ${SCHEDULE_RETRY_AFTER:-60}
-      # админка: пусто = выключена (страница и /api/admin/* не появятся)
+      # админка: секретный путь панели и учётные данные (пусто = выключена)
      ADMIN_PATH: ${ADMIN_PATH:-}
      ADMIN_LOGIN: ${ADMIN_LOGIN:-}
      ADMIN_PASSWORD: ${ADMIN_PASSWORD:-}
-      ADMIN_MAX_ATTEMPTS: ${ADMIN_MAX_ATTEMPTS:-3}
-      ADMIN_LOCKOUT_MINUTES: ${ADMIN_LOCKOUT_MINUTES:-15}
-      # настройки админки (ссылка, интервал, история входов) живут в томе
+      SCHEDULE_INTERVAL_MINUTES: ${SCHEDULE_INTERVAL_MINUTES:-15}
+      # настройки админки переживают пересборку благодаря тому /data
      SETTINGS_FILE: ${SETTINGS_FILE:-/data/settings.json}
    volumes:
      - schedule_data:/data
    ports:
-      # api нужен только фронтенду внутри docker-сети; наружу — 127.0.0.1 для отладки
-      - "127.0.0.1:${API_PORT:-8000}:8000"
+      - "${API_PORT:-8000}:8000"
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/healthz', timeout=5)"]
@@ -34,13 +31,10 @@ services:
      context: .
      target: frontend
    environment:
-      # внутри compose api доступен по имени сервиса; менять не нужно
      SCHEDULE_API: ${SCHEDULE_API:-http://api:8000}
-      # страница админки отдаётся фронтендом по этому пути
      ADMIN_PATH: ${ADMIN_PATH:-}
    ports:
-      # фронт обслуживает nginx; наружу напрямую не смотрит
-      - "127.0.0.1:${FRONTEND_PORT:-8080}:8080"
+      - "${FRONTEND_PORT:-8080}:8080"
    restart: unless-stopped
    depends_on:
      api:
--- a/install.sh
+++ b/install.sh
@@ -1,324 +0,0 @@
-#!/usr/bin/env bash
-# Интерактивная установка «Расписания» на чистый сервер.
-#
-# Запуск из распакованного каталога проекта (нужен root — скрипт сам
-# перезапустится через sudo):
-#
-#   bash install.sh
-#
-# Скрипт спросит: как ставить (Docker или прямо в систему), публичную ссылку
-# на таблицу и домен сайта. Затем поставит всё нужное, запустит сервисы и
-# настроит nginx с сертификатом Let's Encrypt.
-#
-# Для автоматизации ответы можно передать аргументами:
-#   --mode docker|system   способ установки
-#   --link URL             публичная ссылка Яндекс.Диска с таблицей
-#   --domain DOMAIN        домен сайта (пусто = без nginx, сайт на 127.0.0.1)
-#   --api-port N           порт api (по умолчанию 8000)
-#   --front-port N         порт сайта (по умолчанию 8080)
-#   --user NAME            пользователь служб (режим «в систему»)
-#   --email ADDR           почта для уведомлений Let's Encrypt
-#   --dry-run              показать план установки, ничего не меняя
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-log() { printf '\033[1;36m==>\033[0m %s\n' "$*"; }
-err() { printf '\033[31m==>\033[0m %s\n' "$*" >&2; }
-die() { err "$*"; exit 1; }
-
-usage() { grep '^#' "$0" | sed 's/^# \{0,1\}//' | tail -n +2; }
-
-MODE="" LINK="" DOMAIN="" DOMAIN_SET=0 API_PORT="" FRONT_PORT="" RUN_USER="" EMAIL="" DRY_RUN=0
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --mode) MODE="$2"; shift 2 ;;
-    --link) LINK="$2"; shift 2 ;;
-    --domain) DOMAIN="$2"; DOMAIN_SET=1; shift 2 ;;
-    --api-port) API_PORT="$2"; shift 2 ;;
-    --front-port) FRONT_PORT="$2"; shift 2 ;;
-    --user) RUN_USER="$2"; shift 2 ;;
-    --email) EMAIL="$2"; shift 2 ;;
-    --dry-run) DRY_RUN=1; shift ;;
-    -h|--help) usage; exit 0 ;;
-    *) die "Неизвестный аргумент: $1 (см. --help)" ;;
-  esac
-done
-
-# ask "Вопрос" [по_умолчанию] — ответ в $REPLY
-ask() {
-  local def="${2:-}" input
-  if ! read -rp "$1${def:+ [$def]}: " input; then
-    die "Нужен интерактивный ввод — запустите в терминале или передайте все параметры флагами (см. --help)"
-  fi
-  REPLY="${input:-$def}"
-}
-
-# --- вопросы -------------------------------------------------------------------
-
-if [[ -z $MODE ]]; then
-  log "Как ставить?"
-  log "  1) Docker — изолированные контейнеры, автоперезапуск, обновление одной командой (рекомендуется)"
-  log "  2) Система — без Docker: venv + службы systemd"
-  while true; do
-    ask "Способ установки (docker/system)" "docker"
-    REPLY=$(echo "$REPLY" | tr '[:upper:]' '[:lower:]' | xargs)
-    if [[ $REPLY == 1 ]]; then
-      REPLY=docker
-    elif [[ $REPLY == 2 ]]; then
-      REPLY=system
-    fi
-    [[ $REPLY =~ ^(docker|system)$ ]] && break || err "Ответьте docker или system"
-  done
-  MODE=$REPLY
-fi
-[[ $MODE =~ ^(docker|system)$ ]] || die "--mode: только docker или system"
-
-if [[ -z $LINK ]]; then
-  while true; do
-    ask "Публичная ссылка на таблицу (Яндекс.Диск)"
-    REPLY=$(echo "$REPLY" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//' | tr -d '"')
-    [[ -n $REPLY ]] && break || err "Без ссылки приложение не сможет скачать расписание"
-  done
-  LINK=$REPLY
-fi
-
-if [[ $DOMAIN_SET == 0 && -z $DOMAIN ]]; then
-  ask "Домен сайта, например sched.example.ru (пусто = без nginx, сайт только на 127.0.0.1)"
-  DOMAIN=$(echo "$REPLY" | tr '[:upper:]' '[:lower:]' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
-fi
-if [[ -n $DOMAIN && ! $DOMAIN =~ ^[a-z0-9.-]+$ ]]; then die "Кривое имя домена: $DOMAIN"; fi
-
-if [[ -z $API_PORT ]]; then
-  ask "Порт api (нужен только для диагностики)" "8000"
-  API_PORT=$REPLY
-fi
-if [[ -z $FRONT_PORT ]]; then
-  ask "Порт сайта" "8080"
-  FRONT_PORT=$REPLY
-fi
-[[ $API_PORT =~ ^[0-9]+$ && $FRONT_PORT =~ ^[0-9]+$ ]] || die "Порты должны быть числами"
-
-if [[ $MODE == system ]]; then
-  if [[ -z $RUN_USER ]]; then
-    ask "Пользователь, от которого будут работать службы" "${SUDO_USER:-$(id -un)}"
-    RUN_USER=$REPLY
-  fi
-  id "$RUN_USER" >/dev/null 2>&1 || die "Пользователь $RUN_USER не существует"
-fi
-if [[ -n $DOMAIN && -z $EMAIL ]]; then
-  ask "Почта для уведомлений Let's Encrypt" "admin@$DOMAIN"
-  EMAIL=$REPLY
-fi
-
-if [[ $DRY_RUN == 1 ]]; then
-  log "План установки (dry-run, ничего не выполнено):"
-  echo "  режим:      $MODE"
-  echo "  таблица:    $LINK"
-  echo "  домен:      ${DOMAIN:-(не задан — nginx и https пропускаются, сайт на 127.0.0.1)}"
-  echo "  порты:      api $API_PORT, сайт $FRONT_PORT"
-  if [[ $MODE == system ]]; then
-    echo "  службы от:  $RUN_USER"
-  fi
-  if [[ -n $DOMAIN ]]; then
-    echo "  сертификат: Let's Encrypt для $DOMAIN (почта: $EMAIL)"
-  fi
-  exit 0
-fi
-
-# --- права ----------------------------------------------------------------------
-
-if [[ $EUID -ne 0 ]]; then
-  if [[ ${INSTALL_NO_SUDO:-0} == 1 ]]; then
-    err "Запущено без root (INSTALL_NO_SUDO=1) — часть шагов может не пройти"
-  else
-    log "Нужны права root — перезапускаюсь через sudo"
-    exec sudo bash "$0" "$@"
-  fi
-fi
-
-# --- помощники ------------------------------------------------------------------
-
-pkg_install() {
-  local missing=() p
-  for p in "$@"; do command -v "$p" >/dev/null 2>&1 || missing+=("$p"); done
-  if [[ ${#missing[@]} -eq 0 ]]; then
-    return 0
-  fi
-  log "Ставлю пакеты: ${missing[*]}"
-  if command -v apt-get >/dev/null 2>&1; then
-    apt-get update -y
-    DEBIAN_FRONTEND=noninteractive apt-get install -y "${missing[@]}"
-  elif command -v dnf >/dev/null 2>&1; then
-    dnf install -y "${missing[@]}"
-  else
-    die "Не нашёл apt-get/dnf — поставьте вручную: ${missing[*]}"
-  fi
-}
-
-wait_health() {
-  local url="$1" name="$2" i
-  printf '%s' "==> Жду $name ($url)"
-  for i in $(seq 1 60); do
-    if curl -sf -m 2 "$url" >/dev/null 2>&1; then echo " — готово"; return 0; fi
-    printf '.'; sleep 1
-  done
-  echo
-  die "$name не отвечает на $url — смотрите логи (docker logs / journalctl)"
-}
-
-write_env() {
-  cd "$ROOT"
-  if [[ -f .env && ! -f .env.install-backup ]]; then
-    cp .env .env.install-backup
-  fi
-  cat > .env <<EOF
-# Сгенерировано install.sh
-SCHEDULE_LINK=$LINK
-SCHEDULE_INTERVAL_MINUTES=15
-SCHEDULE_RETRY_AFTER=60
-API_PORT=$API_PORT
-FRONTEND_PORT=$FRONT_PORT
-
-# Админка (необязательно). Заполните path/логин/пароль, чтобы включить панель:
-# страница будет доступна только по https://<домен><ADMIN_PATH>
-ADMIN_PATH=
-ADMIN_LOGIN=
-ADMIN_PASSWORD=
-ADMIN_MAX_ATTEMPTS=3
-ADMIN_LOCKOUT_MINUTES=15
-EOF
-  log ".env записан (прежний, если был, сохранён в .env.install-backup)"
-}
-
-install_docker() {
-  if command -v docker >/dev/null 2>&1; then
-    log "Docker уже установлен"
-  else
-    log "Ставлю Docker..."
-    curl -fsSL https://get.docker.com | sh
-  fi
-  if [[ $EUID -eq 0 ]]; then
-    systemctl enable --now docker
-  fi
-}
-
-setup_nginx() {
-  pkg_install nginx certbot curl
-  if [[ ! -d /etc/nginx/sites-available ]]; then
-    die "Нужен nginx с поддержкой sites-available (Debian/Ubuntu); на других системах настройте конфиг по README"
-  fi
-  log "Временный http-конфиг $DOMAIN — для выпуска сертификата"
-  cat > "/etc/nginx/sites-available/$DOMAIN" <<'NGINX'
-# Сгенерировано install.sh: временный конфиг для certbot, потом заменяется
-server {
-    listen 80;
-    listen [::]:80;
-    server_name __DOMAIN__;
-    root /var/www/html;
-    location /.well-known/acme-challenge/ { }
-}
-NGINX
-  sed -i "s/__DOMAIN__/$DOMAIN/" "/etc/nginx/sites-available/$DOMAIN"
-  ln -sf "/etc/nginx/sites-available/$DOMAIN" "/etc/nginx/sites-enabled/$DOMAIN"
-  nginx -t && systemctl reload nginx
-
-  log "Выпускаю сертификат Let's Encrypt для $DOMAIN (webroot, без остановки nginx)"
-  certbot certonly --webroot -w /var/www/html -d "$DOMAIN" \
-    --non-interactive --agree-tos -m "$EMAIL"
-
-  log "Финальный конфиг сайта: https + прокси на 127.0.0.1:$FRONT_PORT"
-  "$ROOT/deploy/nginx-site.sh" --domain "$DOMAIN" --cert "$DOMAIN" --port "$FRONT_PORT"
-}
-
-# --- установка ------------------------------------------------------------------
-
-if [[ $MODE == docker ]]; then
-  install_docker
-  write_env
-  log "Собираю и запускаю контейнеры (первая сборка — несколько минут)..."
-  (cd "$ROOT" && docker compose up -d --build)
-  wait_health "http://127.0.0.1:$FRONT_PORT/healthz" "frontend"
-else
-  log "Проверяю Python..."
-  pkg_install python3 python3-pip
-  if command -v apt-get >/dev/null 2>&1; then
-    apt-get install -y python3-venv   # на Debian/Ubuntu venv без этого пакета не работает
-  fi
-  python3 - <<'PY' || die "Нужен Python 3.11 или новее (см. README, «Зависимости»)"
-import sys
-sys.exit(0 if sys.version_info >= (3, 11) else 1)
-PY
-  write_env
-  log "Создаю виртуальное окружение и ставлю зависимости..."
-  [[ -d "$ROOT/.venv" ]] || python3 -m venv "$ROOT/.venv"
-  "$ROOT/.venv/bin/pip" install -q --upgrade pip
-  "$ROOT/.venv/bin/pip" install -q -r "$ROOT/requirements.txt"
-
-  log "Настраиваю службы systemd..."
-  cat > /etc/systemd/system/schedule-api.service <<EOF
-[Unit]
-Description=Schedule API (FastAPI)
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-User=$RUN_USER
-WorkingDirectory=$ROOT/src/backend
-ExecStart=$ROOT/.venv/bin/python -m uvicorn main:app --host 127.0.0.1 --port $API_PORT
-Restart=always
-RestartSec=3
-
-[Install]
-WantedBy=multi-user.target
-EOF
-  cat > /etc/systemd/system/schedule-frontend.service <<EOF
-[Unit]
-Description=Schedule frontend (FastAPI)
-After=network-online.target schedule-api.service
-Wants=network-online.target schedule-api.service
-
-[Service]
-User=$RUN_USER
-WorkingDirectory=$ROOT/src/frontend
-Environment=SCHEDULE_API=http://127.0.0.1:$API_PORT
-ExecStart=$ROOT/.venv/bin/python -m uvicorn main:app --host 127.0.0.1 --port $FRONT_PORT
-Restart=always
-RestartSec=3
-
-[Install]
-WantedBy=multi-user.target
-EOF
-  chown -R "$RUN_USER" "$ROOT"
-  systemctl daemon-reload
-  systemctl enable --now schedule-api.service schedule-frontend.service
-  wait_health "http://127.0.0.1:$API_PORT/healthz" "api"
-  wait_health "http://127.0.0.1:$FRONT_PORT/healthz" "frontend"
-fi
-
-if [[ -n $DOMAIN ]]; then
-  setup_nginx
-else
-  log "Домен не задан — nginx и https пропущены. Сайт работает на http://127.0.0.1:$FRONT_PORT"
-fi
-
-# --- итог -----------------------------------------------------------------------
-
-log "Установка завершена."
-if [[ -n $DOMAIN ]]; then
-  echo "  Сайт:        https://$DOMAIN"
-else
-  echo "  Сайт:        http://127.0.0.1:$FRONT_PORT (с самого сервера)"
-fi
-echo "  Таблица:     $LINK"
-echo "  Настройки:   $ROOT/.env"
-if [[ $MODE == docker ]]; then
-  echo "  Логи:        sudo docker logs api / frontend"
-  echo "  Обновление:  cd $ROOT && sudo docker compose up -d --build"
-  echo "  Напоминание: настройте ротацию логов Docker (/etc/docker/daemon.json), см. README"
-else
-  echo "  Службы:      sudo systemctl status schedule-api schedule-frontend"
-  echo "  Логи:        journalctl -u schedule-api -u schedule-frontend"
-  echo "  Обновление:  заменить файлы проекта, затем sudo systemctl restart schedule-api schedule-frontend"
-fi
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,2 +1,3 @@
+-r requirements.txt
 pytest==9.1.1
 httpx2==2.12.0
--- a/src/backend/admin.py
+++ b/src/backend/admin.py
@@ -1,18 +1,15 @@
 """Админка расписания.

 Отдельного входа на сайте нет: панель открывается по секретному пути из
-ADMIN_PATH, логин и пароль задаются в ADMIN_LOGIN/ADMIN_PASSWORD. Если они
-пусты, админка выключена и маршруты /api/admin/* не регистрируются.
-
-После нескольких неудачных попыток вход блокируется на время из
-ADMIN_LOCKOUT_MINUTES (по умолчанию: 3 попытки и 15 минут). Каждая попытка
-запоминается (откуда, когда, успешна ли) — это видно в панели и пишется в лог.
+ADMIN_PATH, логин и пароль задаются в ADMIN_LOGIN/ADMIN_PASSWORD. После
+входа ставим подписанную HMAC-cookie (ключ — пароль), поэтому состояние
+между запросами не хранится.

 Что умеет администратор:
-    GET  /api/admin/state     — состояние кэша, ссылка, интервал, история входов;
-    POST /api/admin/link      — проверить и поставить новую ссылку на таблицу;
+    GET  /api/admin/state     — текущая ссылка, интервал, состояние кэша;
+    POST /api/admin/link      — проверить и поставить новую ссылку;
    POST /api/admin/interval  — интервал обновления в минутах;
-    POST /api/admin/refresh   — принудительно перечитать таблицу сейчас.
+    POST /api/admin/refresh   — принудительно обновить расписание сейчас.
 """

 from __future__ import annotations
@@ -25,32 +22,62 @@ import logging
 import threading
 import time
 from dataclasses import dataclass
-from datetime import datetime

 from fastapi import APIRouter, Depends, HTTPException, Request, Response
 from pydantic import BaseModel

 from schedule import ScheduleCache, ScheduleError
-from schedule.settings import SettingsStore

 log = logging.getLogger(__name__)

 COOKIE_NAME = "schedule_admin"
 SESSION_TTL_SECONDS = 12 * 3600

-DEFAULT_MAX_ATTEMPTS = 3
-DEFAULT_LOCKOUT_MINUTES = 15
+# защита от перебора пароля: не больше N неудач с одного адреса за окно
+LOGIN_MAX_FAILURES = 10
+LOGIN_WINDOW_SECONDS = 300.0
+
+
+class LoginThrottle:
+    """Простейший счётчик неудачных попыток входа по IP."""
+
+    def __init__(
+        self,
+        max_failures: int = LOGIN_MAX_FAILURES,
+        window: float = LOGIN_WINDOW_SECONDS,
+    ) -> None:
+        self._max = max_failures
+        self._window = window
+        self._lock = threading.Lock()
+        self._failures: dict[str, list[float]] = {}
+
+    def _recent(self, key: str, now: float) -> list[float]:
+        return [ts for ts in self._failures.get(key, []) if now - ts < self._window]
+
+    def blocked(self, key: str) -> bool:
+        now = time.time()
+        with self._lock:
+            recent = self._recent(key, now)
+            self._failures[key] = recent
+            return len(recent) >= self._max
+
+    def register_failure(self, key: str) -> None:
+        now = time.time()
+        with self._lock:
+            self._failures[key] = [*self._recent(key, now), now]
+
+    def reset(self, key: str) -> None:
+        with self._lock:
+            self._failures.pop(key, None)


@dataclass
 class AdminConfig:
-    """Настройки админки: секретный путь, учётные данные и защита от перебора."""
+    """Настройки админки: секретный путь и учётные данные из .env."""

    path: str = ""
    login: str = ""
    password: str = ""
-    max_attempts: int = DEFAULT_MAX_ATTEMPTS
-    lockout_minutes: int = DEFAULT_LOCKOUT_MINUTES

    @property
    def enabled(self) -> bool:
@@ -71,7 +98,9 @@ def _same(left: str, right: str) -> bool:


 def make_token(login: str, password: str, ttl: int = SESSION_TTL_SECONDS) -> str:
-    payload = json.dumps({"sub": login, "exp": int(time.time()) + ttl}, separators=(",", ":")).encode()
+    payload = json.dumps(
+        {"sub": login, "exp": int(time.time()) + ttl}, separators=(",", ":")
+    ).encode()
    sig = hmac.new(password.encode(), payload, hashlib.sha256).digest()
    return f"{_b64e(payload)}.{_b64e(sig)}"

@@ -88,46 +117,6 @@ def verify_token(token: str, password: str) -> bool:
        return False


-class LoginThrottle:
-    """Счётчик неудачных попыток: N промахов — пауза на lockout_minutes."""
-
-    def __init__(self, max_attempts: int = DEFAULT_MAX_ATTEMPTS, lockout_minutes: int = DEFAULT_LOCKOUT_MINUTES) -> None:
-        self.max_attempts = max(1, int(max_attempts))
-        self.lockout_seconds = max(1, int(lockout_minutes)) * 60
-        self._lock = threading.Lock()
-        self._failures: dict[str, int] = {}
-        self._blocked_until: dict[str, float] = {}
-
-    def locked_until(self, key: str) -> float | None:
-        with self._lock:
-            until = self._blocked_until.get(key)
-            if until is None:
-                return None
-            if until <= time.time():
-                self._blocked_until.pop(key, None)
-                self._failures.pop(key, None)
-                return None
-            return until
-
-    def attempts_left(self, key: str) -> int:
-        with self._lock:
-            return max(0, self.max_attempts - self._failures.get(key, 0))
-
-    def register_failure(self, key: str) -> None:
-        with self._lock:
-            failures = self._failures.get(key, 0) + 1
-            if failures >= self.max_attempts:
-                self._blocked_until[key] = time.time() + self.lockout_seconds
-                self._failures[key] = 0
-            else:
-                self._failures[key] = failures
-
-    def reset(self, key: str) -> None:
-        with self._lock:
-            self._failures.pop(key, None)
-            self._blocked_until.pop(key, None)
-
-
 class LoginBody(BaseModel):
    login: str
    password: str
@@ -141,30 +130,9 @@ class IntervalBody(BaseModel):
    interval_minutes: int


-def _client_ip(request: Request) -> str:
-    """Реальный адрес клиента: за nginx он приходит в X-Forwarded-For."""
-    forwarded = request.headers.get("x-forwarded-for", "")
-    if forwarded:
-        return forwarded.split(",")[0].strip() or "неизвестно"
-    return request.client.host if request.client else "неизвестно"
-
-
-def _human_dt(iso: str | None) -> str:
-    if not iso:
-        return "—"
-    try:
-        return datetime.fromisoformat(iso).strftime("%d.%m.%Y %H:%M:%S")
-    except ValueError:
-        return iso
-
-
-def create_admin_router(
-    cache: ScheduleCache,
-    settings: SettingsStore | None,
-    config: AdminConfig,
-) -> APIRouter:
+def create_admin_router(cache: ScheduleCache, config: AdminConfig) -> APIRouter:
    router = APIRouter(prefix="/api/admin", tags=["admin"])
-    throttle = LoginThrottle(config.max_attempts, config.lockout_minutes)
+    throttle = LoginThrottle()

    def require_auth(request: Request) -> None:
        token = request.cookies.get(COOKIE_NAME, "")
@@ -175,55 +143,24 @@ def create_admin_router(
        proto = request.headers.get("x-forwarded-proto", "") or request.url.scheme
        return proto.split(",")[0].strip() == "https"

-    def _remember(ip: str, ok: bool) -> None:
-        if settings is not None:
-            settings.record_login(ip, ok)
+    def _client_key(request: Request) -> str:
+        return request.client.host if request.client else "unknown"

    @router.post("/login")
    def login(body: LoginBody, request: Request, response: Response) -> dict:
-        ip = _client_ip(request)
-        until = throttle.locked_until(ip)
-        if until is not None:
-            minutes = max(1, round((until - time.time()) / 60))
-            log.warning("Вход в админку заблокирован (%s), осталось ~%d мин", ip, minutes)
+        key = _client_key(request)
+        if throttle.blocked(key):
+            log.warning("Вход в админку: слишком много неудачных попыток с %s", key)
            raise HTTPException(
-                status_code=429,
-                detail=f"Слишком много неудачных попыток. Вход заблокирован ещё на ~{minutes} мин.",
+                status_code=429, detail="Слишком много попыток входа, попробуйте позже"
            )
        ok_login = _same(body.login.strip(), config.login)
        ok_password = _same(body.password, config.password)
        if not (ok_login and ok_password):
-            throttle.register_failure(ip)
-            _remember(ip, False)
-            left = throttle.attempts_left(ip)
-            if throttle.locked_until(ip) is not None:
-                log.warning(
-                    "Неудачная попытка входа (%s): исчерпаны попытки, пауза %d мин",
-                    ip,
-                    config.lockout_minutes,
-                )
-                raise HTTPException(
-                    status_code=429,
-                    detail=f"Неверный логин или пароль. Попытки исчерпаны — вход заблокирован на {config.lockout_minutes} мин.",
-                )
-            log.warning("Неудачная попытка входа (%s), осталось попыток: %d", ip, left)
-            raise HTTPException(
-                status_code=401,
-                detail=f"Неверный логин или пароль. Осталось попыток: {left}.",
-            )
-        throttle.reset(ip)
-        previous = settings.last_attempt if settings is not None else None
-        _remember(ip, True)
-        if previous:
-            log.info(
-                "Успешный вход в админку (%s). Предыдущая попытка: %s, %s, %s",
-                ip,
-                _human_dt(previous.get("at")),
-                previous.get("ip"),
-                "успешная" if previous.get("ok") else "неудачная",
-            )
-        else:
-            log.info("Успешный вход в админку (%s)", ip)
+            throttle.register_failure(key)
+            log.warning("Неудачная попытка входа в админку (логин %r)", body.login[:40])
+            raise HTTPException(status_code=401, detail="Неверный логин или пароль")
+        throttle.reset(key)
        response.set_cookie(
            COOKIE_NAME,
            make_token(config.login, config.password),
@@ -233,6 +170,7 @@ def create_admin_router(
            secure=_secure(request),
            path="/",
        )
+        log.info("Вход в админку выполнен")
        return {"ok": True}

    @router.post("/logout")
@@ -241,17 +179,8 @@ def create_admin_router(
        return {"ok": True}

    @router.get("/state", dependencies=[Depends(require_auth)])
-    def state(request: Request) -> dict:
-        ip = _client_ip(request)
-        until = throttle.locked_until(ip)
-        payload = cache.state()
-        payload["throttle"] = {
-            "max_attempts": config.max_attempts,
-            "lockout_minutes": config.lockout_minutes,
-            "attempts_left": throttle.attempts_left(ip),
-            "locked_until": datetime.fromtimestamp(until).astimezone().isoformat() if until else None,
-        }
-        return payload
+    def state() -> dict:
+        return cache.state()

    @router.post("/refresh", dependencies=[Depends(require_auth)])
    def refresh() -> dict:
--- a/src/backend/main.py
+++ b/src/backend/main.py
@@ -1,9 +1,4 @@
-"""API-приложение расписания (FastAPI).
-
-Кроме публичных данных здесь живёт админка (backend/admin.py): она включается
-только если заданы ADMIN_LOGIN и ADMIN_PASSWORD, и открывается по секретному
-пути ADMIN_PATH. Все параметры — переменные окружения, см. .env.example.
-"""
+"""API-приложение расписания (FastAPI)."""

 from __future__ import annotations

@@ -27,7 +22,7 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name


 def _find_dotenv() -> Path | None:
-    """Ищем .env вверх от каталога модуля (общий .env в корне проекта)."""
+    """Ищем .env вверх от каталога модуля (локальная разработка)."""
    path = Path(__file__).resolve().parent
    for _ in range(5):
        env = path / ".env"
@@ -54,25 +49,12 @@ def _normalize_admin_path(raw: str | None) -> str:
    return path.rstrip("/") or "/"


-def _int_env(name: str, default: int) -> int:
-    raw = (os.getenv(name) or "").strip()
-    if not raw:
-        return default
-    try:
-        return int(raw)
-    except ValueError:
-        log.warning("%s=%r не число, беру %d", name, raw, default)
-        return default
-
-
 SCHEDULE_LINK = (os.getenv("SCHEDULE_LINK") or "").strip()
 RETRY_AFTER = float(os.getenv("SCHEDULE_RETRY_AFTER", "60"))
 SETTINGS_FILE = (os.getenv("SETTINGS_FILE") or "").strip()
 ADMIN_PATH = _normalize_admin_path(os.getenv("ADMIN_PATH"))
 ADMIN_LOGIN = (os.getenv("ADMIN_LOGIN") or "").strip()
 ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD") or ""
-ADMIN_MAX_ATTEMPTS = _int_env("ADMIN_MAX_ATTEMPTS", 3)
-ADMIN_LOCKOUT_MINUTES = _int_env("ADMIN_LOCKOUT_MINUTES", 15)


 def default_settings() -> SettingsStore:
@@ -108,17 +90,10 @@ def _day_arg(day: str) -> str:
 def create_app(
    cache: ScheduleCache | None = None,
    admin: AdminConfig | None = None,
-    settings: SettingsStore | None = None,
 ) -> FastAPI:
-    if cache is None:
-        settings = settings or default_settings()
-        cache = ScheduleCache(settings=settings, retry_after=RETRY_AFTER)
+    cache = cache or default_cache()
    admin = admin if admin is not None else AdminConfig(
-        path=ADMIN_PATH,
-        login=ADMIN_LOGIN,
-        password=ADMIN_PASSWORD,
-        max_attempts=ADMIN_MAX_ATTEMPTS,
-        lockout_minutes=ADMIN_LOCKOUT_MINUTES,
+        path=ADMIN_PATH, login=ADMIN_LOGIN, password=ADMIN_PASSWORD
    )

    @asynccontextmanager
@@ -135,13 +110,13 @@ def create_app(
    app.state.admin = admin

    if admin.enabled:
-        app.include_router(create_admin_router(cache, settings, admin))
+        app.include_router(create_admin_router(cache, admin))
        if admin.path:
-            log.info("Админка включена (путь задан в ADMIN_PATH)")
+            log.info("Админка включена (секретный путь задан)")
        else:
            log.warning("Админка включена, но ADMIN_PATH не задан — страница панели недоступна")
    else:
-        log.info("Админка выключена (не заданы ADMIN_LOGIN/ADMIN_PASSWORD)")
+        log.info("Админка выключена: не заданы ADMIN_LOGIN/ADMIN_PASSWORD")

    def _data() -> tuple[dict, list[dict]]:
        try:
@@ -173,7 +148,7 @@ def create_app(
        return {
            "title": "Расписание",
            "endpoints": {
-                "/groups": "Список групп (в порядке столбцов таблицы)",
+                "/groups": "Список групп",
                "/schedule/{group}": "Расписание группы",
                "/schedule/{group}/{day}": "Расписание группы на день",
                "/today?group={group}": "Расписание группы на сегодня",
--- a/src/backend/schedule/cache.py
+++ b/src/backend/schedule/cache.py
@@ -9,7 +9,8 @@
  удачное состояние и повторяем попытку не чаще, чем раз в retry_after секунд
  (вместо скачивания на каждый запрос);
 - настройки администратора (ссылка, интервал) живут в SettingsStore и
-  применяются на лету: смена ссылки проверяется до сохранения.
+  применяются на лету: смена ссылки проверяется до сохранения, принудительное
+  обновление идёт вне расписания.
 """

 from __future__ import annotations
@@ -100,24 +101,22 @@ class ScheduleCache:
            return self._day_times

    def status(self) -> dict:
-        """Состояние кэша (публичный /status): без ссылки и без админских данных."""
        with self._lock:
-            return self._status()
+            return {
+                "cache_ttl_seconds": self._ttl,
+                "interval_minutes": self.interval_minutes,
+                "last_updated": self._iso(self._loaded_at),
+                "table_modified": self._modified,
+                "error": self._error,
+            }

    def state(self) -> dict:
-        """Состояние для админки: то же плюс текущая ссылка и настройки."""
+        """Полное состояние для админки."""
        with self._lock:
-            state = self._status()
-            state["link"] = self._link
-            if self._settings is not None:
-                state["settings_file"] = str(self._settings.path) if self._settings.path else None
-                state["settings_save_error"] = self._settings.save_error
-                state["last_attempt"] = self._settings.last_attempt
-                state["last_success"] = self._settings.last_success
-            return state
+            return self._state()

    def warmup(self) -> None:
-        """Первая загрузка данных на старте приложения (ошибка не фатальна)."""
+        """Первый загруз данных на старте приложения (ошибка не фатальна)."""
        try:
            self.get()
        except ScheduleError as exc:
@@ -126,7 +125,7 @@ class ScheduleCache:
    # --- действия администратора ------------------------------------------------

    def force_reload(self) -> dict:
-        """Принудительно обновить расписание: скачиваем таблицу в любом случае."""
+        """Принудительно обновить расписание вне интервала (кнопка в админке)."""
        with self._lock:
            now = time.time()
            modified = fetch_table_modified(self._link) if self._link else None
@@ -137,7 +136,7 @@ class ScheduleCache:
                self._last_failed = now
                log.warning("Принудительное обновление не удалось: %s", exc)
                raise
-            return self.state()
+            return self._state()

    def apply_link(self, link: str) -> dict:
        """Проверить новую ссылку и, если она рабочая, переключить кэш на неё."""
@@ -162,11 +161,11 @@ class ScheduleCache:
                raise ScheduleError(f"Ссылка не подошла: {exc}") from exc
            if self._settings is not None:
                self._settings.set_link(link)
-            return self.state()
+            return self._state()

    def set_interval_minutes(self, minutes: int | str) -> int:
        if self._settings is None:
-            raise ScheduleError("Настройки не подключены: интервал задаётся в .env")
+            raise ScheduleError("Настройки не подключены: интервал задаётся через .env")
        value = self._settings.set_interval_minutes(minutes)
        with self._lock:
            self._ttl = value * 60
@@ -181,15 +180,16 @@ class ScheduleCache:
            return None
        return datetime.fromtimestamp(ts, datetime.now().astimezone().tzinfo).isoformat()

-    def _status(self) -> dict:
+    def _state(self) -> dict:
        return {
-            "cache_ttl_seconds": self._ttl,
+            "link": self._link,
            "interval_minutes": max(1, round(self._ttl / 60)),
            "last_updated": self._iso(self._loaded_at),
            "table_modified": self._modified,
            "error": self._error,
            "groups": len(self._data) if self._data else 0,
            "has_data": self._data is not None,
+            # при последнем чтении файла: изменилось ли его содержимое
            "changed": self._changed,
            "changed_at": self._iso(self._changed_at),
            "content_hash": (self._content_hash or "")[:12],
@@ -205,9 +205,9 @@ class ScheduleCache:
        )
        if fresh:
            return
-        self._refresh(now)
+        self._reload(now)

-    def _refresh(self, now: float) -> None:
+    def _reload(self, now: float) -> None:
        # служим старые данные, пока не истекло время повторной попытки
        if (
            self._data is not None
@@ -249,7 +249,6 @@ class ScheduleCache:
        digest = hashlib.sha256(xlsx).hexdigest()
        first_load = self._content_hash is None
        changed = not first_load and digest != self._content_hash
-
        sheets = parse_workbook(xlsx)
        data = parsing.parse_schedule(sheets)
        weeks = parsing.extract_week_ranges(sheets)
--- a/src/backend/schedule/lessons.py
+++ b/src/backend/schedule/lessons.py
@@ -495,40 +495,6 @@ def _normalize_marker_of(line: str) -> Optional[str]:
    return _normalize_marker(num or None)


-def _merge_detached_fragments(lessons: list[Lesson]) -> list[Lesson]:
-    """Достраивает занятие из оторвавшихся пустой строкой преподавателя/аудитории.
-
-    Пустая строка внутри ячейки (или красная заметка, снятая с целой строки)
-    отрывает хвост от предмета: «Предмет\nЛарина Ю.А.\n\n ауд.210» разбирается
-    как занятие без аудитории и «ауд. 210» без предмета — в индексе аудиторий
-    от такого занятия остаётся только список групп. Кусок без предмета цепляем
-    к предыдущему занятию, но только если у того этих полей ещё нет, иначе
-    это похоже на отдельное занятие параллельной подгруппы.
-    """
-    merged: list[Lesson] = []
-    for lesson in lessons:
-        prev = merged[-1] if merged else None
-        if (
-            prev is not None
-            and prev.subject
-            and not lesson.subject
-            and (lesson.teacher or lesson.room)
-            and (not lesson.marker or lesson.marker == prev.marker)
-            and (not lesson.teacher or not prev.teacher)
-            and (not lesson.room or not prev.room)
-        ):
-            notes = [n for n in (prev.note + "\n" + lesson.note).split("\n") if n]
-            merged[-1] = replace(
-                prev,
-                teacher=lesson.teacher or prev.teacher,
-                room=lesson.room or prev.room,
-                note="\n".join(dict.fromkeys(notes)),
-            )
-        else:
-            merged.append(lesson)
-    return merged
-
-
 def parse_lesson_cell(cell_text: str) -> list[Lesson]:
    """Текст ячейки -> список занятий.

@@ -559,8 +525,6 @@ def parse_lesson_cell(cell_text: str) -> list[Lesson]:
            lesson = replace(lesson, marker=last_marker)
        lessons.append(lesson)

-    lessons = _merge_detached_fragments(lessons)
-
    if not cell_notes:
        return lessons
    if not lessons:
--- a/src/backend/schedule/settings.py
+++ b/src/backend/schedule/settings.py
@@ -1,10 +1,8 @@
-"""Настройки, которые правит администратор.
+"""Настройки расписания, которые правит администратор.

-Хранятся в JSON-файле (`SETTINGS_FILE`, по умолчанию `data/settings.json` в
-корне проекта), поэтому переживают перезапуск службы: ссылка на таблицу,
-интервал обновления и история входов в админку. Если файл недоступен для
-записи — настройки живут в памяти, а сервис продолжает работать (об этом
-пишется предупреждение в лог и в состояние админки).
+Хранятся в JSON-файле (если задан путь) — так ссылка и интервал переживают
+перезапуск контейнера. Если путь не задан, настройки живут только в памяти
+(поведение прежних версий, прод можно не трогать).
 """

 from __future__ import annotations
@@ -13,8 +11,7 @@ import json
 import logging
 import os
 import threading
-from dataclasses import dataclass
-from datetime import datetime
+from dataclasses import asdict, dataclass
 from pathlib import Path

 from .errors import ScheduleError
@@ -25,40 +22,14 @@ DEFAULT_INTERVAL_MINUTES = 15
 MIN_INTERVAL_MINUTES = 1
 MAX_INTERVAL_MINUTES = 24 * 60

-def _default_settings_path() -> Path:
-    """`<корень проекта>/data/settings.json`.
-
-    В репозитории это три уровня вверх от пакета, а в docker-образе файлы лежат
-    плоско (/app/...), поэтому ищем корень по маркеру — requirements.txt.
-    """
-    here = Path(__file__).resolve()
-    for parent in here.parents:
-        if (parent / "requirements.txt").is_file():
-            return parent / "data" / "settings.json"
-    return here.parent / "data" / "settings.json"
-
-
-DEFAULT_SETTINGS_PATH = _default_settings_path()
-

@dataclass
 class Settings:
    link: str = ""
    interval_minutes: int = DEFAULT_INTERVAL_MINUTES
-    last_attempt: dict | None = None  # {"at": iso, "ip": str, "ok": bool}
-    last_success: dict | None = None  # {"at": iso, "ip": str}

    def as_dict(self) -> dict:
-        return {
-            "link": self.link,
-            "interval_minutes": self.interval_minutes,
-            "last_attempt": self.last_attempt,
-            "last_success": self.last_success,
-        }
-
-
-def clamp_interval(minutes: int) -> int:
-    return max(MIN_INTERVAL_MINUTES, min(MAX_INTERVAL_MINUTES, int(minutes)))
+        return asdict(self)


 def interval_from_env(default: int = DEFAULT_INTERVAL_MINUTES) -> int:
@@ -68,19 +39,18 @@ def interval_from_env(default: int = DEFAULT_INTERVAL_MINUTES) -> int:
        try:
            return clamp_interval(int(float(raw_minutes)))
        except ValueError:
-            log.warning("SCHEDULE_INTERVAL_MINUTES=%r не число, беру по умолчанию", raw_minutes)
+            log.warning("SCHEDULE_INTERVAL_MINUTES=%r не число, беру значение по умолчанию", raw_minutes)
    raw_ttl = (os.getenv("SCHEDULE_CACHE_TTL") or "").strip()
    if raw_ttl:
        try:
            return clamp_interval(round(float(raw_ttl) / 60) or 1)
        except ValueError:
-            log.warning("SCHEDULE_CACHE_TTL=%r не число, беру по умолчанию", raw_ttl)
+            log.warning("SCHEDULE_CACHE_TTL=%r не число, беру значение по умолчанию", raw_ttl)
    return default


-def settings_path_from_env() -> Path | None:
-    raw = (os.getenv("SETTINGS_FILE") or "").strip()
-    return Path(raw) if raw else DEFAULT_SETTINGS_PATH
+def clamp_interval(minutes: int) -> int:
+    return max(MIN_INTERVAL_MINUTES, min(MAX_INTERVAL_MINUTES, int(minutes)))


 class SettingsStore:
@@ -94,7 +64,6 @@ class SettingsStore:
    ) -> None:
        self._path = Path(path) if path else None
        self._lock = threading.RLock()
-        self._save_error: str | None = None
        self._settings = Settings(
            link=(link or "").strip(), interval_minutes=clamp_interval(interval_minutes)
        )
@@ -102,10 +71,6 @@ class SettingsStore:

    # --- чтение -----------------------------------------------------------------

-    @property
-    def path(self) -> Path | None:
-        return self._path
-
    @property
    def link(self) -> str:
        with self._lock:
@@ -116,22 +81,6 @@ class SettingsStore:
        with self._lock:
            return self._settings.interval_minutes

-    @property
-    def last_attempt(self) -> dict | None:
-        with self._lock:
-            return dict(self._settings.last_attempt) if self._settings.last_attempt else None
-
-    @property
-    def last_success(self) -> dict | None:
-        with self._lock:
-            return dict(self._settings.last_success) if self._settings.last_success else None
-
-    @property
-    def save_error(self) -> str | None:
-        """Текст ошибки, если настройки не удаётся сохранить на диск."""
-        with self._lock:
-            return self._save_error
-
    def as_dict(self) -> dict:
        with self._lock:
            return self._settings.as_dict()
@@ -161,17 +110,6 @@ class SettingsStore:
            self._save()
        return value

-    def record_login(self, ip: str, ok: bool) -> dict:
-        """Запомнить попытку входа: откуда, когда и чем закончилась."""
-        now = datetime.now().astimezone().replace(microsecond=0)
-        attempt = {"at": now.isoformat(), "ip": ip or "неизвестно", "ok": bool(ok)}
-        with self._lock:
-            self._settings.last_attempt = attempt
-            if ok:
-                self._settings.last_success = {"at": attempt["at"], "ip": attempt["ip"]}
-            self._save()
-        return attempt
-
    # --- файл -------------------------------------------------------------------

    def _load(self) -> None:
@@ -180,7 +118,7 @@ class SettingsStore:
        try:
            raw = json.loads(self._path.read_text(encoding="utf-8"))
        except (OSError, ValueError) as exc:
-            log.warning("Не читается файл настроек %s: %s (беру значения из окружения)", self._path, exc)
+            log.warning("Не читается файл настроек %s: %s (остаюсь на значениях из окружения)", self._path, exc)
            return
        if not isinstance(raw, dict):
            log.warning("Файл настроек %s не JSON-объект, игнорирую", self._path)
@@ -193,10 +131,6 @@ class SettingsStore:
                self._settings.interval_minutes = clamp_interval(int(raw["interval_minutes"]))
            except (TypeError, ValueError):
                log.warning("interval_minutes в %s не число, игнорирую", self._path)
-        for key in ("last_attempt", "last_success"):
-            value = raw.get(key)
-            if isinstance(value, dict) and value.get("at"):
-                setattr(self._settings, key, value)
        log.info(
            "Настройки из %s: интервал %s мин, ссылка %s",
            self._path,
@@ -215,7 +149,5 @@ class SettingsStore:
                encoding="utf-8",
            )
            tmp.replace(self._path)
-            self._save_error = None
        except OSError as exc:
-            self._save_error = str(exc)
            log.warning("Не удалось сохранить настройки в %s: %s (живу в памяти)", self._path, exc)
--- a/src/frontend/admin.html
+++ b/src/frontend/admin.html
@@ -4,11 +4,11 @@
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="robots" content="noindex, nofollow">
-  <title>Админка расписания</title>
+  <title>Админ кабинет</title>
  <link rel="icon" type="image/svg+xml" href="/img/app-icon.svg">
  <link rel="stylesheet" href="/style.css">
  <style>
-    .admin-wrap { max-width: 760px; margin: 0 auto; padding: 26px 18px 60px; }
+    .admin-wrap { max-width: 720px; margin: 0 auto; padding: 26px 18px 60px; }
    .admin-head { display: flex; align-items: center; gap: 12px; margin-bottom: 6px; }
    .admin-head img { width: 40px; height: 40px; }
    .admin-title { font-size: 22px; font-weight: 700; color: var(--text); }
@@ -40,33 +40,49 @@
    .admin-chip .k { font-size: 12px; color: var(--muted); }
    .admin-chip .v { font-size: 14px; font-weight: 600; color: var(--text); word-break: break-word; overflow-wrap: anywhere; }
    .admin-error { color: var(--accent-red-bright); font-size: 13px; margin-top: 10px; word-break: break-word; overflow-wrap: anywhere; }
-    .admin-warn { color: #b8860b; font-size: 13px; margin-top: 10px; word-break: break-word; }
    .admin-hint { color: var(--muted-2); font-size: 12px; margin-top: 8px; }
    .hidden { display: none !important; }
-    .bad { color: var(--accent-red-bright); }
-    .good { color: #2f9e5f; }
+    abbr.code { font-family: monospace; font-size: 13px; color: var(--text); word-break: break-all; }

    /* всплывающие уведомления вместо alert(): сами исчезают через 15 секунд */
    #toast-wrap {
-      position: fixed; left: 50%; bottom: 18px; transform: translateX(-50%);
-      z-index: 9999; display: flex; flex-direction: column; gap: 8px;
+      position: fixed;
+      left: 50%;
+      bottom: 18px;
+      transform: translateX(-50%);
+      z-index: 9999;
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
      width: min(560px, calc(100vw - 32px));
    }
    .toast {
-      display: flex; align-items: flex-start; gap: 10px;
-      background: var(--surface); border: 1px solid var(--border-2);
+      display: flex;
+      align-items: flex-start;
+      gap: 10px;
+      background: var(--surface);
+      border: 1px solid var(--border-2);
      border-left: 4px solid var(--accent-blue);
      box-shadow: 0 8px 24px var(--shadow);
-      padding: 12px 14px; font-size: 14px; color: var(--text);
-      white-space: pre-line; animation: toast-in .18s ease-out;
+      padding: 12px 14px;
+      font-size: 14px;
+      color: var(--text);
+      white-space: pre-line;
+      animation: toast-in .18s ease-out;
    }
    .toast.ok { border-left-color: #2f9e5f; }
    .toast.error { border-left-color: var(--accent-red-bright); }
    .toast.hide { opacity: 0; transition: opacity .3s ease; }
    .toast .toast-text { flex: 1; min-width: 0; overflow-wrap: anywhere; }
    .toast .toast-close {
-      flex: 0 0 auto; border: none; background: none; color: var(--muted);
-      font-size: 15px; line-height: 1; cursor: pointer; padding: 2px 4px;
+      flex: 0 0 auto;
+      border: none;
+      background: none;
+      color: var(--muted);
+      font-size: 15px;
+      line-height: 1;
+      cursor: pointer;
+      padding: 2px 4px;
    }
    .toast .toast-close:hover { color: var(--text); }
    @keyframes toast-in {
@@ -79,9 +95,8 @@
  <div class="admin-wrap">
    <div class="admin-head">
      <img src="/img/owl.svg" alt="">
-      <div class="admin-title">Админка расписания</div>
+      <div class="admin-title">Админ кабинет</div>
    </div>
-    <div class="admin-sub">Управление источником данных и обновлением. Страница доступна только по секретной ссылке.</div>

    <section id="login-card" class="admin-card hidden">
      <h2>Вход</h2>
@@ -100,13 +115,6 @@
        <h2>Состояние</h2>
        <div class="admin-status" id="status-chips"></div>
        <div id="state-error" class="admin-error hidden"></div>
-        <div id="state-warn" class="admin-warn hidden"></div>
-      </div>
-
-      <div class="admin-card">
-        <h2>Входы в админку</h2>
-        <div class="admin-status" id="auth-chips"></div>
-        <div class="admin-hint">Каждая попытка входа запоминается: откуда, когда и чем закончилась. После нескольких неудач вход временно блокируется.</div>
      </div>

      <div class="admin-card">
@@ -119,7 +127,7 @@
          <button class="admin-btn" id="save-link" type="button">Сохранить ссылку</button>
        </div>
        <div class="admin-hint">Ссылка проверяется скачиванием: если не открывается — не сохранится, данные на сайте останутся прежними.
-          Значение хранится в файле настроек и <b>имеет приоритет над .env</b> — именно по нему сайт берёт расписание.</div>
+          Это значение хранится в настройках стенда и <b>имеет приоритет над .env</b> — именно по нему сайт берёт расписание.</div>
      </div>

      <div class="admin-card">
@@ -132,7 +140,8 @@
          <button class="admin-btn secondary" id="save-interval" type="button">Сохранить интервал</button>
          <button class="admin-btn" id="refresh" type="button">Обновить сейчас</button>
        </div>
-        <div class="admin-hint">По интервалу расписание перечитывается, только если на Диске изменилась дата файла. Кнопка «Обновить сейчас» скачивает таблицу всегда — её и нажимайте сразу после правок.</div>
+        <div class="admin-hint">«Обновить сейчас» скачивает таблицу вне интервала; при большой таблице занимает несколько секунд.
+          Правки в таблице подхватываются этой кнопкой или очередным обновлением по интервалу; после обновления видно, изменился ли файл на Диске.</div>
      </div>

      <div class="admin-card">
@@ -162,6 +171,7 @@
      close.setAttribute("aria-label", "Закрыть");
      el.append(text, close);
      wrap.appendChild(el);
+
      const hide = () => {
        clearTimeout(timer);
        el.classList.add("hide");
@@ -198,71 +208,33 @@
      return isNaN(d) ? String(value) : d.toLocaleString("ru-RU", { dateStyle: "short", timeStyle: "short" });
    }

-    function chip(key, value, cls) {
+    function chip(key, value) {
      const div = document.createElement("div");
      div.className = "admin-chip";
      div.innerHTML = `<div class="k">${key}</div><div class="v"></div>`;
-      const v = div.querySelector(".v");
-      v.textContent = value;
-      if (cls) v.classList.add(cls);
+      div.querySelector(".v").textContent = value;
      return div;
    }

-    function loginText(info) {
-      if (!info) return "нет данных";
-      // у успешного входа поля ok нет — там итог и так известен
-      const status = info.ok === undefined ? "" : ` · ${info.ok ? "успешно" : "неудачно"}`;
-      return `${fmt(info.at)} · ${info.ip}${status}`;
-    }
-
    function renderState(state) {
      const chips = $("status-chips");
      chips.innerHTML = "";
      chips.appendChild(chip("Интервал обновления", `${state.interval_minutes} мин`));
      chips.appendChild(chip("Обновлено", fmt(state.last_updated)));
+      chips.appendChild(chip("Таблица изменена", fmt(state.table_modified)));
      chips.appendChild(chip(
        "Файл при последнем обновлении",
-        state.changed ? "изменился" : "без изменений",
-        state.changed ? "good" : null,
+        state.changed ? "изменился ✓" : "без изменений (та же версия)",
      ));
-      chips.appendChild(chip("Дата файла на Диске", fmt(state.table_modified)));
-      chips.appendChild(chip("Групп в расписании", String(state.groups)));
+      chips.appendChild(chip("Содержимое менялось", fmt(state.changed_at)));
      if (state.content_hash) chips.appendChild(chip("sha256 файла", state.content_hash));
+      chips.appendChild(chip("Групп в расписании", String(state.groups)));
      chips.appendChild(chip("Текущая ссылка", state.link || "не задана"));
-      if (state.settings_file) chips.appendChild(chip("Файл настроек", state.settings_file));
-
-      const auth = $("auth-chips");
-      auth.innerHTML = "";
-      const attempt = state.last_attempt;
-      auth.appendChild(chip(
-        "Последняя попытка входа",
-        loginText(attempt),
-        attempt ? (attempt.ok ? "good" : "bad") : null,
-      ));
-      auth.appendChild(chip("Последний успешный вход", loginText(state.last_success)));
-      const throttle = state.throttle || {};
-      if (throttle.locked_until) {
-        auth.appendChild(chip("Вход заблокирован до", fmt(throttle.locked_until), "bad"));
-      } else if (throttle.max_attempts) {
-        auth.appendChild(chip(
-          "Осталось попыток",
-          `${throttle.attempts_left} из ${throttle.max_attempts}`,
-        ));
-      }
-
      $("link").value = state.link || "";
      $("interval").value = state.interval_minutes;
-
      const err = $("state-error");
      err.textContent = state.error ? "Ошибка загрузки: " + state.error : "";
      err.classList.toggle("hidden", !state.error);
-
-      const warn = $("state-warn");
-      warn.textContent = state.settings_save_error
-        ? "Настройки не сохраняются на диск: " + state.settings_save_error +
-          " — после перезапуска службы ссылка и интервал вернутся к значениям из .env."
-        : "";
-      warn.classList.toggle("hidden", !state.settings_save_error);
    }

    function showLogin(show) {
@@ -281,10 +253,7 @@
    async function loadState() {
      const r = await api("/state");
      if (r.status === 401) { showLogin(true); return; }
-      if (!r.ok) {
-        toast("Не удалось получить состояние: " + ((r.data && r.data.detail) || r.status), "error");
-        return;
-      }
+      if (!r.ok) { toast("Не удалось получить состояние: " + ((r.data && r.data.detail) || r.status), "error"); return; }
      showLogin(false);
      renderState(r.data);
    }
--- a/src/frontend/main.py
+++ b/src/frontend/main.py
@@ -1,7 +1,7 @@
-"""Фронтенд расписания: статики, прокси к API и страница админки.
+"""Фронтенд расписания: статики, прокси к API бэкенда и страница админки.

-Страница админки отдаётся по секретному пути из ADMIN_PATH; сам API админки —
-/api/admin/* (проксируется в backend). Если ADMIN_PATH не задан, страницы нет.
+Админка живёт по секретному пути из ADMIN_PATH (см. backend/admin.py):
+сам путь не публикуется, входа с сайта нет.
 """

 from __future__ import annotations
@@ -21,32 +21,14 @@ from fastapi.staticfiles import StaticFiles
 log = logging.getLogger(__name__)
 logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")

+load_dotenv(Path(__file__).parent / ".env")

-def _find_dotenv() -> Path | None:
-    """Ищем .env вверх от каталога модуля: один общий .env в корне проекта."""
-    path = Path(__file__).resolve().parent
-    for _ in range(5):
-        env = path / ".env"
-        if env.is_file():
-            return env
-        if path.parent == path:
-            break
-        path = path.parent
-    return None
-
-
-_dotenv_path = _find_dotenv()
-if _dotenv_path:
-    load_dotenv(_dotenv_path)
-
-# Адрес бэкенда: в docker это http://api:8000 (задаётся в docker-compose),
-# локально — http://127.0.0.1:8000.
-SCHEDULE_API = os.getenv("SCHEDULE_API", "http://127.0.0.1:8000").rstrip("/")
 # Бэкенд на холодном кэше скачивает таблицу (до 2 минут), таймаут выше.
+SCHEDULE_API = os.getenv("SCHEDULE_API", "http://127.0.0.1:8000").rstrip("/")
 PROXY_TIMEOUT = float(os.getenv("SCHEDULE_PROXY_TIMEOUT", "150"))
 ADMIN_PATH = (os.getenv("ADMIN_PATH") or "").strip().rstrip("/")
 STATIC_DIR = Path(__file__).parent / "static"
-# страница админки вне static: прямой доступ по /admin.html закрыт
+# страница админки лежит ВНЕ static: прямой доступ по /admin.html запрещён
 ADMIN_PAGE = Path(__file__).parent / "admin.html"

 app = FastAPI(title="Расписание — фронт")
@@ -69,7 +51,7 @@ def _proxy(path: str, params: dict) -> object:
        except Exception:
            detail = resp.text
        raise HTTPException(status_code=resp.status_code, detail=detail)
-    # данные не кэшируем: браузер всегда показывает актуальное расписание
+    # данные не кэшируем: после «Обновить сейчас» браузер должен видеть свежее
    return JSONResponse(content=resp.json(), headers={"Cache-Control": "no-store"})


@@ -162,18 +144,12 @@ async def api_admin(rest: str, request: Request):
    cookie = request.headers.get("cookie")
    if cookie:
        headers["Cookie"] = cookie
-    forwarded = request.headers.get("x-forwarded-for")
-    if forwarded:
-        headers["X-Forwarded-For"] = forwarded
-    forwarded_proto = request.headers.get("x-forwarded-proto")
-    if forwarded_proto:
-        headers["X-Forwarded-Proto"] = forwarded_proto
    return await run_in_threadpool(
        _proxy_admin, request.method, f"api/admin/{rest}", body, headers
    )


-# --- статики и админка --------------------------------------------------------
+# --- статики -----------------------------------------------------------------


@app.get("/")
--- a/tests/test_admin.py
+++ b/tests/test_admin.py
@@ -1,12 +1,13 @@
-"""Тесты админки: вход, блокировка после неудач, история входов, ссылка/интервал/force."""
+"""Тесты админки: вход по cookie, смена ссылки/интервала, принудительное обновление."""

 import json
+import time

 import pytest
 from fastapi.testclient import TestClient

 import main
-from admin import AdminConfig, make_token, verify_token
+from admin import LOGIN_MAX_FAILURES, AdminConfig, make_token, verify_token
 from fixtures import fixture_xlsx, make_cache
 from schedule import ScheduleError
 from schedule.settings import SettingsStore
@@ -28,8 +29,8 @@ def cache(monkeypatch, store):


@pytest.fixture()
-def client(cache, store):
-    app = main.create_app(cache, admin=ADMIN, settings=store)
+def client(cache):
+    app = main.create_app(cache, admin=ADMIN)
    with TestClient(app) as c:
        yield c

@@ -74,7 +75,6 @@ def test_login_and_state(client, cache):
    assert state["interval_minutes"] == 15
    assert state["groups"] == 2
    assert state["error"] is None
-    assert state["throttle"]["max_attempts"] == ADMIN.max_attempts


 def test_logout(client):
@@ -84,6 +84,14 @@ def test_logout(client):
    assert client.get("/api/admin/state").status_code == 401


+def test_login_throttled_after_failures(client):
+    for _ in range(LOGIN_MAX_FAILURES):
+        assert do_login(client, password="неверный").status_code == 401
+    # дальше — отказ, даже с верным паролем, пока не истекло окно
+    assert do_login(client, password="неверный").status_code == 429
+    assert do_login(client, password="s3cret").status_code == 429
+
+
 def test_token_helpers():
    token = make_token("admin", "s3cret", ttl=60)
    assert verify_token(token, "s3cret")
@@ -93,51 +101,7 @@ def test_token_helpers():
    assert not verify_token(make_token("admin", "s3cret", ttl=-5), "s3cret")


-# --- блокировка после неудачных попыток ------------------------------------------
-
-
-def test_lockout_after_configured_attempts(client):
-    """Разрешённые попытки тратятся, следующая попытка включает паузу."""
-    for _ in range(ADMIN.max_attempts - 1):
-        resp = do_login(client, password="неверный")
-        assert resp.status_code == 401
-        assert "Осталось попыток" in resp.json()["detail"]
-
-    exhausted = do_login(client, password="неверный")
-    assert exhausted.status_code == 429
-    assert "заблокирован" in exhausted.json()["detail"].lower()
-    # пауза действует и для верного пароля
-    assert do_login(client, password="s3cret").status_code == 429
-
-
-def test_successful_login_resets_failures(client):
-    assert do_login(client, password="неверный").status_code == 401
-    assert do_login(client).status_code == 200
-    # счётчик сброшен: ещё две неудачи не блокируют
-    assert do_login(client, password="неверный").status_code == 401
-    assert do_login(client, password="неверный").status_code == 401
-    assert do_login(client).status_code == 200
-
-
-# --- история входов ---------------------------------------------------------------
-
-
-def test_login_history_visible_and_saved(client, store):
-    assert do_login(client, password="неверный").status_code == 401
-    assert do_login(client).status_code == 200
-
-    state = client.get("/api/admin/state").json()
-    assert state["last_attempt"]["ok"] is True
-    assert state["last_attempt"]["ip"]  # откуда
-    assert state["last_attempt"]["at"]  # когда
-    assert state["last_success"]["ip"] == state["last_attempt"]["ip"]
-
-    saved = json.loads(store.path.read_text(encoding="utf-8"))
-    assert saved["last_attempt"]["ok"] is True
-    assert saved["last_success"]["at"]
-
-
-# --- интервал --------------------------------------------------------------------
+# --- интервал ------------------------------------------------------------------


 def test_set_interval(client, cache, store):
@@ -148,9 +112,11 @@ def test_set_interval(client, cache, store):
    assert cache.interval_minutes == 30
    assert cache._ttl == 1800
    assert client.get("/api/admin/state").json()["interval_minutes"] == 30
-    saved = json.loads(store.path.read_text(encoding="utf-8"))
+    # сохранилось на диск
+    saved = json.loads((store._path).read_text(encoding="utf-8"))
    assert saved["interval_minutes"] == 30
-    assert SettingsStore(path=store.path).interval_minutes == 30
+    # новый процесс видит сохранённое значение
+    assert SettingsStore(path=store._path).interval_minutes == 30


@pytest.mark.parametrize("value, status", [(0, 400), (1441, 400), (-5, 400), ("abc", 422)])
@@ -168,9 +134,10 @@ def test_set_link(client, cache, store):
    before = cache.calls["download"]
    resp = client.post("/api/admin/link", json={"link": "  https://disk.yandex.ru/i/new  "})
    assert resp.status_code == 200
-    assert resp.json()["link"] == "https://disk.yandex.ru/i/new"
+    state = resp.json()
+    assert state["link"] == "https://disk.yandex.ru/i/new"
    assert cache.calls["download"] == before + 1  # перечитали таблицу
-    assert json.loads(store.path.read_text(encoding="utf-8"))["link"] == "https://disk.yandex.ru/i/new"
+    assert json.loads(store._path.read_text(encoding="utf-8"))["link"] == "https://disk.yandex.ru/i/new"


 def test_set_link_rejects_broken(client, cache, store):
@@ -180,10 +147,12 @@ def test_set_link_rejects_broken(client, cache, store):
    resp = client.post("/api/admin/link", json={"link": "https://disk.yandex.ru/i/broken"})
    assert resp.status_code == 400
    assert "не подошла" in resp.json()["detail"]
+    # ссылка и данные не изменились
    assert cache.state()["link"] == old_link
    assert cache.state()["has_data"] is True
-    if store.path.exists():
-        assert json.loads(store.path.read_text(encoding="utf-8"))["link"] != "https://disk.yandex.ru/i/broken"
+    # в файл настроек нерабочая ссылка не попала
+    if store._path.exists():
+        assert json.loads(store._path.read_text(encoding="utf-8"))["link"] != "https://disk.yandex.ru/i/broken"


 def test_set_empty_link(client, cache):
@@ -198,9 +167,9 @@ def test_set_empty_link(client, cache):

 def test_force_refresh_ignores_ttl_and_modified(client, cache):
    do_login(client)
-    client.get("/api/admin/state")
+    client.get("/api/admin/state")  # кэш свежий, дальше без принуждения не качали бы
    downloads = cache.calls["download"]
-    cache._ttl = 3600  # кэш свежий; обычное обновление не сработало бы
+    cache._ttl = 3600
    resp = client.post("/api/admin/refresh")
    assert resp.status_code == 200
    assert cache.calls["download"] == downloads + 1
@@ -213,14 +182,15 @@ def test_force_refresh_reports_error(client, cache):
    resp = client.post("/api/admin/refresh")
    assert resp.status_code == 502
    assert cache.state()["error"] is not None
-    assert cache.state()["has_data"] is True  # старые данные не потеряли
+    # старые данные не потеряли
+    assert cache.state()["has_data"] is True


 # --- выключенная админка -----------------------------------------------------------


-def test_admin_disabled_without_credentials(cache, store):
-    app = main.create_app(cache, admin=AdminConfig(), settings=store)
+def test_admin_disabled_without_credentials(cache):
+    app = main.create_app(cache, admin=AdminConfig())
    with TestClient(app) as c:
        assert c.get("/api/admin/state").status_code == 404
        assert c.post("/api/admin/login", json={"login": "a", "password": "b"}).status_code == 404
--- a/tests/test_api.py
+++ b/tests/test_api.py
@@ -171,7 +171,11 @@ def test_cache_no_repeated_download(client, cache):


 def test_modified_unchanged_no_download(cache):
-    """По интервалу сверяем modified: если таблица не менялась — не скачиваем."""
+    """По интервалу сверяем modified: если таблица не менялась — не скачиваем.
+
+    Принудительное обновление из админки при этом качает файл всегда
+    (см. test_force_refresh_ignores_ttl_and_modified).
+    """
    cache._ttl = 0
    cache.get()
    cache.get()
@@ -179,7 +183,7 @@ def test_modified_unchanged_no_download(cache):
    assert cache.calls["modified"] >= 2


-def test_status_reports_file_changes(monkeypatch):
+def test_state_reports_file_changes(monkeypatch):
    """Кэш показывает, изменилось ли содержимое файла при последнем чтении."""
    import schedule.cache as cache_mod
    from fixtures import fixture_sheets
@@ -190,30 +194,25 @@ def test_status_reports_file_changes(monkeypatch):
        sheets["Бакалавры и магистры"].rows[2][6] = f"Математика\nСмирнов А.В.\nауд. {room}"
        return build_workbook(sheets)

-    files = {"data": xlsx_with_room("215"), "modified": "m1"}
-    monkeypatch.setattr(
-        cache_mod, "fetch_table_modified", lambda url, timeout=20.0: files["modified"]
-    )
+    files = {"data": xlsx_with_room("215")}
+    monkeypatch.setattr(cache_mod, "fetch_table_modified", lambda url, timeout=20.0: "m1")
    monkeypatch.setattr(cache_mod, "download_schedule", lambda url, timeout=60.0: files["data"])
-    cache = ScheduleCache("test-link", ttl_seconds=0, retry_after=60)
+    cache = ScheduleCache("test-link", ttl_seconds=3600, retry_after=60)

    cache.get()
-    first = cache.status()
+    first = cache.state()
    assert first["content_hash"]
    assert first["changed"] is False  # первая загрузка — не «изменение»
    assert first["changed_at"] is not None

    files["data"] = xlsx_with_room("216")
-    files["modified"] = "m2"
-    cache.get()  # ttl=0 и новый modified — перечитываем таблицу
-    changed = cache.status()
+    cache.force_reload()
+    changed = cache.state()
    assert changed["changed"] is True
    assert changed["content_hash"] != first["content_hash"]

-    # новая ревизия файла с тем же содержимым → скачали, но изменений нет
-    files["modified"] = "m3"
-    cache.get()
-    assert cache.status()["changed"] is False
+    cache.force_reload()
+    assert cache.state()["changed"] is False  # тот же файл — изменений нет


 def test_cache_stale_while_error(cache):
--- a/tests/test_deploy.py
+++ b/tests/test_deploy.py
@@ -1,8 +1,7 @@
 """Проверки сборки образов: все нужные файлы должны копироваться.

-Ошибка «в Dockerfile забыли COPY какого-то модуля» роняет контейнер на импорте,
-а тесты из исходников её не видят (они запускаются из рабочей копии). Ловим
-статически, без docker.
+Ошибка «в Dockerfile забыли COPY admin.py» роняет контейнер на импорте, а
+локальные тесты её не видят (они запускаются из исходников). Ловим статически.
 """

 from pathlib import Path
@@ -34,18 +33,15 @@ def test_frontend_image_copies_page_and_static():
        assert path in stage, f"{path} не копируется в образ frontend"


-def test_compose_passes_required_env():
+def test_compose_passes_admin_settings():
    compose = COMPOSE.read_text(encoding="utf-8")
    for var in (
-        "SCHEDULE_LINK",
-        "SCHEDULE_INTERVAL_MINUTES",
-        "SCHEDULE_API",
        "ADMIN_PATH",
        "ADMIN_LOGIN",
        "ADMIN_PASSWORD",
-        "ADMIN_MAX_ATTEMPTS",
-        "ADMIN_LOCKOUT_MINUTES",
+        "SCHEDULE_INTERVAL_MINUTES",
        "SETTINGS_FILE",
+        "SCHEDULE_API",
    ):
        assert var in compose, f"{var} не передаётся контейнерам"
    assert "schedule_data:/data" in compose, "том для настроек админки не подключён"
--- a/tests/test_lessons.py
+++ b/tests/test_lessons.py
@@ -14,7 +14,7 @@ def lessons(text):

 def one(text):
    ls = parse_lesson_cell(text)
-    assert len(ls) == 1, f"ожидалось 1 занятие, got: {ls}"
+    assert len(ls) == 1, f"ожидалося 1 занятие, got: {ls}"
    return ls[0].to_dict()


@@ -295,53 +295,6 @@ def test_lesson_with_red_between_lessons():
    assert ls[1]["subject"] == "Язык UML и CASE-системы"


-# --- оторвавшиеся пустой строкой преподаватель/аудитория ---------------------------
-
-
-def test_room_detached_by_blank_line():
-    # ПИЭ-31БО, вторник: «ауд.210» оторвана пустой строкой от предмета
-    result = one("Программная инженерия\nЛарина Ю.А.\n\n ауд.210")
-    assert result["subject"] == "Программная инженерия"
-    assert result["teacher"] == "Ларина Ю.А."
-    assert result["room"] == "ауд. 210"
-
-
-def test_teacher_and_room_detached_by_red_note():
-    # ИВТ-13БО, четверг: красная заметка снята со своей строки, осталась пустая
-    raw = f"Практикум по матанализу\n{R}пара для тех кто не ТОП{Cc}\nШабаршина Г.В.\nауд. 219"
-    result = one(raw)
-    assert result["subject"] == "Практикум по матанализу"
-    assert result["teacher"] == "Шабаршина Г.В."
-    assert result["room"] == "ауд. 219"
-    assert result["note"] == "пара для тех кто не ТОП"
-
-
-def test_detached_room_inherits_marker():
-    ls = lessons("к.в. - 2\nФизика\nИванов И.И.\n\nауд. 301")
-    assert len(ls) == 1
-    assert ls[0]["marker"] == "к.в. - 2"
-    assert ls[0]["room"] == "ауд. 301"
-
-
-def test_detached_room_kept_if_prev_has_room():
-    ls = lessons("Физика\nСмирнов А.В.\nауд. 221\n\nауд. 222")
-    assert len(ls) == 2
-    assert ls[0]["room"] == "ауд. 221"
-
-
-def test_detached_teacher_kept_if_prev_has_teacher():
-    ls = lessons("Физика\nСмирнов А.В.\nауд. 221\n\nПетров П.П.\nауд. 222")
-    assert len(ls) == 2
-    assert ls[0]["teacher"] == "Смирнов А.В."
-
-
-def test_lesson_after_detached_room_starts_fresh():
-    ls = lessons("Физика\nСмирнов А.В.\n\nауд. 221\n\nХимия\nПетров П.П.\nауд. 222")
-    assert len(ls) == 2
-    assert ls[0]["room"] == "ауд. 221"
-    assert ls[1]["subject"] == "Химия"
-
-
 # --- пустые и экзотические ----------------------------------------------------------


--- a/tests/test_parsing.py
+++ b/tests/test_parsing.py
@@ -145,18 +145,6 @@ def test_teacher_room_index(data):
    assert room_301["2"]["ч"][0]["groups"] == ["ИВТ-11БО"]


-def test_room_index_detached_room():
-    """Аудитория, оторванная пустой строкой, попадает в индекс с предметом и преподавателем."""
-    sheets = fixture_sheets()
-    sheets[parsing.MAIN_SHEET].rows[6][7] = "Химия\nПетров П.П.\n\n ауд. 201"
-    data = parsing.parse_schedule(make_sheets(sheets))
-    _, rooms = parsing.build_teacher_room_index(data)
-    entry = rooms["ауд. 201"]["вторник"]["1"]["ч"][0]
-    assert entry["subject"] == "Химия"
-    assert entry["teacher"] == "Петров П.П."
-    assert entry["groups"] == ["ИТ-12БО"]
-
-
 def test_day_times(data):
    times = parsing.build_day_times(data)
    assert times["понедельник"] == {"1": "9:00-10:35", "2": "10:45-12:20"}
--- a/tests/test_settings.py
+++ b/tests/test_settings.py
@@ -1,4 +1,4 @@
-"""Тесты хранилища настроек админки: ссылка, интервал, история входов."""
+"""Тесты хранилища настроек администратора (ссылка, интервал)."""

 import json

@@ -17,8 +17,6 @@ def test_defaults():
    store = SettingsStore()
    assert store.link == ""
    assert store.interval_minutes == DEFAULT_INTERVAL_MINUTES
-    assert store.last_attempt is None
-    assert store.last_success is None


 def test_persist_and_reload(tmp_path):
@@ -64,46 +62,20 @@ def test_corrupt_file_is_tolerated(tmp_path):
    assert store.interval_minutes == 7


-def test_login_history_saved(tmp_path):
-    path = tmp_path / "settings.json"
-    store = SettingsStore(link="l", path=path)
-
-    store.record_login("10.0.0.1", ok=False)
-    assert store.last_attempt["ip"] == "10.0.0.1"
-    assert store.last_attempt["ok"] is False
-    assert store.last_attempt["at"]
-    assert store.last_success is None  # успешных ещё не было
-
-    store.record_login("10.0.0.2", ok=True)
-    assert store.last_success["ip"] == "10.0.0.2"
-
-    # история переживает перезапуск: читаем тем же путём
-    again = SettingsStore(path=path)
-    assert again.last_attempt["ip"] == "10.0.0.2"
-    assert again.last_attempt["ok"] is True
-    assert again.last_success["ip"] == "10.0.0.2"
+def test_no_path_keeps_settings_in_memory():
+    store = SettingsStore(link="l", interval_minutes=3)
+    assert store.set_interval_minutes(10) == 10
+    assert store.interval_minutes == 10
+    assert store.set_link("l2") == "l2"
+    assert store.link == "l2"


-def test_unwritable_path_marks_save_error(tmp_path):
+def test_unwritable_path_does_not_crash(tmp_path):
    blocker = tmp_path / "blocker"
    blocker.write_text("x", encoding="utf-8")
    store = SettingsStore(link="l", interval_minutes=3, path=blocker / "settings.json")
-    assert store.set_interval_minutes(10) == 10  # в памяти меняется
+    assert store.set_interval_minutes(10) == 10
    assert store.interval_minutes == 10
-    assert store.save_error  # и видно, что на диск не сохранилось
-
-
-def test_default_settings_path_is_inside_project():
-    """Путь по умолчанию вычисляется от корня проекта, а не от глубины файла.
-
-    В docker-образе файлы лежат плоско (/app/...), поэтому глубину не считаем.
-    """
-    from schedule.settings import DEFAULT_SETTINGS_PATH
-
-    assert DEFAULT_SETTINGS_PATH.name == "settings.json"
-    assert DEFAULT_SETTINGS_PATH.parent.name == "data"
-    root = DEFAULT_SETTINGS_PATH.parent.parent
-    assert (root / "requirements.txt").is_file()  # корень найден по маркеру


 def test_clamp_interval():
Author	SHA1	Message	Date
Vladislav Kopnin	a4798c4a36	Поправка по кэшу: по интервалу снова сверяем modified, всегда качает только кнопка Как и просили: фоновое обновление по интервалу сначала смотрит на дату изменения файла и, если таблица не менялась, не скачивает её. Всегда перечитывать таблицу — только принудительное обновление из админки (force_reload, кнопка «Обновить сейчас»). Тесты: по интервалу — без скачивания при неизменном modified; кнопка — скачивает независимо от modified (test_force_refresh_ignores_ttl_and_modified).	2026-10-06 15:01:07 +03:00
Vladislav Kopnin	475eb3801e	Группы: ТОП-имена и порядок как в таблице В таблице появились группы с «ТОП» в имени (ИВТ-ТОП-11БО, ИТ-ТОП-12БО): шаблон требовал цифру сразу после первого дефиса, поэтому такие столбцы пропускались целиком. Теперь имя группы — буквенные части через дефис, номер потока и необязательный суффикс, т.е. распознаются и «ИВТ-11БО», и «ПИЭ-13МО», и «ИВТ-ТОП-11БО» (похожие заголовки с пробелами — нет). GET /groups больше не сортирует по алфавиту с приоритетом БО/МО, а отдаёт группы в порядке столбцов таблицы — как просили, «как в расписании». Состав групп (появление/переименование/скрытие) подхватывается сам при следующем обновлении, потому что источник истины — заголовок листа. Тесты: ТОП-имена + порядок столбцов, отсев похожих не-групповых заголовков.	2026-09-30 09:42:27 +03:00
Vladislav Kopnin	67a6671d90	Админка: всплывающие уведомления вместо alert() alert() блокирует страницу и требует клика; заменил на тост внизу экрана: появляется с анимацией, сам скрывается через 15 секунд (вход — 5 сек), закрывается крестиком. Цвет полосы зависит от исхода: зелёный — успех, красный — ошибка, синий — информация (например, «файл не изменился»). Сообщения тех же действий: вход, сохранение ссылки, сохранение интервала, принудительное обновление, ошибки запросов.	2026-09-29 15:32:47 +03:00
Vladislav Kopnin	d177560f7d	Видно, изменился ли файл при обновлении (sha256 + отметка в админке) Просьба с эксплуатации: после «Обновить сейчас» непонятно, подхватились ли правки таблицы. Теперь кэш считает sha256 скачанного файла и сравнивает с предыдущим чтением: - в логе: «Расписание загружено: N групп …; файл изменился/не изменился (sha256 ab12cd34)»; - состояние для админки дополнено полями changed / changed_at / content_hash; - в панели чипы «Файл при последнем обновлении», «Содержимое менялось», «sha256 файла», а после кнопки — понятное сообщение: «обнаружены изменения» либо «файл не изменился (на Диске та же версия)» с подсказкой про задержку публикации у Яндекса; - ответы API отдаются с Cache-Control: no-store, чтобы браузер не показывал закэшированные данные после обновления; - запросы к Яндекс.Диску идут с no-cache заголовками и меткой времени — меньше шансов получить закэшированную версию файла. Тест: test_state_reports_file_changes (первая загрузка, изменение файла, повторное чтение без изменений).	2026-09-29 15:27:01 +03:00
Vladislav Kopnin	d4b47c30bf	Кэш: по интервалу таблица перечитывается всегда Поле modified у публичной ссылки Яндекса может «застыть» (кэш на стороне Диска), и проверка «modified не изменился → не скачиваем» держала старые данные до неопределённого момента: стенд показывал прежнее расписание, хотя в таблице правки уже были. Теперь на каждое обновление (и по интервалу, и по кнопке) таблица скачивается заново; modified только показывается в админке. Плюс к этому: - при старте пишем в лог предупреждение, если ссылка в настройках отличается от SCHEDULE_LINK из окружения (именно так терялось время в прошлый раз: на стенде в настройках была сохранена другая ссылка); - на странице админки у поля ссылки пояснение, что значение хранится в настройках стенда и имеет приоритет над .env.	2026-09-29 13:50:17 +03:00
Vladislav Kopnin	ab92fb44e1	Доки стенда: порт nginx должен совпадать с FRONTEND_PORT из .env	2026-09-28 13:56:32 +03:00
Vladislav Kopnin	f69003be75	Фикс сборки: api-образ не копировал admin.py (контейнер падал на импорте) Dockerfile для stage api копировал только main.py и schedule/, поэтому в контейнере 'from admin import ...' давал ModuleNotFoundError — api стартовал и сразу падал, compose останавливался на 'dependency failed to start'. Добавлен COPY admin.py и тест tests/test_deploy.py: проверяет, что в образ api попадают все модули backend, в frontend — страница админки и статика, а compose передаёт ADMIN_* и подключает том настроек.	2026-09-28 13:37:23 +03:00
Vladislav Kopnin	e007a85f56	Админка: защита от перебора пароля и правка дефолта SETTINGS_FILE - не больше 10 неудачных входов с одного адреса за 5 минут, дальше 429 (панель доступна из интернета, простой перебор закрываем); успешный вход сбрасывает счётчик; - .env.example: SETTINGS_FILE пустой — локально настройки живут в памяти, в docker compose подставляет /data/settings.json по умолчанию.	2026-09-28 12:07:45 +03:00
Vladislav Kopnin	cfa6a99639	Админка: секретный путь, смена ссылки, интервал и принудительное обновление Панель без публичного входа: страница живёт по ADMIN_PATH, логин/пароль — ADMIN_LOGIN/ADMIN_PASSWORD из .env (пусто = админка выключена и маршруты /api/admin/* не регистрируются, прод можно не трогать). Умеет: посмотреть текущую ссылку и состояние кэша, вставить новую ссылку (проверяется скачиванием и разбором до сохранения, при ошибке откат), принудительно обновить таблицу вне интервала и без проверки modified, задать интервал в минутах (1..1440). Реализация: - backend/admin.py — cookie-сессия на HMAC (ключ = пароль, 12 часов, HttpOnly/SameSite/Secure-за-https), сравнение за постоянное время; compare_digest по байтам — кириллица в логине не роняет сервер; - schedule/settings.py — ссылка и интервал в JSON (SETTINGS_FILE), атомарная запись, терпимость к битому/недоступному файлу (тогда живёт в памяти); - schedule/cache.py — интервал вместо TTL, apply_link с откатом, force_reload, state() для панели; кэш без ссылки больше не роняет старт; - frontend: страница admin.html (вне static, прямой /admin.html закрыт) и прокси /api/admin/* с телом и Set-Cookie; - docker-compose: том schedule_data для настроек, ADMIN_* в окружении; - deploy/: nginx-конфиг и инструкция для стенда dev.schedule.our-place.ru. Тесты: 138 (новые — админ-API, сессии, ссылка/интервал, force, хранилище).	2026-09-28 12:06:25 +03:00