Что скажешь об этом коде? Важно даю тебе побольше времени. Не спеши! Скорость твоём в ответе для меня не главное:
```python
import os
import logging
import argparse
import subprocess
import asyncio
import tkinter as tk
from tkinter import filedialog, messagebox, StringVar
from tkinterdnd2 import DND_FILES, TkinterDnD
from pytube import YouTube
from pydub import AudioSegment, effects
from tqdm import tqdm
import requests
import noisereduce as nr
import torchaudio
from demucs import pretrained
from demucs.apply import apply_model
import json
import re

# Настройка логирования
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[
    logging.FileHandler("audio_extraction.log"),
    logging.StreamHandler()
])

# Конфигурация
CONFIG_FILE = "config.json"

DEFAULT_CONFIG = {
    "output_path": "audio",
    "audio_format": "flac",  # Задаем формат по умолчанию
    "use_demucs": False, 
    "bitrate": "320k",  # Битрейт по умолчанию
}

# Загрузка конфигурации
def load_config():
    if os.path.exists(CONFIG_FILE):
        with open(CONFIG_FILE, "r") as f:
            return json.load(f)
    return DEFAULT_CONFIG

# Сохранение конфигурации
def save_config(config):
    with open(CONFIG_FILE, "w") as f:
        json.dump(config, f, indent=4)

# Проверка обновлений
def check_for_updates(current_version):
    """Проверяет наличие обновлений."""
    try:
        response = requests.get('https://example.com/version')  # Замените на реальный URL
        latest_version = response.text.strip()
        if latest_version != current_version:
            logging.info(f"Доступна новая версия: {latest_version}. Пожалуйста, обновите программу.")
    except Exception as e:
        logging.error(f"Ошибка проверки обновлений: {e}")

# Проверка на валидные URL
def is_valid_url(url):
    regex = re.compile(
        r'^(https?:\/\/)?(www\.)?(youtube\.com|youtu\.be|vimeo\.com|rutube\.ru)\/.+$'
    )
    return re.match(regex, url) is not None

def enhance_audio(audio_path):
    """Улучшает аудио без использования Demucs."""
    try:
        logging.info(f"Улучшение аудио: {audio_path}")
        audio = AudioSegment.from_file(audio_path)
        audio = effects.normalize(audio)
        samples = audio.get_array_of_samples()
        reduced_noise = nr.reduce_noise(y=samples, sr=audio.frame_rate)

        enhanced_audio = AudioSegment(
            reduced_noise.tobytes(),
            frame_rate=audio.frame_rate,
            sample_width=audio.sample_width,
            channels=audio.channels
        )

        enhanced_audio.export(audio_path, format=audio_path.split('.')[-1], bitrate="320k")
    except Exception as e:
        logging.error(f"Ошибка улучшения аудио {audio_path}: {e}")
        return None

def enhance_audio_with_demucs(audio_path):
    """Использует модель Demucs для улучшения качества аудио."""
    try:
        logging.info(f"Улучшение аудио с помощью Demucs: {audio_path}")
        model = pretrained.get_model('demucs')
        waveform, sr = torchaudio.load(audio_path)
        enhanced_waveform = apply_model(model, waveform, sr)
        torchaudio.save(audio_path, enhanced_waveform, sr)
    except Exception as e:
        logging.error(f"Ошибка улучшения аудио с помощью Demucs для {audio_path}: {e}")
        return None

def process_audio(audio_path, use_demucs):
    """Обрабатывает аудио файл для улучшения его качества."""
    if use_demucs:
        enhance_audio_with_demucs(audio_path)
    else:
        enhance_audio(audio_path)

def extract_audio_from_local_file(file_path, output_path, audio_format, use_demucs, bitrate):
    """Извлекает аудио из локального видеофайла."""
    if not os.path.exists(output_path):
        os.makedirs(output_path)

    try:
        logging.info(f"Извлечение аудио из локального файла: {file_path}")
        audio_path = os.path.join(output_path, os.path.splitext(os.path.basename(file_path))[0] + f'.{audio_format}')
        logging.info("Конвертация и улучшение аудио с помощью FFmpeg...")
        subprocess.run(['ffmpeg', '-i', file_path, '-af', 'loudnorm', '-b:a', bitrate, audio_path], check=True)

        asyncio.create_task(process_audio(audio_path, use_demucs))
        logging.info(f'Аудио сохранено: {audio_path}')
        return audio_path
    except Exception as e:
        logging.error(f"Ошибка обработки локального файла: {e}")
        return None

def download_audio_from_youtube(url, output_path, audio_format, use_demucs, bitrate):
    """Загружает аудио из видео YouTube и сохраняет в указанном формате с максимальным качеством."""
    if not os.path.exists(output_path):
        os.makedirs(output_path)

    try:
        logging.info(f"Загрузка аудио с YouTube: {url}")
        yt = YouTube(url)
        stream = yt.streams.filter(only_audio=True).order_by('abr').desc().first()
        video_path = stream.download(output_path)
        audio_path = os.path.join(output_path, os.path.splitext(os.path.basename(video_path))[0] + f'.{audio_format}')

        logging.info("Конвертация и улучшение аудио с помощью FFmpeg...")
        subprocess.run(['ffmpeg', '-i', video_path, '-af', 'loudnorm', '-b:a', bitrate, audio_path], check=True)

        os.remove(video_path)

        asyncio.create_task(process_audio(audio_path, use_demucs))

        logging.info(f'Аудио сохранено: {audio_path}')
        return audio_path
    except Exception as e:
        logging.error(f"Ошибка с YouTube: {e}")
        return None

def download_audio_from_rutube(url, output_path, audio_format, use_demucs, bitrate):
    """Загружает аудио из видео RuTube."""
    if not os.path.exists(output_path):
        os.makedirs(output_path)

    try:
        logging.info(f"Загрузка аудио с RuTube: {url}")
        command = [
            'youtube-dl',
            '-x',
            '--audio-format', audio_format,
            '--audio-quality', '0',
            '--output', f'{output_path}/%(title)s.%(ext)s',
            url
        ]
        subprocess.run(command, check=True)
        logging.info('Аудио успешно загружено и извлечено.')
        return True
    except subprocess.CalledProcessError as e:
        logging.error(f"Ошибка с RuTube: {e}")
        return None

async def process_video(urls, output_path, audio_format, use_demucs, bitrate):
    tasks = []
    for url in urls:
        if not is_valid_url(url):
            logging.warning(f"Недействительный URL: {url}")
            continue
        if os.path.isfile(url):
            tasks.append(asyncio.to_thread(extract_audio_from_local_file, url, output_path, audio_format, use_demucs, bitrate))
        elif "youtube.com" in url or "youtu.be" in url:
            tasks.append(asyncio.to_thread(download_audio_from_youtube, url, output_path, audio_format, use_demucs, bitrate))
        elif "rutube.ru" in url:
            tasks.append(asyncio.to_thread(download_audio_from_rutube, url, output_path, audio_format, use_demucs, bitrate))
        else:
            logging.warning(f"Поддерживаются только YouTube, RuTube и локальные файлы: {url}")

    return await asyncio.gather(*tasks)

def show_summary(results):
    successful_count = sum(1 for result in results if result is not None)
    messagebox.showinfo("Завершено", f"Обработка завершена!\nУспешно обработано: {successful_count}/{len(results)}")
    
def gui_main():
    """Графический интерфейс пользователя."""
    config = load_config()

    def start_processing():
        urls = list(entry_urls.get().split(','))
        file_paths = file_listbox.get(0, tk.END)
        urls.extend(file_paths)

        output_dir = filedialog.askdirectory(title="Выберите папку для сохранения") or config['output_path']
        audio_format = format_var.get()
        use_demucs = demucs_var.get()
        bitrate = bitrate_var.get()

        if not urls or not output_dir:
            messagebox.showwarning("Предупреждение", "Пожалуйста, введите ссылки или добавьте файлы, и выберите путь для сохранения.")
            return

        results = asyncio.run(process_video(urls, output_dir, audio_format, use_demucs, bitrate))
        show_summary(results)

        config['output_path'] = output_dir
        config['audio_format'] = audio_format
        config['use_demucs'] = use_demucs
        config['bitrate'] = bitrate
        save_config(config)

    def drag_and_drop(event):
        files = root.tk.splitlist(event.data)
        for file in files:
            file_listbox.insert(tk.END, file)

    root = TkinterDnD.Tk()
    root.title("Извлечение Аудио")

    frame = tk.Frame(root, padx=10, pady=10)
    frame.pack(padx=10, pady=10)

    label_urls = tk.Label(frame, text="Ссылки на видео (через запятую):")
    label_urls.grid(row=0, column=0, sticky='w')

    entry_urls = tk.Entry(frame, width=50)
    entry_urls.grid(row=1, column=0, pady=5)

    label_drag_drop = tk.Label(frame, text="Перетащите файлы сюда:")
    label_drag_drop.grid(row=2, column=0, sticky='w')

    file_listbox = tk.Listbox(frame, width=50, height=5)
    file_listbox.grid(row=3, column=0, pady=5)
    file_listbox.drop_target_register(DND_FILES)
    file_listbox.dnd_bind('<<Drop>>', drag_and_drop)

    label_format = tk.Label(frame, text="Формат аудио:")
    label_format.grid(row=4, column=0, sticky='w')

    format_var = tk.StringVar(value=config['audio_format'])
    entry_format = tk.OptionMenu(frame, format_var, 
                                  'mp3 (Стандартный формат сжатия)', 
                                  'wav (Несжатый формат, лучшее качество)', 
                                  'flac (Сжатый без потерь, для архивирования)', 
                                  'aac (Современный формат с высоким качеством)')
    entry_format.grid(row=5, column=0, pady=5)

    label_bitrate = tk.Label(frame, text="Битрейт (выберите один):")
    label_bitrate.grid(row=6, column=0, sticky='w')

    bitrate_var = StringVar(value=config['bitrate'])
    entry_bitrate = tk.OptionMenu(frame, bitrate_var, 
        '128k (Стандартное качество)', 
        '192k (Выше среднего качества)', 
        '256k (Высокое качество)', 
        '320k (Максимальное качество)')
    entry_bitrate.grid(row=7, column=0, pady=5)

    demucs_var = tk.BooleanVar(value=config['use_demucs'])
    checkbox_demucs = tk.Checkbutton(frame, text="Использовать Demucs для улучшения", variable=demucs_var)
    checkbox_demucs.grid(row=8, column=0, sticky='w')

    button_start = tk.Button(frame, text="Начать", command=start_processing)
    button_start.grid(row=9, column=0, pady=10)

    root.mainloop()

if __name__ == '__main__':
    check_for_updates(current_version="1.0.0")
    gui_main()
```

============
import os
import logging
import threading
import subprocess
import tkinter as tk
from tkinter import filedialog, messagebox, StringVar
from tkinterdnd2 import DND_FILES, TkinterDnD
from pytube import YouTube
from pydub import AudioSegment, effects
import requests
import json
import re

# Попытка импортировать torchaudio и Demucs
try:
    import torchaudio
    from demucs import pretrained
    from demucs.apply import apply_model
    DEMUCS_AVAILABLE = True
except ImportError:
    DEMUCS_AVAILABLE = False

# Настройка логирования
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[
    logging.FileHandler("audio_extraction.log"),
    logging.StreamHandler()
])

# Конфигурация
CONFIG_FILE = "config.json"

DEFAULT_CONFIG = {
    "output_path": "audio",
    "audio_format": "flac",  # Формат по умолчанию
    "use_demucs": False,
    "bitrate": "320k",  # Битрейт по умолчанию
}

# Загрузка конфигурации
def load_config():
    if os.path.exists(CONFIG_FILE):
        with open(CONFIG_FILE, "r") as f:
            return json.load(f)
    return DEFAULT_CONFIG

# Сохранение конфигурации
def save_config(config):
    with open(CONFIG_FILE, "w") as f:
        json.dump(config, f, indent=4)

# Проверка обновлений
def check_for_updates(current_version):
    """Проверяет наличие обновлений."""
    try:
        response = requests.get('https://example.com/version')  # Заглушка для URL обновлений
        latest_version = response.text.strip()
        if latest_version != current_version:
            logging.info(f"Доступна новая версия: {latest_version}. Пожалуйста, обновите программу.")
    except Exception as e:
        logging.error(f"Ошибка проверки обновлений: {e}")

# Проверка на валидные URL
def is_valid_url(url):
    regex = re.compile(
        r'^(https?://)?(www.)?(youtube.com|youtu.be|rutube.ru)/.+$'
    )
    return re.match(regex, url) is not None

def enhance_audio(audio_path):
    """Улучшает аудио без использования Demucs."""
    try:
        logging.info(f"Улучшение аудио: {audio_path}")
        audio = AudioSegment.from_file(audio_path)
        audio = effects.normalize(audio)
        audio.export(audio_path, format=audio_path.split('.')[-1], bitrate="320k")
    except Exception as e:
        logging.error(f"Ошибка улучшения аудио {audio_path}: {e}")

def enhance_audio_with_demucs(audio_path):
    """Использует модель Demucs для улучшения качества аудио."""
    if not DEMUCS_AVAILABLE:
        logging.error("Demucs не установлен или не может быть импортирован.")
        return
    try:
        logging.info(f"Улучшение аудио с помощью Demucs: {audio_path}")
        model = pretrained.get_model('demucs')
        waveform, sr = torchaudio.load(audio_path)
        enhanced_waveform = apply_model(model, waveform, model=model)
        torchaudio.save(audio_path, enhanced_waveform, sr)
    except Exception as e:
        logging.error(f"Ошибка улучшения аудио с помощью Demucs для {audio_path}: {e}")

def process_audio(audio_path, use_demucs):
    """Обрабатывает аудио файл для улучшения его качества."""
    if use_demucs:
        if DEMUCS_AVAILABLE:
            enhance_audio_with_demucs(audio_path)
        else:
            logging.warning("Demucs недоступен. Будет использовано стандартное улучшение.")
            enhance_audio(audio_path)
    else:
        enhance_audio(audio_path)

def extract_audio_from_local_file(file_path, output_path, audio_format, use_demucs, bitrate):
    """Извлекает аудио из локального видеофайла."""
    if not os.path.exists(output_path):
        os.makedirs(output_path)

    try:
        logging.info(f"Извлечение аудио из локального файла: {file_path}")
        audio_path = os.path.join(output_path, os.path.splitext(os.path.basename(file_path))[0] + f'.{audio_format}')
        logging.info("Конвертация и улучшение аудио с помощью FFmpeg...")
        subprocess.run(['ffmpeg', '-i', file_path, '-af', 'loudnorm', '-b:a', bitrate, audio_path], check=True)

        process_audio(audio_path, use_demucs)
        logging.info(f'Аудио сохранено: {audio_path}')
        return audio_path
    except Exception as e:
        logging.error(f"Ошибка обработки локального файла: {e}")
        return None

def download_audio_from_youtube(url, output_path, audio_format, use_demucs, bitrate):
    """Загружает аудио из видео YouTube и сохраняет в указанном формате с максимальным качеством."""
    if not os.path.exists(output_path):
        os.makedirs(output_path)

    try:
        logging.info(f"Загрузка аудио с YouTube: {url}")
        yt = YouTube(url)
        stream = yt.streams.filter(only_audio=True).order_by('abr').desc().first()
        video_path = stream.download(output_path)
        audio_path = os.path.join(output_path, os.path.splitext(os.path.basename(video_path))[0] + f'.{audio_format}')

        logging.info("Конвертация и улучшение аудио с помощью FFmpeg...")
        subprocess.run(['ffmpeg', '-i', video_path, '-af', 'loudnorm', '-b:a', bitrate, audio_path], check=True)

        os.remove(video_path)

        process_audio(audio_path, use_demucs)

        logging.info(f'Аудио сохранено: {audio_path}')
        return audio_path
    except Exception as e:
        logging.error(f"Ошибка с YouTube: {e}")
        return None

def download_audio_from_rutube(url, output_path, audio_format, use_demucs, bitrate):
    """Загружает аудио из видео RuTube."""
    if not os.path.exists(output_path):
        os.makedirs(output_path)

    try:
        logging.info(f"Загрузка аудио с RuTube: {url}")
        command = [
            'youtube-dl',
            '-x',
            '--audio-format', audio_format,
            '--audio-quality', '0',
            '--output', f'{output_path}/%(title)s.%(ext)s',
            url
        ]
        subprocess.run(command, check=True)
        logging.info('Аудио успешно загружено и извлечено.')
        return True
    except subprocess.CalledProcessError as e:
        logging.error(f"Ошибка с RuTube: {e}")
        return None

def process_video(urls, output_path, audio_format, use_demucs, bitrate):
    results = []
    for url in urls:
        url = url.strip()
        if not url:
            continue
        if os.path.isfile(url):
            result = extract_audio_from_local_file(url, output_path, audio_format, use_demucs, bitrate)
            results.append(result)
        elif is_valid_url(url):
            if "youtube.com" in url or "youtu.be" in url:
                result = download_audio_from_youtube(url, output_path, audio_format, use_demucs, bitrate)
                results.append(result)
            elif "rutube.ru" in url:
                result = download_audio_from_rutube(url, output_path, audio_format, use_demucs, bitrate)
                results.append(result)
            else:
                logging.warning(f"Поддерживаются только YouTube, RuTube и локальные файлы: {url}")
        else:
            logging.warning(f"Недействительный путь или URL: {url}")
    return results

def show_summary(results):
    successful_count = sum(1 for result in results if result is not None)
    messagebox.showinfo("Завершено", f"Обработка завершена!\nУспешно обработано: {successful_count}/{len(results)}")

def gui_main():
    """Графический интерфейс пользователя."""
    config = load_config()

    # Маппинги форматов и битрейтов
    AUDIO_FORMAT_OPTIONS = {
        'mp3 (Стандартный формат сжатия)': 'mp3',
        'wav (Несжатый формат, лучшее качество)': 'wav',
        'flac (Сжатый без потерь, для архивирования)': 'flac',
        'aac (Современный формат с высоким качеством)': 'aac'
    }

    BITRATE_OPTIONS = {
        '128k (Стандартное качество)': '128k',
        '192k (Выше среднего качества)': '192k',
        '256k (Высокое качество)': '256k',
        '320k (Максимальное качество)': '320k'
    }

    # Инициализация главного окна
    root = TkinterDnD.Tk()
    root.title("Извлечение Аудио")

    frame = tk.Frame(root, padx=10, pady=10)
    frame.pack(padx=10, pady=10)

    # Ссылки на видео
    label_urls = tk.Label(frame, text="Ссылки на видео (через запятую):")
    label_urls.grid(row=0, column=0, sticky='w')

    entry_urls = tk.Entry(frame, width=50)
    entry_urls.grid(row=1, column=0, pady=5)

    # Перетаскивание файлов
    label_drag_drop = tk.Label(frame, text="Перетащите файлы сюда:")
    label_drag_drop.grid(row=2, column=0, sticky='w')

    file_listbox = tk.Listbox(frame, width=50, height=5)
    file_listbox.grid(row=3, column=0, pady=5)
    file_listbox.drop_target_register(DND_FILES)
    file_listbox.dnd_bind('<<Drop>>', lambda event: drag_and_drop(event, file_listbox))

    # Формат аудио
    label_format = tk.Label(frame, text="Формат аудио:")
    label_format.grid(row=4, column=0, sticky='w')

    # Установка значения по умолчанию для формата
    for key, value in AUDIO_FORMAT_OPTIONS.items():
        if value == config['audio_format']:
            format_default_option = key
            break
    else:
        format_default_option = 'mp3 (Стандартный формат сжатия)'

    format_var = tk.StringVar(value=format_default_option)
    entry_format = tk.OptionMenu(frame, format_var, *AUDIO_FORMAT_OPTIONS.keys())
    entry_format.grid(row=5, column=0, pady=5)

    # Битрейт
    label_bitrate = tk.Label(frame, text="Битрейт:")
    label_bitrate.grid(row=6, column=0, sticky='w')

    # Установка значения по умолчанию для битрейта
    for key, value in BITRATE_OPTIONS.items():
        if value == config['bitrate']:
            bitrate_default_option = key
            break
    else:
        bitrate_default_option = '320k (Максимальное качество)'

    bitrate_var = StringVar(value=bitrate_default_option)
    entry_bitrate = tk.OptionMenu(frame, bitrate_var, *BITRATE_OPTIONS.keys())
    entry_bitrate.grid(row=7, column=0, pady=5)

    # Использование Demucs
    demucs_var = tk.BooleanVar(value=config['use_demucs'])
    checkbox_demucs = tk.Checkbutton(frame, text="Использовать Demucs для улучшения", variable=demucs_var)
    checkbox_demucs.grid(row=8, column=0, sticky='w')

    if not DEMUCS_AVAILABLE:
        checkbox_demucs.config(state='disabled')
        label_demucs_unavailable = tk.Label(frame, text="Demucs недоступен.", fg="red")
        label_demucs_unavailable.grid(row=9, column=0, sticky='w')

    # Кнопка "Начать"
    button_start = tk.Button(frame, text="Начать", command=lambda: start_processing(
        entry_urls, file_listbox, config, AUDIO_FORMAT_OPTIONS, BITRATE_OPTIONS, format_var, bitrate_var, demucs_var, root))
    button_start.grid(row=10, column=0, pady=10)

    root.mainloop()

def drag_and_drop(event, file_listbox):
    files = event.data
    files = root.tk.splitlist(files)
    for file in files:
        file_listbox.insert(tk.END, file)

def start_processing(entry_urls, file_listbox, config, AUDIO_FORMAT_OPTIONS, BITRATE_OPTIONS, format_var, bitrate_var, demucs_var, root):
    """Запуск обработки в отдельном потоке."""
    threading.Thread(target=lambda: processing_task(
        entry_urls, file_listbox, config, AUDIO_FORMAT_OPTIONS, BITRATE_OPTIONS, format_var, bitrate_var, demucs_var, root)).start()

def processing_task(entry_urls, file_listbox, config, AUDIO_FORMAT_OPTIONS, BITRATE_OPTIONS, format_var, bitrate_var, demucs_var, root):
    urls = list(entry_urls.get().split(','))
    file_paths = file_listbox.get(0, tk.END)
    urls.extend(file_paths)

    output_dir = filedialog.askdirectory(title="Выберите папку для сохранения") or config['output_path']
    audio_format = AUDIO_FORMAT_OPTIONS.get(format_var.get(), 'mp3')
    use_demucs = demucs_var.get()
    bitrate = BITRATE_OPTIONS.get(bitrate_var.get(), '320k')

    if not urls or not output_dir:
        messagebox.showwarning("Предупреждение", "Пожалуйста, введите ссылки или добавьте файлы, и выберите путь для сохранения.")
        return

    results = process_video(urls, output_dir, audio_format, use_demucs, bitrate)
    root.after(0, show_summary, results)

    config['output_path'] = output_dir
    config['audio_format'] = audio_format
    config['use_demucs'] = use_demucs
    config['bitrate'] = bitrate
    save_config(config)

if name == 'main':
    check_for_updates(current_version="1.0.0")
    gui_main().