Запомни весь мой код точь-в-точь и полностью пойми. так как необходимо чозоанить все аозможности и функциональность.
Нужно в полной мере абсолютно  полностью, комплексно, всесторонне, профессионально в лучшем варианте и качестве реализовать все эти твои замечания (обязательно все а не часть) и рекомендаций Которые ты прислал, кроме:
URL для проверки обновлений (https://example.com/version) является заглушкой и не выполняет никакой реальной функции. Оно должно быть, но никак не влиять на выполнение сейчас. torchaudio и Demucs так же должнв быть, но опционально. Ведь  они как минимум нужны мне и требовательным пользователям.
Тут я просто хотел чтобы был не только выбор формата и подобное, но чтобы были предустановленные данные и вообще было понятно незнакомому различия. (Например мои знакомые абсолбтнотне понимают различий и им нужны подсказки или описание при выборе.)
Возможности по расширению функциональности в части пункта 9 и 10 пока не нужны.

Итгоаый код проекта должен быть полность готовый, работоспособный код без упрощений, поверхностностия формальностей, несоответствия и не полноценности! 

Сам код:
```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()
```