Вот код севрера:
```py
# app.py
import shutil
import sqlite3
import zipfile
from io import BytesIO

from flask import Flask, request, jsonify, send_from_directory, render_template, send_file, url_for
from flask_cors import CORS
from database import Database
import os
import uuid
from werkzeug.utils import secure_filename

app = Flask(__name__, static_folder='static', template_folder='templates')
CORS(app)

db = Database()

# Убедимся, что папка для хранения треков существует
TRACKS_DIR = os.path.join(app.static_folder, 'tracks')
os.makedirs(TRACKS_DIR, exist_ok=True)

# Ограничение для допустимых расширений файлов
ALLOWED_EXTENSIONS = {'mp3', 'wav', 'aac', 'flac', 'ogg', 'm4a'}

def allowed_file(filename):
    return '.' in filename and \
           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS

# Ограничение размера файла, например, до 100MB
MAX_CONTENT_LENGTH = 100 * 1024 * 1024  # 100MB
app.config['MAX_CONTENT_LENGTH'] = MAX_CONTENT_LENGTH

# Главная страница
@app.route('/')
def index():
    return render_template('index.html')

# Обслуживание статических файлов
@app.route('/static/<path:path>')
def send_static_files(path):
    print(f"pathpathpathpathpath =  {path}")
    return send_from_directory('static', path)

# 1. Получение всех треков (с пагинацией)
@app.route('/tracks', methods=['GET'])
def get_tracks():
    page = request.args.get('page', 1, type=int)
    per_page = 1000
    name = request.args.get('name', type=str)

    if name:
        tracks, total = db.search_tracks_paginated(
            name=name,
            page=page,
            per_page=per_page
        )
    else:
        tracks, total = db.get_tracks(page, per_page)

    return jsonify({'tracks': tracks, 'total': total})

# 2. Поиск треков
@app.route('/tracks/search', methods=['GET'])
def search_tracks():
    description = request.args.get('description', '', type=str)
    tags = request.args.getlist('tags')
    tracks = db.search_tracks(description, tags)
    return jsonify({'tracks': tracks})

# 3. Добавление нового трека с загрузкой файла
@app.route('/tracks', methods=['POST'])
def add_track():
    # Получение оригинальной ссылки, если она существует
    original_url = request.form.get('url')  # Сделали необязательным

    # Проверяем наличие файла в запросе
    if 'file' not in request.files:
        return jsonify({'error': 'Файл трека обязателен.'}), 400

    file = request.files['file']

    # Получаем другие поля формы
    name = request.form.get('name')
    description = request.form.get('description')
    tags = request.form.getlist('tags')  # Ожидаем, что теги передаются как список

    # Проверяем обязательные поля
    if not name:
        return jsonify({'error': 'Название трека обязательно.'}), 400

    if file.filename == '':
        return jsonify({'error': 'Выберите файл для загрузки.'}), 400

    if file and allowed_file(file.filename):
        # Обезопасим имя файла
        filename = secure_filename(file.filename)
        # Генерируем уникальное имя файла
        unique_filename = f"{uuid.uuid4()}_{filename}"
        file_path = os.path.join(TRACKS_DIR, unique_filename)
        file.save(file_path)

        # URL для доступа к файлу
        local_url = url_for('static', filename=f"tracks/{unique_filename}")

        # Добавляем трек в базу данных
        track_id = db.add_track(name, description, local_url, original_url, tags)

        return jsonify({'message': 'Трек успешно добавлен.', 'track_id': track_id}), 201
    else:
        return jsonify({'error': 'Недопустимый тип файла. Поддерживаемые форматы: mp3, wav, aac, flac, ogg, m4a.'}), 400

# 4. Удаление трека
@app.route('/tracks/<int:track_id>', methods=['DELETE'])
def delete_track(track_id):
    # Получаем трек по ID
    track = db.get_track_by_id(track_id)
    if not track:
        return jsonify({'error': 'Трек не найден.'}), 404

    # Удаляем трек из базы данных
    db.delete_track(track_id)

    # Удаляем локальный файл
    file_path = os.path.join(app.root_path, track['url'].lstrip('/'))
    if os.path.exists(file_path):
        try:
            os.remove(file_path)
        except Exception as e:
            # Можно логировать ошибку или обработать иначе
            pass

    return jsonify({'message': 'Трек успешно удален.'}), 200

@app.route('/get_db')
def download_db():
    try:
        memory_file = BytesIO()
        with zipfile.ZipFile(memory_file, 'w', zipfile.ZIP_DEFLATED) as zipf:
            # Добавляем базу данных в архив
            zipf.write(db.db_path, arcname='tracks.db')

            # Добавляем файлы треков в архив
            for root, _, files in os.walk(TRACKS_DIR):
                for file in files:
                    zipf.write(os.path.join(root, file), arcname=os.path.relpath(os.path.join(root, file), app.static_folder))

        memory_file.seek(0)

        return send_file(memory_file, as_attachment=True, download_name="tracks_backup.zip", mimetype="application/zip")

    except Exception as e:
        print(f"Error creating backup: {e}")
        return jsonify({'error': 'Ошибка при создании бэкапа.'}), 500

@app.route('/set_db', methods=['POST'])
def upload_db():
    if 'db_file' not in request.files:
        return jsonify({'error': 'Файл базы данных не найден.'}), 400

    file = request.files['db_file']
    if file.filename == '':
        return jsonify({'error': 'Файл не выбран.'}), 400

    temp_dir = os.path.join(app.instance_path, f"temp_{uuid.uuid4()}")  # instance_path более безопасный
    os.makedirs(temp_dir, exist_ok=True)

    temp_db_path = None

    try:
        file.save(os.path.join(temp_dir, "temp_backup.zip"))

        with zipfile.ZipFile(os.path.join(temp_dir, "temp_backup.zip"), 'r') as zip_ref:
            zip_ref.extractall(temp_dir)

        temp_db_path = os.path.join(temp_dir, 'tracks.db')

        # Подключаемся к временной базе данных
        temp_conn = sqlite3.connect(temp_db_path)
        temp_cursor = temp_conn.cursor()

        def get_tags_from_temp_db(temp_cursor, track_name):
            temp_cursor.execute('''
                SELECT t.name, g.name
                FROM tracks AS t
                INNER JOIN track_tags AS tt ON t.id = tt.track_id
                INNER JOIN tags AS g ON tt.tag_id = g.id
                WHERE t.name = ?
            ''', (track_name,))
            tags = [tag[1] for tag in temp_cursor.fetchall() if tag[0] == track_name]
            return tags

        temp_cursor.execute("SELECT name, description, url, original_url FROM tracks")
        tracks = temp_cursor.fetchall()

        # Перемещаем треки в static/tracks
        temp_tracks_dir = os.path.join(temp_dir, 'tracks')
        if os.path.exists(temp_tracks_dir):
            for filename in os.listdir(temp_tracks_dir):
                shutil.move(os.path.join(temp_tracks_dir, filename), TRACKS_DIR)

        for track in tracks:
            # обновляем url, чтобы он указывал на правильное место
            track_url = track[2]  # url из временной БД
            track_filename = os.path.basename(track_url.lstrip('/tracks/'))  # достаем имя файла из url
            new_track_url = url_for('static', filename=f"tracks/{track_filename}")  # Изменено на /static/tracks/
            new_track_id = db.add_track(track[0], track[1], new_track_url, track[3], [])  # используем новый url
            tags = get_tags_from_temp_db(temp_cursor, track[0])
            if tags:
                db.add_tags_to_track(new_track_id, tags)

        temp_conn.close()

        return jsonify({'message': 'Данные из базы данных успешно загружены.'}), 200

    except sqlite3.Error as e:
        return jsonify({'error': f'Ошибка SQLite: {e}'}), 400  # более информативное сообщение
    except Exception as e:
        import traceback
        print(traceback.format_exc())
        return jsonify({'error': f'Ошибка при загрузке данных: {e}'}), 500
    finally:
        # Удалить временную директорию и все ее содержимое
        if temp_dir:
            try:
                shutil.rmtree(temp_dir)
            except OSError as e:
                print("Error: %s - %s." % (e.filename, e.strerror))

# Обработка ошибки превышения размера файла
@app.errorhandler(413)
def request_entity_too_large(error):
    return jsonify({'error': 'Файл слишком большой. Максимальный размер: 100MB.'}), 413

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=6390)
```

Вот код загрузки новой бд:
```py
import requests

# Путь к zip-архиву
zip_path = "getshit/tracks_backup.zip"  # Замените на свой путь

# Отправляем запрос
with open(zip_path, 'rb') as f:
    files = {'db_file': ('tracks_backup.zip', f, 'application/zip')}
    try:
        r = requests.post('http://127.0.0.1:6390/set_db', files=files)
        r.raise_for_status()
        print(r.text)
    except requests.exceptions.RequestException as e:
        print(f"Error during upload: {e}")
```

Почемау там пишется:
```
Error during upload: ('Connection aborted.', ConnectionAbortedError(10053, 'Программа на вашем хост-компьютере разорвала установленное подключение', None, 10053, None))
```