main

  1"""
  2FastAPI-приложение навыка управления задачами для Яндекс Алисы.
  3
  4Основная точка входа: обрабатывает POST-запросы от Яндекс Диалогов,
  5парсит команды пользователя, выполняет CRUD-операции с задачами
  6и возвращает ответы в формате JSON. Также предоставляет health-check
  7и включает фоновые ассистенты (перенос задач, очистка Langfuse)
  8через APScheduler.
  9"""
 10
 11import logging
 12import os
 13import sys
 14import uuid
 15import asyncio
 16
 17from fastapi import FastAPI, HTTPException, Query, APIRouter
 18from fastapi.staticfiles import StaticFiles
 19from datetime import datetime
 20from typing import Optional
 21from pydantic import BaseModel
 22from fastapi.concurrency import asynccontextmanager
 23from apscheduler.schedulers.asyncio import AsyncIOScheduler
 24from apscheduler.triggers.cron import CronTrigger
 25from langfuse import Langfuse
 26from langfuse import observe
 27from loguru import logger
 28
 29from e_lib.assistants import LangfuseCleanerAssistant, LLMWarmupAssistant
 30from Assistants.otm import OTMAssistant
 31from command_parser import CommandParser
 32from e_lib import Config
 33
 34config = Config("config.yaml")
 35APP_VERSION = os.getenv("PRODUCTS_VERSION", "dev")
 36from models import AliceRequest
 37from taskman import DB_FILE, TaskManager
 38
 39_langfuse_instance = None
 40
 41llm_warmup_assistant = None
 42_llm_warmup_tasks = set()
 43
 44
 45def _trigger_llm_warmup() -> None:
 46    """
 47    Запускает фоновый прогрев LLM (best-effort).
 48
 49    Вызывается при старте сессии навыка: пока пользователь формулирует
 50    вопрос, ассистент подгружает модель лёгким запросом. Повторные вызовы
 51    при активном прогоне пропускаются самим ассистентом. Ошибки не роняют
 52    запрос — прогрев строго фоновый.
 53    """
 54    global llm_warmup_assistant
 55    if llm_warmup_assistant is None:
 56        return
 57    task = asyncio.create_task(llm_warmup_assistant.run())
 58    _llm_warmup_tasks.add(task)
 59    task.add_done_callback(_llm_warmup_tasks.discard)
 60
 61
 62def get_langfuse() -> Langfuse:
 63    """
 64    Возвращает экземпляр Langfuse для observability (синглтон).
 65
 66    При первом вызове создаёт подключение к Langfuse
 67    с использованием переменных окружения LANGFUSE_PUBLIC_KEY,
 68    LANGFUSE_SECRET_KEY и LANGFUSE_HOST.
 69
 70    Returns:
 71        Langfuse: Экземпляр Langfuse-клиента
 72    """
 73    global _langfuse_instance
 74    if _langfuse_instance is None:
 75        _langfuse_instance = Langfuse(
 76            public_key=os.getenv("LANGFUSE_PUBLIC_KEY"),
 77            secret_key=os.getenv("LANGFUSE_SECRET_KEY"),
 78            host=os.getenv("LANGFUSE_HOST"),
 79        )
 80    return _langfuse_instance
 81
 82
 83class InterceptHandler(logging.Handler):
 84    """
 85    Перехватчик логов из стандартного logging в loguru.
 86
 87    Перенаправляет все сообщения из логгеров uvicorn и fastapi
 88    в форматированный вывод loguru.
 89    """
 90
 91    def emit(self, record):
 92        """
 93        Обрабатывает и перенаправляет запись лога в loguru.
 94
 95        Args:
 96            record: Запись лога из стандартного модуля logging
 97        """
 98        try:
 99            level = logger.level(record.levelname).name
100        except ValueError:
101            level = record.levelno
102
103        frame, depth = logging.currentframe(), 2
104        while frame.f_code.co_filename == logging.__file__:
105            frame = frame.f_back
106            depth += 1
107
108        logger.opt(depth=depth, exception=record.exc_info).log(
109            level, record.getMessage()
110        )
111
112
113def setup_logging():
114    """
115    Настраивает логирование приложения.
116
117    Перенаправляет логи uvicorn и fastapi в loguru с цветным
118    форматированным выводом в stdout. Уровень DEBUG для всех
119    сообщений приложения.
120    """
121    logger.remove()
122
123    logger.add(
124        sys.stdout,
125        format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> | <level>{message}</level>",
126        level="DEBUG",
127        colorize=True,
128    )
129
130    intercept_handler = InterceptHandler()
131
132    root_logger = logging.getLogger()
133    root_logger.handlers = [intercept_handler]
134    root_logger.setLevel(logging.INFO)
135
136    for logger_name in ["uvicorn", "uvicorn.access", "uvicorn.error", "fastapi"]:
137        logging_logger = logging.getLogger(logger_name)
138        logging_logger.handlers = [intercept_handler]
139        logging_logger.setLevel(logging.INFO)
140        logging_logger.propagate = False
141
142
143@observe(name="Build response")
144def build_response(request: AliceRequest, text: str, tts: str | None = None) -> dict:
145    """
146    Формирует ответ навыка Яндекс Алисы.
147
148    Args:
149        request: Входящий запрос Алисы (для копирования session/version)
150        text: Текстовый ответ навыка
151        tts: Озвучиваемый текст (если отличается от text)
152
153    Returns:
154        dict: Ответ в формате Яндекс Диалогов
155    """
156    response: dict = {
157        "text": text,
158        "end_session": False,
159    }
160    if tts is not None:
161        response["tts"] = tts
162    return {
163        "version": request.version,
164        "session": {
165            "message_id": request.session.message_id,
166            "session_id": request.session.session_id,
167            "user_id": request.session.user_id,
168            "skill_id": request.session.skill_id,
169        },
170        "response": response,
171    }
172
173
174@observe(name="Build error response")
175def build_error_response(
176    text: str = "Произошла ошибка при обработке запроса. Попробуйте еще раз.",
177) -> dict:
178    """
179    Формирует ответ с сообщением об ошибке.
180
181    Args:
182        text: Текст ошибки (по умолчанию стандартное сообщение)
183
184    Returns:
185        dict: Ответ-заглушка с текстом ошибки
186    """
187    return {
188        "version": "1.0",
189        "session": {
190            "message_id": 0,
191            "session_id": "",
192            "user_id": "",
193            "skill_id": "",
194        },
195        "response": {
196            "text": text,
197            "end_session": False,
198        },
199    }
200
201
202class TaskCreate(BaseModel):
203    """Модель для создания задачи через веб-API."""
204
205    user_id: str
206    text: str
207    date: Optional[str] = None
208
209
210class TaskUpdate(BaseModel):
211    """Модель для обновления задачи через веб-API."""
212
213    date: Optional[str] = None
214    completed: Optional[bool] = None
215
216
217web_router = APIRouter()
218
219
220@web_router.get("/api/tasks")
221async def web_list_tasks(
222    user_id: str,
223    date: Optional[str] = None,
224    order: Optional[str] = Query(
225        None
226    ),  # "newest-first" или "oldest-first", по умолч. "newest-first"
227):
228    """Возвращает список задач пользователя с фильтрацией по дате и сортировкой."""
229    if date == "all":
230        tasks = task_manager.get_all_tasks(user_id)
231
232        # Сортировка: сначала новые (с датой), потом без даты, затем по убыванию даты
233        def sort_key(task):
234            if not task.get("date"):
235                return ("0", datetime.min)  # Без даты - в конец
236            has_future_date = task["date"] != "2100-01-01"
237            if has_future_date:
238                # Реальная дата - сортируем по убыванию (новые первыми)
239                try:
240                    dt = datetime.strptime(task["date"], "%Y-%m-%d")
241                    return ("1", dt)
242                except ValueError:
243                    return ("1", datetime.min)
244            else:
245                # Задачи без даты (2100-01-01) - в конец
246                return ("0", datetime.max)
247
248        if order == "oldest-first":
249            tasks.sort(key=sort_key, reverse=False)  # oldest-first: ascending
250        else:
251            tasks.sort(key=sort_key, reverse=True)  # newest-first: descending
252
253        return {"tasks": tasks, "date": "all"}
254    if date is None:
255        date = task_manager.get_today_date()
256    tasks = task_manager.get_tasks_by_date(user_id, date)
257    return {"tasks": tasks, "date": date}
258
259
260@web_router.post("/api/tasks")
261async def web_create_task(body: TaskCreate):
262    """Создаёт новую задачу."""
263    task_id = task_manager.add_task(body.user_id, body.text, body.date)
264    task = task_manager.get_task(body.user_id, task_id)
265    return {"task": task}
266
267
268@web_router.put("/api/tasks/{task_id}")
269async def web_update_task(task_id: int, body: TaskUpdate, user_id: str = Query(...)):
270    """Обновляет задачу (дату и/или статус выполнения)."""
271    if body.date is not None:
272        from datetime import datetime as _dt
273
274        try:
275            date = _dt.strptime(body.date, "%Y-%m-%d").strftime("%Y-%m-%d")
276        except ValueError:
277            raise HTTPException(
278                status_code=400, detail="Invalid date format, expected YYYY-MM-DD"
279            )
280        with task_manager._get_conn() as conn:
281            conn.execute(
282                "UPDATE tasks SET date = ? WHERE user_id = ? AND id = ?",
283                (date, user_id, task_id),
284            )
285    if body.completed is not None:
286        if body.completed:
287            task_manager.complete_task(user_id, task_id)
288    task = task_manager.get_task(user_id, task_id)
289    if task is None:
290        raise HTTPException(status_code=404, detail="Task not found")
291    return {"task": task}
292
293
294@web_router.delete("/api/tasks/{task_id}")
295async def web_delete_task(task_id: int, user_id: str = Query(...)):
296    """Удаляет задачу по ID."""
297    if task_manager.delete_task(user_id, task_id):
298        return {"deleted": True}
299    raise HTTPException(status_code=404, detail="Task not found")
300
301
302@web_router.get("/api/users")
303async def web_list_users():
304    """Возвращает список пользователей из config.data."""
305    users = {}
306    for name, ids in config.data.get("USERS", {}).items():
307        users[name] = ids
308    return {"users": users}
309
310
311@asynccontextmanager
312async def lifespan(app: FastAPI):
313    """
314    Управляет жизненным циклом FastAPI-приложения.
315
316    При запуске настраивает логирование и запускает APScheduler
317    с фоновыми ассистентами (перенос задач, очистка Langfuse).
318    При остановке корректно завершает планировщик.
319    """
320    setup_logging()
321
322    try:
323        command_parser.cache_prompt()
324    except Exception as e:
325        logger.warning(f"Langfuse: ошибка инициализации промпта: {e}")
326
327    products_log = None
328    try:
329        from e_lib.product_log import ProductsLog
330
331        products_log = ProductsLog("AliceTodoSkill", APP_VERSION, logger=logger)
332        products_log.post_started()
333    except Exception as e:
334        products_log = None
335        logger.warning(f"ProductsLog: {e}")
336
337    scheduler = AsyncIOScheduler()
338
339    def to_cron(time_str: str) -> str:
340        """
341        Преобразует время в формате HH:MM в cron-выражение.
342
343        Args:
344            time_str: Время в формате "ЧЧ:ММ"
345
346        Returns:
347            str: Cron-выражение для ежедневного запуска
348        """
349        h, m = time_str.split(":")
350        return f"{m} {h} * * *"
351
352    if config.data["Assistants"]["TaskMover"]["ENABLED"]:
353        old_task_move_assistant = OTMAssistant(
354            name=config.data["Assistants"]["TaskMover"]["NAME"],
355            task_manager=task_manager,
356        )
357        scheduler.add_job(
358            old_task_move_assistant.run,
359            CronTrigger.from_crontab(
360                to_cron(config.data["Assistants"]["TaskMover"]["TIME"])
361            ),
362            id="old_task_mover",
363            replace_existing=True,
364        )
365        logger.info(
366            f'Ассистент "{config.data["Assistants"]["TaskMover"]["NAME"]}" включён'
367        )
368
369    if config.data["Assistants"]["LangfuseCleaner"]["ENABLED"]:
370        lf_cleaner_assistant = LangfuseCleanerAssistant(
371            project_slug=config.data["Assistants"]["LangfuseCleaner"]["PROJECT"],
372            period=config.data["Assistants"]["LangfuseCleaner"]["RETENTION_DAYS"],
373            logger=logger,
374        )
375        scheduler.add_job(
376            lf_cleaner_assistant.run,
377            CronTrigger.from_crontab(
378                to_cron(config.data["Assistants"]["LangfuseCleaner"]["TIME"])
379            ),
380            id="lf_cleaner",
381            replace_existing=True,
382        )
383        logger.info(
384            f'Ассистент "{config.data["Assistants"]["LangfuseCleaner"]["NAME"]}" включён'
385        )
386
387    if config.data["Assistants"]["LLMWarmup"]["ENABLED"]:
388        global llm_warmup_assistant
389        llm_warmup_assistant = LLMWarmupAssistant(
390            prompt=config.data["Assistants"]["LLMWarmup"]["PROMPT"],
391            model=config.data["Assistants"]["LLMWarmup"]["MODEL"],
392            retries=config.data["Assistants"]["LLMWarmup"]["RETRIES"],
393            delay=config.data["Assistants"]["LLMWarmup"]["DELAY"],
394            logger=logger,
395        )
396        logger.info(
397            f'Ассистент "{config.data["Assistants"]["LLMWarmup"]["NAME"]}" включён'
398        )
399
400    scheduler.start()
401    logger.info("Приложение запущено")
402    yield
403    scheduler.shutdown(wait=False)
404    logger.info("Приложение остановлено")
405    try:
406        if products_log:
407            products_log.post_shutdown()
408    except Exception as e:
409        logger.warning(f"ProductsLog: {e}")
410
411
412app = FastAPI(
413    title="Alice Todo Skill",
414    description="Навык для Яндекс Алисы для управления задачами",
415    version="1.0.0",
416    lifespan=lifespan,
417)
418
419task_manager = TaskManager()
420command_parser = CommandParser()
421
422app.include_router(web_router, prefix="/web")
423
424if os.path.isdir(os.path.join(os.path.dirname(__file__), "web", "dist")):
425    app.mount(
426        "/web",
427        StaticFiles(
428            directory=os.path.join(os.path.dirname(__file__), "web", "dist"), html=True
429        ),
430        name="web",
431    )
432
433
434@app.post("/")
435@observe(name="Alice Todo Skill Observability")
436async def handle_alice(request: AliceRequest):
437    """
438    Основной обработчик запросов от Яндекс Алисы.
439
440    Принимает POST-запрос от Диалогов, проверяет skill_id,
441    парсит команду пользователя и выполняет соответствующее действие
442    (добавление, просмотр, выполнение, удаление, перенос задач
443    или вывод справки). Возвращает ответ в формате Яндекс Диалогов.
444
445    Args:
446        request: Валидированный запрос от Яндекс Алисы
447
448    Returns:
449        dict: Ответ навыка в формате Яндекс Диалогов
450
451    Raises:
452        HTTPException: 403 если skill_id не совпадает
453    """
454    request_id = uuid.uuid4().hex[:8]
455    log = logger.bind(request_id=request_id)
456
457    if request.session.skill_id != os.getenv("SKILL_ID"):
458        log.warning(f"Неверный skill_id: {request.session.skill_id}")
459        raise HTTPException(status_code=403, detail="Forbidden")
460
461    try:
462        user_id = request.session.user_id
463        for user in config.data["USERS"]:
464            if user_id in config.data["USERS"][user]:
465                user_id = user
466                break
467
468        command = request.request.command.lower()
469        original_utterance = request.request.original_utterance.lower()
470
471        log.info(f"Запрос от пользователя {user_id}: {command}")
472
473        if not original_utterance.strip():
474            _trigger_llm_warmup()
475            return build_response(request, "")
476
477        parsed = command_parser.parse(command, original_utterance)
478        response_tts = None
479
480        if parsed is None:
481            response_text = "Мой ежедневник"
482            response_tts = "-"
483        elif parsed.action == "ping":
484            response_text = "pong"
485        elif parsed.action == "add_task":
486            if parsed.date_keyword is None:
487                task_id = task_manager.add_task(user_id, parsed.task_text)
488                response_text = (
489                    f"Задача '{parsed.task_text}' добавлена. ID задачи: {task_id}"
490                )
491            else:
492                date = parsed.date_keyword
493                task_id = task_manager.add_task(user_id, parsed.task_text, date)
494                response_text = f"Задача '{parsed.task_text}' добавлена на {parsed.date_label or parsed.date_keyword}. ID задачи: {task_id}"
495        elif parsed.action == "no_task_text":
496            response_text = "Не смогла понять, какую задачу добавить."
497        elif parsed.action == "list_tasks":
498            if parsed.date_keyword is None:
499                tasks = task_manager.get_all_tasks(user_id)
500                incomplete_count = len(tasks)
501                scope = "all"
502            else:
503                date = parsed.date_keyword
504                tasks = task_manager.get_tasks_by_date(user_id, date)
505                incomplete_count = task_manager.get_incomplete_tasks_count(
506                    user_id, date
507                )
508                scope = "date"
509
510            if incomplete_count == 0:
511                if scope == "all":
512                    response_text = "Невыполненных задач нет."
513                else:
514                    response_text = f"На {parsed.date_label or parsed.date_keyword} невыполненных задач нет."
515            else:
516                if scope == "all":
517                    prefix = f"У вас {incomplete_count} невыполненных задач: "
518                else:
519                    prefix = f"На {parsed.date_label or parsed.date_keyword} у вас {incomplete_count} невыполненных задач: "
520                response_text = prefix + task_manager.format_task_list_truncated(
521                    tasks, show_completed=False, max_chars=1024 - len(prefix)
522                )
523                tts_formatted = task_manager.format_task_list_truncated(
524                    tasks, show_completed=False, max_chars=1024
525                )
526                if "\nи еще" in tts_formatted or tts_formatted.startswith(
527                    "Не показано"
528                ):
529                    summary = task_manager.get_incomplete_tasks_summary(user_id)
530                    response_tts = (
531                        f"У вас {summary['total']} невыполненных задач. "
532                        f"На сегодня {summary['today']}, на завтра {summary['tomorrow']}."
533                    )
534                else:
535                    response_tts = tts_formatted
536        elif parsed.action == "help":
537            response_text = (
538                "Я помогу вам управлять задачами. Вот что я умею:\n"
539                "• 'Добавь задачу купить молоко' - добавить задачу без срока\n"
540                "• 'Добавь задачу на завтра сходить к врачу' - добавить на завтра\n"
541                "• 'Добавь задачу на послезавтра ...' - добавить на послезавтра\n"
542                "• 'Какие задачи на сегодня?' - показать невыполненные задачи\n"
543                "• 'Дела на завтра' - показать задачи на завтра\n"
544                "• 'Что купить?' - найти задачи, начинающиеся с 'купить'\n"
545                "• 'Пометь задачу 3 выполненной' - отметить задачу как выполненную\n"
546                "• 'Удали задачу 2' / 'убери задачу 2' - удалить задачу\n"
547                "• 'Перенеси задачу 1 на завтра' - перенести одну задачу\n"
548                "• 'Перенеси задачи на завтра' - перенести все задачи"
549            )
550        elif parsed.action == "what":
551            date = parsed.date_keyword
552            tasks = task_manager.get_tasks_by_date(user_id, date)
553            filtered_tasks = [
554                t for t in tasks if t["text"].lower().startswith(parsed.keyword)
555            ]
556            incomplete_count = sum(1 for t in filtered_tasks if not t["completed"])
557
558            if incomplete_count == 0:
559                response_text = f"На {parsed.date_label or parsed.date_keyword} нет задач, начинающихся с '{parsed.keyword}'."
560            else:
561                prefix = f"На {parsed.date_label or parsed.date_keyword} у вас {incomplete_count} задач: "
562                response_text = prefix + task_manager.format_task_list_truncated(
563                    filtered_tasks, show_completed=False, max_chars=1024 - len(prefix)
564                )
565                tts_formatted = task_manager.format_task_list_truncated(
566                    filtered_tasks, show_completed=False, max_chars=1024
567                )
568                if "\nи еще" in tts_formatted or tts_formatted.startswith(
569                    "Не показано"
570                ):
571                    summary = task_manager.get_incomplete_tasks_summary(user_id)
572                    response_tts = (
573                        f"У вас {summary['total']} невыполненных задач. "
574                        f"На сегодня {summary['today']}, на завтра {summary['tomorrow']}."
575                    )
576                else:
577                    response_tts = tts_formatted
578        elif parsed.action == "complete":
579            if task_manager.complete_task(user_id, parsed.task_id):
580                response_text = f"Задача {parsed.task_id} отмечена как выполненная."
581            else:
582                response_text = f"Задача с номером {parsed.task_id} не найдена."
583        elif parsed.action == "delete":
584            if task_manager.delete_task(user_id, parsed.task_id):
585                response_text = f"Задача {parsed.task_id} удалена."
586            else:
587                response_text = f"Задача с номером {parsed.task_id} не найдена."
588        elif parsed.action == "no_task_id":
589            response_text = "Не смогла найти номер задачи."
590        elif parsed.action == "move_one":
591            date = parsed.date_keyword
592            if task_manager.move_task(user_id, parsed.task_id, date):
593                response_text = f"Задача {parsed.task_id} перенесена на {parsed.date_label or parsed.date_keyword}."
594            else:
595                response_text = f"Задача с номером {parsed.task_id} не найдена."
596        elif parsed.action == "move_all":
597            date = parsed.date_keyword
598            task_manager.move_tasks(user_id, date)
599            response_text = (
600                f"Задачи перенесены на {parsed.date_label or parsed.date_keyword}."
601            )
602
603        try:
604            get_langfuse().update_current_span(
605                metadata={
606                    "user_id": user_id,
607                    "action": parsed.action if parsed else None,
608                    "command": command,
609                    "text_length": len(response_text),
610                    "tts_length": len(response_tts) if response_tts else 0,
611                }
612            )
613        except Exception:
614            pass
615        log.info(f"Отправляем ответ: {response_text}")
616        return build_response(request, response_text, tts=response_tts)
617
618    except Exception as e:
619        log.error(f"Ошибка обработки запроса: {e}")
620        return build_error_response()
621
622
623@app.get("/")
624async def root():
625    """
626    Корневой эндпоинт для проверки доступности навыка.
627
628    Returns:
629        dict: Статус приложения и путь к файлу данных
630    """
631    return {
632        "message": "Alice Todo Skill is running",
633        "status": "ok",
634        "data_file": DB_FILE,
635    }
636
637
638@app.get("/health")
639async def health_check():
640    """
641    Эндпоинт проверки здоровья приложения.
642
643    Returns:
644        dict: Статус health, временная метка и количество пользователей
645    """
646    return {
647        "status": "healthy",
648        "timestamp": datetime.now().isoformat(),
649        "users_count": task_manager.get_user_count(),
650    }
651
652
653if __name__ == "__main__":
654    import uvicorn
655
656    uvicorn.run(app, host="0.0.0.0", port=8000)