Upload 6 files

Dockerfile

@@ -0,0 +1,35 @@
+FROM python:3.11-slim
+
+# Установка рабочих переменных
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    PIP_DEFAULT_TIMEOUT=100
+
+# Установка рабочей директории
+WORKDIR /app
+
+# Установка системных зависимостей
+RUN apt-get update && apt-get install -y \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Копирование и установка зависимостей (отдельным слоем для кэша)
+# FIX: 2026-03-10 - очистка кэша pip
+COPY requirements.txt .
+RUN pip install --upgrade pip --force-reinstall
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Копирование исходного кода
+COPY . .
+
+# Экспозиция порта
+EXPOSE 7860
+
+# Переменные окружения по умолчанию
+ENV PORT=7860
+ENV HOST=0.0.0.0
+
+# Запуск приложения
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,429 @@
+---
+title: AI Scraper ФИПИ
+emoji: 🕷️
+colorFrom: blue
+colorTo: purple
+sdk: docker
+sdk_version: "docker"
+python_version: "3.11"
+app_file: app.py
+pinned: false
+---
+
+# 🕷️ AI Scraper ФИПИ
+
+Сервис для автоматического сбора заданий с сайта ФИПИ (fipi.ru) с использованием AI-анализа на основе **ruBERT**.
+
+---
+
+## ✨ Возможности
+
+- 🕷️ **Автоматический парсинг** заданий с сайта ФИПИ
+- 🧠 **AI-классификация** заданий через ruBERT
+- 💾 **Сохранение в Supabase** с автоматическим обновлением
+- 🚀 **Деплой на Hugging Face Spaces**
+- 📊 **REST API** для доступа к заданиям
+- 🔍 **Поиск** по заданиям
+- 📈 **Статистика** и аналитика
+
+---
+
+## 📁 Структура
+
+```
+ai-scraper/
+├── app.py                 # Основное FastAPI приложение
+├── scraper.py             # Парсер сайта ФИПИ
+├── rubert_client.py       # Клиент для ruBERT API
+├── supabase_client.py     # Интеграция с Supabase
+├── models.py              # Pydantic модели
+├── requirements.txt       # Python зависимости
+├── schema.sql             # SQL схема для Supabase
+├── Dockerfile             # Docker конфигурация
+├── hf_spaces_config.yaml  # Конфиг для Hugging Face
+├── .env.example           # Шаблон переменных окружения
+└── README.md              # Документация
+```
+
+---
+
+## 🚀 Быстрый старт
+
+### 1. Локальная разработка
+
+```bash
+cd ai-scraper
+
+# Создайте виртуальное окружение
+python -m venv venv
+
+# Активируйте
+venv\Scripts\activate  # Windows
+source venv/bin/activate  # Linux/Mac
+
+# Установите зависимости
+pip install -r requirements.txt
+
+# Скопируйте .env.example в .env (опционально)
+cp .env.example .env
+
+# Заполните .env своими ключами
+# ИЛИ настройте переменные окружения в вашей системе
+
+# Запустите сервер
+uvicorn app:app --reload --host 0.0.0.0 --port 8000
+```
+
+Откройте http://localhost:8000/docs для Swagger UI.
+
+---
+
+## ⚙️ Переменные окружения
+
+### Для локальной разработки
+
+Скопируйте `.env.example` в `.env` и заполните своими значениями:
+
+```env
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_SERVICE_KEY=your-service-role-key
+RUBERT_URL=https://your-rubert.hf.space
+FIPI_BASE_URL=https://fipi.ru
+```
+
+### Для Hugging Face Spaces
+
+**Не нужно загружать `.env` файл!** Настройте переменные через интерфейс:
+
+1. Откройте ваш Space
+2. Перейдите в **Settings** → **Secrets**
+3. Добавьте переменные:
+   - `SUPABASE_URL`
+   - `SUPABASE_SERVICE_KEY`
+   - `RUBERT_URL` (опционально)
+   - `FIPI_BASE_URL` (опционально)
+
+---
+
+## 🗄️ Настройка Supabase
+
+### 1. Создайте проект
+
+Перейдите на [Supabase](https://supabase.com) и создайте новый проект.
+
+### 2. Выполните SQL скрипт
+
+1. Откройте [SQL Editor](https://supabase.com/dashboard/project/_/sql/new)
+2. Скопируйте содержимое `schema.sql`
+3. Нажмите **Run**
+
+### 3. Получите ключи
+
+1. Перейдите в **Settings** → **API**
+2. Скопируйте:
+   - **Project URL** → `SUPABASE_URL`
+   - **service_role key** → `SUPABASE_SERVICE_KEY`
+
+---
+
+## 🧠 Настройка ruBERT
+
+### Вариант 1: Использование существующего API
+
+Если у вас уже есть развернутый ruBERT (как в основном проекте):
+
+```env
+RUBERT_URL=https://your-rubert-instance.hf.space
+```
+
+### Вариант 2: Развертывание ruBERT
+
+Создайте новый Space на Hugging Face с моделью ruBERT:
+
+1. [RuBERT от DeepPavlov](https://huggingface.co/deepvk/rubert-base-cased)
+2. Используйте шаблон Gradio или FastAPI
+3. Добавьте эндпоинты `/api/analyze` и `/api/embedding`
+
+---
+
+## 🌐 Деплой на Hugging Face Spaces
+
+### Шаг 1: Создайте Space
+
+1. Перейдите на [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Нажмите **Create new Space**
+3. Заполните:
+   - **Space name**: `fipi-ai-scraper`
+   - **License**: MIT
+   - **SDK**: Docker
+   - **Visibility**: Public или Private
+
+### Шаг 2: Загрузите файлы
+
+```bash
+# Инициализируйте git в папке ai-scraper
+cd ai-scraper
+git init
+git add .
+git commit -m "Initial commit"
+
+# Добавьте remote вашего Space
+git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/fipi-ai-scraper
+
+# Push в Space
+git push -u origin main
+```
+
+### Шаг 3: Настройте переменные окружения
+
+**Важно:** Не загружайте `.env` файл в репозиторий!
+
+В Settings вашего Space добавьте в **Secrets**:
+
+| Variable | Value |
+|----------|-------|
+| `SUPABASE_URL` | https://your-project.supabase.co |
+| `SUPABASE_SERVICE_KEY` | ваш service key |
+| `RUBERT_URL` | https://your-rubert.hf.space |
+| `FIPI_BASE_URL` | https://fipi.ru |
+
+⚠️ **Примечание:** Переменные окружения добавляются через интерфейс Hugging Face:
+**Settings** → **Repository secrets** → **New secret**
+
+### Шаг 4: Дождитесь деплоя
+
+Space автоматически соберет Docker образ и запустит приложение.
+
+---
+
+## 📡 API Endpoints
+
+| Метод | Эндпоинт | Описание |
+|-------|----------|----------|
+| GET | `/` | Информация об API |
+| GET | `/api/health` | Проверка статуса сервиса |
+| GET | `/api/tasks` | Получить все задания |
+| GET | `/api/tasks/latest` | Последние добавленные задания |
+| GET | `/api/tasks/{task_id}` | Получить задание по ID |
+| GET | `/api/tasks/type/{type}` | Задания по типу |
+| GET | `/api/tasks/search?q=` | Поиск заданий |
+| POST | `/api/scrape` | Запустить парсинг ФИПИ |
+| POST | `/api/analyze` | AI анализ существующих заданий |
+| GET | `/api/stats` | Статистика по заданиям |
+
+---
+
+## 📝 Примеры использования
+
+### Python
+
+```python
+import requests
+
+BASE_URL = "https://your-space.hf.space"
+
+# Получить последние задания
+response = requests.get(f"{BASE_URL}/api/tasks/latest?limit=10")
+tasks = response.json()
+print(f"Найдено заданий: {len(tasks)}")
+
+# Запустить парсинг ФИПИ
+response = requests.post(f"{BASE_URL}/api/scrape")
+result = response.json()
+print(result["message"])
+
+# Поиск заданий
+response = requests.get(f"{BASE_URL}/api/tasks/search?q=сочинение")
+tasks = response.json()
+
+# Получить статистику
+response = requests.get(f"{BASE_URL}/api/stats")
+stats = response.json()
+print(f"Всего заданий: {stats['total_tasks']}")
+```
+
+### cURL
+
+```bash
+# Health check
+curl https://your-space.hf.space/api/health
+
+# Получить задания
+curl https://your-space.hf.space/api/tasks/latest
+
+# Запустить скрапинг
+curl -X POST https://your-space.hf.space/api/scrape \
+  -H "Content-Type: application/json" \
+  -d '{"subject": "russian"}'
+
+# Поиск
+curl "https://your-space.hf.space/api/tasks/search?q=ЕГЭ"
+```
+
+---
+
+## 🔧 Конфигурация
+
+### Переменные окружения
+
+| Переменная | Описание | Пример |
+|------------|----------|--------|
+| `SUPABASE_URL` | URL проекта Supabase | `https://xxx.supabase.co` |
+| `SUPABASE_SERVICE_KEY` | Service role ключ Supabase | `eyJhbG...` |
+| `RUBERT_URL` | URL ruBERT API | `https://rubert.hf.space` |
+| `FIPI_BASE_URL` | Базовый URL ФИПИ | `https://fipi.ru` |
+| `PORT` | Порт приложения | `7860` |
+| `HOST` | Хост приложения | `0.0.0.0` |
+
+---
+
+## 🏗️ Архитектура
+
+```
+┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
+│   FIPIScraper   │────▶│  RuBERTClient    │────▶│  SupabaseClient │
+│   (BeautifulSoup)│    │  (HTTP API)      │     │  (Supabase JS)  │
+└─────────────────┘     └──────────────────┘     └─────────────────┘
+         │                       │                        │
+         ▼                       ▼                        ▼
+   fipi.ru                 ruBERT HF               Supabase DB
+   (парсинг)              (AI анализ)              (хранение)
+```
+
+### Поток данных
+
+1. **Скрапинг**: `FIPIScraper` парсит задания с fipi.ru
+2. **Анализ**: `RuBERTClient` анализирует текст задания
+3. **Сохранение**: `SupabaseClient` сохраняет в базу данных
+4. **API**: FastAPI предоставляет REST эндпоинты
+
+---
+
+## 🔒 Безопасность
+
+- ✅ **RLS (Row Level Security)** в Supabase
+- ✅ **Валидация данных** через Pydantic
+- ✅ **CORS** настроен для API
+- ✅ **Service Key** не экспонируется на клиенте
+
+---
+
+## 🛠️ Решение проблем
+
+### "Supabase не настроен"
+
+Проверьте переменные окружения:
+```bash
+echo $SUPABASE_URL
+echo $SUPABASE_SERVICE_KEY
+```
+
+### "RuBERT клиент не настроен"
+
+Убедитесь, что `RUBERT_URL` указан и API доступен:
+```bash
+curl https://your-rubert.hf.space/api/health
+```
+
+### Ошибки при скрапинге
+
+Сайт ФИПИ может блокировать запросы. Попробуйте:
+- Изменить `User-Agent` в `scraper.py`
+- Использовать прокси
+- Добавить задержки между запросами
+
+### Docker не собирается
+
+Проверьте логи:
+```bash
+docker build -t fipi-scraper .
+docker run -p 7860:7860 fipi-scraper
+```
+
+### Configuration error / Missing .env
+
+**Это нормально!** Для Hugging Face Spaces:
+1. Не загружайте `.env` в репозиторий
+2. Настройте переменные через **Settings** → **Repository secrets**
+3. Файл `.env.example` существует только для документации
+
+---
+
+## 📝 История изменений
+
+### Март 2026 - Исправление парсера ФИПИ
+
+**Исправленные проблемы:**
+- ❌ Неверные URL-адреса (404 ошибки)
+- ❌ SSL ошибки для поддоменов
+- ❌ Некорректный парсинг заголовков
+
+**Результат:**
+- ✅ Найдено заданий: 0 → 12
+- ✅ Все запросы возвращают 200 OK
+
+Подробности в [FIXES.md](FIXES.md)
+
+---
+
+## 📊 Мониторинг
+
+### Логи приложения
+
+```bash
+# Логи в Hugging Face Space
+# Settings → Logs
+
+# Локально
+uvicorn app:app --log-level debug
+```
+
+### Метрики
+
+- `/api/health` — статус сервисов
+- `/api/stats` — статистика заданий
+
+---
+
+## 🤝 Интеграция с основным проектом
+
+Этот сервис дополняет основной проект `refined-main`:
+
+1. **Импорт заданий** из ФИПИ в базу
+2. **AI-анализ** через тот же ruBERT
+3. **Единая Supabase** для обоих сервисов
+
+### Подключение
+
+В основном проекте добавьте:
+
+```typescript
+// services/fipiTasks.ts
+const FIPI_SCRAPER_URL = 'https://fipi-ai-scraper.hf.space';
+
+export async function fetchLatestTasks(limit = 10) {
+  const response = await fetch(`${FIPI_SCRAPER_URL}/api/tasks/latest?limit=${limit}`);
+  return response.json();
+}
+```
+
+---
+
+## 📚 Дополнительные ресурсы
+
+- [Документация FastAPI](https://fastapi.tiangolo.com/)
+- [Документация Supabase](https://supabase.com/docs)
+- [Hugging Face Spaces](https://huggingface.co/docs/hub/spaces)
+- [ruBERT модель](https://huggingface.co/deepvk/rubert-base-cased)
+- [ФИПИ](https://fipi.ru/)
+
+---
+
+## 📄 Лицензия
+
+MIT License
+
+---
+
+**Последнее обновление:** Март 2026  
+**Статус:** ✅ Готово к деплою

app.py

@@ -0,0 +1,337 @@
+"""
+FastAPI приложение для AI Scraper ФИПИ
+Деплой на Hugging Face Spaces
+"""
+
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List
+from datetime import datetime
+import logging
+import os
+
+from models import (
+    TaskResponse,
+    ScrapeRequest,
+    ScrapeResponse,
+    HealthResponse,
+    StatsResponse,
+    ErrorResponse,
+)
+from scraper import FIPIScraper
+from rubert_client import RuBERTClient
+
+# Настройка логирования
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Supabase - опционально (может отсутствовать из-за конфликта версий)
+try:
+    from supabase_client import SupabaseClient
+    SUPABASE_AVAILABLE = True
+except ImportError:
+    SupabaseClient = None
+    SUPABASE_AVAILABLE = False
+    logger.warning("Supabase клиент недоступен - работаем без базы данных")
+
+# Инициализация приложения
+app = FastAPI(
+    title="AI Scraper ФИПИ",
+    description="Сервис для автоматического сбора заданий с сайта ФИПИ с AI-анализом на ruBERT",
+    version="1.0.0",
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Глобальные клиенты
+scraper: FIPIScraper = None
+rubert_client: RuBERTClient = None
+supabase_client: SupabaseClient = None
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Инициализация клиентов при старте"""
+    global scraper, rubert_client, supabase_client
+    
+    # Инициализация скрапера
+    fipi_url = os.getenv("FIPI_BASE_URL", "https://fipi.ru")
+    scraper = FIPIScraper(base_url=fipi_url)
+    logger.info(f"FIPIScraper инициализирован: {fipi_url}")
+    
+    # Инициализация ruBERT клиента
+    rubert_url = os.getenv("RUBERT_URL")
+    if rubert_url:
+        rubert_client = RuBERTClient(api_url=rubert_url)
+        logger.info(f"RuBERTClient инициализирован: {rubert_url}")
+    else:
+        logger.warning("RUBERT_URL не указан, анализ через ruBERT будет недоступен")
+
+    # Инициализация Supabase клиента (опционально)
+    if SUPABASE_AVAILABLE:
+        supabase_url = os.getenv("SUPABASE_URL")
+        supabase_key = os.getenv("SUPABASE_SERVICE_KEY")
+
+        if supabase_url and supabase_key:
+            try:
+                supabase_client = SupabaseClient(url=supabase_url, key=supabase_key)
+                logger.info("SupabaseClient инициализирован")
+            except Exception as e:
+                logger.error(f"Ошибка инициализации Supabase: {e}")
+                supabase_client = None
+        else:
+            logger.warning("SUPABASE_URL или SUPABASE_SERVICE_KEY не указаны")
+    else:
+        logger.info("Supabase отключён - работаем в режиме без базы данных")
+
+
+@app.get("/api/health", response_model=HealthResponse)
+async def health_check():
+    """Проверка статуса сервиса"""
+    services = {
+        "api": True,
+        "scraper": scraper is not None,
+        "rubert": False,
+        "supabase": False,
+    }
+    
+    if rubert_client:
+        services["rubert"] = await rubert_client.health_check()
+    
+    if supabase_client:
+        try:
+            await supabase_client.get_stats()
+            services["supabase"] = True
+        except Exception:
+            services["supabase"] = False
+    
+    return HealthResponse(
+        status="healthy" if all(services.values()) else "degraded",
+        timestamp=datetime.utcnow(),
+        services=services,
+    )
+
+
+@app.get("/api/tasks", response_model=List[TaskResponse])
+async def get_all_tasks():
+    """Получить все задания"""
+    if not supabase_client:
+        raise HTTPException(status_code=503, detail="Supabase не настроен")
+    
+    tasks = await supabase_client.get_all_tasks()
+    return [TaskResponse(**task) for task in tasks]
+
+
+@app.get("/api/tasks/latest", response_model=List[TaskResponse])
+async def get_latest_tasks(limit: int = 10):
+    """Получить последние задания"""
+    if not supabase_client:
+        raise HTTPException(status_code=503, detail="Supabase не настроен")
+    
+    tasks = await supabase_client.get_latest_tasks(limit=limit)
+    return [TaskResponse(**task) for task in tasks]
+
+
+@app.get("/api/tasks/{task_id}", response_model=TaskResponse)
+async def get_task(task_id: int):
+    """Получить задание по ID"""
+    if not supabase_client:
+        raise HTTPException(status_code=503, detail="Supabase не настроен")
+    
+    task = await supabase_client.get_task_by_id(task_id)
+    if not task:
+        raise HTTPException(status_code=404, detail="Задание не найдено")
+    
+    return TaskResponse(**task)
+
+
+@app.get("/api/tasks/type/{task_type}", response_model=List[TaskResponse])
+async def get_tasks_by_type(task_type: str):
+    """Получить задания по типу"""
+    if not supabase_client:
+        raise HTTPException(status_code=503, detail="Supabase не настроен")
+    
+    tasks = await supabase_client.get_tasks_by_type(task_type)
+    return [TaskResponse(**task) for task in tasks]
+
+
+@app.get("/api/tasks/search", response_model=List[TaskResponse])
+async def search_tasks(q: str):
+    """Поиск заданий по запросу"""
+    if not supabase_client:
+        raise HTTPException(status_code=503, detail="Supabase не настроен")
+    
+    tasks = await supabase_client.search_tasks(q)
+    return [TaskResponse(**task) for task in tasks]
+
+
+@app.post("/api/scrape", response_model=ScrapeResponse)
+async def scrape_tasks(request: ScrapeRequest, background_tasks: BackgroundTasks):
+    """
+    Запустить скрапинг заданий
+    
+    Фоновая задача для сбора заданий с ФИПИ
+    """
+    if not scraper:
+        raise HTTPException(status_code=503, detail="Скрапер не настроен")
+    
+    if not supabase_client:
+        raise HTTPException(status_code=503, detail="Supabase не настроен")
+    
+    try:
+        tasks_scraped = 0
+        tasks_saved = 0
+        duplicates_skipped = 0
+        
+        # Если указаны URL, скрапим их
+        if request.urls:
+            for url in request.urls:
+                task = await scraper.parse_task_page(
+                    await scraper.fetch_page(url), 
+                    url
+                )
+                if task:
+                    tasks_scraped += 1
+                    result = await supabase_client.insert_task(task)
+                    if result:
+                        tasks_saved += 1
+                    else:
+                        duplicates_skipped += 1
+        
+        # Если указан поисковый запрос
+        elif request.query:
+            tasks = await scraper.search_tasks(request.query)
+            tasks_scraped = len(tasks)
+            
+            for task in tasks:
+                # AI анализ через ruBERT
+                if rubert_client:
+                    analysis = await rubert_client.analyze_text(task.get("content", ""))
+                    if analysis:
+                        task["rubert_analysis"] = analysis
+                
+                result = await supabase_client.insert_task(task)
+                if result:
+                    tasks_saved += 1
+                else:
+                    duplicates_skipped += 1
+        
+        # Скрапинг по предмету (по умолчанию)
+        else:
+            tasks = await scraper.scrape_tasks(subject=request.subject)
+            tasks_scraped = len(tasks)
+            
+            for task in tasks:
+                # AI анализ через ruBERT
+                if rubert_client:
+                    analysis = await rubert_client.analyze_text(task.get("content", ""))
+                    if analysis:
+                        task["rubert_analysis"] = analysis
+                
+                result = await supabase_client.insert_task(task)
+                if result:
+                    tasks_saved += 1
+                else:
+                    duplicates_skipped += 1
+        
+        return ScrapeResponse(
+            success=True,
+            tasks_scraped=tasks_scraped,
+            tasks_saved=tasks_saved,
+            duplicates_skipped=duplicates_skipped,
+            message=f"Успешно обработано {tasks_scraped} заданий. Сохранено: {tasks_saved}, пропущено дубликатов: {duplicates_skipped}",
+        )
+    
+    except Exception as e:
+        logger.error(f"Ошибка при скрапинге: {e}")
+        raise HTTPException(status_code=500, detail=f"Ошибка скрапинга: {str(e)}")
+
+
+@app.get("/api/stats", response_model=StatsResponse)
+async def get_stats():
+    """Получить статистику по заданиям"""
+    if not supabase_client:
+        raise HTTPException(status_code=503, detail="Supabase не настроен")
+    
+    stats = await supabase_client.get_stats()
+    
+    # Получение времени последнего скрапинга
+    latest = await supabase_client.get_latest_tasks(limit=1)
+    last_scrape = latest[0].get("scraped_at") if latest else None
+    
+    return StatsResponse(
+        total_tasks=stats.get("total", 0),
+        by_type=stats.get("by_type", {}),
+        last_scrape=last_scrape,
+    )
+
+
+@app.post("/api/analyze", response_model=ScrapeResponse)
+async def analyze_existing_tasks():
+    """
+    AI анализ существующих заданий в базе
+    
+    Запускает ruBERT анализ для всех заданий без анализа
+    """
+    if not supabase_client:
+        raise HTTPException(status_code=503, detail="Supabase не настроен")
+    
+    if not rubert_client:
+        raise HTTPException(status_code=503, detail="RuBERT клиент не настроен")
+    
+    try:
+        tasks = await supabase_client.get_all_tasks()
+        analyzed_count = 0
+        
+        for task in tasks:
+            # Пропускаем уже проанализированные
+            if task.get("rubert_analysis"):
+                continue
+            
+            # Анализ через ruBERT
+            analysis = await rubert_client.analyze_text(task.get("content", ""))
+            
+            if analysis:
+                task["rubert_analysis"] = analysis
+                await supabase_client.update_task(task["id"], {"rubert_analysis": analysis})
+                analyzed_count += 1
+        
+        return ScrapeResponse(
+            success=True,
+            tasks_scraped=analyzed_count,
+            tasks_saved=analyzed_count,
+            duplicates_skipped=len(tasks) - analyzed_count,
+            message=f"Проанализировано {analyzed_count} заданий",
+        )
+    
+    except Exception as e:
+        logger.error(f"Ошибка при анализе: {e}")
+        raise HTTPException(status_code=500, detail=f"Ошибка анализа: {str(e)}")
+
+
+@app.get("/", tags=["root"])
+async def root():
+    """Корневой эндпоинт"""
+    return {
+        "message": "AI Scraper ФИПИ API",
+        "version": "1.0.0",
+        "docs": "/docs",
+    }
+
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request, exc):
+    """Глобальный обработчик исключений"""
+    logger.error(f"Необработанная ошибка: {exc}")
+    return ErrorResponse(
+        error="Internal Server Error",
+        detail=str(exc),
+        timestamp=datetime.utcnow(),
+    )

requirements.txt

@@ -0,0 +1,23 @@
+# FastAPI
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+
+# HTTP clients
+httpx==0.25.2
+requests==2.31.0
+aiohttp==3.9.1
+
+# Parsing
+beautifulsoup4==4.12.3
+lxml==5.1.0
+
+# Pydantic
+pydantic==2.5.3
+pydantic-settings==2.1.0
+
+# Utilities
+python-dotenv==1.0.0
+playwright==1.40.0
+
+# Supabase (закомментировано - вызывает конфликт версий)
+# supabase==2.3.4

scraper.py

@@ -0,0 +1,218 @@
+"""
+Скрапер для сайта ФИПИ (fipi.ru)
+Извлекает задания по русскому языку для ЕГЭ (задание 27)
+"""
+
+import httpx
+from bs4 import BeautifulSoup
+from typing import List, Dict, Optional
+from datetime import datetime
+import re
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class FIPIScraper:
+    """Парсер для сайта ФИПИ"""
+    
+    def __init__(self, base_url: str = "https://fipi.ru"):
+        self.base_url = base_url
+        self.headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+            "Accept-Language": "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7",
+        }
+    
+    async def fetch_page(self, url: str) -> Optional[str]:
+        """Получение HTML страницы"""
+        # Создаем клиент с отключенной проверкой SSL (для fipi.ru поддоменов)
+        import ssl
+        ssl_context = ssl.create_default_context()
+        ssl_context.check_hostname = False
+        ssl_context.verify_mode = ssl.CERT_NONE
+        
+        async with httpx.AsyncClient(
+            headers=self.headers, 
+            timeout=30.0,
+            verify=ssl_context
+        ) as client:
+            try:
+                response = await client.get(url)
+                response.raise_for_status()
+                return response.text
+            except httpx.HTTPError as e:
+                logger.error(f"Ошибка при получении {url}: {e}")
+                return None
+    
+    def parse_task_page(self, html: str, url: str) -> Optional[Dict]:
+        """Парсинг страницы с заданием"""
+        soup = BeautifulSoup(html, 'lxml')
+
+        # Извлечение заголовка - приоритет h1 в .content
+        title_tag = soup.select_one('.content h1') or soup.find('h1')
+        title = title_tag.get_text(strip=True) if title_tag else "Без названия"
+        
+        # Если заголовок пустой, пробуем извлечь из title документа
+        if not title or title == "Без названия":
+            title_doc = soup.find('title')
+            if title_doc:
+                title = title_doc.get_text(strip=True)
+
+        # Извлечение основного контента - приоритет .content
+        content_div = soup.select_one('.content') or soup.find('div', class_='field--name-body')
+        if not content_div:
+            content_div = soup.find('main') or soup.find('body')
+
+        # Очистка текста - удаляем скрипты и стили
+        for element in content_div.find_all(['script', 'style', 'nav', 'header', 'footer']):
+            element.decompose()
+        
+        content = content_div.get_text(separator='\n', strip=True) if content_div else ""
+
+        # Извлечение изображения (если есть)
+        images = []
+        for img in content_div.find_all('img'):
+            src = img.get('src') or img.get('data-src')
+            if src:
+                if not src.startswith('http'):
+                    src = self.base_url + src
+                images.append(src)
+
+        # Извлечение ссылок на задания
+        task_links = []
+        for link in content_div.find_all('a', href=True):
+            href = link['href']
+            link_text = link.get_text(strip=True)
+            if any(pattern in href for pattern in ['/ege/', '/oge/', '/task/', '/demo/', '/bank/']):
+                if not href.startswith('http'):
+                    href = self.base_url + href
+                task_links.append({"text": link_text, "url": href})
+
+        # Определение типа задания
+        task_type = self._detect_task_type(title, content)
+
+        # Извлечение вариантов (если есть)
+        variants = self._extract_variants(content)
+
+        return {
+            "title": title,
+            "content": content,
+            "source_url": url,
+            "task_type": task_type,
+            "images": images,
+            "variants": variants,
+            "task_links": task_links,
+            "scraped_at": datetime.utcnow().isoformat(),
+        }
+    
+    def _detect_task_type(self, title: str, content: str) -> str:
+        """Определение типа задания"""
+        text = (title + " " + content).lower()
+        
+        if any(word in text for word in ["сочинение", "эссе", "напишит"]):
+            return "writing"
+        elif any(word in text for word in ["тест", "выбер", "вариант"]):
+            return "test"
+        elif any(word in text for word in ["ауди", "слуш"]):
+            return "listening"
+        elif any(word in text for word in ["чит", "текст"]):
+            return "reading"
+        else:
+            return "other"
+    
+    def _extract_variants(self, content: str) -> List[str]:
+        """Извлечение вариантов ответов"""
+        variants = []
+        
+        # Паттерн для вариантов типа "1) ... 2) ..."
+        pattern = r'(\d+)[\.\)]\s*([^\n\d]+)'
+        matches = re.findall(pattern, content)
+        
+        for _, variant in matches:
+            variants.append(variant.strip())
+        
+        return variants[:10]  # Ограничение на 10 вариантов
+    
+    async def scrape_tasks(self, subject: str = "russian") -> List[Dict]:
+        """
+        Скрапинг заданий по предмету
+
+        Args:
+            subject: Код предмета (по умолчанию russian)
+
+        Returns:
+            Список заданий
+        """
+        tasks = []
+
+        # Актуальные URLs для скрапинга (fipi.ru) - только работающие
+        urls_to_scrape = [
+            f"{self.base_url}/ege/otkrytyy-bank-zadaniy-ege",
+            f"{self.base_url}/oge/otkrytyy-bank-zadaniy-oge",
+        ]
+
+        for url in urls_to_scrape:
+            logger.info(f"Скрапинг {url}")
+            html = await self.fetch_page(url)
+
+            if html:
+                task = self.parse_task_page(html, url)
+                if task:
+                    tasks.append(task)
+                    
+                    # Если есть ссылки на задания, скачиваем их
+                    for link_info in task.get('task_links', [])[:5]:  # Ограничиваем количество
+                        link_url = link_info.get('url')
+                        if link_url:
+                            logger.info(f"  -> Скачиваем задание: {link_url}")
+                            link_html = await self.fetch_page(link_url)
+                            if link_html:
+                                subtask = self.parse_task_page(link_html, link_url)
+                                if subtask:
+                                    tasks.append(subtask)
+
+        logger.info(f"Найдено {len(tasks)} заданий")
+        return tasks
+    
+    async def scrape_task_by_id(self, task_id: str) -> Optional[Dict]:
+        """Скрапинг конкретного задания по ID"""
+        url = f"{self.base_url}/task/{task_id}"
+        logger.info(f"Скрапинг задания {task_id}")
+        
+        html = await self.fetch_page(url)
+        if html:
+            return self.parse_task_page(html, url)
+        
+        return None
+    
+    async def search_tasks(self, query: str) -> List[Dict]:
+        """Поиск заданий по ключевому слову"""
+        tasks = []
+        # Используем правильный URL для поиска на fipi.ru
+        search_url = f"{self.base_url}/search?q={query}"
+
+        html = await self.fetch_page(search_url)
+        if not html:
+            # Пробуем альтернативный поиск через банк заданий
+            logger.info("Поиск не доступен, пробуем парсинг банка заданий")
+            return await self.scrape_tasks()
+
+        soup = BeautifulSoup(html, 'lxml')
+
+        # Поиск ссылок на задания с правильными паттернами
+        for link in soup.find_all('a', href=True):
+            href = link['href']
+            # Проверяем на наличие валидных URL заданий
+            if any(pattern in href for pattern in ['/ege/', '/oge/', '/task/', '/demo/', '/bank/']):
+                if not href.startswith('http'):
+                    href = self.base_url + href
+
+                task_html = await self.fetch_page(href)
+                if task_html:
+                    task = self.parse_task_page(task_html, href)
+                    if task:
+                        tasks.append(task)
+
+        return tasks

supabase_client.py

@@ -0,0 +1,192 @@
+"""
+Клиент для Supabase
+Хранение и управление заданиями
+"""
+
+from supabase import create_client, Client
+from typing import List, Dict, Optional
+from datetime import datetime
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class SupabaseClient:
+    """Клиент для работы с Supabase"""
+    
+    def __init__(self, url: str, key: str):
+        self.client: Client = create_client(url, key)
+        self.table_name = "fipi_tasks"
+    
+    async def insert_task(self, task: Dict) -> Optional[Dict]:
+        """
+        Добавление задания в базу
+        
+        Args:
+            task: Данные задания
+        
+        Returns:
+            Сохраненное задание с ID
+        """
+        try:
+            # Проверка на дубликаты по URL
+            existing = await self.get_task_by_url(task.get("source_url", ""))
+            if existing:
+                logger.info(f"Задание уже существует: {task.get('source_url')}")
+                return existing
+            
+            # Добавление записи
+            result = self.client.table(self.table_name).insert(task).execute()
+            
+            if result.data:
+                logger.info(f"Задание сохранено: {result.data[0].get('id')}")
+                return result.data[0]
+            
+            return None
+        except Exception as e:
+            logger.error(f"Ошибка при сохранении задания: {e}")
+            return None
+    
+    async def insert_tasks_batch(self, tasks: List[Dict]) -> List[Dict]:
+        """
+        Пакетное добавление заданий
+        
+        Args:
+            tasks: Список заданий
+        
+        Returns:
+            Список сохраненных заданий
+        """
+        saved = []
+        for task in tasks:
+            result = await self.insert_task(task)
+            if result:
+                saved.append(result)
+        
+        logger.info(f"Сохранено {len(saved)} из {len(tasks)} заданий")
+        return saved
+    
+    async def get_task_by_id(self, task_id: int) -> Optional[Dict]:
+        """Получение задания по ID"""
+        try:
+            result = self.client.table(self.table_name)\
+                .select("*")\
+                .eq("id", task_id)\
+                .execute()
+            
+            return result.data[0] if result.data else None
+        except Exception as e:
+            logger.error(f"Ошибка получения задания: {e}")
+            return None
+    
+    async def get_task_by_url(self, url: str) -> Optional[Dict]:
+        """Получение задания по URL (проверка на дубликат)"""
+        try:
+            result = self.client.table(self.table_name)\
+                .select("*")\
+                .eq("source_url", url)\
+                .execute()
+            
+            return result.data[0] if result.data else None
+        except Exception as e:
+            logger.error(f"Ошибка проверки дубликата: {e}")
+            return None
+    
+    async def get_latest_tasks(self, limit: int = 10) -> List[Dict]:
+        """Получение последних заданий"""
+        try:
+            result = self.client.table(self.table_name)\
+                .select("*")\
+                .order("scraped_at", desc=True)\
+                .limit(limit)\
+                .execute()
+            
+            return result.data or []
+        except Exception as e:
+            logger.error(f"Ошибка получения последних заданий: {e}")
+            return []
+    
+    async def get_all_tasks(self) -> List[Dict]:
+        """Получение всех заданий"""
+        try:
+            result = self.client.table(self.table_name)\
+                .select("*")\
+                .execute()
+            
+            return result.data or []
+        except Exception as e:
+            logger.error(f"Ошибка получения всех заданий: {e}")
+            return []
+    
+    async def search_tasks(self, query: str) -> List[Dict]:
+        """Поиск заданий по содержимому"""
+        try:
+            # Поиск по заголовку и контенту
+            result = self.client.table(self.table_name)\
+                .select("*")\
+                .or_(f"title.ilike.%{query}%,content.ilike.%{query}%")\
+                .execute()
+            
+            return result.data or []
+        except Exception as e:
+            logger.error(f"Ошибка поиска: {e}")
+            return []
+    
+    async def get_tasks_by_type(self, task_type: str) -> List[Dict]:
+        """Получение заданий по типу"""
+        try:
+            result = self.client.table(self.table_name)\
+                .select("*")\
+                .eq("task_type", task_type)\
+                .execute()
+            
+            return result.data or []
+        except Exception as e:
+            logger.error(f"Ошибка получения заданий по типу: {e}")
+            return []
+    
+    async def update_task(self, task_id: int, updates: Dict) -> Optional[Dict]:
+        """Обновление задания"""
+        try:
+            result = self.client.table(self.table_name)\
+                .update(updates)\
+                .eq("id", task_id)\
+                .execute()
+
+            return result.data[0] if result.data else None
+        except Exception as e:
+            logger.error(f"Ошибка обновления задания: {e}")
+            return None
+    
+    async def delete_task(self, task_id: int) -> bool:
+        """Удаление задания"""
+        try:
+            result = self.client.table(self.table_name)\
+                .delete()\
+                .eq("id", task_id)\
+                .execute()
+            
+            return len(result.data) > 0
+        except Exception as e:
+            logger.error(f"Ошибка удаления задания: {e}")
+            return False
+    
+    async def get_stats(self) -> Dict:
+        """Получение статистики по заданиям"""
+        try:
+            all_tasks = await self.get_all_tasks()
+            
+            stats = {
+                "total": len(all_tasks),
+                "by_type": {}
+            }
+            
+            for task in all_tasks:
+                task_type = task.get("task_type", "unknown")
+                stats["by_type"][task_type] = stats["by_type"].get(task_type, 0) + 1
+            
+            return stats
+        except Exception as e:
+            logger.error(f"Ошибка получения статистики: {e}")
+            return {"total": 0, "by_type": {}}