2026-10-08 04:59:33 +03:00
27 changed files with 439 additions and 889 deletions
--- a/.dockerignore
+++ b/.dockerignore
@ -1,7 +0,0 @@
-.git
-.env
-media
-models
-db.sqlite3
-__pycache__
-tests
--- a/.env.example
+++ b/.env.example
@ -1,9 +0,0 @@
-# Обязательно в продакшене
-DJANGO_SECRET_KEY=change-me-to-a-long-random-string
-DJANGO_ALLOWED_HOSTS=localhost,127.0.0.1
-# DJANGO_DEBUG=True  # для разработки
-
-# Необязательно
-API_TOKEN=             # если задан — запросы с заголовком Authorization: Bearer <токен>
-GRPC_SERVER=           # адрес сервиса TextProcessor, например textproc:50051; пусто — не отправлять
-MAX_UPLOAD_SIZE_MB=50
--- a/.gitattributes
+++ b/.gitattributes
@ -1,2 +0,0 @@
-* text=auto eol=lf
-*.ogg binary
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -1,35 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    env:
-      VOSK_MODEL_PATH: ${{ github.workspace }}/models/vosk-model-small-ru-0.22
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-      - run: sudo apt-get update -qq && sudo apt-get install -y -qq ffmpeg
-      - name: Модель Vosk (кэш)
-        id: model
-        uses: actions/cache@v4
-        with:
-          path: models
-          key: vosk-model-small-ru-0.22
-      - if: steps.model.outputs.cache-hit != 'true'
-        run: |
-          mkdir -p models
-          curl -fsSL -o /tmp/model.zip https://alphacephei.com/vosk/models/vosk-model-small-ru-0.22.zip
-          unzip -q /tmp/model.zip -d models
-      - run: pip install -r requirements-dev.txt
-      - run: ruff check --select E9,F,B --exclude proto .
-      - run: python manage.py check && python manage.py makemigrations --check --dry-run
-        env:
-          DJANGO_DEBUG: "True"
-      - run: pytest -q
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@ -1,42 +0,0 @@
-name: Docker
-
-on:
-  push:
-    tags: ["v*"]
-  workflow_dispatch:
-
-jobs:
-  image:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - uses: actions/checkout@v4
-      - uses: docker/setup-buildx-action@v3
-      - uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - uses: docker/login-action@v3
-        with:
-          registry: dcr.deev.su
-          username: ${{ secrets.ZOT_USERNAME }}
-          password: ${{ secrets.ZOT_PASSWORD }}
-      - id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: |
-            ghcr.io/edeev/api_processor
-            dcr.deev.su/edeev/api_processor
-          tags: |
-            type=semver,pattern={{version}}
-            type=semver,pattern={{major}}.{{minor}}
-            type=raw,value=latest
-      - uses: docker/build-push-action@v6
-        with:
-          context: .
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
--- a/.gitignore
+++ b/.gitignore
@ -1,8 +0,0 @@
-.env
-__pycache__/
-*.pyc
-.pytest_cache/
-db.sqlite3
-media/
-staticfiles/
-models/
--- a/33
+++ b/33
@ -1,33 +0,0 @@
-FROM python:3.12-slim
-
-ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1 \
-    DJANGO_DB_PATH=/data/db.sqlite3 \
-    DJANGO_MEDIA_ROOT=/data/media \
-    VOSK_MODEL_PATH=/app/models/vosk-model-small-ru-0.22
-
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends ffmpeg curl unzip \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-# офлайн-модель распознавания русской речи (~45 МБ)
-RUN mkdir -p models \
-    && curl -fsSL -o /tmp/model.zip https://alphacephei.com/vosk/models/vosk-model-small-ru-0.22.zip \
-    && unzip -q /tmp/model.zip -d models \
-    && rm /tmp/model.zip
-
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY manage.py ./
-COPY api_project/ api_project/
-COPY api_app/ api_app/
-COPY proto/ proto/
-
-RUN useradd --create-home --uid 1000 app && mkdir -p /data && chown -R app:app /app /data
-USER app
-VOLUME ["/data"]
-EXPOSE 8000
-
-CMD ["sh", "-c", "python manage.py migrate --noinput && gunicorn api_project.wsgi:application --bind 0.0.0.0:8000 --workers 2 --timeout 300"]
--- a/21
+++ b/21
@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Egor Deev
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
--- a/README.en.md
+++ b/README.en.md
@ -1,129 +0,0 @@
-# API Processor
-
-[Русский](README.md) · **English**
-
-[![CI](https://github.com/EDeev/api_processor/actions/workflows/ci.yml/badge.svg)](https://github.com/EDeev/api_processor/actions/workflows/ci.yml)
-[![Docker](https://github.com/EDeev/api_processor/actions/workflows/docker.yml/badge.svg)](https://github.com/EDeev/api_processor/actions/workflows/docker.yml)
-[![License](https://img.shields.io/github/license/EDeev/api_processor)](LICENSE)
-
-A REST API that turns audio and documents into text:
- speech is recognized offline with a Vosk model;
- text, tables and images are extracted from PDF and DOCX.
-
-The result can be forwarded over gRPC to a text processing service. Speech recognition targets Russian.
-
-**Status:** personal project, completed
-
-**Stack:** Python 3.12 · Django 5.2 · Django REST Framework · Vosk · FFmpeg · pdfplumber · python-docx · gRPC · Docker
-
-## Features
-
- **Audio → text.** Any format FFmpeg reads (OGG, MP3, M4A, WAV…). Audio is converted to 16 kHz mono with
-  noise reduction and loudness normalization first. Recognition is offline, no external services.
- **Document → HTML.** PDF and DOCX: paragraphs in `<p>`, tables as CSV in `<pre>`, images as base64. The
-  document text is escaped, so the result is safe to render in a browser.
- **gRPC.** The text is sent to the `TextProcessor` service (`proto/text_service.proto`), and its reply is
-  returned in `grpc_response`. If no service address is set, the step is skipped.
- Optional access token and a file size limit (50 MB by default).
-
-## API
-
-```bash
-curl -F audio=@examples/sample.ogg http://localhost:8000/api/audio-to-text/
-curl -F document=@report.pdf http://localhost:8000/api/document-to-text/
-```
-
-```json
-{
-  "text": "раз два три проверка перевода голоса текст насколько качественно она работает один два три четыре пять шесть семь восемь девять десять",
-  "grpc_response": null
-}
-```
-
-With `API_TOKEN` set, add `Authorization: Bearer <token>`. Errors come as `{"error": "..."}`:
-
-| Code | When |
-|---|---|
-| 400 | no file or unsupported document format |
-| 403 | wrong token |
-| 413 | file over the limit |
-| 422 | audio could not be read |
-
-## Running
-
-```bash
-git clone https://github.com/EDeev/api_processor.git && cd api_processor
-cp .env.example .env      # set DJANGO_SECRET_KEY
-docker compose up -d      # API at http://localhost:8000
-```
-
-The Vosk model and FFmpeg are inside the image. Prebuilt image: `docker pull ghcr.io/edeev/api_processor` or
-`docker pull dcr.deev.su/edeev/api_processor`.
-
-Without Docker you need:
- FFmpeg in `PATH`;
- the [vosk-model-small-ru-0.22](https://alphacephei.com/vosk/models) model unpacked into `models/`.
-
-Then:
-
-```bash
-pip install -r requirements.txt
-DJANGO_DEBUG=True python manage.py migrate
-DJANGO_DEBUG=True python manage.py runserver
-```
-
-| Variable | Purpose |
-|---|---|
-| `DJANGO_SECRET_KEY` | secret key, required unless `DJANGO_DEBUG=True` |
-| `DJANGO_ALLOWED_HOSTS` | comma-separated domains |
-| `API_TOKEN` | if set, access requires the token |
-| `GRPC_SERVER`, `GRPC_TIMEOUT` | TextProcessor address and timeout, s |
-| `MAX_UPLOAD_SIZE_MB` | file size limit |
-| `VOSK_MODEL_PATH`, `FFMPEG_BINARY` | paths to the model and ffmpeg |
-
-## How it works
-
-```mermaid
-flowchart LR
-    C[Client] -->|multipart| V[DRF APIView]
-    V -->|audio| F[FFmpeg: 16 kHz mono, denoise] --> K[Vosk]
-    V -->|PDF / DOCX| S[pdfplumber / python-docx]
-    K --> T[text]
-    S --> T
-    T -->|gRPC ProcessText| G[TextProcessor]
-    T --> R[JSON response]
-```
-
-The Vosk model is loaded once per process. Each request gets its own temporary file. Uploaded files and
-results are stored in SQLite and `media/`.
-
-## Development
-
-```bash
-pip install -r requirements-dev.txt
-ruff check --select E9,F,B --exclude proto . && pytest
-```
-
-What the tests cover:
- recognition of the whole sample, with every phrase;
- OGG conversion;
- PDF and DOCX extraction with escaping;
- limits and the token;
- a real gRPC server and an unavailable one.
-
-The Docker image is built on `v*` tags and published to GitHub Packages and `dcr.deev.su`.
-
-## License
-
-MIT — see [LICENSE](LICENSE). The Vosk model is licensed under Apache 2.0.
-
-## Author
-
-**Egor Deev** — [GitHub](https://github.com/EDeev) · [Telegram](https://t.me/DeevEgor) · [egor@deev.space](mailto:egor@deev.space)
-
---
-
-<div align="center">
-  <sub>⭐ If you find this project useful, give it a star on GitHub!</sub>
-  <p><sub>Made with ❤️ — <a href="https://deev.space">deev.space</a></sub></p>
-</div>
--- a/README.md
+++ b/README.md
@ -1,142 +1,171 @@
 # API Processor

-**Русский** · [English](README.en.md)
+**Django REST API для обработки аудио и документов с интеграцией gRPC сервисов**

-[![CI](https://github.com/EDeev/api_processor/actions/workflows/ci.yml/badge.svg)](https://github.com/EDeev/api_processor/actions/workflows/ci.yml)
-[![Docker](https://github.com/EDeev/api_processor/actions/workflows/docker.yml/badge.svg)](https://github.com/EDeev/api_processor/actions/workflows/docker.yml)
-[![License](https://img.shields.io/github/license/EDeev/api_processor)](LICENSE)
+API Processor — это мощное решение для автоматической обработки мультимедийного контента. Система выполняет транскрибацию аудиофайлов в текст и извлечение данных из PDF/DOCX документов с последующей отправкой результатов на внешний gRPC сервер для дополнительной обработки.

-REST API, которое превращает аудио и документы в текст:
- речь распознаётся офлайн моделью Vosk;
- из PDF и DOCX извлекаются текст, таблицы и изображения.
+## 🚀 Возможности

-Результат можно отправить дальше по gRPC — на сервис обработки текста.
+- **Аудио транскрипция**: Преобразование аудиофайлов в текст с использованием модели Vosk
+- **Обработка документов**: Извлечение текста, таблиц и изображений из PDF и DOCX файлов
+- **gRPC интеграция**: Автоматическая отправка обработанного текста на внешний сервер
+- **RESTful API**: Простой и понятный интерфейс для взаимодействия
+- **Поддержка форматов**: Audio (WAV, OGG и др.), PDF, DOCX

-**Статус:** личный проект, завершён
+## 🛠 Технологический стек

-**Стек:** Python 3.12 · Django 5.2 · Django REST Framework · Vosk · FFmpeg · pdfplumber · python-docx · gRPC · Docker
+### Backend
+- **Django 4.2.6** - веб-фреймворк
+- **Django REST Framework 3.14.0** - API framework
+- **Python** - основной язык разработки

-## Возможности
+### Обработка контента
+- **Vosk 0.3.45** - распознавание речи
+- **FFmpeg Python 0.2.0** - конвертация аудио
+- **pdfplumber 0.10.2** - извлечение данных из PDF
+- **python-docx 0.8.11** - работа с DOCX файлами
+- **Pillow 10.0.1** - обработка изображений

- **Аудио → текст.** Любой формат, который читает FFmpeg (OGG, MP3, M4A, WAV…). Перед распознаванием
-  звук приводится к 16 кГц моно с шумоподавлением и нормализацией громкости. Распознавание офлайн, без
-  внешних сервисов.
- **Документ → HTML.** PDF и DOCX: абзацы — в `<p>`, таблицы — CSV в `<pre>`, изображения — в base64.
-  Текст документа экранируется, поэтому результат безопасно показывать в браузере.
- **gRPC.** Распознанный текст уходит на сервис `TextProcessor` (`proto/text_service.proto`), его ответ
-  возвращается в поле `grpc_response`. Если адрес сервиса не задан, шаг пропускается.
- Необязательный токен доступа и ограничение размера файла (по умолчанию 50 МБ).
+### Коммуникация
+- **gRPC 1.58.0** - межсервисное взаимодействие
+- **Protocol Buffers** - сериализация данных

-## API
+### База данных
+- **SQLite** - локальное хранение метаданных файлов

-```bash
-curl -F audio=@examples/sample.ogg http://localhost:8000/api/audio-to-text/
-curl -F document=@report.pdf http://localhost:8000/api/document-to-text/
-```
+## 📋 Требования

-```json
-{
-  "text": "раз два три проверка перевода голоса текст насколько качественно она работает один два три четыре пять шесть семь восемь девять десять",
-  "grpc_response": null
-}
-```
+- Python 3.8+
+- FFmpeg (для конвертации аудио)
+- Модель Vosk для русского языка

-Если задан `API_TOKEN`, добавьте заголовок `Authorization: Bearer <токен>`. Ошибки приходят как
-`{"error": "..."}`:
+## ⚡ Быстрый старт

-| Код | Когда |
-|---|---|
-| 400 | нет файла или неподдерживаемый формат документа |
-| 403 | неверный токен |
-| 413 | файл больше лимита |
-| 422 | аудио не удалось прочитать |
-
-## Запуск
-
-```bash
-git clone https://github.com/EDeev/api_processor.git && cd api_processor
-cp .env.example .env      # задайте DJANGO_SECRET_KEY
-docker compose up -d      # API на http://localhost:8000
-```
-
-Модель Vosk и FFmpeg уже внутри образа. Готовый образ: `docker pull ghcr.io/edeev/api_processor` или
-`docker pull dcr.deev.su/edeev/api_processor`.
-
-Без Docker нужны:
- FFmpeg в `PATH`;
- модель [vosk-model-small-ru-0.22](https://alphacephei.com/vosk/models), распакованная в `models/`.
-
-Затем:
+### Установка зависимостей

 ```bash
 pip install -r requirements.txt
-DJANGO_DEBUG=True python manage.py migrate
-DJANGO_DEBUG=True python manage.py runserver
 ```

-| Переменная | Назначение |
-|---|---|
-| `DJANGO_SECRET_KEY` | секретный ключ, обязателен без `DJANGO_DEBUG=True` |
-| `DJANGO_ALLOWED_HOSTS` | домены через запятую |
-| `API_TOKEN` | если задан — доступ только с токеном |
-| `GRPC_SERVER`, `GRPC_TIMEOUT` | адрес сервиса TextProcessor и таймаут, с |
-| `MAX_UPLOAD_SIZE_MB` | лимит размера файла |
-| `VOSK_MODEL_PATH`, `FFMPEG_BINARY` | путь к модели и к ffmpeg |
+### Настройка модели Vosk

-## Как устроено
+1. Скачайте модель `vosk-model-small-ru-0.22`
+2. Разместите в папке `models/vosk-model-small-ru-0.22`

-```mermaid
-flowchart LR
-    C[Клиент] -->|multipart| V[DRF APIView]
-    V -->|аудио| F[FFmpeg: 16 кГц моно, шумоподавление] --> K[Vosk]
-    V -->|PDF / DOCX| S[pdfplumber / python-docx]
-    K --> T[текст]
-    S --> T
-    T -->|gRPC ProcessText| G[TextProcessor]
-    T --> R[JSON-ответ]
-```
+### Настройка FFmpeg

-```
-api_app/views.py                      эндпоинты и проверки
-api_app/services/vosk_recognizer.py   конвертация FFmpeg и распознавание Vosk
-api_app/services/scan.py              извлечение из PDF и DOCX
-api_app/grpc_client/client.py         клиент TextProcessor
-proto/                                описание gRPC-сервиса и сгенерированный код
-```
+1. Скачайте FFmpeg
+2. Разместите в `models/ffmpeg/bin/ffmpeg.exe`

-Модель Vosk загружается один раз на процесс. У каждого запроса свой временный файл. Загруженные файлы и
-результат сохраняются в SQLite и `media/`.
-
-## Разработка
+### Запуск сервера

 ```bash
-pip install -r requirements-dev.txt
-ruff check --select E9,F,B --exclude proto . && pytest
+python manage.py migrate
+python manage.py runserver
 ```

-Что проверяют тесты:
- распознавание образца целиком, со всеми фразами;
- конвертацию OGG;
- извлечение из PDF и DOCX с экранированием;
- лимиты и токен;
- работу с настоящим gRPC-сервером и его недоступность.
+## 📖 API Endpoints

-Docker-образ собирается по тегу `v*` и публикуется в GitHub Packages и `dcr.deev.su`.
+### Транскрипция аудио
+```http
+POST /api/audio-to-text/
+Content-Type: multipart/form-data

-Код gRPC пересобирается так:
-`python -m grpc_tools.protoc -Iproto --python_out=proto --grpc_python_out=proto proto/text_service.proto`.
+audio: <audio_file>
+```

-## Лицензия
+**Ответ:**
+```json
+{
+    "text": "Распознанный текст из аудио",
+    "grpc_response": {
+        "processed_text": "Обработанный текст",
+        "success": true,
+        "error": null
+    }
+}
+```

-MIT — см. [LICENSE](LICENSE). Модель Vosk распространяется под Apache 2.0.
+### Обработка документов
+```http
+POST /api/document-to-text/
+Content-Type: multipart/form-data

-## Автор
+document: <pdf_or_docx_file>
+```

-**Деев Егор Викторович** — [GitHub](https://github.com/EDeev) · [Telegram](https://t.me/DeevEgor) · [egor@deev.space](mailto:egor@deev.space)
+**Ответ:**
+```json
+{
+    "text": "<p>Извлеченный текст</p><pre>таблица,данные</pre>",
+    "grpc_response": {
+        "processed_text": "Обработанный текст",
+        "success": true,
+        "error": null
+    }
+}
+```
+
+## 🧪 Примеры использования
+
+### cURL команды
+
+**Транскрипция аудио:**
+```bash
+curl -X POST -F "audio=@audio.ogg" http://localhost:8000/api/audio-to-text/
+```
+
+**Обработка документа:**
+```bash
+curl -X POST -F "document=@document.pdf" http://localhost:8000/api/document-to-text/
+```
+
+## ⚙️ Конфигурация
+
+### gRPC настройки
+По умолчанию система подключается к gRPC серверу на `localhost:50051`. Для изменения адреса отредактируйте `api_app/grpc_client/client.py`.
+
+### Модели и пути
+Пути к моделям и исполняемым файлам настраиваются в `api_app/services/vosk_recognizer.py`:
+- `MODEL_PATH` - путь к модели Vosk
+- `FFMPEG_PATH` - путь к исполняемому файлу FFmpeg
+
+## 📁 Структура проекта
+
+```
+api_processor/
+├── api_app/                    # Основное приложение
+│   ├── grpc_client/           # gRPC клиент
+│   ├── services/              # Сервисы обработки
+│   ├── migrations/            # Миграции БД
+│   ├── models.py              # Модели данных
+│   └── views.py               # API эндпоинты
+├── api_project/               # Настройки Django
+├── proto/                     # Protocol Buffers схемы
+├── models/                    # Модели и исполняемые файлы
+└── requirements.txt           # Зависимости
+```
+
+## 🔧 Особенности реализации
+
+- **Автоматическая конвертация**: Аудиофайлы автоматически конвертируются в формат WAV 16kHz
+- **Извлечение изображений**: Из документов извлекаются изображения в формате base64
+- **Обработка таблиц**: Таблицы сохраняются в CSV формате
+- **Fallback система**: При недоступности gRPC сервера используются заглушки
+
+## 📄 Лицензия
+
+Этот проект разработан для образовательных и исследовательских целей.
+
+## 🤝 Разработчик
+
+**Деев Егор Викторович** - Backend Developer  
+- GitHub: [@EDeev](https://github.com/EDeev)
+- Email: egor@deev.space
+- Telegram: [@Egor_Deev](https://t.me/Egor_Deev)

 ---

 <div align="center">
-  <sub>⭐ Если проект оказался полезным, поставьте звёздочку на GitHub!</sub>
-  <p><sub>Сделано с ❤️ — <a href="https://deev.space">deev.space</a></sub></p>
+  <p><sub>Создано с ❤️ от вашего дорогого - deev.space ©</sub></p>
 </div>
--- a/api_app/grpc_client/client.py
+++ b/api_app/grpc_client/client.py
@ -1,38 +1,90 @@
-import logging
+# api_project/api_app/grpc_client/client.py
+import grpc
 import os
 import sys

-import grpc
-from django.conf import settings
-
-# сгенерированные модули лежат в proto/ в корне репозитория (раньше путь считался на уровень
-# выше репозитория — импорт всегда падал, и вместо настоящего gRPC работала заглушка
-# с поддельным success: true)
-PROTO_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "proto")
-if PROTO_DIR not in sys.path:
-    sys.path.append(PROTO_DIR)
-
-import text_service_pb2  # noqa: E402
-import text_service_pb2_grpc  # noqa: E402
-
-logger = logging.getLogger(__name__)
-
-
-def send_to_grpc_server(text: str):
-    """Отправляет текст на gRPC-сервер TextProcessor. Если адрес сервера не задан
-    (GRPC_SERVER пустой), шаг пропускается и возвращается None"""
-    if not settings.GRPC_SERVER:
-        return None
+# Добавляем путь для импорта сгенерированных протофайлов
+current_dir = os.path.dirname(os.path.abspath(__file__))
+proto_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(current_dir))), 'proto')
+sys.path.append(proto_dir)

+# Пробуем импортировать сгенерированные протофайлы
+# Если не получится, используем заглушки
 try:
-        with grpc.insecure_channel(settings.GRPC_SERVER) as channel:
+    import text_service_pb2
+    import text_service_pb2_grpc
+    print("Успешно импортированы сгенерированные proto файлы")
+except ImportError:
+    print("Не удалось импортировать сгенерированные proto файлы, используем заглушки")
+    
+    # Создаем заглушки
+    class TextRequest:
+        def __init__(self, text):
+            self.text = text
+    
+    class TextResponse:
+        def __init__(self, processed_text, success, error):
+            self.processed_text = processed_text
+            self.success = success
+            self.error = error
+    
+    class TextProcessorStub:
+        def __init__(self, channel):
+            self.channel = channel
+        
+        def ProcessText(self, request):
+            # Эмулируем ответ от gRPC сервера
+            return TextResponse(
+                processed_text=f"ЗАГЛУШКА ОБРАБОТКИ ТЕКСТА: {request.text}",
+                success=True,
+                error=""
+            )
+    
+    # Создаем модуль заглушки
+    class text_service_pb2:
+        TextRequest = TextRequest
+        TextResponse = TextResponse
+    
+    class text_service_pb2_grpc:
+        TextProcessorStub = TextProcessorStub
+
+def send_to_grpc_server(text: str) -> dict:
+    """
+    Отправляет текст на gRPC сервер для обработки
+    
+    Args:
+        text: Текст для обработки
+        
+    Returns:
+        dict: Результат обработки
+    """
+    try:
+        # Создаем соединение с сервером
+        # Для заглушки это не обязательно, но оставим для совместимости
+        try:
+            channel = grpc.insecure_channel('localhost:50051')
+        except NameError:
+            # Если grpc не импортирован, используем заглушку
+            channel = "dummy_channel"
+        
+        # Создаем клиент
        stub = text_service_pb2_grpc.TextProcessorStub(channel)
-            response = stub.ProcessText(text_service_pb2.TextRequest(text=text), timeout=settings.GRPC_TIMEOUT)
+        
+        # Создаем запрос
+        request = text_service_pb2.TextRequest(text=text)
+        
+        # Отправляем запрос
+        response = stub.ProcessText(request)
+        
+        # Возвращаем результат
        return {
            'processed_text': response.processed_text,
            'success': response.success,
-            'error': response.error or None,
+            'error': response.error if hasattr(response, 'error') and response.error else None
+        }
+    except Exception as e:
+        return {
+            'processed_text': None,
+            'success': False,
+            'error': str(e)
        }
-    except grpc.RpcError as e:
-        logger.warning("gRPC-сервер %s недоступен: %s", settings.GRPC_SERVER, e.code())
-        return {'processed_text': None, 'success': False, 'error': f"gRPC: {e.code().name}"}
--- a/api_app/models.py
+++ b/api_app/models.py
@ -4,7 +4,7 @@ import uuid
 import os

 def get_file_path(instance, filename):
-    ext = filename.split('.')[-1].lower()
+    ext = filename.split('.')[-1]
    filename = f"{uuid.uuid4()}.{ext}"
    return os.path.join('uploads', filename)

--- a/api_app/permissions.py
+++ b/api_app/permissions.py
@ -1,16 +0,0 @@
-import hmac
-
-from django.conf import settings
-from rest_framework.permissions import BasePermission
-
-
-class ApiTokenPermission(BasePermission):
-    """Если задан API_TOKEN, запросы должны нести заголовок Authorization: Bearer <токен>"""
-
-    message = "Нужен заголовок Authorization: Bearer <API_TOKEN>"
-
-    def has_permission(self, request, view):
-        if not settings.API_TOKEN:
-            return True
-        header = request.headers.get("Authorization", "")
-        return hmac.compare_digest(header, f"Bearer {settings.API_TOKEN}")
--- a/api_app/services/scan.py
+++ b/api_app/services/scan.py
@ -1,70 +1,66 @@
-import base64
-import csv
-from html import escape
-from io import StringIO
-
-import docx
 import pdfplumber
-
-# сигнатуры форматов: картинка из PDF — это сырой поток, не обязательно PNG
-IMAGE_SIGNATURES = {
-    b"\x89PNG\r\n\x1a\n": "image/png",
-    b"\xff\xd8\xff": "image/jpeg",
-    b"GIF8": "image/gif",
-}
-
-
-def image_mime(data: bytes):
-    for signature, mime in IMAGE_SIGNATURES.items():
-        if data.startswith(signature):
-            return mime
-    return None
-
-
-def img_tag(data: bytes, mime: str) -> str:
-    return f'<img src="data:{mime};base64,{base64.b64encode(data).decode("utf-8")}"/>'
-
-
-def table_to_pre(rows) -> str:
-    csv_output = StringIO()
-    csv.writer(csv_output).writerows([[cell if cell is not None else "" for cell in row] for row in rows])
-    return f"<pre>{escape(csv_output.getvalue())}</pre>"
+import docx
+import csv
+import os
+from io import StringIO, BytesIO
+from PIL import Image
+import base64


 def extract_text_tables(file_path: str) -> str:
-    """Текст, таблицы (CSV) и изображения документа одной HTML-строкой.
-    Текст экранируется: иначе содержимое документа становится разметкой (XSS у потребителя)"""
    result = ""
-    path = file_path.lower()  # раньше файл «.PDF» молча давал пустой результат
-
-    if path.endswith(".pdf"):
+    if file_path.endswith(".pdf"):
        with pdfplumber.open(file_path) as pdf:
            for page in pdf.pages:
                text = page.extract_text()
                if text:
-                    result += "".join(f"<p>{escape(line)}</p>" for line in text.split("\n"))
+                    result += "<p>" + text.replace("\n", "</p><p>") + "</p>"

-                for table in page.extract_tables() or []:
-                    result += table_to_pre(table)
+                tables = page.extract_tables()
+                if tables:
+                    for table in tables:
+                        csv_output = StringIO()
+                        csv_writer = csv.writer(csv_output)
+                        csv_writer.writerows(table)
+                        result += f"<pre>{csv_output.getvalue()}</pre>"

-                # Извлечение изображений — только тех, что лежат в PDF готовым файлом (PNG/JPEG)
+                # Извлечение изображений
+                if page.images:
                    for img in page.images:
-                    data = img["stream"].get_data()
-                    mime = image_mime(data)
-                    if mime:
-                        result += img_tag(data, mime)
+                        img_data = img["stream"].get_data()
+                        encoded_img = base64.b64encode(img_data).decode("utf-8")
+                        result += f'<img src="data:image/png;base64,{encoded_img}"/>'

-    elif path.endswith(".docx"):
+    elif file_path.endswith(".docx"):
        doc = docx.Document(file_path)

-        result += "".join(f"<p>{escape(para.text)}</p>" for para in doc.paragraphs if para.text.strip())
-        result += "".join(table_to_pre([[cell.text.strip() for cell in row.cells] for row in table.rows])
-                          for table in doc.tables)
+        text_data = []
+        table_data = []
+        image_data = []

-        # Извлечение изображений с их настоящим типом
-        for rel in doc.part.rels.values():
-            if "image" in rel.reltype and not rel.is_external:
-                part = rel.target_part
-                result += img_tag(part.blob, part.content_type)
+        for para in doc.paragraphs:
+            if para.text.strip():
+                text_data.append(f"<p>{para.text}</p>")
+
+        for table in doc.tables:
+            csv_output = StringIO()
+            csv_writer = csv.writer(csv_output)
+            for row in table.rows:
+                csv_writer.writerow([cell.text.strip() for cell in row.cells])
+            table_data.append(f"<pre>{csv_output.getvalue()}</pre>")
+
+        # Извлечение изображений
+        for rel in doc.part.rels:
+            if "image" in doc.part.rels[rel].target_ref:
+                image_data_blob = doc.part.rels[rel].target_part.blob
+                encoded_img = base64.b64encode(image_data_blob).decode("utf-8")
+                image_data.append(f'<img src="data:image/png;base64,{encoded_img}"/>')
+
+        if text_data:
+            result += "".join(text_data)
+        if table_data:
+            result += "".join(table_data)
+        if image_data:
+            result += "".join(image_data)

    return result
--- a/api_app/services/vosk_recognizer.py
+++ b/api_app/services/vosk_recognizer.py
@ -1,81 +1,51 @@
-import json
-import logging
-import os
-import tempfile
-import threading
-import wave
+import os, wave, vosk, ffmpeg

-import ffmpeg
-import vosk
-from django.conf import settings
+MODEL_PATH = r"models/vosk-model-small-ru-0.22"
+FFMPEG_PATH = r"models/ffmpeg/bin/ffmpeg.exe"

-logger = logging.getLogger(__name__)
-vosk.SetLogLevel(-1)
-
-_model = None
-_model_lock = threading.Lock()
-
-
-class RecognitionError(Exception):
-    pass
-
-
-def get_model():
-    """Модель Vosk загружается один раз на процесс (раньше — на каждый запрос, это секунды и сотни МБ)"""
-    global _model
-    with _model_lock:
-        if _model is None:
-            if not os.path.isdir(settings.VOSK_MODEL_PATH):
-                raise RecognitionError(f"Модель Vosk не найдена: {settings.VOSK_MODEL_PATH}")
-            _model = vosk.Model(str(settings.VOSK_MODEL_PATH))
-    return _model
-
-
-def convert_audio_to_wav(input_file, output_file):
-    """WAV 16 кГц моно для Vosk, с шумоподавлением и нормализацией громкости"""
+def convert_audio_to_wav(input_file, output_file, FFMPEG_PATH):
    try:
        (
            ffmpeg
            .input(input_file)
            .output(output_file, format='wav', acodec='pcm_s16le', ar='16000', ac=1,
                    af='acompressor,afftdn,dynaudnorm,aresample=16000')  # 16kHz для Vosk
-            .global_args('-loglevel', 'error')
-            .run(cmd=settings.FFMPEG_BINARY, overwrite_output=True, capture_stdout=True, capture_stderr=True)
+            .global_args('-loglevel', 'quiet')
+            .run(cmd=FFMPEG_PATH, overwrite_output=True)
        )
+        print(f"Конвертация завершена: {output_file}")
    except ffmpeg.Error as e:
-        raise RecognitionError("Не удалось прочитать аудиофайл") from e
+        print("Ошибка при конвертации:", e.stderr.decode())


-def is_vosk_ready_wav(path) -> bool:
-    try:
-        with wave.open(path, "rb") as wf:
-            return wf.getnchannels() == 1 and wf.getsampwidth() == 2 and wf.getframerate() == 16000
-    except (wave.Error, EOFError):
-        return False
-
+vosk.SetLogLevel(-1)

 def recognize_speech(audio_path) -> str:
-    model = get_model()
+    if not os.path.exists(MODEL_PATH):
+        print("Ошибка: Модель не найдена!")
+        return ""

-    # временный файл — свой на каждый запрос (раньше общий audio.wav в текущей папке:
-    # одновременные запросы перезаписывали друг другу аудио)
-    with tempfile.TemporaryDirectory() as tmp:
-        if not (audio_path.lower().endswith(".wav") and is_vosk_ready_wav(audio_path)):
-            wav_path = os.path.join(tmp, "audio.wav")
-            convert_audio_to_wav(audio_path, wav_path)
-            audio_path = wav_path
+    model = vosk.Model(MODEL_PATH)

-        # Vosk отдаёт текст по фразам: раньше бралось только FinalResult(), и в длинной записи
-        # оставалась лишь последняя фраза
-        parts = []
+    if audio_path.split('.')[-1] != "wav":
+        convert.convert_audio_to_wav(audio_path, "audio.wav", FFMPEG_PATH)
+        audio_path = "audio.wav"
+    else:
        with wave.open(audio_path, "rb") as wf:
+            if wf.getnchannels() != 1 or wf.getsampwidth() != 2 or wf.getframerate() != 16000:
+                convert.convert_audio_to_wav(audio_path, "audio.wav", FFMPEG_PATH)
+                audio_path = "audio.wav"
+
+
+    with wave.open(audio_path, "rb") as wf: # использование vosk
        recognizer = vosk.KaldiRecognizer(model, wf.getframerate())
        while True:
-                data = wf.readframes(4000)
+            data = wf.readframes(3200)
            if not data:
                break
-                if recognizer.AcceptWaveform(data):
-                    parts.append(json.loads(recognizer.Result()).get("text", ""))
-        parts.append(json.loads(recognizer.FinalResult()).get("text", ""))
+            recognizer.AcceptWaveform(data)

-    return " ".join(p for p in parts if p)
+    if audio_path == "audio.wav":
+        os.remove(audio_path)
+
+    return recognizer.FinalResult().split(": \"")[-1][:-3]
--- a/api_app/views.py
+++ b/api_app/views.py
@ -1,78 +1,48 @@
-import logging
+# api_project/api_app/views.py
 import os
-
-from django.conf import settings
 from rest_framework import status
-from rest_framework.parsers import FormParser, MultiPartParser
-from rest_framework.response import Response
 from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework.parsers import MultiPartParser, FormParser
+from django.conf import settings

-from .grpc_client.client import send_to_grpc_server
 from .models import AudioFile, DocumentFile
+from .services.vosk_recognizer import recognize_speech
 from .services.scan import extract_text_tables
-from .services.vosk_recognizer import RecognitionError, recognize_speech
+from .grpc_client.client import send_to_grpc_server

-logger = logging.getLogger(__name__)
-
-
-def too_large(uploaded):
-    return uploaded.size > settings.MAX_UPLOAD_SIZE
-
-
-def size_error():
-    return Response({'error': f'Файл больше {settings.MAX_UPLOAD_SIZE // 1024 // 1024} МБ'},
-                    status=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE)
-
-
-class ProcessView(APIView):
+class AudioToTextView(APIView):
    parser_classes = (MultiPartParser, FormParser)
-    field = ""
-    model = None
-
-    def process(self, path):
-        raise NotImplementedError
-
-    def handle(self, uploaded):
-        record = self.model(file=uploaded)
-        record.save()
-
-        try:
-            text = self.process(os.path.join(settings.MEDIA_ROOT, record.file.name))
-        except RecognitionError as e:
-            return Response({'error': str(e)}, status=status.HTTP_422_UNPROCESSABLE_ENTITY)
-        except Exception:
-            # подробности — в лог, а не в ответ клиенту
-            logger.exception("Ошибка обработки %s", record.file.name)
-            return Response({'error': 'Не удалось обработать файл'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-        record.processed_text = text
-        record.save()
-
-        return Response({'text': text, 'grpc_response': send_to_grpc_server(text)}, status=status.HTTP_200_OK)
-
-
-class AudioToTextView(ProcessView):
-    model = AudioFile
-
-    def process(self, path):
-        return recognize_speech(path)
    
    def post(self, request, *args, **kwargs):
        audio_file = request.FILES.get('audio')
        
        if not audio_file:
            return Response({'error': 'Нет аудио файла'}, status=status.HTTP_400_BAD_REQUEST)
-        if too_large(audio_file):
-            return size_error()
        
-        return self.handle(audio_file)
+        audio_model = AudioFile(file=audio_file)
+        audio_model.save()
        
+        try:
+            file_path = os.path.join(settings.MEDIA_ROOT, audio_model.file.name)
            
-class DocumentToTextView(ProcessView):
-    model = DocumentFile
+            text = recognize_speech(file_path)
            
-    def process(self, path):
-        return extract_text_tables(path)
+            audio_model.processed_text = text
+            audio_model.save()
+            
+            grpc_response = send_to_grpc_server(text)
+            
+            return Response({
+                'text': text,
+                'grpc_response': grpc_response
+            }, status=status.HTTP_200_OK)
+            
+        except Exception as e:
+            return Response({'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+class DocumentToTextView(APIView):
+    parser_classes = (MultiPartParser, FormParser)
    
    def post(self, request, *args, **kwargs):
        document_file = request.FILES.get('document')
@ -84,7 +54,24 @@ class DocumentToTextView(ProcessView):
        if file_ext not in ['.pdf', '.docx']:
            return Response({'error': 'Поддерживаются только PDF и DOCX файлы'}, 
                            status=status.HTTP_400_BAD_REQUEST)
-        if too_large(document_file):
-            return size_error()
        
-        return self.handle(document_file)
+        doc_model = DocumentFile(file=document_file)
+        doc_model.save()
+        
+        try:
+            file_path = os.path.join(settings.MEDIA_ROOT, doc_model.file.name)
+            
+            text = extract_text_tables(file_path)
+            
+            doc_model.processed_text = text
+            doc_model.save()
+            
+            grpc_response = send_to_grpc_server(text)
+            
+            return Response({
+                'text': text,
+                'grpc_response': grpc_response
+            }, status=status.HTTP_200_OK)
+            
+        except Exception as e:
+            return Response({'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
--- a/api_project/settings.py
+++ b/api_project/settings.py
@ -3,20 +3,11 @@ from pathlib import Path

 BASE_DIR = Path(__file__).resolve().parent.parent

+SECRET_KEY = 'django-insecure-)+yykzv8cr7dbc38g2#x(8*ifs@+-f_fyan9!c%mmxg1$ekztq'

-def env_bool(name, default=False):
-    return os.environ.get(name, str(default)).lower() in ("1", "true", "yes")
+DEBUG = True

-
-DEBUG = env_bool("DJANGO_DEBUG")
-
-# Ключ по умолчанию — только для разработки (DJANGO_DEBUG=True)
-DEV_SECRET_KEY = "django-insecure-dev-only-change-me"
-SECRET_KEY = os.environ.get("DJANGO_SECRET_KEY", DEV_SECRET_KEY if DEBUG else "")
-if not SECRET_KEY:
-    raise RuntimeError("Задайте DJANGO_SECRET_KEY (или DJANGO_DEBUG=True для разработки)")
-
-ALLOWED_HOSTS = [h for h in os.environ.get("DJANGO_ALLOWED_HOSTS", "localhost,127.0.0.1").split(",") if h]
+ALLOWED_HOSTS = []

 INSTALLED_APPS = [
    'django.contrib.admin',
@ -24,7 +15,7 @@ INSTALLED_APPS = [
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
-    'django.contrib.staticfiles',
+    # 'django.contrib.staticfiles',
    'rest_framework',  # Добавляем DRF
    'api_app',  # Наше API приложение
 ]
@ -62,38 +53,17 @@ WSGI_APPLICATION = 'api_project.wsgi.application'
 DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
-        'NAME': os.environ.get("DJANGO_DB_PATH", BASE_DIR / 'db.sqlite3'),
+        'NAME': BASE_DIR / 'db.sqlite3',
    }
 }

 # Путь для загрузки файлов
 MEDIA_URL = '/media/'
-MEDIA_ROOT = os.environ.get("DJANGO_MEDIA_ROOT", os.path.join(BASE_DIR, 'media'))
-STATIC_URL = '/static/'
-STATIC_ROOT = BASE_DIR / 'staticfiles'
-
-# Распознавание и обработка
-VOSK_MODEL_PATH = os.environ.get("VOSK_MODEL_PATH", BASE_DIR / "models" / "vosk-model-small-ru-0.22")
-FFMPEG_BINARY = os.environ.get("FFMPEG_BINARY", "ffmpeg")  # из PATH; раньше — Windows-путь к ffmpeg.exe
-GRPC_SERVER = os.environ.get("GRPC_SERVER", "localhost:50051")  # пусто — не отправлять на gRPC
-GRPC_TIMEOUT = float(os.environ.get("GRPC_TIMEOUT", "10"))
-API_TOKEN = os.environ.get("API_TOKEN", "")  # если задан — нужен заголовок Authorization: Bearer
-MAX_UPLOAD_SIZE = int(os.environ.get("MAX_UPLOAD_SIZE_MB", "50")) * 1024 * 1024
-FILE_UPLOAD_MAX_MEMORY_SIZE = 5 * 1024 * 1024  # крупные файлы — во временный файл, не в память
+MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

 # Настройки для REST Framework
 REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': [
-        'api_app.permissions.ApiTokenPermission',
+        'rest_framework.permissions.AllowAny',  # Для тестирования, в продакшне лучше ограничить
    ]
 }
-
-LOGGING = {
-    "version": 1,
-    "disable_existing_loggers": False,
-    "handlers": {"console": {"class": "logging.StreamHandler"}},
-    "root": {"handlers": ["console"], "level": "INFO"},
-}
-
-# как в существующей миграции — без новой миграции
-DEFAULT_AUTO_FIELD = 'django.db.models.AutoField'
--- a/compose.yaml
+++ b/compose.yaml
@ -1,13 +0,0 @@
-services:
-  api:
-    build: .
-    image: ghcr.io/edeev/api_processor:latest
-    env_file: .env
-    ports:
-      - "8000:8000"
-    volumes:
-      - data:/data
-    restart: unless-stopped
-
-volumes:
-  data:
--- a/media/uploads/audio.ogg
+++ b/media/uploads/audio.ogg
--- a/proto/text_service_pb2.py
+++ b/proto/text_service_pb2.py
@ -2,7 +2,7 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # NO CHECKED-IN PROTOBUF GENCODE
 # source: text_service.proto
-# Protobuf Python Version: 7.35.1
+# Protobuf Python Version: 5.29.0
 """Generated protocol buffer code."""
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
@ -11,9 +11,9 @@ from google.protobuf import symbol_database as _symbol_database
 from google.protobuf.internal import builder as _builder
 _runtime_version.ValidateProtobufRuntimeVersion(
    _runtime_version.Domain.PUBLIC,
-    7,
-    35,
-    1,
+    5,
+    29,
+    0,
    '',
    'text_service.proto'
 )
--- a/proto/text_service_pb2_grpc.py
+++ b/proto/text_service_pb2_grpc.py
@ -5,7 +5,7 @@ import warnings

 import text_service_pb2 as text__service__pb2

-GRPC_GENERATED_VERSION = '1.84.0'
+GRPC_GENERATED_VERSION = '1.71.0'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False

@ -18,14 +18,14 @@ except ImportError:
 if _version_not_supported:
    raise RuntimeError(
        f'The grpc package installed is at version {GRPC_VERSION},'
-        + ' but the generated code in text_service_pb2_grpc.py depends on'
+        + f' but the generated code in text_service_pb2_grpc.py depends on'
        + f' grpcio>={GRPC_GENERATED_VERSION}.'
        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
    )


-class TextProcessorStub:
+class TextProcessorStub(object):
    """Missing associated documentation comment in .proto file."""

    def __init__(self, channel):
@ -41,7 +41,7 @@ class TextProcessorStub:
                _registered_method=True)


-class TextProcessorServicer:
+class TextProcessorServicer(object):
    """Missing associated documentation comment in .proto file."""

    def ProcessText(self, request, context):
@ -66,7 +66,7 @@ def add_TextProcessorServicer_to_server(servicer, server):


 # This class is part of an EXPERIMENTAL API.
-class TextProcessor:
+class TextProcessor(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
--- a/pytest.ini
+++ b/pytest.ini
@ -1,6 +0,0 @@
-[pytest]
-DJANGO_SETTINGS_MODULE = api_project.settings
-testpaths = tests
-env =
-    D:DJANGO_DEBUG=True
-    D:GRPC_SERVER=
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@ -1,7 +0,0 @@
-r requirements.txt
-grpcio-tools==1.84.0  # только для пересборки proto/*_pb2*.py
-pytest==8.4.2
-pytest-django==4.11.1
-ruff==0.14.0
-fpdf2==2.8.4
-pytest-env==1.1.5
--- a/requirements.txt
+++ b/requirements.txt
@ -1,9 +1,9 @@
-Django==5.2.17
-djangorestframework==3.18.1
-grpcio==1.84.0
-protobuf==7.36.2
-pdfplumber==0.11.10
-python-docx==1.2.0
+django==4.2.6
+djangorestframework==3.14.0
+grpcio==1.58.0
+grpcio-tools==1.58.0
+pdfplumber==0.10.2
+python-docx==0.8.11
+Pillow==10.0.1
 vosk==0.3.45
 ffmpeg-python==0.2.0
-gunicorn==26.2.0
--- a/tests/test_api.py
+++ b/tests/test_api.py
@ -1,139 +0,0 @@
-import io
-import os
-import shutil
-import subprocess
-from concurrent import futures
-
-import docx
-import grpc
-import pytest
-from django.core.files.uploadedfile import SimpleUploadedFile
-from django.test import override_settings
-from fpdf import FPDF
-from rest_framework.test import APIClient
-
-from api_app.grpc_client import client as grpc_client
-from api_app.services.scan import extract_text_tables
-
-import text_service_pb2
-import text_service_pb2_grpc
-
-pytestmark = pytest.mark.django_db
-
-
-@pytest.fixture(autouse=True)
-def media(tmp_path, settings):
-    settings.MEDIA_ROOT = str(tmp_path)
-
-
-def make_docx():
-    d = docx.Document()
-    d.add_paragraph("Привет <script>alert(1)</script> & мир")
-    t = d.add_table(rows=2, cols=2)
-    t.cell(0, 0).text, t.cell(0, 1).text = "a", "b"
-    t.cell(1, 0).text, t.cell(1, 1).text = "1", "<2>"
-    buf = io.BytesIO()
-    d.save(buf)
-    return buf.getvalue()
-
-
-def make_pdf():
-    pdf = FPDF()
-    pdf.add_page()
-    pdf.set_font("Helvetica", size=12)
-    pdf.cell(text="Hello <b>world</b> & co")
-    return bytes(pdf.output())
-
-
-def test_docx_text_is_escaped(tmp_path):
-    path = tmp_path / "a.DOCX"
-    path.write_bytes(make_docx())
-    html = extract_text_tables(str(path))
-    assert "<p>Привет &lt;script&gt;alert(1)&lt;/script&gt; &amp; мир</p>" in html
-    assert "<pre>a,b\r\n1,&lt;2&gt;\r\n</pre>" in html
-
-
-def test_pdf_upper_extension_and_escaping(tmp_path):
-    path = tmp_path / "a.PDF"
-    path.write_bytes(make_pdf())
-    assert "<p>Hello &lt;b&gt;world&lt;/b&gt; &amp; co</p>" in extract_text_tables(str(path))
-
-
-def test_document_endpoint():
-    client = APIClient()
-    resp = client.post("/api/document-to-text/",
-                       {"document": SimpleUploadedFile("r.docx", make_docx())}, format="multipart")
-    assert resp.status_code == 200
-    assert "&lt;script&gt;" in resp.json()["text"] and resp.json()["grpc_response"] is None
-
-
-def test_validation_and_size_limit(settings):
-    client = APIClient()
-    assert client.post("/api/document-to-text/", {}, format="multipart").status_code == 400
-    bad = client.post("/api/document-to-text/", {"document": SimpleUploadedFile("a.txt", b"x")}, format="multipart")
-    assert bad.status_code == 400
-    settings.MAX_UPLOAD_SIZE = 10
-    big = client.post("/api/document-to-text/", {"document": SimpleUploadedFile("a.pdf", b"x" * 100)},
-                      format="multipart")
-    assert big.status_code == 413
-
-
-@override_settings(API_TOKEN="secret")
-def test_api_token():
-    client = APIClient()
-    upload = {"document": SimpleUploadedFile("r.docx", make_docx())}
-    assert client.post("/api/document-to-text/", upload, format="multipart").status_code == 403
-    client.credentials(HTTP_AUTHORIZATION="Bearer secret")
-    upload = {"document": SimpleUploadedFile("r.docx", make_docx())}
-    assert client.post("/api/document-to-text/", upload, format="multipart").status_code == 200
-
-
-class Upper(text_service_pb2_grpc.TextProcessorServicer):
-    def ProcessText(self, request, context):
-        return text_service_pb2.TextResponse(processed_text=request.text.upper(), success=True)
-
-
-def test_grpc_real_server(settings):
-    server = grpc.server(futures.ThreadPoolExecutor(max_workers=1))
-    text_service_pb2_grpc.add_TextProcessorServicer_to_server(Upper(), server)
-    port = server.add_insecure_port("127.0.0.1:0")
-    server.start()
-    try:
-        settings.GRPC_SERVER = f"127.0.0.1:{port}"
-        assert grpc_client.send_to_grpc_server("привет") == {
-            "processed_text": "ПРИВЕТ", "success": True, "error": None}
-    finally:
-        server.stop(None)
-
-
-def test_grpc_unavailable(settings):
-    settings.GRPC_SERVER = "127.0.0.1:1"
-    settings.GRPC_TIMEOUT = 2
-    result = grpc_client.send_to_grpc_server("x")
-    assert result["success"] is False and result["error"].startswith("gRPC")
-
-
-@pytest.mark.skipif(not shutil.which("ffmpeg"), reason="нужен ffmpeg")
-def test_audio_endpoint_converts_ogg(tmp_path, settings):
-    if not os.path.isdir(settings.VOSK_MODEL_PATH):
-        pytest.skip("нет модели Vosk")
-    ogg = tmp_path / "tone.ogg"
-    subprocess.run(["ffmpeg", "-loglevel", "error", "-f", "lavfi", "-i", "sine=frequency=440:duration=2",
-                    "-c:a", "libvorbis", str(ogg)], check=True)
-    resp = APIClient().post("/api/audio-to-text/",
-                            {"audio": SimpleUploadedFile("tone.ogg", ogg.read_bytes())}, format="multipart")
-    assert resp.status_code == 200 and isinstance(resp.json()["text"], str)
-
-
-SAMPLE = os.path.join(os.path.dirname(os.path.dirname(__file__)), "examples", "sample.ogg")
-
-
-@pytest.mark.skipif(not shutil.which("ffmpeg"), reason="нужен ffmpeg")
-def test_sample_recognition_keeps_all_phrases(settings):
-    if not os.path.isdir(settings.VOSK_MODEL_PATH):
-        pytest.skip("нет модели Vosk")
-    from api_app.services.vosk_recognizer import recognize_speech
-
-    text = recognize_speech(SAMPLE)
-    # в записи несколько фраз: раньше оставалась только последняя
-    assert "проверка" in text and "десять" in text
--- a/тесты.txt
+++ b/тесты.txt
@ -0,0 +1,13 @@
+python manage.py runserver
+
+------------------------------------------
+
+Тест расширения для сканирования:
+
+curl -X POST -F "document=@C:\Users\egord\Desktop\API EasyAccess\api_project\media\uploads\Деев Е.В. Резюме.pdf" http://localhost:8000/api/document-to-text/
+
+------------------------------------------
+
+Тест для аудио транскрипции:
+
+curl -X POST -F audio=@"C:\Users\egord\Desktop\API EasyAccess\api_project\media\uploads\audio.ogg" http://localhost:8000/api/audio-to-text/