From de81eba53231645185bf91d9281a781f1b0232d4 Mon Sep 17 00:00:00 2001 From: Serge Zaigraeff Date: Sun, 2 Mar 2025 10:14:15 +0300 Subject: [PATCH] structute optimization --- app/audio_processor.py | 2 +- app/audio_sources.py | 311 +++++++++++++++++++++++++++++++++++++ app/routes.py | 341 ++++++++++++----------------------------- app/transcriber.py | 2 +- config.json | 2 +- 5 files changed, 413 insertions(+), 245 deletions(-) create mode 100644 app/audio_sources.py diff --git a/app/audio_processor.py b/app/audio_processor.py index ba7c428..a1bc4ad 100644 --- a/app/audio_processor.py +++ b/app/audio_processor.py @@ -1,5 +1,5 @@ """ -Файл audio_processor.py содержит класс AudioProcessor, предназначенный для предобработки аудиофайлов +Модуль audio_processor.py содержит класс AudioProcessor, предназначенный для предобработки аудиофайлов перед их использованием в системах распознавания речи. Класс предоставляет методы для конвертации аудио в формат WAV с частотой дискретизации 16 кГц, нормализации уровня громкости, добавления тишины в начало записи, а также для удаления временных файлов, созданных в процессе обработки. diff --git a/app/audio_sources.py b/app/audio_sources.py new file mode 100644 index 0000000..2c9969f --- /dev/null +++ b/app/audio_sources.py @@ -0,0 +1,311 @@ +""" +Модуль audio_sources.py содержит абстрактный класс AudioSource и его конкретные реализации +для обработки различных источников аудиофайлов (загруженные файлы, URL, base64, локальные файлы). +""" + +import os +import uuid +import tempfile +import base64 +import requests +import abc +from typing import Dict, Tuple, Optional, BinaryIO + +from .logger import logger + +class AudioSource(abc.ABC): + """Абстрактный класс для различных источников аудиофайлов. + + Определяет интерфейс для различных источников аудио и предоставляет общие + методы для работы с аудиофайлами, такие как проверка размера файла. + """ + + def __init__(self, max_file_size_mb: int = 100): + """ + Инициализация источника аудио. + + Args: + max_file_size_mb: Максимальный размер файла в МБ. + """ + self.max_file_size_mb = max_file_size_mb + + @abc.abstractmethod + def get_audio_file(self) -> Tuple[Optional[BinaryIO], Optional[str], Optional[str]]: + """ + Получает аудиофайл из источника. + + Returns: + Кортеж (файловый объект, имя файла, сообщение об ошибке). + В случае ошибки, возвращает (None, None, сообщение об ошибке). + """ + pass + + def check_file_size(self, file: BinaryIO) -> Tuple[bool, Optional[str]]: + """ + Проверяет размер файла. + + Args: + file: Файловый объект для проверки. + + Returns: + Кортеж (результат проверки, сообщение об ошибке). + Если проверка пройдена, сообщение об ошибке будет None. + """ + file.seek(0, os.SEEK_END) + file_length = file.tell() + file.seek(0) # Сброс указателя файла после проверки размера + + if file_length > self.max_file_size_mb * 1024 * 1024: + return False, f"File exceeds maximum size of {self.max_file_size_mb}MB" + + return True, None + + +class FakeFile: + """Имитирует файловый объект для унификации обработки из разных источников. + + Позволяет обрабатывать файлы из различных источников (локальный путь, URL, base64) + как стандартные файловые объекты Flask, обеспечивая совместимость с существующей + логикой обработки файлов. + """ + + def __init__(self, file: BinaryIO, filename: str): + """ + Инициализация объекта FakeFile. + + Args: + file: Исходный файловый объект или поток. + filename: Имя файла для метаданных. + """ + self.file = file + self.filename = filename + + def read(self): + """Чтение содержимого файла.""" + return self.file.read() + + def seek(self, offset: int, whence: int = 0): + """Перемещение позиции чтения.""" + self.file.seek(offset, whence) + + def tell(self): + """Получение текущей позиции чтения.""" + return self.file.tell() + + def save(self, destination: str): + """ + Сохраняет содержимое файла в указанное место назначения. + + Args: + destination: Путь для сохранения файла. + """ + with open(destination, 'wb') as f: + content = self.file.read() + f.write(content) + self.file.seek(0) # Сброс указателя после чтения + + @property + def name(self): + """Возвращает имя файла.""" + return self.filename + + +class UploadedFileSource(AudioSource): + """Источник аудио для файлов, загруженных через HTTP-запрос.""" + + def __init__(self, request_files, max_file_size_mb: int = 100): + """ + Инициализация источника для загруженных файлов. + + Args: + request_files: Объект request.files из Flask. + max_file_size_mb: Максимальный размер файла в МБ. + """ + super().__init__(max_file_size_mb) + self.request_files = request_files + + def get_audio_file(self) -> Tuple[Optional[BinaryIO], Optional[str], Optional[str]]: + """ + Получает аудиофайл из загруженных файлов. + + Returns: + Кортеж (файловый объект, имя файла, сообщение об ошибке). + """ + if 'file' not in self.request_files: + return None, None, "No file part" + + file = self.request_files['file'] + + if file.filename == '': + return None, None, "No selected file" + + # Проверка размера файла + is_valid, error_message = self.check_file_size(file) + if not is_valid: + return None, None, error_message + + return file, file.filename, None + + +class URLSource(AudioSource): + """Источник аудио для файлов, доступных по URL.""" + + def __init__(self, url: str, max_file_size_mb: int = 100): + """ + Инициализация источника для файлов по URL. + + Args: + url: URL аудиофайла. + max_file_size_mb: Максимальный размер файла в МБ. + """ + super().__init__(max_file_size_mb) + self.url = url + self.temp_file_path = None + self.temp_dir = None + + def get_audio_file(self) -> Tuple[Optional[BinaryIO], Optional[str], Optional[str]]: + """ + Получает аудиофайл по URL. + + Returns: + Кортеж (файловый объект, имя файла, сообщение об ошибке). + """ + try: + # Скачиваем файл по URL + response = requests.get(self.url, stream=True) + response.raise_for_status() + + # Проверка размера файла (если сервер предоставил информацию о размере) + content_length = response.headers.get('Content-Length') + if content_length and int(content_length) > self.max_file_size_mb * 1024 * 1024: + return None, None, f"File exceeds maximum size of {self.max_file_size_mb}MB" + + # Сохраняем файл во временный файл + self.temp_dir = tempfile.mkdtemp() + self.temp_file_path = os.path.join(self.temp_dir, str(uuid.uuid4()) + ".wav") + + with open(self.temp_file_path, 'wb') as f: + for chunk in response.iter_content(chunk_size=8192): + f.write(chunk) + + # Открываем файл для обработки + file = open(self.temp_file_path, 'rb') + + # Создаем объект файла, как будто он пришел из request.files + fake_file = FakeFile(file, os.path.basename(self.temp_file_path)) + + return fake_file, fake_file.filename, None + + except Exception as e: + logger.error(f"Ошибка при получении файла по URL {self.url}: {e}") + self.cleanup() + return None, None, f"Error retrieving file from URL: {str(e)}" + + def cleanup(self): + """Очищает временные файлы и директории.""" + if self.temp_file_path and os.path.exists(self.temp_file_path): + os.remove(self.temp_file_path) + if self.temp_dir and os.path.exists(self.temp_dir): + os.rmdir(self.temp_dir) + + +class Base64Source(AudioSource): + """Источник аудио для файлов, закодированных в base64.""" + + def __init__(self, base64_data: str, max_file_size_mb: int = 100): + """ + Инициализация источника для base64 файлов. + + Args: + base64_data: Данные аудиофайла в формате base64. + max_file_size_mb: Максимальный размер файла в МБ. + """ + super().__init__(max_file_size_mb) + self.base64_data = base64_data + self.temp_file_path = None + self.temp_dir = None + + def get_audio_file(self) -> Tuple[Optional[BinaryIO], Optional[str], Optional[str]]: + """ + Получает аудиофайл из base64 данных. + + Returns: + Кортеж (файловый объект, имя файла, сообщение об ошибке). + """ + try: + # Декодируем base64 + audio_data = base64.b64decode(self.base64_data) + + # Проверка размера файла + if len(audio_data) > self.max_file_size_mb * 1024 * 1024: + return None, None, f"File exceeds maximum size of {self.max_file_size_mb}MB" + + # Сохраняем файл во временный файл + self.temp_dir = tempfile.mkdtemp() + self.temp_file_path = os.path.join(self.temp_dir, str(uuid.uuid4()) + ".wav") + + with open(self.temp_file_path, 'wb') as f: + f.write(audio_data) + + # Открываем файл для обработки + file = open(self.temp_file_path, 'rb') + + # Создаем объект файла, как будто он пришел из request.files + fake_file = FakeFile(file, os.path.basename(self.temp_file_path)) + + return fake_file, fake_file.filename, None + + except Exception as e: + logger.error(f"Ошибка при декодировании base64 данных: {e}") + self.cleanup() + return None, None, f"Error decoding base64 data: {str(e)}" + + def cleanup(self): + """Очищает временные файлы и директории.""" + if self.temp_file_path and os.path.exists(self.temp_file_path): + os.remove(self.temp_file_path) + if self.temp_dir and os.path.exists(self.temp_dir): + os.rmdir(self.temp_dir) + + +class LocalFileSource(AudioSource): + """Источник аудио для локальных файлов на сервере.""" + + def __init__(self, file_path: str, max_file_size_mb: int = 100): + """ + Инициализация источника для локальных файлов. + + Args: + file_path: Путь к локальному файлу. + max_file_size_mb: Максимальный размер файла в МБ. + """ + super().__init__(max_file_size_mb) + self.file_path = file_path + + def get_audio_file(self) -> Tuple[Optional[BinaryIO], Optional[str], Optional[str]]: + """ + Получает локальный аудиофайл. + + Returns: + Кортеж (файловый объект, имя файла, сообщение об ошибке). + """ + if not os.path.exists(self.file_path): + return None, None, f"File not found: {self.file_path}" + + try: + # Проверка размера файла + file_size = os.path.getsize(self.file_path) + if file_size > self.max_file_size_mb * 1024 * 1024: + return None, None, f"File exceeds maximum size of {self.max_file_size_mb}MB" + + # Открываем файл для обработки + file = open(self.file_path, 'rb') + + # Создаем объект файла, как будто он пришел из request.files + fake_file = FakeFile(file, os.path.basename(self.file_path)) + + return fake_file, fake_file.filename, None + + except Exception as e: + logger.error(f"Ошибка при открытии локального файла {self.file_path}: {e}") + return None, None, f"Error opening local file: {str(e)}" diff --git a/app/routes.py b/app/routes.py index 14140ed..ec5fead 100644 --- a/app/routes.py +++ b/app/routes.py @@ -1,76 +1,32 @@ +""" +Модуль routes.py содержит классы для обработки транскрибации аудиофайлов +и регистрации маршрутов API для сервиса распознавания речи. +""" + import os import uuid import tempfile -import base64 -import requests import time from flask import request, jsonify -from typing import Dict +from typing import Dict, Tuple from .logger import logger +from .audio_sources import ( + AudioSource, + UploadedFileSource, + URLSource, + Base64Source, + LocalFileSource +) -class FakeFile: - """Имитирует файловый объект для унификации обработки из разных источников. + +class TranscriptionService: + """Сервис для обработки и транскрибации аудиофайлов.""" - Позволяет обрабатывать файлы из различных источников (локальный путь, URL, base64) - как стандартные файловые объекты Flask, обеспечивая совместимость с существующей - логикой обработки файлов. - - Атрибуты: - - file: Исходный файловый объект или поток - - filename: Имя файла для метаданных - - Методы эмулируют поведение стандартного файлового объекта: - - read(): Чтение содержимого файла - - seek(): Перемещение позиции чтения - - tell(): Текущая позиция чтения - - name (property): Возвращает имя файла - - Пример использования: - >>> with open('audio.wav', 'rb') as f: - >>> fake = FakeFile(f, 'audio.wav') - >>> fake.save('/tmp/copy.wav') - >>> processor.handle_file(fake) - """ - def __init__(self, file, filename): - self.file = file - self.filename = filename - - def read(self): - return self.file.read() - - def seek(self, offset, whence=0): - self.file.seek(offset, whence) - - def tell(self): - return self.file.tell() - - def save(self, destination): - """Сохраняет содержимое файла в указанное место назначения. - - Args: - destination (str): Путь для сохранения файла - - Реализует совместимость с Flask FileStorage API. После записи - сбрасывает позицию чтения в начало файла для последующих операций. - """ - with open(destination, 'wb') as f: - content = self.file.read() - f.write(content) - self.file.seek(0) # Reset pointer after reading - - @property - def name(self): - return self.filename - -class AudioFileProcessor: - """ - Класс для обработки аудиофайлов, включая проверку размера, сохранение во временный файл и транскрибацию. - """ def __init__(self, transcriber, config: Dict): """ - Инициализация AudioFileProcessor. - + Инициализация сервиса транскрибации. + Args: transcriber: Экземпляр транскрайбера. config: Словарь с конфигурацией. @@ -78,47 +34,49 @@ class AudioFileProcessor: self.transcriber = transcriber self.config = config self.max_file_size_mb = self.config.get("max_file_size", 100) # Default 100MB - - def process_audio_file(self, file, request_form=None): + + def transcribe_from_source(self, source: AudioSource, params: Dict = None) -> Tuple[Dict, int]: """ - Обрабатывает аудиофайл: проверяет размер, сохраняет во временный файл и транскрибирует. - + Транскрибирует аудиофайл из указанного источника. + Args: - file: Объект файла, полученный из запроса. - request_form: Объект request.form, если есть параметры из формы. - + source: Источник аудиофайла. + params: Дополнительные параметры для транскрибации. + Returns: - jsonify: JSON-ответ с результатом транскрибации. + Кортеж (JSON-ответ, HTTP-код). """ + # Получаем файл из источника + file, filename, error = source.get_audio_file() + + # Обрабатываем ошибки получения файла + if error: + return jsonify({"error": error}), 400 + if not file: - return jsonify({"error": "No file part"}), 400 - - if file.filename == '': - return jsonify({"error": "No selected file"}), 400 - - # Проверка размера файла - file.seek(0, os.SEEK_END) - file_length = file.tell() - file.seek(0) # Reset file pointer after reading for size check - - if file_length > self.max_file_size_mb * 1024 * 1024: - return jsonify({"error": f"File exceeds maximum size of {self.max_file_size_mb}MB"}), 413 - + return jsonify({"error": "Failed to get audio file"}), 400 + # Извлекаем параметры из запроса, если они есть - language = request_form.get('language', self.config.get('language', 'en')) if request_form else self.config.get('language', 'en') # Default language - temperature = float(request_form.get('temperature', 0.0)) if request_form else 0.0 # Default temperature - prompt = request_form.get('prompt', '') if request_form else '' # Default prompt - + params = params or {} + language = params.get('language', self.config.get('language', 'en')) + temperature = float(params.get('temperature', 0.0)) + prompt = params.get('prompt', '') + # Сохраняем файл во временный файл temp_dir = tempfile.mkdtemp() - temp_file_path = os.path.join(temp_dir, str(uuid.uuid4()) + "_" + os.path.basename(file.filename)) + temp_file_path = os.path.join(temp_dir, str(uuid.uuid4()) + "_" + os.path.basename(filename)) file.save(temp_file_path) - + + # Для файлов из внешних источников (URL, base64), закрываем их и выполняем очистку + if hasattr(source, 'cleanup'): + file.file.close() # Закрываем файловый объект + source.cleanup() # Очищаем временные файлы источника + try: start_time = time.time() text = self.transcriber.process_file(temp_file_path) processing_time = time.time() - start_time - + # Форматируем ответ в стиле OpenAI return jsonify({ "text": text, @@ -126,57 +84,26 @@ class AudioFileProcessor: "response_size_bytes": len(text.encode('utf-8')), "model": os.path.basename(self.config["model_path"]) }), 200 - + except Exception as e: logger.error(f"Ошибка при транскрибации: {e}") return jsonify({"error": str(e)}), 500 - + finally: # Очистка временных файлов - os.remove(temp_file_path) - os.rmdir(temp_dir) + if os.path.exists(temp_file_path): + os.remove(temp_file_path) + if os.path.exists(temp_dir): + os.rmdir(temp_dir) + class Routes: - """Класс для регистрации всех эндпоинтов API. - - Этот класс содержит все маршруты (endpoints) для взаимодействия с сервером транскрибации. - Он предоставляет функциональность для получения списка доступных моделей, информации о конкретной модели, - а также для транскрибации аудиофайлов, загруженных различными способами. - - Эндпоинты: - - GET /v1/models: - Возвращает JSON-список доступных моделей для транскрибации. Каждая модель содержит информацию об ID, - типе объекта, владельце и разрешениях. - - - GET /v1/models/: - Возвращает JSON-объект с информацией о конкретной модели, идентифицированной по . - Если модель не найдена, возвращает ошибку 404. - - - POST /v1/audio/transcriptions: - Транскрибирует аудиофайл, загруженный через форму. Ожидает, что файл будет передан в поле 'file' - multipart формы. Возвращает JSON с транскрибированным текстом и временем обработки. - Поддерживает параметры language, temperature и prompt, передаваемые также через форму. - - - POST /v1/audio/transcriptions/url: - Транскрибирует аудиофайл, доступный по указанному URL. Ожидает JSON-запрос с полем 'url', - содержащим URL аудиофайла. Возвращает JSON с транскрибированным текстом и временем обработки. - - - POST /v1/audio/transcriptions/base64: - Транскрибирует аудиофайл, закодированный в base64. Ожидает JSON-запрос с полем 'file', - содержащим base64-encoded представление аудиофайла. Возвращает JSON с транскрибированным текстом - и временем обработки. - - - POST /v1/audio/transcriptions/multipart: - Аналогичен /v1/audio/transcriptions, но явно указывает на то, что файл ожидается в multipart форме. - Используется для транскрибации аудиофайла, загруженного через multipart-форму. - Возвращает JSON с транскрибированным текстом и временем обработки. - Поддерживает параметры language, temperature и prompt, передаваемые также через форму. - """ - + """Класс для регистрации всех эндпоинтов API.""" + def __init__(self, app, transcriber, config: Dict): """ Инициализация маршрутов. - + Args: app: Flask-приложение. transcriber: Экземпляр транскрайбера. @@ -184,22 +111,27 @@ class Routes: """ self.app = app self.config = config - self.audio_processor = AudioFileProcessor(transcriber, config) - + self.transcription_service = TranscriptionService(transcriber, config) + # Регистрация маршрутов self._register_routes() - + def _register_routes(self): """Регистрация всех эндпоинтов.""" - + @self.app.route('/health', methods=['GET']) def health_check(): - """Эндпоинт для проверки статуса сервиса и получения конфигурации.""" + """Эндпоинт для проверки статуса сервиса.""" return jsonify({ "status": "ok", - "config": self.config + "version": self.config.get("version", "1.0.0") }), 200 - + + @self.app.route('/config', methods=['GET']) + def get_config(): + """Эндпоинт для получения конфигурации сервиса.""" + return jsonify(self.config), 200 + @self.app.route('/local/transcriptions', methods=['POST']) def local_transcribe(): """Эндпоинт для локальной транскрибации файла по пути на сервере.""" @@ -207,32 +139,19 @@ class Routes: if not data or "file_path" not in data: return jsonify({"error": "No file_path provided"}), 400 - + file_path = data["file_path"] + source = LocalFileSource(file_path, self.config.get("max_file_size", 100)) + + return self.transcription_service.transcribe_from_source(source) - if not os.path.exists(file_path): - return jsonify({"error": "File not found"}), 400 - - try: - with open(file_path, 'rb') as f: - # Создаем объект файла, совместимый с обработчиком - fake_file = FakeFile(f, os.path.basename(file_path)) - return self.audio_processor.process_audio_file(fake_file) - - except Exception as e: - logger.error(f"Ошибка локальной транскрибации: {e}") - return jsonify({ - "error": "Processing error", - "details": str(e) - }), 500 - @self.app.route('/v1/models', methods=['GET']) def list_models(): """Эндпоинт для получения списка доступных моделей.""" return jsonify({ "data": [ { - "id": os.path.basename(self.config["model_path"]), # Имя модели из конфига + "id": os.path.basename(self.config["model_path"]), "object": "model", "owned_by": "openai", "permissions": [] @@ -240,7 +159,7 @@ class Routes: ], "object": "list" }), 200 - + @self.app.route('/v1/models/', methods=['GET']) def retrieve_model(model_id): """Эндпоинт для получения информации о конкретной модели.""" @@ -256,113 +175,51 @@ class Routes: "error": "Model not found", "details": f"Model '{model_id}' does not exist" }), 404 - + @self.app.route('/v1/audio/transcriptions', methods=['POST']) def openai_transcribe_endpoint(): - """Эндпоинт для транскрибации аудиофайла.""" - if 'file' not in request.files: - return jsonify({"error": "No file part"}), 400 - - file = request.files['file'] - return self.audio_processor.process_audio_file(file, request.form) - + """Эндпоинт для транскрибации аудиофайла (multipart-форма).""" + source = UploadedFileSource(request.files, self.config.get("max_file_size", 100)) + return self.transcription_service.transcribe_from_source(source, request.form) + @self.app.route('/v1/audio/transcriptions/url', methods=['POST']) def transcribe_from_url(): """Эндпоинт для транскрибации аудиофайла по URL.""" data = request.json - + if not data or "url" not in data: return jsonify({ "error": "No URL provided", "details": "Please provide 'url' in the JSON request" }), 400 - + url = data["url"] - - try: - # Скачиваем файл по URL - response = requests.get(url, stream=True) - response.raise_for_status() - - # Сохраняем файл во временный файл - temp_dir = tempfile.mkdtemp() - temp_file_path = os.path.join(temp_dir, str(uuid.uuid4()) + ".wav") - with open(temp_file_path, 'wb') as f: - for chunk in response.iter_content(chunk_size=8192): - f.write(chunk) - - # Открываем файл для обработки - with open(temp_file_path, 'rb') as file: - # Создаем объект файла, как будто он пришел из request.files - fake_file = FakeFile(file, os.path.basename(temp_file_path)) - result = self.audio_processor.process_audio_file(fake_file) - - return result - - except Exception as e: - logger.error(f"Ошибка при транскрибации файла по URL {url}: {e}") - return jsonify({ - "error": "Transcription error", - "details": str(e) - }), 500 - - finally: - # Очистка временных файлов - if os.path.exists(temp_file_path): - os.remove(temp_file_path) - if os.path.exists(temp_dir): - os.rmdir(temp_dir) - + # Извлекаем параметры транскрибации, если они есть + params = {k: v for k, v in data.items() if k != "url"} + + source = URLSource(url, self.config.get("max_file_size", 100)) + return self.transcription_service.transcribe_from_source(source, params) + @self.app.route('/v1/audio/transcriptions/base64', methods=['POST']) def transcribe_from_base64(): """Эндпоинт для транскрибации аудио, закодированного в base64.""" data = request.json - + if not data or "file" not in data: return jsonify({ "error": "No base64 file provided", "details": "Please provide 'file' in the JSON request" }), 400 - + base64_data = data["file"] - - try: - # Декодируем base64 - audio_data = base64.b64decode(base64_data) - - # Сохраняем файл во временный файл - temp_dir = tempfile.mkdtemp() - temp_file_path = os.path.join(temp_dir, str(uuid.uuid4()) + ".wav") - with open(temp_file_path, 'wb') as f: - f.write(audio_data) - - # Открываем файл для обработки - with open(temp_file_path, 'rb') as file: - # Создаем объект файла, как будто он пришел из request.files - fake_file = FakeFile(file, os.path.basename(temp_file_path)) - result = self.audio_processor.process_audio_file(fake_file) - - return result - - except Exception as e: - logger.error(f"Ошибка при транскрибации файла из base64: {e}") - return jsonify({ - "error": "Transcription error", - "details": str(e) - }), 500 - - finally: - # Очистка временных файлов - if os.path.exists(temp_file_path): - os.remove(temp_file_path) - if os.path.exists(temp_dir): - os.rmdir(temp_dir) - + # Извлекаем параметры транскрибации, если они есть + params = {k: v for k, v in data.items() if k != "file"} + + source = Base64Source(base64_data, self.config.get("max_file_size", 100)) + return self.transcription_service.transcribe_from_source(source, params) + @self.app.route('/v1/audio/transcriptions/multipart', methods=['POST']) def transcribe_multipart(): """Эндпоинт для транскрибации аудиофайла, загруженного через форму.""" - if 'file' not in request.files: - return jsonify({"error": "No file part"}), 400 - - file = request.files['file'] - return self.audio_processor.process_audio_file(file, request.form) + source = UploadedFileSource(request.files, self.config.get("max_file_size", 100)) + return self.transcription_service.transcribe_from_source(source, request.form) diff --git a/app/transcriber.py b/app/transcriber.py index 6ebe5a5..21b8787 100644 --- a/app/transcriber.py +++ b/app/transcriber.py @@ -1,5 +1,5 @@ """ -Этот файл (transcriber.py) содержит класс WhisperTranscriber, который использует модель Whisper от +Модуль transcribe.py содержит класс WhisperTranscriber, который использует модель Whisper от OpenAI для транскрибации аудиофайлов в текст. Класс включает в себя методы для загрузки модели, обработки аудио (с использованием класса AudioProcessor), и выполнения транскрибации. Обрабатывает выбор устройства (CPU, CUDA, MPS) для выполнения вычислений и обеспечивает diff --git a/config.json b/config.json index a3df9a0..d2458aa 100644 --- a/config.json +++ b/config.json @@ -1,6 +1,6 @@ { "service_port": 5042, - "model_path": "/mnt/cloud/llm/tools/whisper-large-v3-russian", + "model_path": "/mnt/cloud/llm/whisper/whisper-large-v3-russian", "language": "russian", "chunk_length_s": 30, "batch_size": 16,