Initial plan

.github/workflows/main.yml

@@ -4,84 +4,40 @@ on:
   push:
     branches:
       - 'master'
-    paths-ignore:
-      - '**.md'
 
 jobs:
-  quality-checks:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-      - name: Set up Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: lts/*
-      - name: Enable pnpm
-        run: corepack enable
-      - name: Install frontend dependencies
-        working-directory: ui
-        run: pnpm install --frozen-lockfile
-      - name: Run frontend lint
-        working-directory: ui
-        run: pnpm run lint
-      - name: Build frontend
-        working-directory: ui
-        run: pnpm run build
-      - name: Run frontend tests
-        working-directory: ui
-        run: pnpm exec ng test --watch=false
-        env:
-          CI: true
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7
-      - name: Install Python dependencies
-        run: uv sync --frozen --group dev
-      - name: Run backend smoke checks
-        run: python -m compileall app
-      - name: Run backend tests
-        run: uv run pytest app/tests/
-      - name: Run Trivy filesystem scan
-        uses: aquasecurity/trivy-action@v0.36.0
-        with:
-          scan-type: fs
-          scan-ref: .
-          format: table
-          severity: CRITICAL,HIGH
-
   dockerhub-build-push:
-    needs: quality-checks
     runs-on: ubuntu-latest
     steps:
       -
         name: Get current date
         id: date
-        run: echo "date=$(date +'%Y.%m.%d')" >> "$GITHUB_OUTPUT"
+        run: echo "::set-output name=date::$(date +'%Y.%m.%d')"
       -
         name: Checkout
         uses: actions/checkout@v6
       -
         name: Set up QEMU
-        uses: docker/setup-qemu-action@v4
+        uses: docker/setup-qemu-action@v3
       -
         name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
+        uses: docker/setup-buildx-action@v3
       -
         name: Login to DockerHub
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
       -
         name: Login to GitHub Container Registry
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
       -
         name: Build and push
-        uses: docker/build-push-action@v7
+        uses: docker/build-push-action@v6
         with:
           context: .
           platforms: linux/amd64,linux/arm64
@@ -211,7 +167,7 @@ jobs:
             git push origin ":refs/tags/$TAG_NAME" || true
           fi
       - name: Create GitHub Release
-        uses: softprops/action-gh-release@v3
+        uses: softprops/action-gh-release@v2
         with:
           tag_name: ${{ steps.date.outputs.date }}
           name: Release ${{ steps.date.outputs.date }}

.vscode/launch.json

@@ -13,16 +13,12 @@
                 "env": {
                     "DOWNLOAD_DIR": "${env:USERPROFILE}/Downloads",
                     "STATE_DIR": "${env:TEMP}",
-                    "ALLOW_YTDL_OPTIONS_OVERRIDES": "true",
-                    "YTDL_OPTIONS_PRESETS": "{\"sponsorblock\": {\"postprocessors\": [{\"key\": \"SponsorBlock\", \"categories\": [\"sponsor\", \"selfpromo\", \"interaction\"]}, {\"key\": \"ModifyChapters\", \"remove_sponsor_segments\": [\"sponsor\", \"selfpromo\", \"interaction\"]}]}, \"embed-subs\": {\"writesubtitles\": true, \"writeautomaticsub\": true, \"subtitleslangs\": [\"en\", \"de\"], \"postprocessors\": [{\"key\": \"FFmpegEmbedSubtitle\"}]}, \"limit-rate\": {\"ratelimit\": 5000000}}",
                 }
             },
             "osx": {
                 "env": {
                     "DOWNLOAD_DIR": "${env:HOME}/Downloads",
                     "STATE_DIR": "${env:TMPDIR}",
-                    "ALLOW_YTDL_OPTIONS_OVERRIDES": "true",
-                    "YTDL_OPTIONS_PRESETS": "{\"sponsorblock\": {\"postprocessors\": [{\"key\": \"SponsorBlock\", \"categories\": [\"sponsor\", \"selfpromo\", \"interaction\"]}, {\"key\": \"ModifyChapters\", \"remove_sponsor_segments\": [\"sponsor\", \"selfpromo\", \"interaction\"]}]}, \"embed-subs\": {\"writesubtitles\": true, \"writeautomaticsub\": true, \"subtitleslangs\": [\"en\", \"de\"], \"postprocessors\": [{\"key\": \"FFmpegEmbedSubtitle\"}]}, \"limit-rate\": {\"ratelimit\": 5000000}}",
                 }
             },
             "console": "integratedTerminal"

AGENTS.md

@@ -1,60 +0,0 @@
-# Agent Guidelines
-
-## README.md size constraint
-
-The README.md is synced to Docker Hub, which has a **25,000 character limit**.
-Any change to README.md **must** keep the file under 25,000 characters (`wc -c README.md`).
-If an addition would exceed the limit, trim existing prose elsewhere — prefer tightening verbose descriptions over removing sections.
-
-## Tech stack
-
-- **Backend:** Python 3.13+, aiohttp, python-socketio 5.x, yt-dlp
-- **Frontend:** Angular 21, TypeScript, Bootstrap 5, SASS, ngx-socket-io
-- **Package managers:** uv (Python), pnpm (frontend)
-- **Container:** Multi-stage Docker (Node builder + Python runtime), multi-arch (amd64/arm64)
-
-## Build & test commands
-
-```bash
-# Frontend (run from ui/)
-pnpm install --frozen-lockfile
-pnpm run lint
-pnpm run build
-pnpm exec ng test --watch=false
-
-# Backend (run from repo root)
-uv sync --frozen --group dev
-python -m compileall app
-uv run pytest app/tests/
-```
-
-All of these run in CI (`.github/workflows/main.yml`) on every push to master and must pass.
-
-## Code style
-
-Follow `.editorconfig`:
-- Python: 4-space indent
-- Everything else (TypeScript, YAML, JSON, HTML): 2-space indent
-- UTF-8, LF line endings, trim trailing whitespace, final newline
-
-Frontend additionally uses ESLint (`ui/eslint.config.js`) and Prettier (config in `ui/package.json`: `printWidth=100`, `singleQuote=true`).
-
-## Project structure
-
-```
-app/main.py          — HTTP server, Socket.IO events, REST API routes, Config class
-app/ytdl.py          — Download queue logic, yt-dlp integration
-app/subscriptions.py — Channel/playlist subscription manager
-app/state_store.py   — JSON-based persistent storage with atomic writes
-app/dl_formats.py    — Video/audio codec/quality mapping
-app/tests/           — pytest tests (asyncio_mode=auto)
-ui/src/app/          — Angular standalone components (no NgModules)
-```
-
-## Key conventions
-
-- Backend configuration lives in the `Config` class in `app/main.py` with env-var defaults in `_DEFAULTS`. New env vars go there.
-- Real-time communication uses Socket.IO events, not REST polling.
-- Frontend uses standalone Angular components with `inject()` for DI, RxJS Subjects for state, and `takeUntilDestroyed()` for cleanup.
-- State is persisted as JSON files via `AtomicJsonStore` in `app/state_store.py`.
-- No pre-commit hooks — linting and tests are enforced in CI only.

Dockerfile

@@ -26,12 +26,15 @@ RUN sed -i 's/\r$//g' docker-entrypoint.sh && \
       gosu \
       curl \
       tini \
+      file \
+      gdbmtool \
+      sqlite3 \
       build-essential && \
     curl -LsSf https://astral.sh/uv/install.sh | UV_INSTALL_DIR=/usr/local/bin sh && \
     UV_PROJECT_ENVIRONMENT=/usr/local uv sync --frozen --no-dev --compile-bytecode && \
     uv cache clean && \
     rm -f /usr/local/bin/uv /usr/local/bin/uvx /usr/local/bin/uvw && \
-    curl -fsSL https://deno.land/install.sh | DENO_INSTALL=/usr/local sh -s -- -y && \
+    curl -fsSL https://deno.land/install.sh | DENO_INSTALL=/usr/local sh -s -- -y v2.7.2 && \
     apt-get purge -y --auto-remove build-essential && \
     rm -rf /var/lib/apt/lists/* && \
     mkdir /.cache && chmod 777 /.cache
@@ -60,13 +63,11 @@ ENV PUID=1000
 ENV PGID=1000
 ENV UMASK=022
 
-ENV DOWNLOAD_DIR=/downloads
-ENV STATE_DIR=/downloads/.metube
-ENV TEMP_DIR=/downloads
-ENV PORT=8081
+ENV DOWNLOAD_DIR /downloads
+ENV STATE_DIR /downloads/.metube
+ENV TEMP_DIR /downloads
 VOLUME /downloads
 EXPOSE 8081
-HEALTHCHECK --interval=30s --timeout=5s --start-period=20s --retries=3 CMD curl -fsS "http://localhost:${PORT}/" || exit 1
 
 # Add build-time argument for version
 ARG VERSION=dev

README.md

@@ -3,12 +3,7 @@
 ![Build Status](https://github.com/alexta69/metube/actions/workflows/main.yml/badge.svg)
 ![Docker Pulls](https://img.shields.io/docker/pulls/alexta69/metube.svg)
 
-MeTube is a self-hosted web UI for `yt-dlp`, for downloading media from YouTube and [dozens of other sites](https://github.com/yt-dlp/yt-dlp/blob/master/supportedsites.md).
-
-Key capabilities:
-* Download videos, audio, captions, and thumbnails from a browser UI.
-* Download playlists and channels, with configurable output and download options.
-* Subscribe to channels and playlists, periodically check for new items, and queue new uploads automatically.
+Web GUI for youtube-dl (using the [yt-dlp](https://github.com/yt-dlp/yt-dlp) fork) with playlist support. Allows you to download videos from YouTube and [dozens of other sites](https://github.com/yt-dlp/yt-dlp/blob/master/supportedsites.md).
 
 ![screenshot1](https://github.com/alexta69/metube/raw/master/screenshot.gif)
 
@@ -41,9 +36,6 @@ Certain values can be set via environment variables, using the `-e` parameter on
 * __MAX_CONCURRENT_DOWNLOADS__: Maximum number of simultaneous downloads allowed. For example, if set to `5`, then at most five downloads will run concurrently, and any additional downloads will wait until one of the active downloads completes. Defaults to `3`. 
 * __DELETE_FILE_ON_TRASHCAN__: if `true`, downloaded files are deleted on the server, when they are trashed from the "Completed" section of the UI. Defaults to `false`.
 * __DEFAULT_OPTION_PLAYLIST_ITEM_LIMIT__: Maximum number of playlist items that can be downloaded. Defaults to `0` (no limit).
-* __SUBSCRIPTION_DEFAULT_CHECK_INTERVAL__: Default minutes between automatic checks for each subscription. Defaults to `60`.
-* __SUBSCRIPTION_SCAN_PLAYLIST_END__: Maximum playlist/channel entries to fetch per subscription check (newest-first). Defaults to `50`.
-* __SUBSCRIPTION_MAX_SEEN_IDS__: Cap on stored video IDs per subscription to limit state file growth. Defaults to `50000`.
 * __CLEAR_COMPLETED_AFTER__: Number of seconds after which completed (and failed) downloads are automatically removed from the "Completed" list. Defaults to `0` (disabled).
 
 ### 📁 Storage & Directories
@@ -54,7 +46,7 @@ Certain values can be set via environment variables, using the `-e` parameter on
 * __CREATE_CUSTOM_DIRS__: Whether to support automatically creating directories within the __DOWNLOAD_DIR__ (or __AUDIO_DOWNLOAD_DIR__) if they do not exist. When enabled, the download directory selector supports free-text input, and the specified directory will be created recursively. Defaults to `true`.
 * __CUSTOM_DIRS_EXCLUDE_REGEX__: Regular expression to exclude some custom directories from the dropdown. Empty regex disables exclusion. Defaults to `(^|/)[.@].*$`, which means directories starting with `.` or `@`.
 * __DOWNLOAD_DIRS_INDEXABLE__: If `true`, the download directories (__DOWNLOAD_DIR__ and __AUDIO_DOWNLOAD_DIR__) are indexable on the web server. Defaults to `false`.
-* __STATE_DIR__: Path to where MeTube will store its persistent state files (`queue.json`, `pending.json`, `completed.json`, `subscriptions.json`). Defaults to `/downloads/.metube` in the Docker image, and `.` otherwise.
+* __STATE_DIR__: Path to where the queue persistence files will be saved. Defaults to `/downloads/.metube` in the Docker image, and `.` otherwise.
 * __TEMP_DIR__: Path where intermediary download files will be saved. Defaults to `/downloads` in the Docker image, and `.` otherwise.
   * Set this to an SSD or RAM filesystem (e.g., `tmpfs`) for better performance.
   * __Note__: Using a RAM filesystem may prevent downloads from being resumed.
@@ -66,11 +58,8 @@ Certain values can be set via environment variables, using the `-e` parameter on
 * __OUTPUT_TEMPLATE_CHAPTER__: The template for the filenames of the downloaded videos when split into chapters via postprocessors. Defaults to `%(title)s - %(section_number)s %(section_title)s.%(ext)s`.
 * __OUTPUT_TEMPLATE_PLAYLIST__: The template for the filenames of the downloaded videos when downloaded as a playlist. Defaults to `%(playlist_title)s/%(title)s.%(ext)s`. Set to empty to use `OUTPUT_TEMPLATE` instead.
 * __OUTPUT_TEMPLATE_CHANNEL__: The template for the filenames of the downloaded videos when downloaded as a channel. Defaults to `%(channel)s/%(title)s.%(ext)s`. Set to empty to use `OUTPUT_TEMPLATE` instead.
-* __YTDL_OPTIONS__: Additional options to pass to yt-dlp, as a JSON object. See [Configuring yt-dlp options](#%EF%B8%8F-configuring-yt-dlp-options) for details, examples, and available options reference.
-* __YTDL_OPTIONS_FILE__: Path to a JSON file containing yt-dlp options. Monitored and reloaded automatically on changes. See [Configuring yt-dlp options](#%EF%B8%8F-configuring-yt-dlp-options).
-* __YTDL_OPTIONS_PRESETS__: Named bundles of yt-dlp options, selectable per download in the UI. See [Configuring yt-dlp options](#%EF%B8%8F-configuring-yt-dlp-options) for format and examples.
-* __YTDL_OPTIONS_PRESETS_FILE__: Path to a JSON file containing presets. Monitored and reloaded automatically on changes. See [Configuring yt-dlp options](#%EF%B8%8F-configuring-yt-dlp-options).
-* __ALLOW_YTDL_OPTIONS_OVERRIDES__: Whether to show a free-text field in the UI for per-download yt-dlp option overrides. Defaults to `false`. See [Configuring yt-dlp options](#%EF%B8%8F-configuring-yt-dlp-options) for details and security considerations.
+* __YTDL_OPTIONS__: Additional options to pass to yt-dlp in JSON format. [See available options here](https://github.com/yt-dlp/yt-dlp/blob/master/yt_dlp/YoutubeDL.py#L222). They roughly correspond to command-line options, though some do not have exact equivalents here. For example, `--recode-video` has to be specified via `postprocessors`. Also note that dashes are replaced with underscores. You may find [this script](https://github.com/yt-dlp/yt-dlp/blob/master/devscripts/cli_to_api.py) helpful for converting from command-line options to `YTDL_OPTIONS`.
+* __YTDL_OPTIONS_FILE__: A path to a JSON file that will be loaded and used for populating `YTDL_OPTIONS` above. Please note that if both `YTDL_OPTIONS_FILE` and `YTDL_OPTIONS` are specified, the options in `YTDL_OPTIONS` take precedence. The file will be monitored for changes and reloaded automatically when changes are detected.
 
 ### 🌐 Web Server & URLs
 
@@ -82,7 +71,6 @@ Certain values can be set via environment variables, using the `-e` parameter on
 * __HTTPS__: Use `https` instead of `http` (__CERTFILE__ and __KEYFILE__ required). Defaults to `false`.
 * __CERTFILE__: HTTPS certificate file path.
 * __KEYFILE__: HTTPS key file path.
-* __CORS_ALLOWED_ORIGINS__: Comma-separated list of origins permitted to make cross-origin requests to the MeTube API. When unset or empty, all cross-origin requests are denied. Set to `*` to allow all origins. This must be configured for [browser extensions](#-browser-extensions), [bookmarklets](#-bookmarklet), and any other browser-based tools that contact MeTube from a different origin. For browser extensions use `*` (see below); for bookmarklets you can list specific sites, e.g. `https://www.youtube.com,https://www.vimeo.com`.
 * __ROBOTS_TXT__: A path to a `robots.txt` file mounted in the container.
 
 ### 🏠 Basic Setup
@@ -94,124 +82,6 @@ Certain values can be set via environment variables, using the `-e` parameter on
 * __LOGLEVEL__: Log level, can be set to `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`, or `NONE`. Defaults to `INFO`. 
 * __ENABLE_ACCESSLOG__: Whether to enable access log. Defaults to `false`.
 
-## 🎛️ Configuring yt-dlp options
-
-MeTube lets you customize how [yt-dlp](https://github.com/yt-dlp/yt-dlp) behaves at three levels, from broadest to most specific:
-
-1. **Global options** — apply to every download by default.
-2. **Presets** — named bundles of options that users can pick per download from the UI.
-3. **Per-download overrides** — free-form options entered in the UI for a single download.
-
-When a download starts, these layers are combined in order. If the same option appears in more than one layer, the more specific one wins: per-download overrides beat presets, and presets beat global options.
-
-In JSON presets and overrides, setting an option to **`null`** clears that option for that download (for example, `"download_archive": null` overrides a global archive path so the archive is not used). This follows yt-dlp’s usual meaning of `None` for that option.
-
-### Option format
-
-yt-dlp options in MeTube are expressed as JSON objects. The keys are yt-dlp API option names, which roughly correspond to command-line flags with dashes replaced by underscores. For example, the command-line flag `--write-subs` becomes `"writesubtitles": true` in JSON.
-
-> **Tip:** Some command-line flags don't have a direct single-key equivalent — for instance, `--embed-thumbnail` and `--recode-video` must be expressed via `"postprocessors"`. A full list of available API options can be found [in the yt-dlp source](https://github.com/yt-dlp/yt-dlp/blob/master/yt_dlp/YoutubeDL.py#L224), and [this conversion script](https://github.com/yt-dlp/yt-dlp/blob/master/devscripts/cli_to_api.py) can help translate command-line flags to their API equivalents.
-
-### Global options
-
-Global options form the baseline for every download. There are two ways to define them, and you can use either or both:
-
-**Inline via environment variable** (`YTDL_OPTIONS`) — pass a JSON object directly:
-
-```yaml
-environment:
-  - 'YTDL_OPTIONS={"writesubtitles": true, "subtitleslangs": ["en", "de"], "updatetime": false, "writethumbnail": true}'
-```
-
-**Via a JSON file** (`YTDL_OPTIONS_FILE`) — mount a file into the container and point to it:
-
-```yaml
-volumes:
-  - /path/to/ytdl-options.json:/config/ytdl-options.json
-environment:
-  - YTDL_OPTIONS_FILE=/config/ytdl-options.json
-```
-
-where `ytdl-options.json` contains:
-
-```json
-{
-  "writesubtitles": true,
-  "subtitleslangs": ["en", "de"],
-  "updatetime": false,
-  "writethumbnail": true
-}
-```
-
-The file is monitored for changes and reloaded automatically — no container restart needed. If you use both methods and they define the same key, the **file takes precedence**.
-
-### Presets
-
-Presets let you define named bundles of options that appear in the web UI under **Advanced Options** as "Option Presets". Users can select one or more presets per download, making it easy to apply common option combinations without editing global settings.
-
-Like global options, presets can be set inline or via a file:
-
-* `YTDL_OPTIONS_PRESETS` — a JSON object where each key is a preset name and its value is a set of yt-dlp options.
-* `YTDL_OPTIONS_PRESETS_FILE` — path to a JSON file containing presets, monitored and reloaded on changes.
-
-If both are used and they define a preset with the same name, the **file's version takes precedence**.
-
-**Example** — a presets file defining three presets:
-
-```json
-{
-  "sponsorblock": {
-    "postprocessors": [
-      { "key": "SponsorBlock", "categories": ["sponsor", "selfpromo", "interaction"] },
-      { "key": "ModifyChapters", "remove_sponsor_segments": ["sponsor", "selfpromo", "interaction"] }
-    ]
-  },
-  "embed-subs": {
-    "writesubtitles": true,
-    "writeautomaticsub": true,
-    "subtitleslangs": ["en", "de"],
-    "postprocessors": [{ "key": "FFmpegEmbedSubtitle" }]
-  },
-  "limit-rate": {
-    "ratelimit": 5000000
-  }
-}
-```
-
-This makes three presets available in the UI:
-* **sponsorblock** — strips sponsor, self-promo, and interaction segments from videos.
-* **embed-subs** — downloads English and German subtitles and embeds them into the video file.
-* **limit-rate** — caps download speed to ~5 MB/s.
-
-When multiple presets are selected for a download, they are applied in order. If two presets set the same option, the later one wins.
-
-### Per-download overrides
-
-For one-off tweaks, MeTube can expose a free-text JSON field in the UI ("Custom yt-dlp Options") where users type yt-dlp options that apply only to that single download. This is disabled by default:
-
-```yaml
-environment:
-  - ALLOW_YTDL_OPTIONS_OVERRIDES=true
-```
-
-Once enabled, the field appears under **Advanced Options**. Any options entered there take the highest priority, overriding both global options and selected presets.
-
-> **⚠️ Security note:** Enabling this allows arbitrary yt-dlp API options to be supplied by anyone with access to the UI. Depending on the options used, this may enable arbitrary command execution inside the container. Enable only in trusted environments.
-
-### How the layers combine
-
-When a download starts, the final set of yt-dlp options is built in this order:
-
-1. Start with **global options** (`YTDL_OPTIONS` / `YTDL_OPTIONS_FILE`).
-2. Apply each selected **preset** in order (later presets overwrite earlier ones for conflicting keys).
-3. Apply any **per-download overrides** on top (overwrite everything else for conflicting keys).
-
-MeTube always forces its own flat-extract behaviour during the initial metadata fetch (`extract_flat`, `noplaylist`, etc.); presets cannot override those keys for that phase.
-
-**Example:** Suppose your global options set `"writesubtitles": false`, but you select a preset that sets `"writesubtitles": true`. Subtitles will be written for that download because the preset overrides the global setting. If you additionally enter `{"writesubtitles": false}` in the per-download overrides field, that value wins and subtitles will not be written.
-
-### Configuration cookbooks
-
 The project's Wiki contains examples of useful configurations contributed by users of MeTube:
 * [YTDL_OPTIONS Cookbook](https://github.com/alexta69/metube/wiki/YTDL_OPTIONS-Cookbook)
 * [OUTPUT_TEMPLATE Cookbook](https://github.com/alexta69/metube/wiki/OUTPUT_TEMPLATE-Cookbook)
@@ -230,9 +100,7 @@ In case you need to use your browser's cookies with MeTube, for example to downl
 
 ## 🔌 Browser extensions
 
-Browser extensions allow right-clicking videos and sending them directly to MeTube. If you're on an HTTPS page, your MeTube instance must be behind an HTTPS reverse proxy (see below) for extensions to work.
-
-Since browser extensions make requests from their own origin (`chrome-extension://...` or `moz-extension://...`), you must set `CORS_ALLOWED_ORIGINS=*` for them to work.
+Browser extensions allow right-clicking videos and sending them directly to MeTube. Please note that if you're on an HTTPS page, your MeTube instance must be behind an HTTPS reverse proxy (see below) for the extensions to work.
 
 __Chrome:__ contributed by [Rpsl](https://github.com/rpsl). You can install it from [Google Chrome Webstore](https://chrome.google.com/webstore/detail/metube-downloader/fbmkmdnlhacefjljljlbhkodfmfkijdh) or use developer mode and install [from sources](https://github.com/Rpsl/metube-browser-extension).
 
@@ -242,12 +110,21 @@ __Firefox:__ contributed by [nanocortex](https://github.com/nanocortex). You can
 
 [rithask](https://github.com/rithask) created an iOS shortcut to send URLs to MeTube from Safari. Enter the MeTube instance address when prompted which will be saved for later use. You can run the shortcut from Safari’s share menu. The shortcut can be downloaded from [this iCloud link](https://www.icloud.com/shortcuts/66627a9f334c467baabdb2769763a1a6).
 
+## 📱 iOS Compatibility
+
+iOS has strict requirements for video files, requiring h264 or h265 video codec and aac audio codec in MP4 container. This can sometimes be a lower quality than the best quality available. To accommodate iOS requirements, when downloading a MP4 format you can choose "Best (iOS)" to get the best quality formats as compatible as possible with iOS requirements.
+
+To force all downloads to be converted to an iOS-compatible codec, insert this as an environment variable: 
+
+```yaml
+  environment:
+    - 'YTDL_OPTIONS={"format": "best", "exec": "ffmpeg -i %(filepath)q -c:v libx264 -c:a aac %(filepath)q.h264.mp4"}'
+```
+
 ## 🔖 Bookmarklet
 
 [kushfest](https://github.com/kushfest) has created a Chrome bookmarklet for sending the currently open webpage to MeTube. Please note that if you're on an HTTPS page, your MeTube instance must be configured with `HTTPS` as `true` in the environment, or be behind an HTTPS reverse proxy (see below) for the bookmarklet to work.
 
-Since bookmarklets run in the context of the current page (e.g. youtube.com), the requests they make to MeTube are cross-origin. You must add the origins of sites where you use the bookmarklet to the __CORS_ALLOWED_ORIGINS__ environment variable, otherwise the browser will block the requests. For example, to use the bookmarklet on YouTube and Vimeo: `CORS_ALLOWED_ORIGINS=https://www.youtube.com,https://www.vimeo.com`.
-
 GitHub doesn't allow embedding JavaScript as a link, so the bookmarklet has to be created manually by copying the following code to a new bookmark you create on your bookmarks bar. Change the hostname in the URL below to point to your MeTube instance.
 
 ```javascript
@@ -260,15 +137,23 @@ javascript:!function(){xhr=new XMLHttpRequest();xhr.open("POST","https://metube.
 javascript:(function(){xhr=new XMLHttpRequest();xhr.open("POST","https://metube.domain.com/add");xhr.send(JSON.stringify({"url":document.location.href,"quality":"best"}));xhr.onload=function(){if(xhr.status==200){alert("Sent to metube!")}else{alert("Send to metube failed. Check the javascript console for clues.")}}})();
 ```
 
-The above bookmarklets use `alert()` for notifications. This variant shows a toast instead (Chrome — for Firefox, replace the `!function(){...}()` wrapper with `(function(){...})()`):
+The above bookmarklets use `alert()` as a success/failure notification. The following will show a toast message instead:
+
+Chrome:
 
 ```javascript
 javascript:!function(){function notify(msg) {var sc = document.scrollingElement.scrollTop; var text = document.createElement('span');text.innerHTML=msg;var ts = text.style;ts.all = 'revert';ts.color = '#000';ts.fontFamily = 'Verdana, sans-serif';ts.fontSize = '15px';ts.backgroundColor = 'white';ts.padding = '15px';ts.border = '1px solid gainsboro';ts.boxShadow = '3px 3px 10px';ts.zIndex = '100';document.body.appendChild(text);ts.position = 'absolute'; ts.top = 50 + sc + 'px'; ts.left = (window.innerWidth / 2)-(text.offsetWidth / 2) + 'px'; setTimeout(function () { text.style.visibility = "hidden"; }, 1500);}xhr=new XMLHttpRequest();xhr.open("POST","https://metube.domain.com/add");xhr.send(JSON.stringify({"url":document.location.href,"quality":"best"}));xhr.onload=function() { if(xhr.status==200){notify("Sent to metube!")}else {notify("Send to metube failed. Check the javascript console for clues.")}}}();
 ```
 
+Firefox:
+
+```javascript
+javascript:(function(){function notify(msg) {var sc = document.scrollingElement.scrollTop; var text = document.createElement('span');text.innerHTML=msg;var ts = text.style;ts.all = 'revert';ts.color = '#000';ts.fontFamily = 'Verdana, sans-serif';ts.fontSize = '15px';ts.backgroundColor = 'white';ts.padding = '15px';ts.border = '1px solid gainsboro';ts.boxShadow = '3px 3px 10px';ts.zIndex = '100';document.body.appendChild(text);ts.position = 'absolute'; ts.top = 50 + sc + 'px'; ts.left = (window.innerWidth / 2)-(text.offsetWidth / 2) + 'px'; setTimeout(function () { text.style.visibility = "hidden"; }, 1500);}xhr=new XMLHttpRequest();xhr.open("POST","https://metube.domain.com/add");xhr.send(JSON.stringify({"url":document.location.href,"quality":"best"}));xhr.onload=function() { if(xhr.status==200){notify("Sent to metube!")}else {notify("Send to metube failed. Check the javascript console for clues.")}}})();
+```
+
 ## ⚡ Raycast extension
 
-[dotvhs](https://github.com/dotvhs) has created an [extension for Raycast](https://www.raycast.com/dot/metube) for adding videos to MeTube directly from Raycast.
+[dotvhs](https://github.com/dotvhs) has created an [extension for Raycast](https://www.raycast.com/dot/metube) that allows adding videos to MeTube directly from Raycast.
 
 ## 🔒 HTTPS support, and running behind a reverse proxy
 
@@ -292,9 +177,11 @@ services:
       - KEYFILE=/ssl/key.pem
 ```
 
-MeTube can also run behind a reverse proxy for HTTPS termination or authentication. When serving under a subdirectory, set `URL_PREFIX` accordingly.
+It's also possible to run MeTube behind a reverse proxy, in order to support authentication. HTTPS support can also be added in this way.
 
-The [linuxserver/swag](https://docs.linuxserver.io/general/swag) image includes ready-made snippets for MeTube in [subfolder](https://github.com/linuxserver/reverse-proxy-confs/blob/master/metube.subfolder.conf.sample) and [subdomain](https://github.com/linuxserver/reverse-proxy-confs/blob/master/metube.subdomain.conf.sample) modes, plus Authelia for authentication.
+When running behind a reverse proxy which remaps the URL (i.e. serves MeTube under a subdirectory and not under root), don't forget to set the URL_PREFIX environment variable to the correct value.
+
+If you're using the [linuxserver/swag](https://docs.linuxserver.io/general/swag) image for your reverse proxying needs (which I can heartily recommend), it already includes ready snippets for proxying MeTube both in [subfolder](https://github.com/linuxserver/reverse-proxy-confs/blob/master/metube.subfolder.conf.sample) and [subdomain](https://github.com/linuxserver/reverse-proxy-confs/blob/master/metube.subdomain.conf.sample) modes under the `nginx/proxy-confs` directory in the configuration volume. It also includes Authelia which can be used for authentication.
 
 ### 🌐 NGINX
 
@@ -346,20 +233,28 @@ example.com {
 
 ## 🔄 Updating yt-dlp
 
-MeTube is powered by [yt-dlp](https://github.com/yt-dlp/yt-dlp), which requires frequent updates as video sites change their layouts. A nightly build automatically publishes a new Docker image whenever a new yt-dlp version is available, so keep your container up to date — [watchtower](https://github.com/nicholas-fedor/watchtower) works well for this.
+The engine which powers the actual video downloads in MeTube is [yt-dlp](https://github.com/yt-dlp/yt-dlp). Since video sites regularly change their layouts, frequent updates of yt-dlp are required to keep up.
+
+There's an automatic nightly build of MeTube which looks for a new version of yt-dlp, and if one exists, the build pulls it and publishes an updated docker image. Therefore, in order to keep up with the changes, it's recommended that you update your MeTube container regularly with the latest image.
+
+I recommend installing and setting up [watchtower](https://github.com/nicholas-fedor/watchtower) for this purpose.
 
 ## 🔧 Troubleshooting and submitting issues
 
-MeTube is only a UI for [yt-dlp](https://github.com/yt-dlp/yt-dlp). Issues with authentication, postprocessing, permissions, or `YTDL_OPTIONS` should be debugged with yt-dlp directly first — once working, import those options into MeTube. To test inside the container:
+Before asking a question or submitting an issue for MeTube, please remember that MeTube is only a UI for [yt-dlp](https://github.com/yt-dlp/yt-dlp). Any issues you might be experiencing with authentication to video websites, postprocessing, permissions, other `YTDL_OPTIONS` configurations which seem not to work, or anything else that concerns the workings of the underlying yt-dlp library, need not be opened on the MeTube project. In order to debug and troubleshoot them, it's advised to try using the yt-dlp binary directly first, bypassing the UI, and once that is working, importing the options that worked for you into `YTDL_OPTIONS`.
+
+In order to test with the yt-dlp command directly, you can either download it and run it locally, or for a better simulation of its actual conditions, you can run it within the MeTube container itself. Assuming your MeTube container is called `metube`, run the following on your Docker host to get a shell inside the container:
 
 ```bash
 docker exec -ti metube sh
 cd /downloads
 ```
 
+Once there, you can use the yt-dlp command freely.
+
 ## 💡 Submitting feature requests
 
-MeTube development relies on community contributions. If you need additional features, please submit a PR. Create an issue first to discuss the implementation — some PRs may not be accepted to reduce bloat. Feature requests without an accompanying PR are unlikely to be fulfilled.
+MeTube development relies on code contributions by the community. The program as it currently stands fits my own use cases, and is therefore feature-complete as far as I'm concerned. If your use cases are different and require additional features, please feel free to submit PRs that implement those features. It's advisable to create an issue first to discuss the planned implementation, because in an effort to reduce bloat, some PRs may not be accepted. However, note that opening a feature request when you don't intend to implement the feature will rarely result in the request being fulfilled.
 
 ## 🛠️ Building and running locally
 

app/dl_formats.py

@@ -3,13 +3,6 @@ import copy
 AUDIO_FORMATS = ("m4a", "mp3", "opus", "wav", "flac")
 CAPTION_MODES = ("auto_only", "manual_only", "prefer_manual", "prefer_auto")
 
-CODEC_FILTER_MAP = {
-    'h264': "[vcodec~='^(h264|avc)']",
-    'h265': "[vcodec~='^(h265|hevc)']",
-    'av1':  "[vcodec~='^av0?1']",
-    'vp9':  "[vcodec~='^vp0?9']",
-}
-
 
 def _normalize_caption_mode(mode: str) -> str:
     mode = (mode or "").strip()
@@ -21,88 +14,84 @@ def _normalize_subtitle_language(language: str) -> str:
     return language or "en"
 
 
-def get_format(download_type: str, codec: str, format: str, quality: str) -> str:
+def get_format(format: str, quality: str) -> str:
     """
-    Returns yt-dlp format selector.
+    Returns format for download
 
     Args:
-      download_type (str): selected content type (video, audio, captions, thumbnail)
-      codec (str): selected video codec (auto, h264, h265, av1, vp9)
-      format (str): selected output format/profile for type
-      quality (str): selected quality
+      format (str): format selected
+      quality (str): quality selected
 
     Raises:
-      Exception: unknown type/format
+      Exception: unknown quality, unknown format
 
     Returns:
-      str: yt-dlp format selector
+      dl_format: Formatted download string
     """
-    download_type = (download_type or "video").strip().lower()
-    format = (format or "any").strip().lower()
-    codec = (codec or "auto").strip().lower()
-    quality = (quality or "best").strip().lower()
+    format = format or "any"
 
     if format.startswith("custom:"):
         return format[7:]
 
-    if download_type == "thumbnail":
+    if format == "thumbnail":
+        # Quality is irrelevant in this case since we skip the download
         return "bestaudio/best"
 
-    if download_type == "captions":
+    if format == "captions":
+        # Quality is irrelevant in this case since we skip the download
         return "bestaudio/best"
 
-    if download_type == "audio":
-        if format not in AUDIO_FORMATS:
-            raise ValueError(f"Unknown audio format {format}")
+    if format in AUDIO_FORMATS:
+        # Audio quality needs to be set post-download, set in opts
         return f"bestaudio[ext={format}]/bestaudio/best"
 
-    if download_type == "video":
-        if format not in ("any", "mp4", "ios"):
-            raise ValueError(f"Unknown video format {format}")
-        vfmt, afmt = ("[ext=mp4]", "[ext=m4a]") if format in ("mp4", "ios") else ("", "")
-        vres = f"[height<={quality}]" if quality not in ("best", "worst") else ""
+    if format in ("mp4", "any"):
+        if quality == "audio":
+            return "bestaudio/best"
+        # video {res} {vfmt} + audio {afmt} {res} {vfmt}
+        vfmt, afmt = ("[ext=mp4]", "[ext=m4a]") if format == "mp4" else ("", "")
+        vres = f"[height<={quality}]" if quality not in ("best", "best_ios", "worst") else ""
         vcombo = vres + vfmt
-        codec_filter = CODEC_FILTER_MAP.get(codec, "")
 
-        if format == "ios":
+        if quality == "best_ios":
+            # iOS has strict requirements for video files, requiring h264 or h265
+            # video codec and aac audio codec in MP4 container. This format string
+            # attempts to get the fully compatible formats first, then the h264/h265
+            # video codec with any M4A audio codec (because audio is faster to
+            # convert if needed), and falls back to getting the best available MP4
+            # file.
             return f"bestvideo[vcodec~='^((he|a)vc|h26[45])']{vres}+bestaudio[acodec=aac]/bestvideo[vcodec~='^((he|a)vc|h26[45])']{vres}+bestaudio{afmt}/bestvideo{vcombo}+bestaudio{afmt}/best{vcombo}"
-
-        if codec_filter:
-            return f"bestvideo{codec_filter}{vcombo}+bestaudio{afmt}/bestvideo{vcombo}+bestaudio{afmt}/best{vcombo}"
         return f"bestvideo{vcombo}+bestaudio{afmt}/best{vcombo}"
 
-    raise ValueError(f"Unknown download_type {download_type}")
+    raise Exception(f"Unkown format {format}")
 
 
 def get_opts(
-    download_type: str,
-    _codec: str,
     format: str,
     quality: str,
     ytdl_opts: dict,
+    subtitle_format: str = "srt",
     subtitle_language: str = "en",
     subtitle_mode: str = "prefer_manual",
 ) -> dict:
     """
-    Returns extra yt-dlp options/postprocessors.
+    Returns extra download options
+    Mostly postprocessing options
 
     Args:
-      download_type (str): selected content type
-      codec (str): selected codec (unused currently, kept for API consistency)
-      format (str): selected format/profile
-      quality (str): selected quality
+      format (str): format selected
+      quality (str): quality of format selected (needed for some formats)
       ytdl_opts (dict): current options selected
 
     Returns:
-      dict: extended options
+      ytdl_opts: Extra options
     """
-    download_type = (download_type or "video").strip().lower()
-    format = (format or "any").strip().lower()
+
     opts = copy.deepcopy(ytdl_opts)
 
     postprocessors = []
 
-    if download_type == "audio":
+    if format in AUDIO_FORMATS:
         postprocessors.append(
             {
                 "key": "FFmpegExtractAudio",
@@ -111,7 +100,8 @@ def get_opts(
             }
         )
 
-        if format != "wav" and "writethumbnail" not in opts:
+        # Audio formats without thumbnail
+        if format not in ("wav") and "writethumbnail" not in opts:
             opts["writethumbnail"] = True
             postprocessors.append(
                 {
@@ -123,18 +113,19 @@ def get_opts(
             postprocessors.append({"key": "FFmpegMetadata"})
             postprocessors.append({"key": "EmbedThumbnail"})
 
-    if download_type == "thumbnail":
+    if format == "thumbnail":
         opts["skip_download"] = True
         opts["writethumbnail"] = True
         postprocessors.append(
             {"key": "FFmpegThumbnailsConvertor", "format": "jpg", "when": "before_dl"}
         )
 
-    if download_type == "captions":
+    if format == "captions":
         mode = _normalize_caption_mode(subtitle_mode)
         language = _normalize_subtitle_language(subtitle_language)
         opts["skip_download"] = True
-        requested_subtitle_format = (format or "srt").lower()
+        requested_subtitle_format = (subtitle_format or "srt").lower()
+        # txt is a derived, non-timed format produced from SRT after download.
         if requested_subtitle_format == "txt":
             requested_subtitle_format = "srt"
         opts["subtitlesformat"] = requested_subtitle_format

app/main.py

@@ -14,19 +14,27 @@ import logging
 import json
 import pathlib
 import re
-from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
 from watchfiles import DefaultFilter, Change, awatch
 
-from ytdl import DownloadQueueNotifier, DownloadQueue, Download
-from subscriptions import SubscriptionManager, SubscriptionNotifier, SubscriptionInfo, coerce_optional_bool
+from ytdl import DownloadQueueNotifier, DownloadQueue
 from yt_dlp.version import __version__ as yt_dlp_version
 
 log = logging.getLogger('main')
 
 def parseLogLevel(logLevel):
-    if not isinstance(logLevel, str):
-        return None
-    return getattr(logging, logLevel.upper(), None)
+    match logLevel:
+        case 'DEBUG':
+            return logging.DEBUG
+        case 'INFO':
+            return logging.INFO
+        case 'WARNING':
+            return logging.WARNING
+        case 'ERROR':
+            return logging.ERROR
+        case 'CRITICAL':
+            return logging.CRITICAL
+        case _:
+            return None
 
 # Configure logging before Config() uses it so early messages are not dropped.
 # Only configure if no handlers are set (avoid clobbering hosting app settings).
@@ -52,16 +60,9 @@ class Config:
         'OUTPUT_TEMPLATE_PLAYLIST': '%(playlist_title)s/%(title)s.%(ext)s',
         'OUTPUT_TEMPLATE_CHANNEL': '%(channel)s/%(title)s.%(ext)s',
         'DEFAULT_OPTION_PLAYLIST_ITEM_LIMIT' : '0',
-        'SUBSCRIPTION_DEFAULT_CHECK_INTERVAL': '60',
-        'SUBSCRIPTION_SCAN_PLAYLIST_END': '50',
-        'SUBSCRIPTION_MAX_SEEN_IDS': '50000',
         'CLEAR_COMPLETED_AFTER': '0',
         'YTDL_OPTIONS': '{}',
         'YTDL_OPTIONS_FILE': '',
-        'YTDL_OPTIONS_PRESETS': '{}',
-        'YTDL_OPTIONS_PRESETS_FILE': '',
-        'ALLOW_YTDL_OPTIONS_OVERRIDES': 'false',
-        'CORS_ALLOWED_ORIGINS': '',
         'ROBOTS_TXT': '',
         'HOST': '0.0.0.0',
         'PORT': '8081',
@@ -70,12 +71,12 @@ class Config:
         'KEYFILE': '',
         'BASE_DIR': '',
         'DEFAULT_THEME': 'auto',
-        'MAX_CONCURRENT_DOWNLOADS': '3',
+        'MAX_CONCURRENT_DOWNLOADS': 3,
         'LOGLEVEL': 'INFO',
         'ENABLE_ACCESSLOG': 'false',
     }
 
-    _BOOLEAN = ('DOWNLOAD_DIRS_INDEXABLE', 'CUSTOM_DIRS', 'CREATE_CUSTOM_DIRS', 'DELETE_FILE_ON_TRASHCAN', 'HTTPS', 'ENABLE_ACCESSLOG', 'ALLOW_YTDL_OPTIONS_OVERRIDES')
+    _BOOLEAN = ('DOWNLOAD_DIRS_INDEXABLE', 'CUSTOM_DIRS', 'CREATE_CUSTOM_DIRS', 'DELETE_FILE_ON_TRASHCAN', 'HTTPS', 'ENABLE_ACCESSLOG')
 
     def __init__(self):
         for k, v in self._DEFAULTS.items():
@@ -93,25 +94,15 @@ class Config:
         if not self.URL_PREFIX.endswith('/'):
             self.URL_PREFIX += '/'
 
-        for attr in ('PUBLIC_HOST_URL', 'PUBLIC_HOST_AUDIO_URL'):
-            val = getattr(self, attr)
-            if val and not val.endswith('/'):
-                setattr(self, attr, val + '/')
-
         # Convert relative addresses to absolute addresses to prevent the failure of file address comparison
         if self.YTDL_OPTIONS_FILE and self.YTDL_OPTIONS_FILE.startswith('.'):
             self.YTDL_OPTIONS_FILE = str(Path(self.YTDL_OPTIONS_FILE).resolve())
-        if self.YTDL_OPTIONS_PRESETS_FILE and self.YTDL_OPTIONS_PRESETS_FILE.startswith('.'):
-            self.YTDL_OPTIONS_PRESETS_FILE = str(Path(self.YTDL_OPTIONS_PRESETS_FILE).resolve())
 
         self._runtime_overrides = {}
 
         success,_ = self.load_ytdl_options()
         if not success:
             sys.exit(1)
-        success,_ = self.load_ytdl_option_presets()
-        if not success:
-            sys.exit(1)
 
     def set_runtime_override(self, key, value):
         self._runtime_overrides[key] = value
@@ -133,8 +124,6 @@ class Config:
         'PUBLIC_HOST_URL',
         'PUBLIC_HOST_AUDIO_URL',
         'DEFAULT_OPTION_PLAYLIST_ITEM_LIMIT',
-        'SUBSCRIPTION_DEFAULT_CHECK_INTERVAL',
-        'ALLOW_YTDL_OPTIONS_OVERRIDES',
     )
 
     def frontend_safe(self) -> dict:
@@ -176,37 +165,6 @@ class Config:
         self._apply_runtime_overrides()
         return (True, '')
 
-    def load_ytdl_option_presets(self) -> tuple[bool, str]:
-        try:
-            self.YTDL_OPTIONS_PRESETS = json.loads(os.environ.get('YTDL_OPTIONS_PRESETS', '{}'))
-            assert isinstance(self.YTDL_OPTIONS_PRESETS, dict)
-            assert all(isinstance(name, str) and isinstance(options, dict) for name, options in self.YTDL_OPTIONS_PRESETS.items())
-        except (json.decoder.JSONDecodeError, AssertionError):
-            msg = 'Environment variable YTDL_OPTIONS_PRESETS is invalid'
-            log.error(msg)
-            return (False, msg)
-
-        if not self.YTDL_OPTIONS_PRESETS_FILE:
-            return (True, '')
-
-        log.info(f'Loading yt-dlp option presets from "{self.YTDL_OPTIONS_PRESETS_FILE}"')
-        if not os.path.exists(self.YTDL_OPTIONS_PRESETS_FILE):
-            msg = f'File "{self.YTDL_OPTIONS_PRESETS_FILE}" not found'
-            log.error(msg)
-            return (False, msg)
-        try:
-            with open(self.YTDL_OPTIONS_PRESETS_FILE) as json_data:
-                opts = json.load(json_data)
-            assert isinstance(opts, dict)
-            assert all(isinstance(name, str) and isinstance(options, dict) for name, options in opts.items())
-        except (json.decoder.JSONDecodeError, AssertionError):
-            msg = 'YTDL_OPTIONS_PRESETS_FILE contents is invalid'
-            log.error(msg)
-            return (False, msg)
-
-        self.YTDL_OPTIONS_PRESETS.update(opts)
-        return (True, '')
-
 config = Config()
 # Align root logger level with Config (keeps a single source of truth).
 # This re-applies the log level after Config loads, in case LOGLEVEL was
@@ -223,225 +181,19 @@ class ObjectSerializer(json.JSONEncoder):
         elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes)):
             try:
                 return list(obj)
-            except Exception:
+            except:
                 pass
         # Fall back to default behavior
         return json.JSONEncoder.default(self, obj)
 
 serializer = ObjectSerializer()
 app = web.Application()
-_cors_origins = [o.strip() for o in config.CORS_ALLOWED_ORIGINS.split(',') if o.strip()] if config.CORS_ALLOWED_ORIGINS else []
-sio = socketio.AsyncServer(cors_allowed_origins=_cors_origins if _cors_origins else [])
+sio = socketio.AsyncServer(cors_allowed_origins='*')
 sio.attach(app, socketio_path=config.URL_PREFIX + 'socket.io')
 routes = web.RouteTableDef()
 VALID_SUBTITLE_FORMATS = {'srt', 'txt', 'vtt', 'ttml', 'sbv', 'scc', 'dfxp'}
 VALID_SUBTITLE_MODES = {'auto_only', 'manual_only', 'prefer_manual', 'prefer_auto'}
 SUBTITLE_LANGUAGE_RE = re.compile(r'^[A-Za-z0-9][A-Za-z0-9-]{0,34}$')
-VALID_DOWNLOAD_TYPES = {'video', 'audio', 'captions', 'thumbnail'}
-VALID_VIDEO_CODECS = {'auto', 'h264', 'h265', 'av1', 'vp9'}
-VALID_VIDEO_FORMATS = {'any', 'mp4', 'ios'}
-VALID_AUDIO_FORMATS = {'m4a', 'mp3', 'opus', 'wav', 'flac'}
-VALID_THUMBNAIL_FORMATS = {'jpg'}
-def _parse_ytdl_options_overrides(value, *, enabled: bool) -> dict:
-    if value is None or value == '':
-        return {}
-
-    if isinstance(value, str):
-        try:
-            value = json.loads(value)
-        except json.JSONDecodeError as exc:
-            raise web.HTTPBadRequest(reason='ytdl_options_overrides must be valid JSON') from exc
-
-    if not isinstance(value, dict):
-        raise web.HTTPBadRequest(reason='ytdl_options_overrides must be a JSON object')
-
-    if value and not enabled:
-        raise web.HTTPBadRequest(reason='ytdl_options_overrides are disabled')
-
-    return value
-
-
-_YOUTUBE_T_COMPACT_RE = re.compile(
-    r'^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)(?:s)?)?$',
-    re.IGNORECASE,
-)
-
-
-def _parse_youtube_t_compact(value: str) -> float | None:
-    """Parse YouTube-style ``t`` values: ``885``, ``885s``, ``14m45s``, ``1h2m3s``."""
-    v = value.strip()
-    if not v:
-        return None
-    if re.fullmatch(r'-?\d+(\.\d+)?', v):
-        sec = float(v)
-        return sec if sec >= 0 else None
-    m = _YOUTUBE_T_COMPACT_RE.match(v)
-    if m and any(m.groups()):
-        hours = int(m.group(1) or 0)
-        minutes = int(m.group(2) or 0)
-        seconds = int(m.group(3) or 0)
-        total = hours * 3600 + minutes * 60 + seconds
-        return float(total) if total >= 0 else None
-    return None
-
-
-def _parse_clock_timestamp(s: str) -> float:
-    """Parse ``MM:SS``, ``H:MM:SS``, or single segment as seconds (with optional decimals)."""
-    part = s.strip()
-    if not part:
-        raise ValueError('empty timestamp')
-    segments = part.split(':')
-    if len(segments) > 3:
-        raise ValueError('too many segments')
-    try:
-        nums = [float(x) for x in segments]
-    except ValueError as exc:
-        raise ValueError('invalid number') from exc
-    if any(x < 0 for x in nums):
-        raise ValueError('negative segment')
-    if len(segments) == 1:
-        return nums[0]
-    if len(segments) == 2:
-        return nums[0] * 60 + nums[1]
-    return nums[0] * 3600 + nums[1] * 60 + nums[2]
-
-
-def _parse_clip_timestamp_value(value) -> float:
-    """Coerce a clip boundary from JSON to seconds (non-negative)."""
-    if isinstance(value, bool):
-        raise web.HTTPBadRequest(reason='clip timestamp must be a number or string')
-    if isinstance(value, (int, float)):
-        if value < 0:
-            raise web.HTTPBadRequest(reason='clip timestamp must be non-negative')
-        return float(value)
-    s = str(value).strip()
-    if not s:
-        raise web.HTTPBadRequest(reason='clip timestamp cannot be empty')
-    if ':' in s:
-        try:
-            return _parse_clock_timestamp(s)
-        except ValueError as exc:
-            raise web.HTTPBadRequest(reason='invalid clip timestamp format') from exc
-    compact = _parse_youtube_t_compact(s)
-    if compact is not None:
-        return compact
-    raise web.HTTPBadRequest(reason='invalid clip timestamp format')
-
-
-def _optional_clip_field(raw) -> float | None:
-    if raw is None:
-        return None
-    if isinstance(raw, str) and not raw.strip():
-        return None
-    return _parse_clip_timestamp_value(raw)
-
-
-def _clip_field_provided_in_post(raw) -> bool:
-    if raw is None:
-        return False
-    if isinstance(raw, str) and not raw.strip():
-        return False
-    return True
-
-
-def _extract_t_query_from_url(url: str) -> tuple[str, float | None]:
-    """If ``t=`` is present and parseable, return URL without ``t`` and start seconds."""
-    try:
-        parsed = urlparse(url)
-        params = parse_qs(parsed.query)
-    except Exception:
-        return url, None
-    t_values = params.get('t')
-    if not t_values:
-        return url, None
-    start = _parse_youtube_t_compact(t_values[0])
-    if start is None:
-        return url, None
-    filtered = {k: v for k, v in params.items() if k != 't'}
-    new_query = urlencode(filtered, doseq=True)
-    cleaned = urlunparse((
-        parsed.scheme,
-        parsed.netloc,
-        parsed.path,
-        parsed.params,
-        new_query,
-        parsed.fragment,
-    ))
-    return cleaned, float(start)
-
-
-def _parse_ytdl_options_presets(post: dict) -> list[str]:
-    """Normalize preset names from add/subscribe body; supports list or legacy singular string."""
-    raw = post.get('ytdl_options_presets')
-    if raw is None:
-        raw = post.get('ytdl_options_preset')
-    if raw is None:
-        return []
-    if isinstance(raw, list):
-        return [str(x).strip() for x in raw if str(x).strip()]
-    if isinstance(raw, str):
-        s = raw.strip()
-        return [s] if s else []
-    raise web.HTTPBadRequest(
-        reason='ytdl_options_presets must be a JSON array of strings (or legacy ytdl_options_preset string)',
-    )
-
-
-def _migrate_legacy_request(post: dict) -> dict:
-    """
-    BACKWARD COMPATIBILITY: Translate old API request schema into the new one.
-
-    Old API:
-      format (any/mp4/m4a/mp3/opus/wav/flac/thumbnail/captions)
-      quality
-      video_codec
-      subtitle_format (only when format=captions)
-
-    New API:
-      download_type (video/audio/captions/thumbnail)
-      codec
-      format
-      quality
-    """
-    if "download_type" in post:
-        return post
-
-    old_format = str(post.get("format") or "any").strip().lower()
-    old_quality = str(post.get("quality") or "best").strip().lower()
-    old_video_codec = str(post.get("video_codec") or "auto").strip().lower()
-
-    if old_format in VALID_AUDIO_FORMATS:
-        post["download_type"] = "audio"
-        post["codec"] = "auto"
-        post["format"] = old_format
-    elif old_format == "thumbnail":
-        post["download_type"] = "thumbnail"
-        post["codec"] = "auto"
-        post["format"] = "jpg"
-        post["quality"] = "best"
-    elif old_format == "captions":
-        post["download_type"] = "captions"
-        post["codec"] = "auto"
-        post["format"] = str(post.get("subtitle_format") or "srt").strip().lower()
-        post["quality"] = "best"
-    else:
-        # old_format is usually any/mp4 (legacy video path)
-        post["download_type"] = "video"
-        post["codec"] = old_video_codec
-        if old_quality == "best_ios":
-            post["format"] = "ios"
-            post["quality"] = "best"
-        elif old_quality == "audio":
-            # Legacy "audio only" under video format maps to m4a audio.
-            post["download_type"] = "audio"
-            post["codec"] = "auto"
-            post["format"] = "m4a"
-            post["quality"] = "best"
-        else:
-            post["format"] = old_format
-            post["quality"] = old_quality
-
-    return post
 
 class Notifier(DownloadQueueNotifier):
     async def added(self, dl):
@@ -466,35 +218,6 @@ class Notifier(DownloadQueueNotifier):
 
 dqueue = DownloadQueue(config, Notifier())
 app.on_startup.append(lambda app: dqueue.initialize())
-app.on_cleanup.append(lambda app: Download.shutdown_manager())
-
-
-class MetubeSubscriptionNotifier(SubscriptionNotifier):
-    async def subscription_added(self, sub: SubscriptionInfo):
-        log.info("Subscription added: %s", sub.name)
-        await sio.emit('subscription_added', serializer.encode(sub.to_public_dict()))
-
-    async def subscription_updated(self, sub: SubscriptionInfo):
-        await sio.emit('subscription_updated', serializer.encode(sub.to_public_dict()))
-
-    async def subscription_removed(self, sub_id: str):
-        log.info("Subscription removed: %s", sub_id)
-        await sio.emit('subscription_removed', serializer.encode(sub_id))
-
-    async def subscriptions_all(self, subs: list[SubscriptionInfo]):
-        await sio.emit('subscriptions_all', serializer.encode([s.to_public_dict() for s in subs]))
-
-
-submgr = SubscriptionManager(config, dqueue, MetubeSubscriptionNotifier())
-app.on_cleanup.append(lambda app: submgr.close())
-
-
-async def _subscription_loop_startup(app):
-    """aiohttp on_startup requires awaitable receivers; start_background_loop is sync."""
-    submgr.start_background_loop()
-
-
-app.on_startup.append(_subscription_loop_startup)
 
 class FileOpsFilter(DefaultFilter):
     def __call__(self, change_type: int, path: str) -> bool:
@@ -545,37 +268,26 @@ async def watch_files():
 if config.YTDL_OPTIONS_FILE:
     app.on_startup.append(lambda app: watch_files())
 
-
-async def _read_json_request(request: web.Request) -> dict:
-    try:
-        post = await request.json()
-    except json.JSONDecodeError as exc:
-        raise web.HTTPBadRequest(reason='Invalid JSON request body') from exc
-    if not isinstance(post, dict):
-        raise web.HTTPBadRequest(reason='JSON request body must be an object')
-    return post
-
-
-def parse_download_options(post: dict) -> dict:
-    """Validate add/subscribe body; raise HTTPBadRequest on invalid input."""
-    post = _migrate_legacy_request(dict(post))
+@routes.post(config.URL_PREFIX + 'add')
+async def add(request):
+    log.info("Received request to add download")
+    post = await request.json()
+    log.info(f"Request data: {post}")
     url = post.get('url')
-    download_type = post.get('download_type')
-    codec = post.get('codec')
-    format = post.get('format')
     quality = post.get('quality')
-    if not url or not quality or not download_type:
-        raise web.HTTPBadRequest(reason="missing 'url', 'download_type', or 'quality'")
-    url = str(url).strip()
+    if not url or not quality:
+        log.error("Bad request: missing 'url' or 'quality'")
+        raise web.HTTPBadRequest()
+    format = post.get('format')
     folder = post.get('folder')
     custom_name_prefix = post.get('custom_name_prefix')
     playlist_item_limit = post.get('playlist_item_limit')
     auto_start = post.get('auto_start')
     split_by_chapters = post.get('split_by_chapters')
     chapter_template = post.get('chapter_template')
+    subtitle_format = post.get('subtitle_format')
     subtitle_language = post.get('subtitle_language')
     subtitle_mode = post.get('subtitle_mode')
-    ytdl_options_overrides = post.get('ytdl_options_overrides')
 
     if custom_name_prefix is None:
         custom_name_prefix = ''
@@ -589,273 +301,50 @@ def parse_download_options(post: dict) -> dict:
         split_by_chapters = False
     if chapter_template is None:
         chapter_template = config.OUTPUT_TEMPLATE_CHAPTER
+    if subtitle_format is None:
+        subtitle_format = 'srt'
     if subtitle_language is None:
         subtitle_language = 'en'
     if subtitle_mode is None:
         subtitle_mode = 'prefer_manual'
-    download_type = str(download_type).strip().lower()
-    codec = str(codec or 'auto').strip().lower()
-    format = str(format or '').strip().lower()
-    quality = str(quality).strip().lower()
+    subtitle_format = str(subtitle_format).strip().lower()
     subtitle_language = str(subtitle_language).strip()
     subtitle_mode = str(subtitle_mode).strip()
-    ytdl_options_presets = _parse_ytdl_options_presets(post)
-    ytdl_options_overrides = _parse_ytdl_options_overrides(
-        ytdl_options_overrides,
-        enabled=config.ALLOW_YTDL_OPTIONS_OVERRIDES,
-    )
-
     if chapter_template and ('..' in chapter_template or chapter_template.startswith('/') or chapter_template.startswith('\\')):
         raise web.HTTPBadRequest(reason='chapter_template must not contain ".." or start with a path separator')
+    if subtitle_format not in VALID_SUBTITLE_FORMATS:
+        raise web.HTTPBadRequest(reason=f'subtitle_format must be one of {sorted(VALID_SUBTITLE_FORMATS)}')
     if not SUBTITLE_LANGUAGE_RE.fullmatch(subtitle_language):
         raise web.HTTPBadRequest(reason='subtitle_language must match pattern [A-Za-z0-9-] and be at most 35 characters')
     if subtitle_mode not in VALID_SUBTITLE_MODES:
         raise web.HTTPBadRequest(reason=f'subtitle_mode must be one of {sorted(VALID_SUBTITLE_MODES)}')
-    for preset_name in ytdl_options_presets:
-        if preset_name not in config.YTDL_OPTIONS_PRESETS:
-            raise web.HTTPBadRequest(reason='ytdl_options_presets must only contain configured preset names')
 
-    if download_type not in VALID_DOWNLOAD_TYPES:
-        raise web.HTTPBadRequest(reason=f'download_type must be one of {sorted(VALID_DOWNLOAD_TYPES)}')
-    if codec not in VALID_VIDEO_CODECS:
-        raise web.HTTPBadRequest(reason=f'codec must be one of {sorted(VALID_VIDEO_CODECS)}')
+    playlist_item_limit = int(playlist_item_limit)
 
-    if download_type == 'video':
-        if format not in VALID_VIDEO_FORMATS:
-            raise web.HTTPBadRequest(reason=f'format must be one of {sorted(VALID_VIDEO_FORMATS)} for video')
-        if quality not in {'best', 'worst', '2160', '1440', '1080', '720', '480', '360', '240'}:
-            raise web.HTTPBadRequest(reason="quality must be one of ['best', '2160', '1440', '1080', '720', '480', '360', '240', 'worst'] for video")
-    elif download_type == 'audio':
-        if format not in VALID_AUDIO_FORMATS:
-            raise web.HTTPBadRequest(reason=f'format must be one of {sorted(VALID_AUDIO_FORMATS)} for audio')
-        allowed_audio_qualities = {'best'}
-        if format == 'mp3':
-            allowed_audio_qualities |= {'320', '192', '128'}
-        elif format == 'm4a':
-            allowed_audio_qualities |= {'192', '128'}
-        if quality not in allowed_audio_qualities:
-            raise web.HTTPBadRequest(reason=f'quality must be one of {sorted(allowed_audio_qualities)} for format {format}')
-        codec = 'auto'
-    elif download_type == 'captions':
-        if format not in VALID_SUBTITLE_FORMATS:
-            raise web.HTTPBadRequest(reason=f'format must be one of {sorted(VALID_SUBTITLE_FORMATS)} for captions')
-        quality = 'best'
-        codec = 'auto'
-    elif download_type == 'thumbnail':
-        if format not in VALID_THUMBNAIL_FORMATS:
-            raise web.HTTPBadRequest(reason=f'format must be one of {sorted(VALID_THUMBNAIL_FORMATS)} for thumbnail')
-        quality = 'best'
-        codec = 'auto'
-
-    try:
-        playlist_item_limit = int(playlist_item_limit)
-    except (TypeError, ValueError) as exc:
-        raise web.HTTPBadRequest(reason='playlist_item_limit must be an integer') from exc
-
-    clip_start_raw = post.get('clip_start')
-    clip_end_raw = post.get('clip_end')
-    clip_start: float | None
-    clip_end: float | None
-    if download_type in ('captions', 'thumbnail'):
-        if _clip_field_provided_in_post(clip_start_raw) or _clip_field_provided_in_post(clip_end_raw):
-            raise web.HTTPBadRequest(
-                reason='clip_start and clip_end are only supported for video and audio downloads',
-            )
-        clip_start = None
-        clip_end = None
-    else:
-        cleaned_url, url_t = _extract_t_query_from_url(url)
-        if url_t is not None:
-            url = cleaned_url
-        explicit_start = _optional_clip_field(clip_start_raw)
-        explicit_end = _optional_clip_field(clip_end_raw)
-        explicit_start_provided = _clip_field_provided_in_post(clip_start_raw)
-        explicit_end_provided = _clip_field_provided_in_post(clip_end_raw)
-        if explicit_start_provided:
-            clip_start = explicit_start
-        elif explicit_end_provided:
-            clip_start = 0.0
-        elif url_t is not None:
-            clip_start = url_t
-        else:
-            clip_start = None
-        clip_end = explicit_end
-        if clip_end is not None and clip_start is None:
-            clip_start = 0.0
-        if clip_start is not None and clip_end is not None and clip_end <= clip_start:
-            raise web.HTTPBadRequest(reason='clip_end must be greater than clip_start')
-
-    return {
-        'url': url,
-        'download_type': download_type,
-        'codec': codec,
-        'format': format,
-        'quality': quality,
-        'folder': folder,
-        'custom_name_prefix': custom_name_prefix,
-        'playlist_item_limit': playlist_item_limit,
-        'auto_start': auto_start,
-        'split_by_chapters': split_by_chapters,
-        'chapter_template': chapter_template,
-        'subtitle_language': subtitle_language,
-        'subtitle_mode': subtitle_mode,
-        'ytdl_options_presets': ytdl_options_presets,
-        'ytdl_options_overrides': ytdl_options_overrides,
-        'clip_start': clip_start,
-        'clip_end': clip_end,
-    }
-
-
-@routes.post(config.URL_PREFIX + 'add')
-async def add(request):
-    log.info("Received request to add download")
-    post = await _read_json_request(request)
-    try:
-        o = parse_download_options(post)
-    except web.HTTPBadRequest as e:
-        log.error("Bad request: %s", e.reason)
-        raise
-    log.info(
-        "Add download request: type=%s quality=%s format=%s has_folder=%s auto_start=%s",
-        o['download_type'],
-        o['quality'],
-        o['format'],
-        bool(o.get('folder')),
-        o['auto_start'],
-    )
     status = await dqueue.add(
-        o['url'],
-        o['download_type'],
-        o['codec'],
-        o['format'],
-        o['quality'],
-        o['folder'],
-        o['custom_name_prefix'],
-        o['playlist_item_limit'],
-        o['auto_start'],
-        o['split_by_chapters'],
-        o['chapter_template'],
-        o['subtitle_language'],
-        o['subtitle_mode'],
-        o['ytdl_options_presets'],
-        o['ytdl_options_overrides'],
-        o['clip_start'],
-        o['clip_end'],
+        url,
+        quality,
+        format,
+        folder,
+        custom_name_prefix,
+        playlist_item_limit,
+        auto_start,
+        split_by_chapters,
+        chapter_template,
+        subtitle_format,
+        subtitle_language,
+        subtitle_mode,
     )
     return web.Response(text=serializer.encode(status))
 
-
-@routes.get(config.URL_PREFIX + 'presets')
-async def presets(request):
-    return web.Response(
-        text=serializer.encode({'presets': sorted(config.YTDL_OPTIONS_PRESETS.keys())}),
-        content_type='application/json',
-    )
-
 @routes.post(config.URL_PREFIX + 'cancel-add')
 async def cancel_add(request):
     dqueue.cancel_add()
     return web.Response(text=serializer.encode({'status': 'ok'}), content_type='application/json')
 
-
-@routes.post(config.URL_PREFIX + 'subscribe')
-async def subscribe(request):
-    post = await _read_json_request(request)
-    try:
-        o = parse_download_options(post)
-    except web.HTTPBadRequest:
-        raise
-    cic = post.get('check_interval_minutes')
-    if cic is None:
-        cic = config.SUBSCRIPTION_DEFAULT_CHECK_INTERVAL
-    try:
-        cic = int(cic)
-    except (TypeError, ValueError) as exc:
-        raise web.HTTPBadRequest(reason='check_interval_minutes must be an integer') from exc
-    if cic < 1:
-        raise web.HTTPBadRequest(reason='check_interval_minutes must be at least 1')
-    if o.get('clip_start') is not None or o.get('clip_end') is not None:
-        raise web.HTTPBadRequest(reason='clip options are not supported for subscriptions')
-
-    try:
-        skip_subscriber_only = coerce_optional_bool(
-            post.get('skip_subscriber_only'),
-            default=False,
-            field_name='skip_subscriber_only',
-        )
-    except ValueError as exc:
-        raise web.HTTPBadRequest(reason=str(exc)) from exc
-
-    result = await submgr.add_subscription(
-        o['url'],
-        check_interval_minutes=cic,
-        download_type=o['download_type'],
-        codec=o['codec'],
-        format=o['format'],
-        quality=o['quality'],
-        folder=o['folder'] or '',
-        custom_name_prefix=o['custom_name_prefix'],
-        auto_start=o['auto_start'],
-        playlist_item_limit=o['playlist_item_limit'],
-        split_by_chapters=o['split_by_chapters'],
-        chapter_template=o['chapter_template'],
-        subtitle_language=o['subtitle_language'],
-        subtitle_mode=o['subtitle_mode'],
-        ytdl_options_presets=o['ytdl_options_presets'],
-        ytdl_options_overrides=o['ytdl_options_overrides'],
-        title_regex=post.get('title_regex'),
-        skip_subscriber_only=skip_subscriber_only,
-    )
-    return web.Response(text=serializer.encode(result))
-
-
-@routes.get(config.URL_PREFIX + 'subscriptions')
-async def subscriptions_list(request):
-    return web.Response(text=serializer.encode([s.to_public_dict() for s in submgr.list_all()]))
-
-
-@routes.post(config.URL_PREFIX + 'subscriptions/update')
-async def subscriptions_update(request):
-    post = await _read_json_request(request)
-    sub_id = post.get('id')
-    if not sub_id:
-        raise web.HTTPBadRequest(reason='missing subscription id')
-    changes = {
-        k: v
-        for k, v in post.items()
-        if k != 'id'
-        and k in ('enabled', 'check_interval_minutes', 'name', 'title_regex', 'skip_subscriber_only')
-    }
-    if not changes:
-        raise web.HTTPBadRequest(reason='no valid fields to update')
-    log.info("Subscription update requested for %s: %s", sub_id, sorted(changes.keys()))
-    result = await submgr.update_subscription(str(sub_id), changes)
-    return web.Response(text=serializer.encode(result))
-
-
-@routes.post(config.URL_PREFIX + 'subscriptions/delete')
-async def subscriptions_delete(request):
-    post = await _read_json_request(request)
-    ids = post.get('ids')
-    if not ids or not isinstance(ids, list):
-        raise web.HTTPBadRequest(reason='missing ids list')
-    result = await submgr.delete_subscriptions([str(i) for i in ids])
-    return web.Response(text=serializer.encode(result))
-
-
-@routes.post(config.URL_PREFIX + 'subscriptions/check')
-async def subscriptions_check(request):
-    post = await _read_json_request(request)
-    ids = post.get('ids')
-    if ids is not None and not isinstance(ids, list):
-        raise web.HTTPBadRequest(reason='ids must be a list')
-    log.info("Subscription check-now requested for ids=%s", ids if ids else "all-enabled")
-    result = await submgr.check_now([str(i) for i in ids] if ids else None)
-    return web.Response(text=serializer.encode(result))
-
 @routes.post(config.URL_PREFIX + 'delete')
 async def delete(request):
-    post = await _read_json_request(request)
+    post = await request.json()
     ids = post.get('ids')
     where = post.get('where')
     if not ids or where not in ['queue', 'done']:
@@ -867,7 +356,7 @@ async def delete(request):
 
 @routes.post(config.URL_PREFIX + 'start')
 async def start(request):
-    post = await _read_json_request(request)
+    post = await request.json()
     ids = post.get('ids')
     log.info(f"Received request to start pending downloads for ids: {ids}")
     status = await dqueue.start_pending(ids)
@@ -882,23 +371,17 @@ async def upload_cookies(request):
     field = await reader.next()
     if field is None or field.name != 'cookies':
         return web.Response(status=400, text=serializer.encode({'status': 'error', 'msg': 'No cookies file provided'}))
-
-    max_size = 1_000_000  # 1MB limit
     size = 0
-    content = bytearray()
-    while True:
-        chunk = await field.read_chunk()
-        if not chunk:
-            break
-        size += len(chunk)
-        if size > max_size:
-            return web.Response(status=400, text=serializer.encode({'status': 'error', 'msg': 'Cookie file too large (max 1MB)'}))
-        content.extend(chunk)
-
-    tmp_cookie_path = f"{COOKIES_PATH}.tmp"
-    with open(tmp_cookie_path, 'wb') as f:
-        f.write(content)
-    os.replace(tmp_cookie_path, COOKIES_PATH)
+    with open(COOKIES_PATH, 'wb') as f:
+        while True:
+            chunk = await field.read_chunk()
+            if not chunk:
+                break
+            size += len(chunk)
+            if size > 1_000_000:  # 1MB limit
+                os.remove(COOKIES_PATH)
+                return web.Response(status=400, text=serializer.encode({'status': 'error', 'msg': 'Cookie file too large (max 1MB)'}))
+            f.write(chunk)
     config.set_runtime_override('cookiefile', COOKIES_PATH)
     log.info(f'Cookies file uploaded ({size} bytes)')
     return web.Response(text=serializer.encode({'status': 'ok', 'msg': f'Cookies uploaded ({size} bytes)'}))
@@ -956,7 +439,6 @@ async def history(request):
 async def connect(sid, environ):
     log.info(f"Client connected: {sid}")
     await sio.emit('all', serializer.encode(dqueue.get()), to=sid)
-    await sio.emit('subscriptions_all', serializer.encode([s.to_public_dict() for s in submgr.list_all()]), to=sid)
     await sio.emit('configuration', serializer.encode(config.frontend_safe()), to=sid)
     if config.CUSTOM_DIRS:
         await sio.emit('custom_dirs', serializer.encode(get_custom_dirs()), to=sid)
@@ -964,22 +446,6 @@ async def connect(sid, environ):
         await sio.emit('ytdl_options_changed', serializer.encode(get_options_update_time()), to=sid)
 
 def get_custom_dirs():
-    cache_ttl_seconds = 5
-    now = asyncio.get_running_loop().time()
-    cache_key = (
-        config.DOWNLOAD_DIR,
-        config.AUDIO_DOWNLOAD_DIR,
-        config.CUSTOM_DIRS_EXCLUDE_REGEX,
-    )
-    if (
-        hasattr(get_custom_dirs, "_cache_key")
-        and hasattr(get_custom_dirs, "_cache_value")
-        and hasattr(get_custom_dirs, "_cache_time")
-        and get_custom_dirs._cache_key == cache_key
-        and (now - get_custom_dirs._cache_time) < cache_ttl_seconds
-    ):
-        return get_custom_dirs._cache_value
-
     def recursive_dirs(base):
         path = pathlib.Path(base)
 
@@ -1016,24 +482,20 @@ def get_custom_dirs():
     if config.DOWNLOAD_DIR != config.AUDIO_DOWNLOAD_DIR:
         audio_download_dir = recursive_dirs(config.AUDIO_DOWNLOAD_DIR)
 
-    result = {
+    return {
         "download_dir": download_dir,
         "audio_download_dir": audio_download_dir
     }
-    get_custom_dirs._cache_key = cache_key
-    get_custom_dirs._cache_time = now
-    get_custom_dirs._cache_value = result
-    return result
 
 @routes.get(config.URL_PREFIX)
-async def index(request):
+def index(request):
     response = web.FileResponse(os.path.join(config.BASE_DIR, 'ui/dist/metube/browser/index.html'))
     if 'metube_theme' not in request.cookies:
         response.set_cookie('metube_theme', config.DEFAULT_THEME)
     return response
 
 @routes.get(config.URL_PREFIX + 'robots.txt')
-async def robots(request):
+def robots(request):
     if config.ROBOTS_TXT:
         response = web.FileResponse(os.path.join(config.BASE_DIR, config.ROBOTS_TXT))
     else:
@@ -1043,7 +505,7 @@ async def robots(request):
     return response
 
 @routes.get(config.URL_PREFIX + 'version')
-async def version(request):
+def version(request):
     return web.json_response({
         "yt-dlp": yt_dlp_version,
         "version": os.getenv("METUBE_VERSION", "dev")
@@ -1051,11 +513,11 @@ async def version(request):
 
 if config.URL_PREFIX != '/':
     @routes.get('/')
-    async def index_redirect_root(request):
+    def index_redirect_root(request):
         return web.HTTPFound(config.URL_PREFIX)
 
     @routes.get(config.URL_PREFIX[:-1])
-    async def index_redirect_dir(request):
+    def index_redirect_dir(request):
         return web.HTTPFound(config.URL_PREFIX)
 
 routes.static(config.URL_PREFIX + 'download/', config.DOWNLOAD_DIR, show_index=config.DOWNLOAD_DIRS_INDEXABLE)
@@ -1075,18 +537,12 @@ async def add_cors(request):
 
 app.router.add_route('OPTIONS', config.URL_PREFIX + 'add', add_cors)
 app.router.add_route('OPTIONS', config.URL_PREFIX + 'cancel-add', add_cors)
-app.router.add_route('OPTIONS', config.URL_PREFIX + 'subscribe', add_cors)
-app.router.add_route('OPTIONS', config.URL_PREFIX + 'subscriptions', add_cors)
-app.router.add_route('OPTIONS', config.URL_PREFIX + 'subscriptions/update', add_cors)
-app.router.add_route('OPTIONS', config.URL_PREFIX + 'subscriptions/delete', add_cors)
-app.router.add_route('OPTIONS', config.URL_PREFIX + 'subscriptions/check', add_cors)
 app.router.add_route('OPTIONS', config.URL_PREFIX + 'upload-cookies', add_cors)
 app.router.add_route('OPTIONS', config.URL_PREFIX + 'delete-cookies', add_cors)
 
 async def on_prepare(request, response):
-    origin = request.headers.get('Origin')
-    if origin and _cors_origins and ('*' in _cors_origins or origin in _cors_origins):
-        response.headers['Access-Control-Allow-Origin'] = origin
+    if 'Origin' in request.headers:
+        response.headers['Access-Control-Allow-Origin'] = request.headers['Origin']
         response.headers['Access-Control-Allow-Headers'] = 'Content-Type'
 
 app.on_response_prepare.append(on_prepare)

app/state_store.py

@@ -1,156 +0,0 @@
-from __future__ import annotations
-
-import base64
-import collections.abc
-import json
-import logging
-import os
-import shelve
-import tempfile
-import time
-from datetime import datetime
-from typing import Any, Optional
-
-log = logging.getLogger("state_store")
-
-STATE_SCHEMA_VERSION = 2
-_BYTES_MARKER = "__metube_bytes__"
-_DATETIME_MARKER = "__metube_datetime__"
-
-
-def to_json_compatible(value: Any) -> Any:
-    if value is None or isinstance(value, (bool, int, float, str)):
-        return value
-    if isinstance(value, bytes):
-        return {_BYTES_MARKER: base64.b64encode(value).decode("ascii")}
-    if isinstance(value, datetime):
-        return {_DATETIME_MARKER: value.isoformat()}
-    if isinstance(value, collections.abc.Mapping):
-        return {str(k): to_json_compatible(v) for k, v in value.items()}
-    if isinstance(value, (list, tuple, set, frozenset)):
-        return [to_json_compatible(v) for v in value]
-    if isinstance(value, collections.abc.Iterable):
-        return [to_json_compatible(v) for v in value]
-    raise TypeError(f"Value of type {type(value).__name__} is not JSON serializable")
-
-
-def from_json_compatible(value: Any) -> Any:
-    if isinstance(value, list):
-        return [from_json_compatible(v) for v in value]
-    if isinstance(value, dict):
-        if set(value.keys()) == {_BYTES_MARKER}:
-            return base64.b64decode(value[_BYTES_MARKER].encode("ascii"))
-        if set(value.keys()) == {_DATETIME_MARKER}:
-            return datetime.fromisoformat(value[_DATETIME_MARKER])
-        return {k: from_json_compatible(v) for k, v in value.items()}
-    return value
-
-
-def read_legacy_shelf(path: str) -> Optional[list[tuple[Any, Any]]]:
-    if not os.path.exists(path):
-        return None
-    try:
-        with shelve.open(path, "r") as shelf:
-            return list(shelf.items())
-    except Exception as exc:
-        log.warning("Could not read legacy shelf at %s: %s", path, exc)
-        return None
-
-
-class AtomicJsonStore:
-    def __init__(self, path: str, *, kind: str, schema_version: int = STATE_SCHEMA_VERSION):
-        self.path = path
-        self.kind = kind
-        self.schema_version = schema_version
-
-    def _ensure_parent(self) -> None:
-        parent = os.path.dirname(self.path)
-        if parent and not os.path.isdir(parent):
-            os.makedirs(parent, exist_ok=True)
-
-    def _build_payload(self, data: dict[str, Any]) -> dict[str, Any]:
-        payload = {
-            "schema_version": self.schema_version,
-            "kind": self.kind,
-        }
-        payload.update(data)
-        return payload
-
-    def load(self) -> Optional[dict[str, Any]]:
-        if not os.path.exists(self.path):
-            return None
-        try:
-            with open(self.path, encoding="utf-8") as f:
-                payload = json.load(f)
-            if not isinstance(payload, dict):
-                raise ValueError("State file must contain a JSON object")
-            if payload.get("kind") != self.kind:
-                raise ValueError(
-                    f"State file kind mismatch: expected {self.kind}, got {payload.get('kind')}"
-                )
-            return payload
-        except Exception as exc:
-            self.quarantine_invalid_file(exc)
-            return None
-
-    def save(self, data: dict[str, Any]) -> None:
-        self._ensure_parent()
-        payload = self._build_payload(data)
-        parent = os.path.dirname(self.path) or "."
-        fd, tmp_path = tempfile.mkstemp(
-            prefix=f".{os.path.basename(self.path)}.",
-            suffix=".tmp",
-            dir=parent,
-            text=True,
-        )
-        try:
-            with os.fdopen(fd, "w", encoding="utf-8") as f:
-                json.dump(payload, f, ensure_ascii=False, separators=(",", ":"))
-                f.write("\n")
-                f.flush()
-                os.fsync(f.fileno())
-            os.replace(tmp_path, self.path)
-            self._fsync_directory(parent)
-        except Exception:
-            try:
-                os.remove(tmp_path)
-            except OSError:
-                pass
-            raise
-
-    def quarantine_invalid_file(self, exc: Exception) -> None:
-        if not os.path.exists(self.path):
-            return
-        ts = time.strftime("%Y%m%d%H%M%S")
-        backup_path = f"{self.path}.invalid.{ts}"
-        try:
-            os.replace(self.path, backup_path)
-            log.warning(
-                "State file at %s was invalid (%s); moved it to %s",
-                self.path,
-                exc,
-                backup_path,
-            )
-        except OSError as move_exc:
-            log.warning(
-                "State file at %s was invalid (%s) and could not be moved aside: %s",
-                self.path,
-                exc,
-                move_exc,
-            )
-
-    @staticmethod
-    def _fsync_directory(path: str) -> None:
-        try:
-            flags = os.O_RDONLY
-            if hasattr(os, "O_DIRECTORY"):
-                flags |= os.O_DIRECTORY
-            fd = os.open(path, flags)
-        except OSError:
-            return
-        try:
-            os.fsync(fd)
-        except OSError:
-            pass
-        finally:
-            os.close(fd)

app/subscriptions.py

@@ -1,838 +0,0 @@
-"""Channel/playlist subscriptions: periodic yt-dlp flat extract + queue new videos."""
-
-from __future__ import annotations
-
-import asyncio
-import copy
-import logging
-import os
-import re
-import time
-import types
-import uuid
-from dataclasses import dataclass, field, fields
-from typing import Any, Optional
-
-import yt_dlp
-import yt_dlp.networking.impersonate
-from state_store import AtomicJsonStore, read_legacy_shelf
-
-log = logging.getLogger("subscriptions")
-
-VIDEO_ONLY_MSG = (
-    "This URL points to a single video, not a channel or playlist. Use Download instead."
-)
-_MEDIA_HINT_FIELDS = (
-    "duration",
-    "timestamp",
-    "release_timestamp",
-    "upload_date",
-    "view_count",
-    "live_status",
-    "availability",
-)
-
-
-def _impersonate_opt(ytdl_options: dict) -> dict:
-    opts = dict(ytdl_options)
-    if "impersonate" in opts:
-        opts["impersonate"] = yt_dlp.networking.impersonate.ImpersonateTarget.from_str(
-            opts["impersonate"]
-        )
-    return opts
-
-
-def _build_ydl_params(config, *, playlistend: Optional[int] = None) -> dict:
-    params: dict[str, Any] = {
-        "quiet": not logging.getLogger().isEnabledFor(logging.DEBUG),
-        "verbose": logging.getLogger().isEnabledFor(logging.DEBUG),
-        "no_color": True,
-        "extract_flat": True,
-        "ignore_no_formats_error": True,
-        "lazy_playlist": True,
-        "paths": {"home": config.DOWNLOAD_DIR, "temp": config.TEMP_DIR},
-        **config.YTDL_OPTIONS,
-    }
-    params = _impersonate_opt(params)
-    if playlistend is not None and playlistend > 0:
-        params["playlistend"] = playlistend
-    return params
-
-
-def _is_media_entry(entry: Any) -> bool:
-    if not isinstance(entry, dict):
-        return False
-    etype = str(entry.get("_type") or "")
-    if etype in ("playlist", "multi_video", "channel"):
-        return False
-    if entry.get("entries"):
-        return False
-    url = _entry_video_url(entry)
-    if not url:
-        return False
-    ie_key = str(entry.get("ie_key") or entry.get("extractor_key") or "").lower()
-    if any(token in ie_key for token in ("playlist", "channel", "tab")):
-        return any(entry.get(field) is not None for field in _MEDIA_HINT_FIELDS)
-    return True
-
-
-def extract_flat_playlist(config, url: str, playlistend: int, *, _depth: int = 0):
-    """Return (info_dict, entries_list) for playlist/channel URLs."""
-    params = _build_ydl_params(config, playlistend=playlistend)
-    with yt_dlp.YoutubeDL(params=params) as ydl:
-        info = ydl.extract_info(url, download=False)
-    if not info:
-        return None, []
-    etype = info.get("_type") or "video"
-    if etype == "video":
-        return info, []
-    if etype in ("playlist", "channel"):
-        entries = info.get("entries") or []
-        if isinstance(entries, types.GeneratorType):
-            entries = list(entries)
-        # Drop None placeholders from incomplete flat playlists
-        entries = [e for e in entries if e]
-        media_entries = [e for e in entries if _is_media_entry(e)]
-        if media_entries:
-            return info, media_entries
-        if _depth < 1:
-            for ent in entries[:5]:
-                nested_url = _entry_video_url(ent)
-                if not nested_url:
-                    continue
-                nested_info, nested_entries = extract_flat_playlist(
-                    config,
-                    nested_url,
-                    playlistend,
-                    _depth=_depth + 1,
-                )
-                if nested_entries:
-                    return nested_info, nested_entries
-        return info, entries
-    if etype.startswith("url") and info.get("url"):
-        # Single nested URL without playlist wrapper — treat as non-subscribable
-        return info, []
-    return info, []
-
-
-def _entry_video_url(entry: dict) -> Optional[str]:
-    return entry.get("webpage_url") or entry.get("url")
-
-
-def _entry_id(entry: dict) -> Optional[str]:
-    eid = entry.get("id")
-    if eid is not None:
-        return str(eid)
-    url = _entry_video_url(entry)
-    return url
-
-
-def _is_subscriber_only_entry(entry: dict) -> bool:
-    """True when yt-dlp marks the entry as channel member-only (subscriber_only availability)."""
-    return str(entry.get("availability") or "") == "subscriber_only"
-
-
-def coerce_optional_bool(value: Any, *, default: bool = False, field_name: str = "value") -> bool:
-    """Parse optional JSON booleans for subscription settings."""
-    if value is None:
-        return default
-    try:
-        return _coerce_bool(value)
-    except ValueError as exc:
-        raise ValueError(f"{field_name} must be a boolean") from exc
-
-
-@dataclass
-class SubscriptionInfo:
-    id: str
-    name: str
-    url: str
-    enabled: bool = True
-    check_interval_minutes: int = 60
-    download_type: str = "video"
-    codec: str = "auto"
-    format: str = "any"
-    quality: str = "best"
-    folder: str = ""
-    custom_name_prefix: str = ""
-    auto_start: bool = True
-    playlist_item_limit: int = 0
-    split_by_chapters: bool = False
-    chapter_template: str = ""
-    subtitle_language: str = "en"
-    subtitle_mode: str = "prefer_manual"
-    ytdl_options_presets: list[str] = field(default_factory=list)
-    ytdl_options_overrides: dict[str, Any] = field(default_factory=dict)
-    title_regex: str = ""
-    skip_subscriber_only: bool = False
-    last_checked: Optional[float] = None
-    seen_ids: list[str] = field(default_factory=list)
-    error: Optional[str] = None
-    timestamp: float = field(default_factory=time.time)
-
-    def seen_set(self) -> set[str]:
-        return set(self.seen_ids)
-
-    def to_public_dict(self) -> dict:
-        return {
-            "id": self.id,
-            "name": self.name,
-            "url": self.url,
-            "enabled": self.enabled,
-            "check_interval_minutes": self.check_interval_minutes,
-            "download_type": self.download_type,
-            "codec": self.codec,
-            "format": self.format,
-            "quality": self.quality,
-            "folder": self.folder,
-            "title_regex": self.title_regex,
-            "skip_subscriber_only": self.skip_subscriber_only,
-            "last_checked": self.last_checked,
-            "seen_count": len(self.seen_ids),
-            "error": self.error,
-        }
-
-
-def _subscription_to_record(sub: SubscriptionInfo) -> dict[str, Any]:
-    return {
-        "id": sub.id,
-        "name": sub.name,
-        "url": sub.url,
-        "enabled": sub.enabled,
-        "check_interval_minutes": sub.check_interval_minutes,
-        "download_type": sub.download_type,
-        "codec": sub.codec,
-        "format": sub.format,
-        "quality": sub.quality,
-        "folder": sub.folder,
-        "custom_name_prefix": sub.custom_name_prefix,
-        "auto_start": sub.auto_start,
-        "playlist_item_limit": sub.playlist_item_limit,
-        "split_by_chapters": sub.split_by_chapters,
-        "chapter_template": sub.chapter_template,
-        "subtitle_language": sub.subtitle_language,
-        "subtitle_mode": sub.subtitle_mode,
-        "ytdl_options_presets": list(sub.ytdl_options_presets),
-        "ytdl_options_overrides": sub.ytdl_options_overrides,
-        "title_regex": sub.title_regex,
-        "skip_subscriber_only": sub.skip_subscriber_only,
-        "last_checked": sub.last_checked,
-        "seen_ids": list(sub.seen_ids),
-        "error": sub.error,
-    }
-
-
-def _normalize_subscription_record(rec: dict[str, Any]) -> dict[str, Any]:
-    """Migrate legacy ytdl_options_preset (str) to ytdl_options_presets (list)."""
-    out = dict(rec)
-    if "ytdl_options_presets" not in out:
-        old = out.pop("ytdl_options_preset", None)
-        if old is None:
-            out["ytdl_options_presets"] = []
-        elif isinstance(old, list):
-            out["ytdl_options_presets"] = [str(x).strip() for x in old if str(x).strip()]
-        elif isinstance(old, str):
-            out["ytdl_options_presets"] = [old.strip()] if old.strip() else []
-        else:
-            out["ytdl_options_presets"] = []
-    else:
-        out.pop("ytdl_options_preset", None)
-    return out
-
-
-def _subscription_from_record(record: Any) -> Optional[SubscriptionInfo]:
-    field_names = {f.name for f in fields(SubscriptionInfo)}
-    if isinstance(record, SubscriptionInfo):
-        return record
-    if isinstance(record, dict):
-        try:
-            normalized = _normalize_subscription_record(dict(record))
-            return SubscriptionInfo(**{k: v for k, v in normalized.items() if k in field_names})
-        except TypeError:
-            return None
-    return None
-
-
-def _normalize_title_regex_value(value: Any) -> str:
-    if value is None:
-        return ""
-    if isinstance(value, str):
-        return value.strip()
-    return str(value).strip()
-
-
-def validate_title_regex(value: Any) -> str:
-    """Return stored title regex string; non-empty values must compile (re.error on failure)."""
-    s = _normalize_title_regex_value(value)
-    if s:
-        re.compile(s)
-    return s
-
-
-def _coerce_bool(value: Any) -> bool:
-    """Accept JSON booleans and common string forms used by API clients."""
-    if isinstance(value, bool):
-        return value
-    if isinstance(value, str):
-        lowered = value.strip().lower()
-        if lowered in {"true", "1", "on"}:
-            return True
-        if lowered in {"false", "0", "off"}:
-            return False
-    raise ValueError("enabled must be a boolean")
-
-
-class SubscriptionNotifier:
-    """Hook for Socket.IO / UI updates."""
-
-    async def subscription_added(self, sub: SubscriptionInfo) -> None:
-        raise NotImplementedError
-
-    async def subscription_updated(self, sub: SubscriptionInfo) -> None:
-        raise NotImplementedError
-
-    async def subscription_removed(self, sub_id: str) -> None:
-        raise NotImplementedError
-
-    async def subscriptions_all(self, subs: list[SubscriptionInfo]) -> None:
-        raise NotImplementedError
-
-
-class SubscriptionManager:
-    def __init__(self, config, download_queue, notifier: SubscriptionNotifier):
-        self.config = config
-        self.dqueue = download_queue
-        self.notifier = notifier
-        pdir = config.STATE_DIR
-        if not os.path.isdir(pdir):
-            os.makedirs(pdir, exist_ok=True)
-        self._legacy_path = os.path.join(pdir, "subscriptions")
-        self._path = os.path.join(pdir, "subscriptions.json")
-        self._store = AtomicJsonStore(self._path, kind="subscriptions")
-        self._subs: dict[str, SubscriptionInfo] = {}
-        self._url_index: dict[str, str] = {}  # normalized url -> id
-        self._pending_urls: set[str] = set()
-        self._lock = asyncio.Lock()
-        self._loop_task: Optional[asyncio.Task] = None
-        self._load_all()
-
-    def close(self) -> None:
-        # No persistent shelf handle to close.
-        return
-
-    def _normalize_url(self, url: str) -> str:
-        return (url or "").strip()
-
-    def _normalize_seen_ids(self, seen_ids: list[str]) -> list[str]:
-        max_seen = int(getattr(self.config, "SUBSCRIPTION_MAX_SEEN_IDS", 50000))
-        normalized = [str(sid) for sid in dict.fromkeys(seen_ids)]
-        if len(normalized) > max_seen:
-            normalized = normalized[:max_seen]
-        return normalized
-
-    def _load_all(self) -> None:
-        payload = self._store.load()
-        loaded_from_legacy = False
-        if payload is not None:
-            records = payload.get("items") or []
-        else:
-            legacy_items = read_legacy_shelf(self._legacy_path)
-            records = [raw for _key, raw in legacy_items] if legacy_items else []
-            if records:
-                loaded_from_legacy = True
-
-        loaded_subs = self._iter_valid_subs(records)
-        compact_records = []
-        for sub in loaded_subs:
-            sub.seen_ids = self._normalize_seen_ids(sub.seen_ids)
-            self._subs[sub.id] = sub
-            self._url_index[self._normalize_url(sub.url)] = sub.id
-            compact_records.append(_subscription_to_record(sub))
-
-        if loaded_from_legacy or (
-            payload is not None
-            and (
-                payload.get("schema_version") != self._store.schema_version
-                or compact_records != records
-            )
-        ):
-            self._store.save({"items": compact_records})
-
-    def _iter_valid_subs(self, records: list[Any]) -> list[SubscriptionInfo]:
-        subs: list[SubscriptionInfo] = []
-        for record in records:
-            sub = _subscription_from_record(record)
-            if sub is not None:
-                subs.append(sub)
-        return subs
-
-    def _save_locked(self) -> None:
-        self._store.save({"items": [_subscription_to_record(sub) for sub in self._subs.values()]})
-
-    async def _queue_subscription_entries(
-        self,
-        entries: list[dict],
-        *,
-        download_type: str,
-        codec: str,
-        format: str,
-        quality: str,
-        folder: str,
-        custom_name_prefix: str,
-        playlist_item_limit: int,
-        auto_start: bool,
-        split_by_chapters: bool,
-        chapter_template: str,
-        subtitle_language: str,
-        subtitle_mode: str,
-        ytdl_options_presets: Optional[list[str]] = None,
-        ytdl_options_overrides: Optional[dict[str, Any]] = None,
-    ) -> tuple[list[str], list[str]]:
-        queued_ids: list[str] = []
-        queue_errors: list[str] = []
-        presets = list(ytdl_options_presets or [])
-        for ent in entries:
-            eid = _entry_id(ent)
-            vurl = _entry_video_url(ent)
-            if not eid or not vurl:
-                continue
-            queue_entry = dict(ent)
-            if "id" not in queue_entry:
-                queue_entry["id"] = eid
-            queue_entry["_type"] = "video"
-            queue_entry["webpage_url"] = vurl
-            result = await self.dqueue.add_entry(
-                queue_entry,
-                download_type,
-                codec,
-                format,
-                quality,
-                folder or None,
-                custom_name_prefix,
-                playlist_item_limit,
-                auto_start,
-                split_by_chapters,
-                chapter_template or None,
-                subtitle_language,
-                subtitle_mode,
-                presets,
-                ytdl_options_overrides,
-            )
-            if isinstance(result, dict) and result.get("status") == "error":
-                msg = str(result.get("msg") or f"Queueing failed for {vurl}")
-                queue_errors.append(msg)
-                log.warning("Subscription queueing failed for %s: %s", vurl, msg)
-                continue
-            queued_ids.append(eid)
-        return queued_ids, queue_errors
-
-    def list_all(self) -> list[SubscriptionInfo]:
-        return list(self._subs.values())
-
-    def get(self, sub_id: str) -> Optional[SubscriptionInfo]:
-        return self._subs.get(sub_id)
-
-    def start_background_loop(self) -> None:
-        if self._loop_task is not None and not self._loop_task.done():
-            return
-        self._loop_task = asyncio.create_task(self._periodic_loop())
-        self._loop_task.add_done_callback(
-            lambda t: log.error("Subscription loop failed: %s", t.exception())
-            if not t.cancelled() and t.exception()
-            else None
-        )
-
-    async def _periodic_loop(self) -> None:
-        while True:
-            await asyncio.sleep(60)
-            try:
-                await self.run_due_checks()
-            except Exception as e:
-                log.exception("Subscription periodic check error: %s", e)
-
-    async def run_due_checks(self) -> None:
-        now = time.time()
-        due: list[SubscriptionInfo] = []
-        async with self._lock:
-            for sub in list(self._subs.values()):
-                if not sub.enabled:
-                    continue
-                interval_sec = max(60, int(sub.check_interval_minutes) * 60)
-                if sub.last_checked is None:
-                    due.append(sub)
-                    continue
-                if now - sub.last_checked < interval_sec:
-                    continue
-                due.append(sub)
-        for sub in due:
-            await self._check_one_unlocked(sub)
-
-    async def add_subscription(
-        self,
-        url: str,
-        *,
-        check_interval_minutes: int,
-        download_type: str,
-        codec: str,
-        format: str,
-        quality: str,
-        folder: str,
-        custom_name_prefix: str,
-        auto_start: bool,
-        playlist_item_limit: int,
-        split_by_chapters: bool,
-        chapter_template: str,
-        subtitle_language: str,
-        subtitle_mode: str,
-        ytdl_options_presets: Optional[list[str]] = None,
-        ytdl_options_overrides: Optional[dict[str, Any]] = None,
-        title_regex: Any = None,
-        skip_subscriber_only: Any = None,
-    ) -> dict:
-        url = self._normalize_url(url)
-        if not url:
-            return {"status": "error", "msg": "Missing URL"}
-        try:
-            title_regex_stored = validate_title_regex(title_regex)
-        except re.error as exc:
-            return {"status": "error", "msg": f"Invalid title_regex: {exc}"}
-        try:
-            skip_so = coerce_optional_bool(
-                skip_subscriber_only,
-                default=False,
-                field_name="skip_subscriber_only",
-            )
-        except ValueError as exc:
-            return {"status": "error", "msg": str(exc)}
-
-        async with self._lock:
-            if url in self._url_index or url in self._pending_urls:
-                return {"status": "error", "msg": "This URL is already subscribed"}
-            self._pending_urls.add(url)
-
-        try:
-            scan_first = max(int(getattr(self.config, "SUBSCRIPTION_SCAN_PLAYLIST_END", 50)), 1)
-            try:
-                info, entries = extract_flat_playlist(self.config, url, scan_first)
-            except yt_dlp.utils.YoutubeDLError as exc:
-                return {"status": "error", "msg": str(exc)}
-
-            if not info:
-                return {"status": "error", "msg": "Could not resolve URL"}
-
-            etype = info.get("_type") or "video"
-            if etype not in ("playlist", "channel"):
-                return {"status": "error", "msg": VIDEO_ONLY_MSG}
-
-            name = (
-                info.get("title")
-                or info.get("channel")
-                or info.get("playlist_title")
-                or info.get("uploader")
-                or url
-            )
-
-            seen_entries = [ent for ent in entries if _is_media_entry(ent)]
-            all_ids: list[str] = []
-            for ent in seen_entries:
-                if ent.get("live_status") == "is_upcoming":
-                    continue  # Don't mark scheduled streams as seen; queue them when they go live
-                eid = _entry_id(ent)
-                if eid:
-                    all_ids.append(eid)
-
-            sub = SubscriptionInfo(
-                id=str(uuid.uuid4()),
-                name=str(name),
-                url=url,
-                enabled=True,
-                check_interval_minutes=max(1, int(check_interval_minutes)),
-                download_type=download_type,
-                codec=codec,
-                format=format,
-                quality=quality,
-                folder=folder or "",
-                custom_name_prefix=custom_name_prefix or "",
-                auto_start=bool(auto_start),
-                playlist_item_limit=int(playlist_item_limit),
-                split_by_chapters=bool(split_by_chapters),
-                chapter_template=chapter_template or "",
-                subtitle_language=subtitle_language,
-                subtitle_mode=subtitle_mode,
-                ytdl_options_presets=list(ytdl_options_presets or []),
-                ytdl_options_overrides=dict(ytdl_options_overrides or {}),
-                title_regex=title_regex_stored,
-                skip_subscriber_only=skip_so,
-                last_checked=time.time(),
-                seen_ids=list(dict.fromkeys(all_ids)),
-                error=None,
-            )
-
-            async with self._lock:
-                if url in self._url_index:
-                    return {"status": "error", "msg": "This URL is already subscribed"}
-                self._subs[sub.id] = sub
-                self._url_index[url] = sub.id
-                try:
-                    self._save_locked()
-                except Exception:
-                    self._subs.pop(sub.id, None)
-                    self._url_index.pop(url, None)
-                    raise
-
-            await self.notifier.subscription_added(sub)
-            return {"status": "ok", "subscription": sub.to_public_dict()}
-        finally:
-            async with self._lock:
-                self._pending_urls.discard(url)
-
-    async def delete_subscriptions(self, ids: list[str]) -> dict:
-        removed: list[str] = []
-        async with self._lock:
-            previous_subs = self._subs.copy()
-            previous_index = self._url_index.copy()
-            for sid in ids:
-                sub = self._subs.pop(sid, None)
-                if sub:
-                    normalized_url = self._normalize_url(sub.url)
-                    self._url_index.pop(normalized_url, None)
-                    removed.append(sid)
-            if removed:
-                try:
-                    self._save_locked()
-                except Exception:
-                    self._subs = previous_subs
-                    self._url_index = previous_index
-                    raise
-        for sid in removed:
-            await self.notifier.subscription_removed(sid)
-        return {"status": "ok"}
-
-    async def update_subscription(self, sub_id: str, changes: dict) -> dict:
-        validated_tr: Optional[str] = None
-        if "title_regex" in changes:
-            try:
-                validated_tr = validate_title_regex(changes["title_regex"])
-            except re.error as exc:
-                return {"status": "error", "msg": f"Invalid title_regex: {exc}"}
-
-        skip_so_set = False
-        validated_skip_so = False
-        if "skip_subscriber_only" in changes:
-            try:
-                validated_skip_so = coerce_optional_bool(
-                    changes["skip_subscriber_only"],
-                    field_name="skip_subscriber_only",
-                )
-                skip_so_set = True
-            except ValueError as exc:
-                return {"status": "error", "msg": str(exc)}
-
-        async with self._lock:
-            sub = self._subs.get(sub_id)
-            if not sub:
-                return {"status": "error", "msg": "Subscription not found"}
-            previous = copy.deepcopy(sub)
-            old_enabled = sub.enabled
-
-            if "enabled" in changes:
-                sub.enabled = _coerce_bool(changes["enabled"])
-            if "check_interval_minutes" in changes:
-                sub.check_interval_minutes = max(1, int(changes["check_interval_minutes"]))
-            if "name" in changes and changes["name"]:
-                sub.name = str(changes["name"])
-            if validated_tr is not None:
-                sub.title_regex = validated_tr
-            if skip_so_set:
-                sub.skip_subscriber_only = validated_skip_so
-
-            try:
-                self._save_locked()
-            except Exception:
-                self._subs[sub_id] = previous
-                raise
-            updated = sub
-        if "enabled" in changes and updated.enabled != old_enabled:
-            log.info(
-                "Subscription %s %s",
-                updated.name,
-                "resumed" if updated.enabled else "paused",
-            )
-        await self.notifier.subscription_updated(updated)
-        return {"status": "ok", "subscription": updated.to_public_dict()}
-
-    async def check_now(self, ids: Optional[list[str]] = None) -> dict:
-        async with self._lock:
-            targets = (
-                [self._subs[i] for i in ids if i in self._subs]
-                if ids
-                else [s for s in self._subs.values() if s.enabled]
-            )
-        log.info(
-            "Manual subscription check requested for %d subscription(s)",
-            len(targets),
-        )
-        for sub in targets:
-            await self._check_one_unlocked(sub)
-        return {"status": "ok"}
-
-    async def _check_one_unlocked(self, sub: SubscriptionInfo) -> None:
-        sid = sub.id
-        scan = int(getattr(self.config, "SUBSCRIPTION_SCAN_PLAYLIST_END", 50))
-        log.info("Checking subscription: %s", sub.name)
-        try:
-            info, entries = extract_flat_playlist(self.config, sub.url, scan)
-        except yt_dlp.utils.YoutubeDLError as exc:
-            async with self._lock:
-                cur = self._subs.get(sid)
-                if cur:
-                    previous = copy.deepcopy(cur)
-                    cur.error = str(exc)
-                    try:
-                        self._save_locked()
-                    except Exception:
-                        self._subs[sid] = previous
-                        raise
-                    sub = cur
-            log.warning("Subscription check failed for %s: %s", sub.name, exc)
-            await self.notifier.subscription_updated(sub)
-            return
-        entries = [ent for ent in entries if _is_media_entry(ent)]
-
-        etype = (info or {}).get("_type") or "video"
-        if etype == "video" or not entries:
-            async with self._lock:
-                cur = self._subs.get(sid)
-                if cur:
-                    previous = copy.deepcopy(cur)
-                    cur.error = VIDEO_ONLY_MSG
-                    try:
-                        self._save_locked()
-                    except Exception:
-                        self._subs[sid] = previous
-                        raise
-                    sub = cur
-            log.warning("Subscription %s no longer resolves to a subscribable feed", sub.name)
-            await self.notifier.subscription_updated(sub)
-            return
-
-        async with self._lock:
-            cur = self._subs.get(sid)
-            if not cur:
-                return
-            seen = cur.seen_set()
-            seen_ids_snapshot = list(cur.seen_ids)
-            dl_type = cur.download_type
-            dl_codec = cur.codec
-            dl_format = cur.format
-            dl_quality = cur.quality
-            dl_folder = cur.folder
-            dl_prefix = cur.custom_name_prefix
-            dl_plimit = cur.playlist_item_limit
-            dl_autostart = cur.auto_start
-            dl_split = cur.split_by_chapters
-            dl_chapter = cur.chapter_template
-            dl_sublang = cur.subtitle_language
-            dl_submode = cur.subtitle_mode
-            dl_ytdl_presets = list(cur.ytdl_options_presets)
-            dl_ytdl_overrides = dict(cur.ytdl_options_overrides)
-            dl_title_regex = cur.title_regex or ""
-            dl_skip_subscriber_only = bool(cur.skip_subscriber_only)
-
-        new_entries: list[dict] = []
-        for ent in entries:
-            eid = _entry_id(ent)
-            if not eid:
-                continue
-            if eid in seen and ent.get("live_status") != "is_live":
-                continue
-            new_entries.append(ent)
-
-        pattern_re: Optional[re.Pattern[str]] = None
-        if dl_title_regex:
-            try:
-                pattern_re = re.compile(dl_title_regex)
-            except re.error:
-                log.warning(
-                    "Invalid stored title_regex on subscription %s, ignoring filter",
-                    sub.name,
-                )
-
-        queue_entries: list[dict] = []
-        filtered_ids: list[str] = []
-        for ent in new_entries:
-            eid = _entry_id(ent)
-            if pattern_re is not None:
-                title = str(ent.get("title") or "")
-                if not pattern_re.search(title):
-                    if eid:
-                        filtered_ids.append(eid)
-                    continue
-            queue_entries.append(ent)
-
-        subscriber_filtered_ids: list[str] = []
-        if dl_skip_subscriber_only:
-            kept_entries: list[dict] = []
-            for ent in queue_entries:
-                eid = _entry_id(ent)
-                if _is_subscriber_only_entry(ent):
-                    if eid:
-                        subscriber_filtered_ids.append(eid)
-                    continue
-                kept_entries.append(ent)
-            queue_entries = kept_entries
-
-        queued_ids, queue_errors = await self._queue_subscription_entries(
-            queue_entries,
-            download_type=dl_type,
-            codec=dl_codec,
-            format=dl_format,
-            quality=dl_quality,
-            folder=dl_folder,
-            custom_name_prefix=dl_prefix,
-            playlist_item_limit=dl_plimit,
-            auto_start=dl_autostart,
-            split_by_chapters=dl_split,
-            chapter_template=dl_chapter or "",
-            subtitle_language=dl_sublang,
-            subtitle_mode=dl_submode,
-            ytdl_options_presets=dl_ytdl_presets,
-            ytdl_options_overrides=dl_ytdl_overrides,
-        )
-        log.info(
-            "Subscription check finished for %s: %d new, %d filtered, %d subscriber_skipped, %d queued, %d failed",
-            sub.name,
-            len(new_entries),
-            len(filtered_ids),
-            len(subscriber_filtered_ids),
-            len(queued_ids),
-            len(queue_errors),
-        )
-
-        merged = list(
-            dict.fromkeys(
-                queued_ids + filtered_ids + subscriber_filtered_ids + seen_ids_snapshot
-            )
-        )
-        max_seen = int(getattr(self.config, "SUBSCRIPTION_MAX_SEEN_IDS", 50000))
-        if len(merged) > max_seen:
-            merged = merged[:max_seen]
-
-        async with self._lock:
-            cur = self._subs.get(sid)
-            if not cur:
-                return
-            previous = copy.deepcopy(cur)
-            cur.seen_ids = merged
-            cur.last_checked = time.time()
-            cur.error = "; ".join(queue_errors[:3]) if queue_errors else None
-            try:
-                self._save_locked()
-            except Exception:
-                self._subs[sid] = previous
-                raise
-            sub = cur
-        await self.notifier.subscription_updated(sub)
-
-    async def emit_all(self) -> None:
-        await self.notifier.subscriptions_all(self.list_all())

app/tests/conftest.py

@@ -1,32 +0,0 @@
-"""Pytest configuration: set env and filesystem layout before importing ``main``."""
-
-from __future__ import annotations
-
-import os
-import tempfile
-from pathlib import Path
-
-
-def _ensure_test_env() -> None:
-    if os.environ.get("METUBE_TEST_ENV_READY"):
-        return
-    tmp = tempfile.mkdtemp(prefix="metube-pytest-")
-    base = Path(tmp)
-    browser = base / "ui" / "dist" / "metube" / "browser"
-    browser.mkdir(parents=True)
-    (browser / "index.html").write_text("<html><body></body></html>", encoding="utf-8")
-    dl = base / "downloads"
-    st = base / "state"
-    dl.mkdir(parents=True)
-    st.mkdir(parents=True)
-    os.environ["DOWNLOAD_DIR"] = str(dl)
-    os.environ["STATE_DIR"] = str(st)
-    os.environ["TEMP_DIR"] = str(dl)
-    os.environ["YTDL_OPTIONS"] = "{}"
-    os.environ["YTDL_OPTIONS_FILE"] = ""
-    os.environ["BASE_DIR"] = str(base)
-    os.environ["LOGLEVEL"] = "INFO"
-    os.environ["METUBE_TEST_ENV_READY"] = "1"
-
-
-_ensure_test_env()

app/tests/test_api.py

@@ -1,308 +0,0 @@
-"""HTTP handler tests for ``main`` using mocked ``web.Request`` (no TestServer)."""
-
-from __future__ import annotations
-
-import json
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-from aiohttp import web
-
-import main
-
-
-@pytest.fixture
-def mock_dqueue(monkeypatch):
-    d = MagicMock()
-    d.initialize = AsyncMock(return_value=None)
-    d.add = AsyncMock(return_value={"status": "ok"})
-    d.cancel = AsyncMock(return_value={"status": "ok"})
-    d.start_pending = AsyncMock(return_value={"status": "ok"})
-    d.cancel_add = MagicMock()
-    d.queue = MagicMock()
-    d.done = MagicMock()
-    d.pending = MagicMock()
-    d.queue.saved_items = MagicMock(return_value=[])
-    d.done.saved_items = MagicMock(return_value=[])
-    d.pending.saved_items = MagicMock(return_value=[])
-    d.get = MagicMock(return_value=([], []))
-    monkeypatch.setattr(main, "dqueue", d)
-    return d
-
-
-def _valid_video_add_body(**kwargs):
-    base = {
-        "url": "https://example.com/watch?v=1",
-        "download_type": "video",
-        "codec": "auto",
-        "format": "any",
-        "quality": "best",
-        "ytdl_options_presets": [],
-        "ytdl_options_overrides": "",
-    }
-    base.update(kwargs)
-    return base
-
-
-def _json_request(body: dict | None):
-    req = MagicMock(spec=web.Request)
-    req.json = AsyncMock(return_value=body)
-    return req
-
-
-@pytest.mark.asyncio
-async def test_add_ok(mock_dqueue):
-    req = _json_request(_valid_video_add_body())
-    resp = await main.add(req)
-    assert resp.status == 200
-    text = resp.text
-    data = json.loads(text)
-    assert data["status"] == "ok"
-    mock_dqueue.add.assert_awaited_once()
-
-
-@pytest.mark.asyncio
-async def test_add_passes_preset_and_overrides(mock_dqueue, monkeypatch):
-    monkeypatch.setattr(main.config, "YTDL_OPTIONS_PRESETS", {"Preset A": {"writesubtitles": True}})
-    monkeypatch.setattr(main.config, "ALLOW_YTDL_OPTIONS_OVERRIDES", True)
-    req = _json_request(
-        _valid_video_add_body(
-            ytdl_options_presets=["Preset A"],
-            ytdl_options_overrides='{"writesubtitles": true}',
-        )
-    )
-    resp = await main.add(req)
-    assert resp.status == 200
-    call = mock_dqueue.add.await_args
-    assert call is not None
-    assert call.args[13] == ["Preset A"]
-    assert call.args[14] == {"writesubtitles": True}
-
-
-@pytest.mark.asyncio
-async def test_add_legacy_string_preset_normalized(mock_dqueue, monkeypatch):
-    monkeypatch.setattr(main.config, "YTDL_OPTIONS_PRESETS", {"Legacy": {}})
-    body = _valid_video_add_body()
-    del body["ytdl_options_presets"]
-    body["ytdl_options_preset"] = "Legacy"
-    req = _json_request(body)
-    resp = await main.add(req)
-    assert resp.status == 200
-    call = mock_dqueue.add.await_args
-    assert call.args[13] == ["Legacy"]
-
-
-@pytest.mark.asyncio
-async def test_add_missing_url_returns_400(mock_dqueue):
-    req = _json_request({"download_type": "video", "quality": "best", "format": "any"})
-    with pytest.raises(web.HTTPBadRequest):
-        await main.add(req)
-    mock_dqueue.add.assert_not_called()
-
-
-@pytest.mark.asyncio
-async def test_add_invalid_download_type(mock_dqueue):
-    req = _json_request(_valid_video_add_body(download_type="invalid"))
-    with pytest.raises(web.HTTPBadRequest):
-        await main.add(req)
-
-
-@pytest.mark.asyncio
-async def test_add_invalid_video_quality(mock_dqueue):
-    req = _json_request(_valid_video_add_body(quality="9999"))
-    with pytest.raises(web.HTTPBadRequest):
-        await main.add(req)
-
-
-@pytest.mark.asyncio
-async def test_add_invalid_subtitle_language(mock_dqueue):
-    req = _json_request(
-        {
-            "url": "https://example.com/v",
-            "download_type": "captions",
-            "codec": "auto",
-            "format": "srt",
-            "quality": "best",
-            "subtitle_language": "bad language!",
-        }
-    )
-    with pytest.raises(web.HTTPBadRequest):
-        await main.add(req)
-
-
-@pytest.mark.asyncio
-async def test_add_custom_name_prefix_path_traversal(mock_dqueue):
-    req = _json_request(_valid_video_add_body(custom_name_prefix="../evil"))
-    with pytest.raises(web.HTTPBadRequest):
-        await main.add(req)
-
-
-@pytest.mark.asyncio
-async def test_add_chapter_template_path_traversal(mock_dqueue):
-    req = _json_request(
-        _valid_video_add_body(
-            split_by_chapters=True,
-            chapter_template="/etc/passwd%(title)s",
-        )
-    )
-    with pytest.raises(web.HTTPBadRequest):
-        await main.add(req)
-
-
-@pytest.mark.asyncio
-async def test_add_invalid_json_body(mock_dqueue):
-    req = MagicMock(spec=web.Request)
-    req.json = AsyncMock(side_effect=json.JSONDecodeError("msg", "", 0))
-    with pytest.raises(web.HTTPBadRequest):
-        await main.add(req)
-
-
-@pytest.mark.asyncio
-async def test_add_invalid_ytdl_options_override_json(mock_dqueue):
-    req = _json_request(_valid_video_add_body(ytdl_options_overrides="{bad json}"))
-    with pytest.raises(web.HTTPBadRequest):
-        await main.add(req)
-
-
-@pytest.mark.asyncio
-async def test_add_rejects_ytdl_options_overrides_when_disabled(mock_dqueue):
-    req = _json_request(_valid_video_add_body(ytdl_options_overrides='{"exec": "rm -rf /"}'))
-    with pytest.raises(web.HTTPBadRequest):
-        await main.add(req)
-
-
-@pytest.mark.asyncio
-async def test_add_allows_any_ytdl_options_override_key_when_enabled(mock_dqueue, monkeypatch):
-    monkeypatch.setattr(main.config, "ALLOW_YTDL_OPTIONS_OVERRIDES", True)
-    req = _json_request(_valid_video_add_body(ytdl_options_overrides='{"exec": "echo hi"}'))
-    resp = await main.add(req)
-    assert resp.status == 200
-    call = mock_dqueue.add.await_args
-    assert call is not None
-    assert call.args[14] == {"exec": "echo hi"}
-
-
-@pytest.mark.asyncio
-async def test_add_unknown_ytdl_preset(mock_dqueue):
-    req = _json_request(_valid_video_add_body(ytdl_options_presets=["Missing"]))
-    with pytest.raises(web.HTTPBadRequest):
-        await main.add(req)
-
-
-@pytest.mark.asyncio
-async def test_delete_missing_ids(mock_dqueue):
-    req = _json_request({"where": "queue"})
-    with pytest.raises(web.HTTPBadRequest):
-        await main.delete(req)
-
-
-@pytest.mark.asyncio
-async def test_delete_queue_calls_cancel(mock_dqueue):
-    req = _json_request({"where": "queue", "ids": ["http://x"]})
-    resp = await main.delete(req)
-    assert resp.status == 200
-    mock_dqueue.cancel.assert_awaited_once_with(["http://x"])
-
-
-@pytest.mark.asyncio
-async def test_start_pending(mock_dqueue):
-    req = _json_request({"ids": ["a"]})
-    resp = await main.start(req)
-    assert resp.status == 200
-    mock_dqueue.start_pending.assert_awaited_once_with(["a"])
-
-
-@pytest.mark.asyncio
-async def test_history_shape(mock_dqueue):
-    mock_dqueue.queue.saved_items.return_value = []
-    mock_dqueue.done.saved_items.return_value = []
-    mock_dqueue.pending.saved_items.return_value = []
-    req = MagicMock(spec=web.Request)
-    resp = await main.history(req)
-    assert resp.status == 200
-    data = json.loads(resp.text)
-    assert set(data.keys()) == {"done", "queue", "pending"}
-
-
-@pytest.mark.asyncio
-async def test_version_json(mock_dqueue):
-    req = MagicMock(spec=web.Request)
-    resp = await main.version(req)
-    assert resp.status == 200
-    body = json.loads(resp.text)
-    assert "yt-dlp" in body and "version" in body
-
-
-@pytest.mark.asyncio
-async def test_presets_endpoint_returns_names(mock_dqueue, monkeypatch):
-    monkeypatch.setattr(main.config, "YTDL_OPTIONS_PRESETS", {"Preset B": {}, "Preset A": {}})
-    req = MagicMock(spec=web.Request)
-    resp = await main.presets(req)
-    assert resp.status == 200
-    assert json.loads(resp.text) == {"presets": ["Preset A", "Preset B"]}
-
-
-@pytest.mark.asyncio
-async def test_cookie_status(mock_dqueue):
-    req = MagicMock(spec=web.Request)
-    resp = await main.cookie_status(req)
-    assert resp.status == 200
-    data = json.loads(resp.text)
-    assert data.get("status") == "ok"
-    assert "has_cookies" in data
-
-
-@pytest.mark.asyncio
-async def test_options_add_cors(mock_dqueue):
-    req = MagicMock(spec=web.Request)
-    resp = await main.add_cors(req)
-    assert resp.status == 200
-
-
-@pytest.mark.asyncio
-async def test_upload_cookies_missing_field(mock_dqueue):
-    req = MagicMock(spec=web.Request)
-    reader = MagicMock()
-    field = MagicMock()
-    field.name = "wrongname"
-    reader.next = AsyncMock(side_effect=[field, None])
-    req.multipart = AsyncMock(return_value=reader)
-    resp = await main.upload_cookies(req)
-    assert resp.status == 400
-
-
-@pytest.mark.asyncio
-async def test_add_legacy_format_migrated(mock_dqueue):
-    req = _json_request({"url": "https://example.com/v", "format": "m4a", "quality": "best"})
-    resp = await main.add(req)
-    assert resp.status == 200
-    call = mock_dqueue.add.await_args
-    assert call is not None
-    assert call.args[1] == "audio"
-
-
-@pytest.mark.asyncio
-async def test_add_passes_clip_bounds_to_queue(mock_dqueue):
-    req = _json_request(
-        _valid_video_add_body(clip_start="2:26", clip_end="3:24"),
-    )
-    resp = await main.add(req)
-    assert resp.status == 200
-    call = mock_dqueue.add.await_args
-    assert call is not None
-    assert call.args[15] == pytest.approx(146.0)
-    assert call.args[16] == pytest.approx(204.0)
-
-
-@pytest.mark.asyncio
-async def test_subscribe_rejects_clip_options(mock_dqueue, monkeypatch):
-    monkeypatch.setattr(main.submgr, "add_subscription", AsyncMock())
-    req = _json_request(
-        {
-            **_valid_video_add_body(clip_start="10"),
-            "check_interval_minutes": 60,
-        }
-    )
-    with pytest.raises(web.HTTPBadRequest):
-        await main.subscribe(req)
-    main.submgr.add_subscription.assert_not_awaited()

app/tests/test_config.py

@@ -1,150 +0,0 @@
-"""Tests for ``Config`` (env parsing, yt-dlp options, frontend_safe)."""
-
-from __future__ import annotations
-
-import json
-import os
-import tempfile
-import unittest
-from unittest.mock import patch
-
-from main import Config
-
-
-def _base_env(**overrides: str) -> dict[str, str]:
-    env = {k: str(v) for k, v in Config._DEFAULTS.items()}
-    env.update(overrides)
-    return env
-
-
-class ConfigTests(unittest.TestCase):
-    def test_url_prefix_gets_trailing_slash(self):
-        with patch.dict(os.environ, _base_env(URL_PREFIX="foo"), clear=False):
-            c = Config()
-        self.assertEqual(c.URL_PREFIX, "foo/")
-
-    def test_public_host_url_gets_trailing_slash(self):
-        with patch.dict(
-            os.environ,
-            _base_env(PUBLIC_HOST_URL="https://ytdl.example.com"),
-            clear=False,
-        ):
-            c = Config()
-        self.assertEqual(c.PUBLIC_HOST_URL, "https://ytdl.example.com/")
-
-    def test_public_host_audio_url_gets_trailing_slash(self):
-        with patch.dict(
-            os.environ,
-            _base_env(PUBLIC_HOST_AUDIO_URL="https://audio.example.com"),
-            clear=False,
-        ):
-            c = Config()
-        self.assertEqual(c.PUBLIC_HOST_AUDIO_URL, "https://audio.example.com/")
-
-    def test_public_host_url_empty_stays_empty(self):
-        with patch.dict(
-            os.environ,
-            _base_env(PUBLIC_HOST_URL="", PUBLIC_HOST_AUDIO_URL=""),
-            clear=False,
-        ):
-            c = Config()
-        self.assertEqual(c.PUBLIC_HOST_URL, "")
-        self.assertEqual(c.PUBLIC_HOST_AUDIO_URL, "")
-
-    def test_public_host_url_already_slashed_unchanged(self):
-        with patch.dict(
-            os.environ,
-            _base_env(
-                PUBLIC_HOST_URL="https://ytdl.example.com/",
-                PUBLIC_HOST_AUDIO_URL="https://audio.example.com/",
-            ),
-            clear=False,
-        ):
-            c = Config()
-        self.assertEqual(c.PUBLIC_HOST_URL, "https://ytdl.example.com/")
-        self.assertEqual(c.PUBLIC_HOST_AUDIO_URL, "https://audio.example.com/")
-
-    def test_ytdl_options_json_loaded(self):
-        opts = {"quiet": True, "no_warnings": True}
-        with patch.dict(
-            os.environ,
-            _base_env(YTDL_OPTIONS=json.dumps(opts)),
-            clear=False,
-        ):
-            c = Config()
-        self.assertEqual(c.YTDL_OPTIONS["quiet"], True)
-
-    def test_ytdl_option_presets_json_loaded(self):
-        presets = {"Audio extras": {"embed_thumbnail": True}}
-        with patch.dict(
-            os.environ,
-            _base_env(YTDL_OPTIONS_PRESETS=json.dumps(presets)),
-            clear=False,
-        ):
-            c = Config()
-        self.assertEqual(c.YTDL_OPTIONS_PRESETS["Audio extras"]["embed_thumbnail"], True)
-
-    def test_invalid_ytdl_options_exits(self):
-        with patch.dict(os.environ, _base_env(YTDL_OPTIONS="not-json"), clear=False):
-            with self.assertRaises(SystemExit):
-                Config()
-
-    def test_invalid_boolean_env_exits(self):
-        with patch.dict(os.environ, _base_env(CUSTOM_DIRS="maybe"), clear=False):
-            with self.assertRaises(SystemExit):
-                Config()
-
-    def test_frontend_safe_excludes_secrets(self):
-        with patch.dict(os.environ, _base_env(), clear=False):
-            c = Config()
-        safe = c.frontend_safe()
-        self.assertNotIn("YTDL_OPTIONS", safe)
-        self.assertNotIn("HOST", safe)
-        self.assertEqual(safe["ALLOW_YTDL_OPTIONS_OVERRIDES"], False)
-
-    def test_allow_ytdl_options_overrides_boolean_loaded(self):
-        with patch.dict(os.environ, _base_env(ALLOW_YTDL_OPTIONS_OVERRIDES="true"), clear=False):
-            c = Config()
-        self.assertTrue(c.ALLOW_YTDL_OPTIONS_OVERRIDES)
-
-    def test_runtime_override_roundtrip(self):
-        with patch.dict(os.environ, _base_env(), clear=False):
-            c = Config()
-            c.set_runtime_override("cookiefile", "/tmp/c.txt")
-            self.assertEqual(c.YTDL_OPTIONS.get("cookiefile"), "/tmp/c.txt")
-            c.remove_runtime_override("cookiefile")
-            self.assertIsNone(c.YTDL_OPTIONS.get("cookiefile"))
-
-    def test_ytdl_options_file_merges(self):
-        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as f:
-            json.dump({"extractor_args": {"youtube": {"player_client": ["web"]}}}, f)
-            path = f.name
-        try:
-            with patch.dict(
-                os.environ,
-                _base_env(YTDL_OPTIONS="{}", YTDL_OPTIONS_FILE=path),
-                clear=False,
-            ):
-                c = Config()
-            self.assertIn("extractor_args", c.YTDL_OPTIONS)
-        finally:
-            os.unlink(path)
-
-    def test_ytdl_option_presets_file_merges(self):
-        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as f:
-            json.dump({"With subtitles": {"writesubtitles": True}}, f)
-            path = f.name
-        try:
-            with patch.dict(
-                os.environ,
-                _base_env(YTDL_OPTIONS_PRESETS="{}", YTDL_OPTIONS_PRESETS_FILE=path),
-                clear=False,
-            ):
-                c = Config()
-            self.assertIn("With subtitles", c.YTDL_OPTIONS_PRESETS)
-        finally:
-            os.unlink(path)
-
-
-if __name__ == "__main__":
-    unittest.main()

app/tests/test_dl_formats.py

@@ -1,139 +0,0 @@
-"""Tests for ``app.dl_formats`` format selectors and yt-dlp option mapping."""
-
-from __future__ import annotations
-
-import copy
-import unittest
-
-from app.dl_formats import (
-    _normalize_caption_mode,
-    _normalize_subtitle_language,
-    get_format,
-    get_opts,
-)
-
-
-class DlFormatsTests(unittest.TestCase):
-    def test_audio_unknown_format_raises_value_error(self):
-        with self.assertRaises(ValueError):
-            get_format("audio", "auto", "invalid", "best")
-
-    def test_wav_does_not_enable_thumbnail_postprocessing(self):
-        opts = get_opts("audio", "auto", "wav", "best", {})
-        self.assertNotIn("writethumbnail", opts)
-
-    def test_mp3_enables_thumbnail_postprocessing(self):
-        opts = get_opts("audio", "auto", "mp3", "best", {})
-        self.assertTrue(opts.get("writethumbnail"))
-
-    def test_custom_format_passthrough(self):
-        self.assertEqual(get_format("video", "auto", "custom:bestvideo+bestaudio", "best"), "bestvideo+bestaudio")
-
-    def test_thumbnail_and_captions_format_strings(self):
-        self.assertEqual(get_format("thumbnail", "auto", "jpg", "best"), "bestaudio/best")
-        self.assertEqual(get_format("captions", "auto", "srt", "best"), "bestaudio/best")
-
-    def test_audio_formats(self):
-        for fmt in ("m4a", "mp3", "opus", "wav", "flac"):
-            with self.subTest(fmt=fmt):
-                self.assertIn(f"ext={fmt}", get_format("audio", "auto", fmt, "best"))
-
-    def test_video_unknown_format_raises(self):
-        with self.assertRaises(ValueError):
-            get_format("video", "auto", "mkv", "best")
-
-    def test_unknown_download_type_raises(self):
-        with self.assertRaises(ValueError):
-            get_format("unknown", "auto", "any", "best")
-
-    def test_video_any_mp4_ios_with_height_quality(self):
-        self.assertIn("height<=1080", get_format("video", "auto", "any", "1080"))
-        self.assertNotIn("height<=", get_format("video", "auto", "any", "best"))
-        self.assertNotIn("height<=", get_format("video", "auto", "any", "worst"))
-
-    def test_video_codec_filters(self):
-        self.assertIn("h264", get_format("video", "h264", "any", "best"))
-        self.assertIn("hevc", get_format("video", "h265", "any", "best"))
-        self.assertIn("av0?1", get_format("video", "av1", "any", "best"))
-        self.assertIn("vp0?9", get_format("video", "vp9", "any", "best"))
-
-    def test_video_mp4_includes_m4a_audio(self):
-        s = get_format("video", "auto", "mp4", "720")
-        self.assertIn("[ext=m4a]", s)
-
-    def test_video_ios_selector_contains_avc_pattern(self):
-        s = get_format("video", "auto", "ios", "best")
-        self.assertIn("h26[45]", s)
-
-    def test_get_opts_deepcopy_does_not_mutate_input(self):
-        base = {"postprocessors": [{"key": "Existing"}]}
-        orig = copy.deepcopy(base)
-        get_opts("audio", "auto", "mp3", "best", base)
-        self.assertEqual(base, orig)
-
-    def test_get_opts_audio_m4a_postprocessors(self):
-        opts = get_opts("audio", "auto", "m4a", "best", {})
-        keys = [p["key"] for p in opts["postprocessors"]]
-        self.assertIn("FFmpegExtractAudio", keys)
-
-    def test_get_opts_audio_mp3_quality_not_best(self):
-        opts = get_opts("audio", "auto", "mp3", "192", {})
-        ext = next(p for p in opts["postprocessors"] if p["key"] == "FFmpegExtractAudio")
-        self.assertEqual(ext["preferredquality"], "192")
-
-    def test_get_opts_thumbnail_skip_download(self):
-        opts = get_opts("thumbnail", "auto", "jpg", "best", {})
-        self.assertTrue(opts.get("skip_download"))
-        self.assertTrue(opts.get("writethumbnail"))
-
-    def test_get_opts_captions_manual_only(self):
-        opts = get_opts(
-            "captions", "auto", "vtt", "best", {}, subtitle_language="fr", subtitle_mode="manual_only"
-        )
-        self.assertTrue(opts.get("writesubtitles"))
-        self.assertFalse(opts.get("writeautomaticsub"))
-        self.assertEqual(opts["subtitleslangs"], ["fr"])
-
-    def test_get_opts_captions_auto_only(self):
-        opts = get_opts(
-            "captions", "auto", "srt", "best", {}, subtitle_language="de", subtitle_mode="auto_only"
-        )
-        self.assertFalse(opts.get("writesubtitles"))
-        self.assertTrue(opts.get("writeautomaticsub"))
-        self.assertEqual(opts["subtitleslangs"], ["de-orig", "de"])
-
-    def test_get_opts_captions_prefer_auto(self):
-        opts = get_opts(
-            "captions", "auto", "srt", "best", {}, subtitle_language="es", subtitle_mode="prefer_auto"
-        )
-        self.assertTrue(opts.get("writesubtitles"))
-        self.assertTrue(opts.get("writeautomaticsub"))
-        self.assertEqual(opts["subtitleslangs"], ["es-orig", "es"])
-
-    def test_get_opts_captions_prefer_manual_default_branch(self):
-        opts = get_opts(
-            "captions", "auto", "srt", "best", {}, subtitle_language="it", subtitle_mode="prefer_manual"
-        )
-        self.assertEqual(opts["subtitleslangs"], ["it", "it-orig"])
-
-    def test_get_opts_captions_txt_maps_to_srt_format(self):
-        opts = get_opts("captions", "auto", "txt", "best", {})
-        self.assertEqual(opts["subtitlesformat"], "srt")
-
-    def test_get_opts_merges_existing_postprocessors(self):
-        opts = get_opts("audio", "auto", "opus", "best", {"postprocessors": [{"key": "SponsorBlock"}]})
-        keys = [p["key"] for p in opts["postprocessors"]]
-        self.assertIn("SponsorBlock", keys)
-        self.assertIn("FFmpegExtractAudio", keys)
-
-    def test_normalize_caption_mode_invalid_defaults(self):
-        self.assertEqual(_normalize_caption_mode(""), "prefer_manual")
-        self.assertEqual(_normalize_caption_mode("not_a_mode"), "prefer_manual")
-
-    def test_normalize_subtitle_language_empty_defaults_en(self):
-        self.assertEqual(_normalize_subtitle_language(""), "en")
-        self.assertEqual(_normalize_subtitle_language("  "), "en")
-
-
-if __name__ == "__main__":
-    unittest.main()

app/tests/test_download_queue.py

@@ -1,388 +0,0 @@
-"""Tests for ``DownloadQueue`` with mocked yt-dlp extraction."""
-
-from __future__ import annotations
-
-import os
-import tempfile
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from ytdl import DownloadQueue
-
-
-@pytest.fixture
-def dq_env():
-    with tempfile.TemporaryDirectory() as tmp:
-        dl = os.path.join(tmp, "downloads")
-        st = os.path.join(tmp, "state")
-        os.makedirs(dl, exist_ok=True)
-        os.makedirs(st, exist_ok=True)
-        cfg = MagicMock()
-        cfg.STATE_DIR = st
-        cfg.DOWNLOAD_DIR = dl
-        cfg.AUDIO_DOWNLOAD_DIR = dl
-        cfg.TEMP_DIR = dl
-        cfg.MAX_CONCURRENT_DOWNLOADS = "3"
-        cfg.YTDL_OPTIONS = {}
-        cfg.YTDL_OPTIONS_PRESETS = {}
-        cfg.CUSTOM_DIRS = True
-        cfg.CREATE_CUSTOM_DIRS = True
-        cfg.CLEAR_COMPLETED_AFTER = "0"
-        cfg.DELETE_FILE_ON_TRASHCAN = False
-        cfg.OUTPUT_TEMPLATE = "%(title)s.%(ext)s"
-        cfg.OUTPUT_TEMPLATE_CHAPTER = "%(title)s.%(ext)s"
-        cfg.OUTPUT_TEMPLATE_PLAYLIST = ""
-        cfg.OUTPUT_TEMPLATE_CHANNEL = ""
-        yield cfg
-
-
-def test_cancel_add_increments_generation(dq_env):
-    notifier = MagicMock()
-    dq = DownloadQueue(dq_env, notifier)
-    before = dq._add_generation
-    dq.cancel_add()
-    assert dq._add_generation == before + 1
-
-
-def test_get_returns_tuple_of_lists(dq_env):
-    notifier = MagicMock()
-    dq = DownloadQueue(dq_env, notifier)
-    q, done = dq.get()
-    assert q == [] and done == []
-
-
-@pytest.mark.asyncio
-async def test_add_single_video_goes_to_pending_when_auto_start_false(dq_env):
-    notifier = AsyncMock()
-
-    def fake_extract(self, url, ytdl_options_presets=None, ytdl_options_overrides=None):
-        return {
-            "_type": "video",
-            "id": "vid1",
-            "title": "Test Video",
-            "url": url,
-            "webpage_url": url,
-        }
-
-    dq = DownloadQueue(dq_env, notifier)
-    with patch.object(DownloadQueue, "_DownloadQueue__extract_info", fake_extract):
-        result = await dq.add(
-            "https://example.com/watch?v=1",
-            "video",
-            "auto",
-            "any",
-            "best",
-            "",
-            "",
-            0,
-            auto_start=False,
-        )
-    assert result["status"] == "ok"
-    assert dq.pending.exists("https://example.com/watch?v=1")
-
-
-@pytest.mark.asyncio
-async def test_cancel_removes_from_pending(dq_env):
-    notifier = AsyncMock()
-
-    def fake_extract(self, url, ytdl_options_presets=None, ytdl_options_overrides=None):
-        return {
-            "_type": "video",
-            "id": "vid1",
-            "title": "Test Video",
-            "url": url,
-            "webpage_url": url,
-        }
-
-    dq = DownloadQueue(dq_env, notifier)
-    with patch.object(DownloadQueue, "_DownloadQueue__extract_info", fake_extract):
-        await dq.add(
-            "https://example.com/pending",
-            "video",
-            "auto",
-            "any",
-            "best",
-            "",
-            "",
-            0,
-            auto_start=False,
-        )
-    url = "https://example.com/pending"
-    await dq.cancel([url])
-    assert not dq.pending.exists(url)
-    notifier.canceled.assert_awaited()
-
-
-@pytest.mark.asyncio
-async def test_cancel_before_start_marks_download_canceled(dq_env):
-    """Regression test for the race condition where cancel() arrives after the
-    download has been placed in the queue and ``__start_download`` has been
-    scheduled via ``asyncio.create_task`` but has not yet executed. Without the
-    fix, the pending task would run ``download.start()`` despite the user
-    cancelling, because its ``download.canceled`` guard was never flipped."""
-    notifier = AsyncMock()
-
-    def fake_extract(self, url, ytdl_options_presets=None, ytdl_options_overrides=None):
-        return {
-            "_type": "video",
-            "id": "vid1",
-            "title": "Test Video",
-            "url": url,
-            "webpage_url": url,
-        }
-
-    dq = DownloadQueue(dq_env, notifier)
-    url = "https://example.com/race"
-    start_mock = AsyncMock()
-    with patch.object(DownloadQueue, "_DownloadQueue__extract_info", fake_extract), \
-         patch.object(DownloadQueue, "_DownloadQueue__start_download", start_mock):
-        await dq.add(
-            url,
-            "video",
-            "auto",
-            "any",
-            "best",
-            "",
-            "",
-            0,
-            auto_start=True,
-        )
-        assert dq.queue.exists(url)
-        download = dq.queue.get(url)
-        assert download.canceled is False
-        await dq.cancel([url])
-        assert not dq.queue.exists(url)
-        assert download.canceled is True
-        notifier.canceled.assert_awaited_with(url)
-
-
-@pytest.mark.asyncio
-async def test_start_pending_moves_to_queue(dq_env):
-    notifier = AsyncMock()
-
-    def fake_extract(self, url, ytdl_options_presets=None, ytdl_options_overrides=None):
-        return {
-            "_type": "video",
-            "id": "vid1",
-            "title": "Test Video",
-            "url": url,
-            "webpage_url": url,
-        }
-
-    dq = DownloadQueue(dq_env, notifier)
-    with patch.object(DownloadQueue, "_DownloadQueue__extract_info", fake_extract):
-        await dq.add(
-            "https://example.com/startme",
-            "video",
-            "auto",
-            "any",
-            "best",
-            "",
-            "",
-            0,
-            auto_start=False,
-        )
-    url = "https://example.com/startme"
-    # Starting will spawn real download — cancel immediately before worker runs much
-    with patch.object(DownloadQueue, "_DownloadQueue__start_download", AsyncMock()):
-        await dq.start_pending([url])
-    assert not dq.pending.exists(url)
-
-
-@pytest.mark.asyncio
-async def test_add_entry_queues_single_video_without_reextracting(dq_env):
-    notifier = AsyncMock()
-    dq = DownloadQueue(dq_env, notifier)
-    entry = {
-        "_type": "video",
-        "id": "vid1",
-        "title": "Test Video",
-        "url": "https://example.com/watch?v=1",
-        "webpage_url": "https://example.com/watch?v=1",
-        "playlist_index": "01",
-        "playlist_title": "Playlist",
-    }
-
-    with patch.object(DownloadQueue, "_DownloadQueue__extract_info", side_effect=AssertionError("should not re-extract")):
-        result = await dq.add_entry(
-            entry,
-            "video",
-            "auto",
-            "any",
-            "best",
-            "",
-            "",
-            0,
-            auto_start=False,
-        )
-
-    assert result["status"] == "ok"
-    assert dq.pending.exists("https://example.com/watch?v=1")
-
-
-@pytest.mark.asyncio
-async def test_add_merges_global_preset_and_override_options(dq_env):
-    notifier = AsyncMock()
-    dq_env.YTDL_OPTIONS = {"writesubtitles": False, "cookiefile": "/tmp/global.txt"}
-    dq_env.YTDL_OPTIONS_PRESETS = {
-        "Preset A": {"writesubtitles": True, "proxy": "http://preset-a"},
-        "Preset B": {"writesubtitles": False, "ratelimit": 1000},
-    }
-
-    def fake_extract(self, url, ytdl_options_presets=None, ytdl_options_overrides=None):
-        return {
-            "_type": "video",
-            "id": "vid2",
-            "title": "Preset Video",
-            "url": url,
-            "webpage_url": url,
-        }
-
-    dq = DownloadQueue(dq_env, notifier)
-    with patch.object(DownloadQueue, "_DownloadQueue__extract_info", fake_extract):
-        result = await dq.add(
-            "https://example.com/preset",
-            "video",
-            "auto",
-            "any",
-            "best",
-            "",
-            "",
-            0,
-            auto_start=False,
-            ytdl_options_presets=["Preset A", "Preset B"],
-            ytdl_options_overrides={"proxy": "http://override", "embed_thumbnail": True},
-        )
-
-    assert result["status"] == "ok"
-    queued = dq.pending.get("https://example.com/preset")
-    assert queued.ytdl_opts["cookiefile"] == "/tmp/global.txt"
-    assert queued.ytdl_opts["writesubtitles"] is False
-    assert queued.ytdl_opts["ratelimit"] == 1000
-    assert queued.ytdl_opts["proxy"] == "http://override"
-    assert queued.ytdl_opts["embed_thumbnail"] is True
-
-
-@pytest.mark.asyncio
-async def test_extract_info_preset_null_download_archive_overrides_global(dq_env):
-    """Preset download_archive:null must apply during extract_info (global archive otherwise wins first)."""
-    dq_env.YTDL_OPTIONS = {"download_archive": "/tmp/archive.txt"}
-    dq_env.YTDL_OPTIONS_PRESETS = {"NoArchive": {"download_archive": None}}
-
-    captured_params: list = []
-
-    class FakeYoutubeDL:
-        def __init__(self, params=None):
-            captured_params.append(params)
-
-        def extract_info(self, url, download=False):
-            return {
-                "_type": "video",
-                "id": "vid-archive",
-                "title": "Archive Test",
-                "url": url,
-                "webpage_url": url,
-            }
-
-    notifier = AsyncMock()
-    dq = DownloadQueue(dq_env, notifier)
-    with patch("ytdl.yt_dlp.YoutubeDL", FakeYoutubeDL):
-        result = await dq.add(
-            "https://example.com/archive-test",
-            "video",
-            "auto",
-            "any",
-            "best",
-            "",
-            "",
-            0,
-            auto_start=False,
-            ytdl_options_presets=["NoArchive"],
-        )
-
-    assert result["status"] == "ok"
-    assert len(captured_params) == 1
-    extract_params = captured_params[0]
-    assert extract_params.get("download_archive") is None
-    assert extract_params["extract_flat"] is True
-    assert extract_params["noplaylist"] is True
-
-
-@pytest.mark.asyncio
-async def test_extract_info_metube_extract_keys_win_over_preset(dq_env):
-    """MeTube's flat-extract settings must not be overridden by presets."""
-    dq_env.YTDL_OPTIONS = {}
-    dq_env.YTDL_OPTIONS_PRESETS = {
-        "TryOverride": {"extract_flat": False, "noplaylist": False},
-    }
-
-    captured_params: list = []
-
-    class FakeYoutubeDL:
-        def __init__(self, params=None):
-            captured_params.append(params)
-
-        def extract_info(self, url, download=False):
-            return {
-                "_type": "video",
-                "id": "vid-flat",
-                "title": "Flat Test",
-                "url": url,
-                "webpage_url": url,
-            }
-
-    notifier = AsyncMock()
-    dq = DownloadQueue(dq_env, notifier)
-    with patch("ytdl.yt_dlp.YoutubeDL", FakeYoutubeDL):
-        result = await dq.add(
-            "https://example.com/flat-test",
-            "video",
-            "auto",
-            "any",
-            "best",
-            "",
-            "",
-            0,
-            auto_start=False,
-            ytdl_options_presets=["TryOverride"],
-        )
-
-    assert result["status"] == "ok"
-    assert captured_params[0]["extract_flat"] is True
-    assert captured_params[0]["noplaylist"] is True
-
-
-@pytest.mark.asyncio
-async def test_add_sets_clip_bounds_on_download_info(dq_env):
-    notifier = AsyncMock()
-
-    def fake_extract(self, url, ytdl_options_presets=None, ytdl_options_overrides=None):
-        return {
-            "_type": "video",
-            "id": "vid1",
-            "title": "Test Video",
-            "url": url,
-            "webpage_url": url,
-        }
-
-    dq = DownloadQueue(dq_env, notifier)
-    with patch.object(DownloadQueue, "_DownloadQueue__extract_info", fake_extract):
-        result = await dq.add(
-            "https://example.com/clip",
-            "video",
-            "auto",
-            "any",
-            "best",
-            "",
-            "",
-            0,
-            auto_start=False,
-            clip_start=10.0,
-            clip_end=99.5,
-        )
-
-    assert result["status"] == "ok"
-    download = dq.pending.get("https://example.com/clip")
-    assert download.info.clip_start == 10.0
-    assert download.info.clip_end == 99.5

app/tests/test_main_helpers.py

@@ -1,284 +0,0 @@
-"""Tests for pure helpers in ``main`` (legacy API migration, logging, JSON serializer)."""
-
-from __future__ import annotations
-
-import json
-import logging
-import unittest
-
-import main
-
-
-class MigrateLegacyRequestTests(unittest.TestCase):
-    def test_already_new_schema_unchanged(self):
-        post = {"download_type": "video", "codec": "h264", "format": "mp4", "quality": "1080"}
-        before = post.copy()
-        self.assertIs(main._migrate_legacy_request(post), post)
-        self.assertEqual(post, before)
-
-    def test_legacy_audio_m4a(self):
-        post = {"format": "m4a", "quality": "best"}
-        main._migrate_legacy_request(post)
-        self.assertEqual(post["download_type"], "audio")
-        self.assertEqual(post["codec"], "auto")
-        self.assertEqual(post["format"], "m4a")
-
-    def test_legacy_thumbnail(self):
-        post = {"format": "thumbnail", "quality": "best"}
-        main._migrate_legacy_request(post)
-        self.assertEqual(post["download_type"], "thumbnail")
-        self.assertEqual(post["format"], "jpg")
-        self.assertEqual(post["quality"], "best")
-
-    def test_legacy_captions_with_subtitle_format(self):
-        post = {"format": "captions", "subtitle_format": "vtt", "quality": "best"}
-        main._migrate_legacy_request(post)
-        self.assertEqual(post["download_type"], "captions")
-        self.assertEqual(post["format"], "vtt")
-
-    def test_legacy_video_best_ios(self):
-        post = {"format": "any", "quality": "best_ios", "video_codec": "auto"}
-        main._migrate_legacy_request(post)
-        self.assertEqual(post["download_type"], "video")
-        self.assertEqual(post["format"], "ios")
-        self.assertEqual(post["quality"], "best")
-
-    def test_legacy_video_quality_audio_maps_to_m4a(self):
-        post = {"format": "mp4", "quality": "audio", "video_codec": "h264"}
-        main._migrate_legacy_request(post)
-        self.assertEqual(post["download_type"], "audio")
-        self.assertEqual(post["format"], "m4a")
-        self.assertEqual(post["quality"], "best")
-
-    def test_legacy_video_default(self):
-        post = {"format": "mp4", "quality": "1080", "video_codec": "h265"}
-        main._migrate_legacy_request(post)
-        self.assertEqual(post["download_type"], "video")
-        self.assertEqual(post["codec"], "h265")
-        self.assertEqual(post["format"], "mp4")
-        self.assertEqual(post["quality"], "1080")
-
-
-class ParseLogLevelTests(unittest.TestCase):
-    def test_valid_levels(self):
-        self.assertEqual(main.parseLogLevel("INFO"), logging.INFO)
-        self.assertEqual(main.parseLogLevel("debug"), logging.DEBUG)
-
-    def test_invalid_returns_none(self):
-        self.assertIsNone(main.parseLogLevel("not_a_level"))
-        self.assertIsNone(main.parseLogLevel(123))
-
-
-class ObjectSerializerTests(unittest.TestCase):
-    def test_dict_like_object(self):
-        class Obj:
-            def __init__(self):
-                self.a = 1
-
-        ser = main.ObjectSerializer()
-        self.assertEqual(json.loads(ser.encode(Obj())), {"a": 1})
-
-    def test_generator_becomes_list(self):
-        ser = main.ObjectSerializer()
-
-        def gen():
-            yield 1
-            yield 2
-
-        self.assertEqual(json.loads(ser.encode(gen())), [1, 2])
-
-    def test_string_not_split_to_chars(self):
-        ser = main.ObjectSerializer()
-        self.assertEqual(json.loads(ser.encode("hello")), "hello")
-
-
-class FrontendSafeTests(unittest.TestCase):
-    def test_only_expected_keys(self):
-        safe = main.config.frontend_safe()
-        for key in main.Config._FRONTEND_KEYS:
-            self.assertIn(key, safe)
-        self.assertNotIn("YTDL_OPTIONS", safe)
-        self.assertNotIn("DOWNLOAD_DIR", safe)
-        self.assertIn("ALLOW_YTDL_OPTIONS_OVERRIDES", safe)
-
-
-class ParseYtdlOverridesTests(unittest.TestCase):
-    def test_empty_override_string_returns_empty_dict(self):
-        self.assertEqual(main._parse_ytdl_options_overrides("", enabled=False), {})
-
-    def test_rejects_non_object_json(self):
-        with self.assertRaises(main.web.HTTPBadRequest):
-            main._parse_ytdl_options_overrides('["bad"]', enabled=True)
-
-    def test_rejects_non_empty_overrides_when_disabled(self):
-        with self.assertRaises(main.web.HTTPBadRequest):
-            main._parse_ytdl_options_overrides('{"exec": "rm -rf /"}', enabled=False)
-
-    def test_allows_any_keys_when_enabled(self):
-        self.assertEqual(
-            main._parse_ytdl_options_overrides('{"exec": "rm -rf /"}', enabled=True),
-            {"exec": "rm -rf /"},
-        )
-
-
-class ParseDownloadOptionsTests(unittest.TestCase):
-    def test_accepts_known_preset_and_overrides(self):
-        previous = dict(main.config.YTDL_OPTIONS_PRESETS)
-        previous_allow = main.config.ALLOW_YTDL_OPTIONS_OVERRIDES
-        main.config.YTDL_OPTIONS_PRESETS = {"With subtitles": {"writesubtitles": True}}
-        main.config.ALLOW_YTDL_OPTIONS_OVERRIDES = True
-        try:
-            parsed = main.parse_download_options({
-                "url": "https://example.com/v",
-                "download_type": "video",
-                "codec": "auto",
-                "format": "any",
-                "quality": "best",
-                "ytdl_options_preset": "With subtitles",
-                "ytdl_options_overrides": '{"writesubtitles": true}',
-            })
-        finally:
-            main.config.YTDL_OPTIONS_PRESETS = previous
-            main.config.ALLOW_YTDL_OPTIONS_OVERRIDES = previous_allow
-        self.assertEqual(parsed["ytdl_options_presets"], ["With subtitles"])
-        self.assertEqual(parsed["ytdl_options_overrides"], {"writesubtitles": True})
-
-    def test_accepts_multiple_presets_in_order(self):
-        previous = dict(main.config.YTDL_OPTIONS_PRESETS)
-        main.config.YTDL_OPTIONS_PRESETS = {
-            "A": {"writesubtitles": True},
-            "B": {"writesubtitles": False},
-        }
-        try:
-            parsed = main.parse_download_options({
-                "url": "https://example.com/v",
-                "download_type": "video",
-                "codec": "auto",
-                "format": "any",
-                "quality": "best",
-                "ytdl_options_presets": ["A", "B"],
-            })
-        finally:
-            main.config.YTDL_OPTIONS_PRESETS = previous
-        self.assertEqual(parsed["ytdl_options_presets"], ["A", "B"])
-
-    def test_legacy_singular_preset_string_normalized_to_list(self):
-        previous = dict(main.config.YTDL_OPTIONS_PRESETS)
-        main.config.YTDL_OPTIONS_PRESETS = {"Solo": {}}
-        try:
-            parsed = main.parse_download_options({
-                "url": "https://example.com/v",
-                "download_type": "video",
-                "codec": "auto",
-                "format": "any",
-                "quality": "best",
-                "ytdl_options_preset": "Solo",
-            })
-        finally:
-            main.config.YTDL_OPTIONS_PRESETS = previous
-        self.assertEqual(parsed["ytdl_options_presets"], ["Solo"])
-
-    def test_rejects_unknown_preset(self):
-        with self.assertRaises(main.web.HTTPBadRequest):
-            main.parse_download_options({
-                "url": "https://example.com/v",
-                "download_type": "video",
-                "codec": "auto",
-                "format": "any",
-                "quality": "best",
-                "ytdl_options_presets": ["Missing preset"],
-            })
-
-    def test_rejects_unknown_preset_in_list(self):
-        previous = dict(main.config.YTDL_OPTIONS_PRESETS)
-        main.config.YTDL_OPTIONS_PRESETS = {"Known": {}}
-        try:
-            with self.assertRaises(main.web.HTTPBadRequest):
-                main.parse_download_options({
-                    "url": "https://example.com/v",
-                    "download_type": "video",
-                    "codec": "auto",
-                    "format": "any",
-                    "quality": "best",
-                    "ytdl_options_presets": ["Known", "Nope"],
-                })
-        finally:
-            main.config.YTDL_OPTIONS_PRESETS = previous
-
-    def test_clip_start_end_seconds_and_clock(self):
-        parsed = main.parse_download_options({
-            "url": "https://example.com/watch?v=1",
-            "download_type": "video",
-            "codec": "auto",
-            "format": "any",
-            "quality": "best",
-            "clip_start": "2:26",
-            "clip_end": "3:24",
-        })
-        self.assertEqual(parsed["clip_start"], 146.0)
-        self.assertEqual(parsed["clip_end"], 204.0)
-
-    def test_clip_url_t_param_strips_query_and_sets_start(self):
-        parsed = main.parse_download_options({
-            "url": "https://example.com/watch?v=1&t=855s",
-            "download_type": "video",
-            "codec": "auto",
-            "format": "any",
-            "quality": "best",
-        })
-        self.assertEqual(parsed["url"], "https://example.com/watch?v=1")
-        self.assertEqual(parsed["clip_start"], 855.0)
-        self.assertIsNone(parsed["clip_end"])
-
-    def test_clip_explicit_start_wins_over_url_t(self):
-        parsed = main.parse_download_options({
-            "url": "https://example.com/watch?v=1&t=100",
-            "download_type": "video",
-            "codec": "auto",
-            "format": "any",
-            "quality": "best",
-            "clip_start": "50",
-        })
-        self.assertEqual(parsed["url"], "https://example.com/watch?v=1")
-        self.assertEqual(parsed["clip_start"], 50.0)
-        self.assertIsNone(parsed["clip_end"])
-
-    def test_clip_end_only_sets_start_zero_and_strips_url_t(self):
-        parsed = main.parse_download_options({
-            "url": "https://example.com/watch?v=1&t=999",
-            "download_type": "video",
-            "codec": "auto",
-            "format": "any",
-            "quality": "best",
-            "clip_end": "60",
-        })
-        self.assertEqual(parsed["url"], "https://example.com/watch?v=1")
-        self.assertEqual(parsed["clip_start"], 0.0)
-        self.assertEqual(parsed["clip_end"], 60.0)
-
-    def test_clip_rejects_end_before_start(self):
-        with self.assertRaises(main.web.HTTPBadRequest):
-            main.parse_download_options({
-                "url": "https://example.com/watch?v=1",
-                "download_type": "video",
-                "codec": "auto",
-                "format": "any",
-                "quality": "best",
-                "clip_start": "100",
-                "clip_end": "50",
-            })
-
-    def test_clip_rejected_for_captions(self):
-        with self.assertRaises(main.web.HTTPBadRequest):
-            main.parse_download_options({
-                "url": "https://example.com/watch?v=1",
-                "download_type": "captions",
-                "codec": "auto",
-                "format": "srt",
-                "quality": "best",
-                "clip_start": "1",
-            })
-
-
-if __name__ == "__main__":
-    unittest.main()

app/tests/test_persistent_queue.py

@@ -1,291 +0,0 @@
-"""Integration tests for ``PersistentQueue`` using the JSON state store."""
-
-from __future__ import annotations
-
-import json
-import os
-import shelve
-import sys
-import tempfile
-import types
-import unittest
-from unittest.mock import patch
-
-fake_yt_dlp = types.ModuleType("yt_dlp")
-fake_networking = types.ModuleType("yt_dlp.networking")
-fake_impersonate = types.ModuleType("yt_dlp.networking.impersonate")
-fake_utils = types.ModuleType("yt_dlp.utils")
-
-
-class _ImpersonateTarget:
-    @staticmethod
-    def from_str(value):
-        return value
-
-
-fake_impersonate.ImpersonateTarget = _ImpersonateTarget
-fake_networking.impersonate = fake_impersonate
-fake_utils.STR_FORMAT_RE_TMPL = r"(?P<prefix>)%\((?P<has_key>{})\)(?P<format>[-0-9.]*{})"
-fake_utils.STR_FORMAT_TYPES = "diouxXeEfFgGcrsa"
-fake_yt_dlp.networking = fake_networking
-fake_yt_dlp.utils = fake_utils
-sys.modules.setdefault("yt_dlp", fake_yt_dlp)
-sys.modules.setdefault("yt_dlp.networking", fake_networking)
-sys.modules.setdefault("yt_dlp.networking.impersonate", fake_impersonate)
-sys.modules.setdefault("yt_dlp.utils", fake_utils)
-
-from ytdl import DownloadInfo, PersistentQueue
-
-
-class _FakeDownload:
-    __slots__ = ("info",)
-
-    def __init__(self, info: DownloadInfo):
-        self.info = info
-
-
-def _make_info(url: str = "https://example.com/v") -> DownloadInfo:
-    return DownloadInfo(
-        id="id1",
-        title="Title",
-        url=url,
-        quality="best",
-        download_type="video",
-        codec="auto",
-        format="any",
-        folder="",
-        custom_name_prefix="",
-        error=None,
-        entry=None,
-        playlist_item_limit=0,
-        split_by_chapters=False,
-        chapter_template="",
-    )
-
-
-def _create_legacy_shelf(path: str, *infos: DownloadInfo) -> None:
-    with shelve.open(path, "c") as shelf:
-        for info in infos:
-            shelf[info.url] = info
-
-
-class PersistentQueueTests(unittest.TestCase):
-    def test_put_get_delete_roundtrip(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = os.path.join(tmp, "queue")
-            pq = PersistentQueue("queue", path)
-            dl = _FakeDownload(_make_info("http://a.example"))
-            pq.put(dl)
-            self.assertTrue(os.path.exists(path + ".json"))
-            self.assertTrue(pq.exists("http://a.example"))
-            self.assertFalse(pq.empty())
-            got = pq.get("http://a.example")
-            self.assertEqual(got.info.url, "http://a.example")
-            pq.delete("http://a.example")
-            self.assertFalse(pq.exists("http://a.example"))
-
-    def test_saved_items_sorted_by_timestamp(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = os.path.join(tmp, "queue")
-            pq = PersistentQueue("queue", path)
-            a = _FakeDownload(_make_info("http://first.example"))
-            b = _FakeDownload(_make_info("http://second.example"))
-            a.info.timestamp = 100
-            b.info.timestamp = 200
-            pq.put(a)
-            pq.put(b)
-            keys = [k for k, _ in pq.saved_items()]
-            self.assertEqual(keys, ["http://first.example", "http://second.example"])
-
-    def test_load_restores_from_json(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = os.path.join(tmp, "queue")
-            pq1 = PersistentQueue("queue", path)
-            pq1.put(_FakeDownload(_make_info("http://load.example")))
-            pq2 = PersistentQueue("queue", path)
-            pq2.load()
-            self.assertTrue(pq2.exists("http://load.example"))
-
-    def test_load_imports_legacy_shelve(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = os.path.join(tmp, "queue")
-            _create_legacy_shelf(path, _make_info("http://legacy.example"))
-            pq = PersistentQueue("queue", path)
-            pq.load()
-            self.assertTrue(pq.exists("http://legacy.example"))
-            self.assertTrue(os.path.exists(path + ".json"))
-
-    def test_queue_persists_only_compact_entry_subset(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = os.path.join(tmp, "queue")
-            pq = PersistentQueue("queue", path)
-            info = _make_info("http://entry.example")
-            info.entry = {
-                "playlist_index": "01",
-                "playlist_title": "Playlist",
-                "channel_index": "02",
-                "channel_title": "Channel",
-                "formats": [{"id": "huge"}],
-                "description": "very large payload",
-            }
-            pq.put(_FakeDownload(info))
-
-            with open(path + ".json", encoding="utf-8") as f:
-                payload = json.load(f)
-
-            record = payload["items"][0]["info"]
-            self.assertEqual(
-                record["entry"],
-                {
-                    "playlist_index": "01",
-                    "playlist_title": "Playlist",
-                    "channel_index": "02",
-                    "channel_title": "Channel",
-                },
-            )
-            self.assertNotIn("formats", record["entry"])
-            self.assertNotIn("description", record["entry"])
-
-    def test_completed_queue_does_not_persist_entry_or_transient_progress(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = os.path.join(tmp, "completed")
-            pq = PersistentQueue("completed", path)
-            info = _make_info("http://done.example")
-            info.status = "finished"
-            info.percent = 88
-            info.speed = 123
-            info.eta = 9
-            info.entry = {
-                "playlist_index": "01",
-                "playlist_title": "Playlist",
-                "formats": [{"id": "huge"}],
-            }
-            info.filename = "done.mp4"
-            pq.put(_FakeDownload(info))
-
-            with open(path + ".json", encoding="utf-8") as f:
-                payload = json.load(f)
-
-            record = payload["items"][0]["info"]
-            self.assertNotIn("entry", record)
-            self.assertNotIn("percent", record)
-            self.assertNotIn("speed", record)
-            self.assertNotIn("eta", record)
-            self.assertEqual(record["filename"], "done.mp4")
-
-    def test_invalid_json_is_quarantined_and_legacy_is_imported(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = os.path.join(tmp, "queue")
-            _create_legacy_shelf(path, _make_info("http://legacy.example"))
-            with open(path + ".json", "w", encoding="utf-8") as f:
-                f.write("{not valid json")
-
-            pq = PersistentQueue("queue", path)
-            pq.load()
-
-            self.assertTrue(pq.exists("http://legacy.example"))
-            self.assertTrue(
-                any(name.startswith("queue.json.invalid.") for name in os.listdir(tmp))
-            )
-
-    def test_loading_old_json_rewrites_to_compact_format(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = os.path.join(tmp, "queue")
-            with open(path + ".json", "w", encoding="utf-8") as f:
-                json.dump(
-                    {
-                        "schema_version": 1,
-                        "kind": "persistent_queue:queue",
-                        "items": [
-                            {
-                                "key": "http://legacy-json.example",
-                                "info": {
-                                    "id": "id1",
-                                    "title": "Title",
-                                    "url": "http://legacy-json.example",
-                                    "quality": "best",
-                                    "download_type": "video",
-                                    "codec": "auto",
-                                    "format": "any",
-                                    "folder": "",
-                                    "custom_name_prefix": "",
-                                    "playlist_item_limit": 0,
-                                    "split_by_chapters": False,
-                                    "chapter_template": "",
-                                    "subtitle_language": "en",
-                                    "subtitle_mode": "prefer_manual",
-                                    "status": "pending",
-                                    "timestamp": 1,
-                                    "entry": {
-                                        "playlist_index": "01",
-                                        "playlist_title": "Playlist",
-                                        "formats": [{"id": "huge"}],
-                                    },
-                                    "percent": 15,
-                                    "speed": 20,
-                                    "eta": 30,
-                                },
-                            }
-                        ],
-                    },
-                    f,
-                )
-
-            pq = PersistentQueue("queue", path)
-            pq.load()
-
-            with open(path + ".json", encoding="utf-8") as f:
-                payload = json.load(f)
-
-            record = payload["items"][0]["info"]
-            self.assertEqual(payload["schema_version"], 2)
-            self.assertEqual(record["entry"], {"playlist_index": "01", "playlist_title": "Playlist"})
-            self.assertNotIn("percent", record)
-            self.assertNotIn("speed", record)
-            self.assertNotIn("eta", record)
-
-    def test_put_rollbacks_in_memory_queue_when_state_write_fails(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = os.path.join(tmp, "queue")
-            pq = PersistentQueue("queue", path)
-            dl = _FakeDownload(_make_info("http://rollback.example"))
-            self.assertFalse(pq.exists("http://rollback.example"))
-
-            orig_save = __import__("state_store").AtomicJsonStore.save
-
-            def bad_save(store, data):
-                if store.path == path + ".json":
-                    raise OSError("simulated shelf failure")
-                return orig_save(store, data)
-
-            with patch("ytdl.AtomicJsonStore.save", bad_save):
-                with self.assertRaises(OSError):
-                    pq.put(dl)
-
-            self.assertFalse(pq.exists("http://rollback.example"))
-
-    def test_put_rollbacks_to_previous_download_when_replace_fails(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = os.path.join(tmp, "queue")
-            pq = PersistentQueue("queue", path)
-            first = _FakeDownload(_make_info("http://same.example"))
-            second = _FakeDownload(_make_info("http://same.example"))
-            second.info.title = "Replaced title"
-            pq.put(first)
-
-            orig_save = __import__("state_store").AtomicJsonStore.save
-
-            def bad_save(store, data):
-                if store.path == path + ".json":
-                    raise OSError("simulated shelf failure")
-                return orig_save(store, data)
-
-            with patch("ytdl.AtomicJsonStore.save", bad_save):
-                with self.assertRaises(OSError):
-                    pq.put(second)
-
-            self.assertEqual(pq.get("http://same.example").info.title, "Title")
-
-
-if __name__ == "__main__":
-    unittest.main()

app/tests/test_state_store.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-import os
-import tempfile
-import unittest
-from datetime import datetime
-
-from state_store import AtomicJsonStore, from_json_compatible, to_json_compatible
-
-
-class StateStoreTests(unittest.TestCase):
-    def test_save_and_load_roundtrip(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = os.path.join(tmp, "queue.json")
-            store = AtomicJsonStore(path, kind="persistent_queue:queue")
-            store.save({"items": [{"key": "a", "info": {"title": "hello"}}]})
-
-            payload = store.load()
-
-            self.assertEqual(payload["kind"], "persistent_queue:queue")
-            self.assertEqual(payload["schema_version"], 2)
-            self.assertEqual(payload["items"][0]["info"]["title"], "hello")
-
-    def test_invalid_file_is_quarantined(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = os.path.join(tmp, "queue.json")
-            with open(path, "w", encoding="utf-8") as f:
-                f.write("{broken")
-
-            store = AtomicJsonStore(path, kind="persistent_queue:queue")
-            payload = store.load()
-
-            self.assertIsNone(payload)
-            self.assertTrue(
-                any(name.startswith("queue.json.invalid.") for name in os.listdir(tmp))
-            )
-
-    def test_json_compat_helpers_roundtrip_bytes_and_datetime(self):
-        raw = {
-            "payload": b"abc",
-            "timestamp": datetime(2024, 1, 2, 3, 4, 5),
-            "items": (1, 2, 3),
-        }
-
-        restored = from_json_compatible(to_json_compatible(raw))
-
-        self.assertEqual(restored["payload"], b"abc")
-        self.assertEqual(restored["timestamp"], datetime(2024, 1, 2, 3, 4, 5))
-        self.assertEqual(restored["items"], [1, 2, 3])
-
-
-if __name__ == "__main__":
-    unittest.main()

app/tests/test_ytdl_utils.py

@@ -1,313 +0,0 @@
-"""Tests for pure helpers and migration logic in ``ytdl``."""
-
-from __future__ import annotations
-
-import pickle
-import sys
-import tempfile
-import threading
-import types
-import unittest
-from pathlib import Path
-
-fake_yt_dlp = types.ModuleType("yt_dlp")
-fake_networking = types.ModuleType("yt_dlp.networking")
-fake_impersonate = types.ModuleType("yt_dlp.networking.impersonate")
-fake_utils = types.ModuleType("yt_dlp.utils")
-
-
-class _ImpersonateTarget:
-    @staticmethod
-    def from_str(value):
-        return value
-
-
-fake_impersonate.ImpersonateTarget = _ImpersonateTarget
-fake_networking.impersonate = fake_impersonate
-# The inner ``key`` group mirrors the real ``STR_FORMAT_RE_TMPL`` so that
-# ``_OUTTMPL_FIELD_RE`` (compiled at import time) has the named group that
-# ``_resolve_outtmpl_fields`` reads via ``match.group('key')``.
-fake_utils.STR_FORMAT_RE_TMPL = r"(?P<prefix>)%\((?P<has_key>(?P<key>{}))\)(?P<format>[-0-9.]*{})"
-fake_utils.STR_FORMAT_TYPES = "diouxXeEfFgGcrsa"
-fake_yt_dlp.networking = fake_networking
-fake_yt_dlp.utils = fake_utils
-sys.modules.setdefault("yt_dlp", fake_yt_dlp)
-sys.modules.setdefault("yt_dlp.networking", fake_networking)
-sys.modules.setdefault("yt_dlp.networking.impersonate", fake_impersonate)
-sys.modules.setdefault("yt_dlp.utils", fake_utils)
-
-from ytdl import (
-    DownloadInfo,
-    _compact_persisted_entry,
-    _convert_srt_to_txt_file,
-    _resolve_outtmpl_fields,
-    _sanitize_entry_for_pickle,
-    _sanitize_path_component,
-)
-
-# Detect whether the real yt-dlp is loaded (as opposed to the minimal fake
-# shim above).  _resolve_outtmpl_fields needs YoutubeDL at runtime.
-_has_real_ytdlp = hasattr(sys.modules.get("yt_dlp"), "YoutubeDL")
-
-
-class SanitizePathComponentTests(unittest.TestCase):
-    def test_replaces_windows_invalid_chars(self):
-        self.assertEqual(_sanitize_path_component('a:b*c?d"e<f>g|h'), "a_b_c_d_e_f_g_h")
-
-    def test_non_string_passthrough(self):
-        self.assertIs(_sanitize_path_component(None), None)
-        self.assertEqual(_sanitize_path_component(42), 42)
-
-
-@unittest.skipUnless(_has_real_ytdlp, "requires real yt-dlp")
-class ResolveOuttmplFieldsTests(unittest.TestCase):
-    """Tests for _resolve_outtmpl_fields (delegates to yt-dlp's template engine)."""
-
-    def test_simple_playlist_substitution(self):
-        info = {"playlist_title": "My PL", "playlist_index": "03"}
-        result = _resolve_outtmpl_fields("%(playlist_title)s/%(title)s.%(ext)s", info, ("playlist",))
-        self.assertEqual(result, "My PL/%(title)s.%(ext)s")
-
-    def test_format_spec_int(self):
-        info = {"playlist_index": "3"}
-        result = _resolve_outtmpl_fields("%(playlist_index)02d-%(title)s", info, ("playlist",))
-        self.assertEqual(result, "03-%(title)s")
-
-    def test_non_targeted_fields_unchanged(self):
-        info = {"playlist_title": "PL"}
-        result = _resolve_outtmpl_fields("%(title)s/%(ext)s", info, ("playlist",))
-        self.assertEqual(result, "%(title)s/%(ext)s")
-
-    def test_default_value(self):
-        info = {"playlist_index": "1"}
-        result = _resolve_outtmpl_fields("%(playlist_title|Unknown)s/%(playlist_index)s", info, ("playlist",))
-        self.assertEqual(result, "Unknown/1")
-
-    def test_channel_prefix(self):
-        info = {"channel": "MyChan", "channel_index": "05"}
-        result = _resolve_outtmpl_fields("%(channel)s/%(channel_index)02d-%(title)s", info, ("channel",))
-        self.assertEqual(result, "MyChan/05-%(title)s")
-
-    def test_math_operation(self):
-        info = {"playlist_index": "3"}
-        result = _resolve_outtmpl_fields("%(playlist_index+100)d", info, ("playlist",))
-        self.assertEqual(result, "103")
-
-    def test_playlist_count_and_autonumber(self):
-        info = {
-            "playlist_title": "My PL",
-            "playlist_index": "03",
-            "playlist_count": 10,
-            "playlist_autonumber": 3,
-            "n_entries": 10,
-            "__last_playlist_index": 10,
-        }
-        result = _resolve_outtmpl_fields(
-            "%(playlist_title)s/%(playlist_autonumber)s of %(playlist_count)s - %(title)s.%(ext)s",
-            info,
-            ("playlist",),
-        )
-        # playlist_autonumber is auto-padded by yt-dlp using __last_playlist_index
-        self.assertEqual(result, "My PL/03 of 10 - %(title)s.%(ext)s")
-
-    def test_conditional_playlist_index(self):
-        info = {
-            "playlist_index": "5",
-            "playlist_count": 10,
-        }
-        result = _resolve_outtmpl_fields(
-            "%(playlist_index&{} - |)s%(title)s.%(ext)s",
-            info,
-            ("playlist",),
-        )
-        self.assertEqual(result, "5 - %(title)s.%(ext)s")
-
-
-class SanitizeEntryForPickleTests(unittest.TestCase):
-    def test_nested(self):
-        def g():
-            yield 1
-
-        obj = {"a": g(), "b": [g()]}
-        out = _sanitize_entry_for_pickle(obj)
-        self.assertEqual(out, {"a": [1], "b": [[1]]})
-        pickle.dumps(out)
-
-    def test_plain(self):
-        self.assertEqual(_sanitize_entry_for_pickle(5), 5)
-
-    def test_set_converted_to_list(self):
-        obj = {"s": {1, 2}}
-        out = _sanitize_entry_for_pickle(obj)
-        self.assertEqual(sorted(out["s"]), [1, 2])
-        pickle.dumps(out)
-
-    def test_map_iterator(self):
-        out = _sanitize_entry_for_pickle({"m": map(int, ["1", "2"])})
-        self.assertEqual(out, {"m": [1, 2]})
-
-    def test_lock_replaced_with_none(self):
-        lock = threading.Lock()
-        out = _sanitize_entry_for_pickle({"k": lock})
-        self.assertIsNone(out["k"])
-        pickle.dumps(out)
-
-    def test_ordered_dict(self):
-        from collections import OrderedDict
-
-        od = OrderedDict([("z", 1), ("a", 2)])
-        out = _sanitize_entry_for_pickle(od)
-        self.assertEqual(out, {"z": 1, "a": 2})
-
-
-class ConvertSrtToTxtTests(unittest.TestCase):
-    def test_basic_conversion(self):
-        srt = """1
-00:00:01,000 --> 00:00:02,000
-Hello <b>world</b>
-
-2
-00:00:03,000 --> 00:00:04,000
-Second line
-"""
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "sub.srt"
-            path.write_text(srt, encoding="utf-8")
-            txt_path = _convert_srt_to_txt_file(str(path))
-            self.assertIsNotNone(txt_path)
-            self.assertTrue(txt_path.endswith(".txt"))
-            content = Path(txt_path).read_text(encoding="utf-8")
-            self.assertIn("Hello world", content)
-            self.assertIn("Second line", content)
-
-
-class DownloadInfoSetstateTests(unittest.TestCase):
-    def _base_state(self, **kwargs):
-        base = {
-            "id": "id1",
-            "title": "t",
-            "url": "http://example.com/v",
-            "folder": "",
-            "custom_name_prefix": "",
-            "error": None,
-            "entry": None,
-            "playlist_item_limit": 0,
-            "split_by_chapters": False,
-            "chapter_template": "",
-            "msg": None,
-            "percent": None,
-            "speed": None,
-            "eta": None,
-            "status": "pending",
-            "size": None,
-            "timestamp": 0,
-        }
-        base.update(kwargs)
-        return base
-
-    def test_migrates_old_audio_format(self):
-        state = self._base_state(format="m4a", quality="best")
-        di = DownloadInfo.__new__(DownloadInfo)
-        di.__setstate__(state)
-        self.assertEqual(di.download_type, "audio")
-        self.assertEqual(di.codec, "auto")
-
-    def test_migrates_thumbnail(self):
-        state = self._base_state(format="thumbnail", quality="best")
-        di = DownloadInfo.__new__(DownloadInfo)
-        di.__setstate__(state)
-        self.assertEqual(di.download_type, "thumbnail")
-        self.assertEqual(di.format, "jpg")
-
-    def test_migrates_captions(self):
-        state = self._base_state(format="captions", subtitle_format="vtt", quality="best")
-        di = DownloadInfo.__new__(DownloadInfo)
-        di.__setstate__(state)
-        self.assertEqual(di.download_type, "captions")
-        self.assertEqual(di.format, "vtt")
-
-    def test_migrates_best_ios(self):
-        state = self._base_state(
-            format="any", quality="best_ios", video_codec="auto"
-        )
-        di = DownloadInfo.__new__(DownloadInfo)
-        di.__setstate__(state)
-        self.assertEqual(di.format, "ios")
-        self.assertEqual(di.quality, "best")
-
-    def test_migrates_quality_audio(self):
-        state = self._base_state(format="mp4", quality="audio", video_codec="h264")
-        di = DownloadInfo.__new__(DownloadInfo)
-        di.__setstate__(state)
-        self.assertEqual(di.download_type, "audio")
-        self.assertEqual(di.format, "m4a")
-
-    def test_new_state_has_subtitle_files(self):
-        state = self._base_state(
-            download_type="video",
-            codec="auto",
-            format="any",
-            quality="best",
-        )
-        di = DownloadInfo.__new__(DownloadInfo)
-        di.__setstate__(state)
-        self.assertEqual(di.subtitle_files, [])
-
-    def test_missing_optional_fields_are_defaulted(self):
-        state = self._base_state(
-            download_type="video",
-            codec="auto",
-            format="any",
-            quality="best",
-        )
-        state.pop("folder")
-        state.pop("custom_name_prefix")
-        state.pop("playlist_item_limit")
-        state.pop("split_by_chapters")
-        state.pop("chapter_template")
-        di = DownloadInfo.__new__(DownloadInfo)
-        di.__setstate__(state)
-        self.assertEqual(di.folder, "")
-        self.assertEqual(di.custom_name_prefix, "")
-        self.assertEqual(di.playlist_item_limit, 0)
-        self.assertFalse(di.split_by_chapters)
-        self.assertEqual(di.chapter_template, "")
-
-
-class CompactPersistedEntryTests(unittest.TestCase):
-    def test_keeps_only_playlist_and_channel_keys(self):
-        entry = {
-            "playlist_index": "01",
-            "playlist_title": "Playlist",
-            "playlist_count": 10,
-            "playlist_autonumber": 1,
-            "channel_index": "02",
-            "channel_title": "Channel",
-            "n_entries": 10,
-            "__last_playlist_index": 10,
-            "formats": [{"id": "huge"}],
-            "description": "big blob",
-        }
-
-        compact = _compact_persisted_entry(entry)
-
-        self.assertEqual(
-            compact,
-            {
-                "playlist_index": "01",
-                "playlist_title": "Playlist",
-                "playlist_count": 10,
-                "playlist_autonumber": 1,
-                "channel_index": "02",
-                "channel_title": "Channel",
-                "n_entries": 10,
-                "__last_playlist_index": 10,
-            },
-        )
-
-    def test_returns_none_when_no_restart_relevant_keys_exist(self):
-        self.assertIsNone(_compact_persisted_entry({"id": "x", "title": "y"}))
-
-
-if __name__ == "__main__":
-    unittest.main()

pyproject.toml

@@ -15,13 +15,4 @@ dependencies = [
 [dependency-groups]
 dev = [
     "pylint",
-    "pytest>=8.0",
-    "pytest-aiohttp>=1.0",
-    "pytest-asyncio>=0.24",
 ]
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
-testpaths = ["app/tests"]
-pythonpath = [".", "app"]
-addopts = "-v"

ui/angular.json

@@ -33,7 +33,9 @@
               "node_modules/@ng-select/ng-select/themes/default.theme.css",
               "src/styles.sass"
             ],
-            "scripts": [],
+            "scripts": [
+              "node_modules/bootstrap/dist/js/bootstrap.bundle.min.js"
+            ],
             "serviceWorker": "ngsw-config.json",
             "browser": "src/main.ts",
             "polyfills": [
@@ -75,8 +77,7 @@
               "buildTarget": "metube:build:production"
             },
              "development": {
-              "buildTarget": "metube:build:development",
-              "proxyConfig": "proxy.conf.json"
+              "buildTarget": "metube:build:development"
             }
           },
            "defaultConfiguration": "development"

ui/package.json

@@ -23,24 +23,24 @@
   },
   "private": true,
   "dependencies": {
-    "@angular/animations": "^21.2.9",
-    "@angular/common": "^21.2.9",
-    "@angular/compiler": "^21.2.9",
-    "@angular/core": "^21.2.9",
-    "@angular/forms": "^21.2.9",
-    "@angular/platform-browser": "^21.2.9",
-    "@angular/platform-browser-dynamic": "^21.2.9",
-    "@angular/service-worker": "^21.2.9",
+    "@angular/animations": "^21.2.1",
+    "@angular/common": "^21.2.1",
+    "@angular/compiler": "^21.2.1",
+    "@angular/core": "^21.2.1",
+    "@angular/forms": "^21.2.1",
+    "@angular/platform-browser": "^21.2.1",
+    "@angular/platform-browser-dynamic": "^21.2.1",
+    "@angular/service-worker": "^21.2.1",
     "@fortawesome/angular-fontawesome": "~4.0.0",
     "@fortawesome/fontawesome-svg-core": "^7.2.0",
     "@fortawesome/free-brands-svg-icons": "^7.2.0",
     "@fortawesome/free-regular-svg-icons": "^7.2.0",
     "@fortawesome/free-solid-svg-icons": "^7.2.0",
     "@ng-bootstrap/ng-bootstrap": "^20.0.0",
-    "@ng-select/ng-select": "^21.8.0",
+    "@ng-select/ng-select": "^21.5.2",
     "@popperjs/core": "^2.11.8",
     "bootstrap": "^5.3.8",
-    "ngx-cookie-service": "^21.3.1",
+    "ngx-cookie-service": "^21.1.0",
     "ngx-socket-io": "~4.10.0",
     "rxjs": "~7.8.2",
     "tslib": "^2.8.1",
@@ -48,16 +48,16 @@
   },
   "devDependencies": {
     "@angular-eslint/builder": "21.1.0",
-    "@angular/build": "^21.2.7",
-    "@angular/cli": "^21.2.7",
-    "@angular/compiler-cli": "^21.2.9",
-    "@angular/localize": "^21.2.9",
-    "@eslint/js": "^9.39.4",
+    "@angular/build": "^21.2.1",
+    "@angular/cli": "^21.2.1",
+    "@angular/compiler-cli": "^21.2.1",
+    "@angular/localize": "^21.2.1",
+    "@eslint/js": "^9.39.3",
     "angular-eslint": "21.1.0",
-    "eslint": "^9.39.4",
+    "eslint": "^9.39.3",
     "jsdom": "^27.4.0",
     "typescript": "~5.9.3",
     "typescript-eslint": "8.47.0",
-    "vitest": "^4.1.5"
+    "vitest": "^4.0.18"
   }
 }

ui/pnpm-workspace.yaml

@@ -1,6 +0,0 @@
-allowBuilds:
-  '@parcel/watcher': true
-  core-js: true
-  esbuild: true
-  lmdb: true
-  msgpackr-extract: true

ui/src/app/app.config.ts

@@ -1,4 +1,4 @@
-import { ApplicationConfig, provideBrowserGlobalErrorListeners, isDevMode, provideZoneChangeDetection } from '@angular/core';
+import { ApplicationConfig, provideBrowserGlobalErrorListeners, isDevMode, provideZonelessChangeDetection, provideZoneChangeDetection } from '@angular/core';
 import { provideServiceWorker } from '@angular/service-worker';
 import { provideHttpClient, withInterceptorsFromDi } from '@angular/common/http';
 

ui/src/app/app.sass

@@ -1,7 +1,29 @@
+.button-toggle-theme:focus, .button-toggle-theme:active
+    box-shadow: none
+    outline: 0px
+
 .add-url-box
     max-width: 960px
     margin: 4rem auto
 
+.add-url-component
+    margin: 0.5rem auto
+
+.add-url-group
+    width: 100%
+
+button.add-url
+    width: 100%
+
+.folder-dropdown-menu
+    width: 500px
+    max-width: calc(100vw - 3rem)
+
+.folder-dropdown-menu .input-group
+    display: flex
+    padding-left: 5px
+    padding-right: 5px
+
 .metube-section-header
     font-size: 1.8rem
     font-weight: 300
@@ -44,11 +66,39 @@ td
     width: 12rem
     margin-left: auto
 
+.batch-panel
+  margin-top: 15px
+  border: 1px solid #ccc
+  border-radius: 8px
+  padding: 15px
+  background-color: #fff
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1)
+
+.batch-panel-header
+  border-bottom: 1px solid #eee
+  padding-bottom: 8px
+  margin-bottom: 15px
+  h4
+    font-size: 1.5rem
+    margin: 0
+
+.batch-panel-body
+  textarea.form-control
+    resize: vertical
+
+.batch-status
+  font-size: 0.9rem
+  color: #555
+
+.d-flex.my-3
+  margin-top: 1rem
+  margin-bottom: 1rem
+
 .modal.fade.show
   background-color: rgba(0, 0, 0, 0.5)
 
 .modal-header
-  border-bottom: 1px solid var(--bs-border-color)
+  border-bottom: 1px solid #eee
 
 .modal-body
   textarea.form-control
@@ -62,12 +112,20 @@ td
   .spinner-border
     margin-right: 0.5rem
 
-.add-progress-btn
-  min-width: 9.5rem
-  cursor: default
-
-.add-cancel-btn
-  min-width: 3.25rem
+::ng-deep .ng-select
+    flex: 1
+    .ng-select-container
+        min-height: 38px
+    .ng-value
+        white-space: nowrap
+        overflow: visible
+    .ng-dropdown-panel
+        .ng-dropdown-panel-items
+            max-height: 300px
+            .ng-option
+                white-space: nowrap
+                overflow: visible
+                text-overflow: ellipsis
 
 :host
   display: flex
@@ -182,18 +240,6 @@ main
     opacity: 0.65
     pointer-events: none
 
-.settings-section-label
-  font-size: 0.8rem
-  text-transform: uppercase
-  letter-spacing: 0.1em
-  font-weight: 600
-  color: var(--bs-body-color)
-  margin-top: 1.75rem
-  margin-bottom: 0.75rem
-
-  &:first-child
-    margin-top: 0
-
 .action-group-label
   font-size: 0.7rem
   text-transform: uppercase

ui/src/app/app.spec.ts

@@ -1,134 +1,26 @@
 import { TestBed } from '@angular/core/testing';
-import { HttpClient } from '@angular/common/http';
-import { Subject, of } from 'rxjs';
 import { App } from './app';
-import { DownloadsService } from './services/downloads.service';
-import { SubscriptionsService } from './services/subscriptions.service';
-import { CookieService } from 'ngx-cookie-service';
 
-class DownloadsServiceStub {
-  loading = false;
-  queue = new Map();
-  done = new Map();
-  configuration: Record<string, unknown> = { CUSTOM_DIRS: true, CREATE_CUSTOM_DIRS: true, ALLOW_YTDL_OPTIONS_OVERRIDES: false };
-  customDirs = { download_dir: [], audio_download_dir: [] };
-  queueChanged = new Subject<void>();
-  doneChanged = new Subject<void>();
-  configurationChanged = new Subject<Record<string, unknown>>();
-  customDirsChanged = new Subject<Record<string, string[]>>();
-  ytdlOptionsChanged = new Subject<Record<string, unknown>>();
-  updated = new Subject<void>();
+vi.hoisted(() => {
+  Object.defineProperty(window, "matchMedia", {
+    writable: true,
+    enumerable: true,
+    value: vi.fn().mockImplementation((query) => ({
+      matches: false,
+      media: query,
+      onchange: null,
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+ })),
+ });
+});
 
-  getCookieStatus() {
-    return of({ status: 'ok', has_cookies: false });
-  }
-
-  getPresets() {
-    return of({ presets: ['Preset A'] });
-  }
-
-  add() {
-    return of({ status: 'ok' as const });
-  }
-
-  cancelAdd() {
-    return of({ status: 'ok' as const });
-  }
-
-  startById() {
-    return of({});
-  }
-
-  delById() {
-    return of({});
-  }
-
-  delByFilter() {
-    return of({});
-  }
-
-  startByFilter() {
-    return of({});
-  }
-
-  uploadCookies() {
-    return of({ status: 'ok' });
-  }
-
-  deleteCookies() {
-    return of({ status: 'ok' });
-  }
-}
-
-class SubscriptionsServiceStub {
-  subscriptions = new Map();
-  subscriptionsChanged = new Subject<void>();
-  subscribeCalls: unknown[] = [];
-
-  subscribe(payload: unknown) {
-    this.subscribeCalls.push(payload);
-    return of({ status: 'ok' as const });
-  }
-
-  delete() {
-    return of({});
-  }
-
-  update() {
-    return of({ status: 'ok' as const });
-  }
-
-  refreshList() {
-    return of([]);
-  }
-}
-
-class CookieServiceStub {
-  private cookies = new Map<string, string>();
-
-  get(name: string) {
-    return this.cookies.get(name) ?? '';
-  }
-
-  set(name: string, value: string) {
-    this.cookies.set(name, value);
-  }
-
-  check(name: string) {
-    return this.cookies.has(name);
-  }
-}
 
 describe('App', () => {
-  let downloads: DownloadsServiceStub;
-
   beforeEach(async () => {
-    Object.defineProperty(window, 'matchMedia', {
-      writable: true,
-      enumerable: true,
-      value: vi.fn().mockImplementation((query: string) => ({
-        matches: false,
-        media: query,
-        onchange: null,
-        addEventListener: vi.fn(),
-        removeEventListener: vi.fn(),
-        dispatchEvent: vi.fn(),
-      })),
-    });
-    downloads = new DownloadsServiceStub();
     await TestBed.configureTestingModule({
       imports: [App],
-      providers: [
-        { provide: DownloadsService, useValue: downloads },
-        { provide: SubscriptionsService, useClass: SubscriptionsServiceStub },
-        { provide: CookieService, useClass: CookieServiceStub },
-        {
-          provide: HttpClient,
-          useValue: {
-            get: vi.fn().mockReturnValue(of({ 'yt-dlp': 'test', version: 'test' })),
-          },
-        },
-      ],
     }).compileComponents();
   });
 
@@ -138,109 +30,4 @@ describe('App', () => {
     expect(app).toBeTruthy();
   });
 
-  it('hides manual override input when disabled', () => {
-    const fixture = TestBed.createComponent(App);
-    fixture.componentInstance.isAdvancedOpen = true;
-    fixture.detectChanges();
-
-    const root = fixture.nativeElement as HTMLElement;
-    expect(root.querySelector('input[name="ytdlOptionsOverrides"]')).toBeNull();
-
-    const presetWrapper = root.querySelector('ng-select[name="ytdlOptionsPresets"]')?.closest('.col-12');
-    expect(presetWrapper?.classList.contains('col-md-6')).toBe(false);
-
-    const presetRow = root.querySelector('ng-select[name="ytdlOptionsPresets"]')?.closest('.row');
-    expect(presetRow?.querySelector('input[name="checkIntervalMinutes"]')).toBeNull();
-  });
-
-  it('shows manual override input when enabled', () => {
-    downloads.configuration['ALLOW_YTDL_OPTIONS_OVERRIDES'] = true;
-
-    const fixture = TestBed.createComponent(App);
-    fixture.componentInstance.isAdvancedOpen = true;
-    fixture.detectChanges();
-
-    const root = fixture.nativeElement as HTMLElement;
-    expect(root.querySelector('input[name="ytdlOptionsOverrides"]')).not.toBeNull();
-
-    const presetWrapper = root.querySelector('ng-select[name="ytdlOptionsPresets"]')?.closest('.col-12');
-    expect(presetWrapper?.classList.contains('col-md-6')).toBe(true);
-
-    const presetRow = root.querySelector('ng-select[name="ytdlOptionsPresets"]')?.closest('.row');
-    expect(presetRow?.querySelector('input[name="checkIntervalMinutes"]')).toBeNull();
-    expect(presetRow?.querySelector('input[name="ytdlOptionsOverrides"]')).not.toBeNull();
-  });
-
-  it('does not submit manual overrides when disabled', () => {
-    const fixture = TestBed.createComponent(App);
-    const app = fixture.componentInstance;
-
-    app.ytdlOptionsOverrides = '{"exec":"echo hi"}';
-
-    const payload = app['buildAddPayload']();
-
-    expect(payload.ytdlOptionsOverrides).toBe('');
-  });
-
-  it('includes titleRegex in subscribe payload', () => {
-    const fixture = TestBed.createComponent(App);
-    const app = fixture.componentInstance;
-    const subs = TestBed.inject(SubscriptionsService) as unknown as SubscriptionsServiceStub;
-    app.addUrl = 'https://example.com/channel';
-    app.titleRegex = 'EPISODE';
-    app.addSubscription();
-    expect(subs.subscribeCalls.length).toBe(1);
-    const payload = subs.subscribeCalls[0] as { titleRegex: string; skipSubscriberOnly: boolean };
-    expect(payload.titleRegex).toBe('EPISODE');
-    expect(payload.skipSubscriberOnly).toBe(false);
-  });
-
-  it('includes skipSubscriberOnly true when checked', () => {
-    const fixture = TestBed.createComponent(App);
-    const app = fixture.componentInstance;
-    const subs = TestBed.inject(SubscriptionsService) as unknown as SubscriptionsServiceStub;
-    app.addUrl = 'https://example.com/channel';
-    app.skipSubscriberOnly = true;
-    app.addSubscription();
-    expect(subs.subscribeCalls.length).toBe(1);
-    const payload = subs.subscribeCalls[0] as { skipSubscriberOnly: boolean };
-    expect(payload.skipSubscriberOnly).toBe(true);
-  });
-
-  it('omits clip fields from subscribe payload', () => {
-    const fixture = TestBed.createComponent(App);
-    const app = fixture.componentInstance;
-    const subs = TestBed.inject(SubscriptionsService) as unknown as SubscriptionsServiceStub;
-    app.addUrl = 'https://example.com/channel';
-    app.clipStart = '1:00';
-    app.clipEnd = '2:00';
-    app.addSubscription();
-    expect(subs.subscribeCalls.length).toBe(1);
-    const payload = subs.subscribeCalls[0] as Record<string, unknown>;
-    expect('clipStart' in payload).toBe(false);
-    expect('clipEnd' in payload).toBe(false);
-  });
-
-  it('buildAddPayload includes clip times', () => {
-    const fixture = TestBed.createComponent(App);
-    const app = fixture.componentInstance;
-    app.clipStart = '0:10';
-    app.clipEnd = '1:20';
-    const payload = app['buildAddPayload']();
-    expect(payload.clipStart).toBe('0:10');
-    expect(payload.clipEnd).toBe('1:20');
-  });
-
-  it('blocks subscribe with invalid title regex', () => {
-    const alertSpy = vi.spyOn(window, 'alert').mockImplementation(() => undefined);
-    const fixture = TestBed.createComponent(App);
-    const app = fixture.componentInstance;
-    const subs = TestBed.inject(SubscriptionsService) as unknown as SubscriptionsServiceStub;
-    app.addUrl = 'https://example.com/channel';
-    app.titleRegex = '[';
-    app.addSubscription();
-    expect(subs.subscribeCalls.length).toBe(0);
-    expect(alertSpy).toHaveBeenCalledWith('Invalid subscription title filter (regex)');
-    alertSpy.mockRestore();
-  });
 });

ui/src/app/components/index.ts

@@ -1,2 +1,2 @@
-export { SelectAllCheckboxComponent } from './master-checkbox.component';
-export { ItemCheckboxComponent } from './slave-checkbox.component';
+export { MasterCheckboxComponent } from './master-checkbox.component';
+export { SlaveCheckboxComponent } from './slave-checkbox.component';

ui/src/app/components/master-checkbox.component.spec.ts

@@ -1,23 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { SelectAllCheckboxComponent } from './master-checkbox.component';
-import { Checkable } from '../interfaces';
-
-describe('SelectAllCheckboxComponent', () => {
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      imports: [SelectAllCheckboxComponent],
-    }).compileComponents();
-  });
-
-  it('clicked sets checked on all list items', () => {
-    const fixture = TestBed.createComponent(SelectAllCheckboxComponent);
-    const list = new Map<string, Checkable>();
-    list.set('u1', { checked: false });
-    fixture.componentRef.setInput('id', 'queue');
-    fixture.componentRef.setInput('list', list);
-    fixture.componentInstance.selected = true;
-    fixture.detectChanges();
-    fixture.componentInstance.clicked();
-    expect(list.get('u1')?.checked).toBe(true);
-  });
-});

ui/src/app/components/master-checkbox.component.ts

@@ -3,18 +3,18 @@ import { Checkable } from "../interfaces";
 import { FormsModule } from "@angular/forms";
 
 @Component({
-    selector: 'app-select-all-checkbox',
+    selector: 'app-master-checkbox',
     template: `
   <div class="form-check">
-    <input type="checkbox" class="form-check-input" id="{{id()}}-select-all" #masterCheckbox [(ngModel)]="selected" (change)="clicked()" [attr.aria-label]="'Select all ' + id() + ' items'">
-    <label class="form-check-label visually-hidden" for="{{id()}}-select-all">Select all</label>
+    <input type="checkbox" class="form-check-input" id="{{id()}}-select-all" #masterCheckbox [(ngModel)]="selected" (change)="clicked()">
+    <label class="form-check-label" for="{{id()}}-select-all"></label>
   </div>
 `,
 imports: [
   FormsModule
 ]
 })
-export class SelectAllCheckboxComponent {
+export class MasterCheckboxComponent {
   readonly id = input.required<string>();
   readonly list = input.required<Map<string, Checkable>>();
   readonly changed = output<number>();
@@ -33,7 +33,7 @@ export class SelectAllCheckboxComponent {
       return;
     let checked = 0;
     this.list().forEach(item => { if(item.checked) checked++ });
-    this.selected = checked > 0 && checked === this.list().size;
+    this.selected = checked > 0 && checked == this.list().size;
     masterCheckbox.nativeElement.indeterminate = checked > 0 && checked < this.list().size;
     this.changed.emit(checked);
   }

ui/src/app/components/slave-checkbox.component.spec.ts

@@ -1,25 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { SelectAllCheckboxComponent } from './master-checkbox.component';
-import { ItemCheckboxComponent } from './slave-checkbox.component';
-
-describe('ItemCheckboxComponent', () => {
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      imports: [ItemCheckboxComponent, SelectAllCheckboxComponent],
-    }).compileComponents();
-  });
-
-  it('creates with master and checkable inputs', () => {
-    const masterFixture = TestBed.createComponent(SelectAllCheckboxComponent);
-    masterFixture.componentRef.setInput('id', 'q');
-    masterFixture.componentRef.setInput('list', new Map());
-    masterFixture.detectChanges();
-
-    const itemFixture = TestBed.createComponent(ItemCheckboxComponent);
-    itemFixture.componentRef.setInput('id', 'row1');
-    itemFixture.componentRef.setInput('master', masterFixture.componentInstance);
-    itemFixture.componentRef.setInput('checkable', { checked: false });
-    itemFixture.detectChanges();
-    expect(itemFixture.componentInstance).toBeTruthy();
-  });
-});

ui/src/app/components/slave-checkbox.component.ts

@@ -1,22 +1,22 @@
 import { Component, input } from '@angular/core';
-import { SelectAllCheckboxComponent } from './master-checkbox.component';
+import { MasterCheckboxComponent } from './master-checkbox.component';
 import { Checkable } from '../interfaces';
 import { FormsModule } from '@angular/forms';
 
 @Component({
-    selector: 'app-item-checkbox',
+    selector: 'app-slave-checkbox',
     template: `
   <div class="form-check">
-    <input type="checkbox" class="form-check-input" id="{{master().id()}}-{{id()}}-select" [(ngModel)]="checkable().checked" (change)="master().selectionChanged()" [attr.aria-label]="'Select item ' + id()">
-    <label class="form-check-label visually-hidden" for="{{master().id()}}-{{id()}}-select">Select item</label>
+    <input type="checkbox" class="form-check-input" id="{{master().id()}}-{{id()}}-select" [(ngModel)]="checkable().checked" (change)="master().selectionChanged()">
+    <label class="form-check-label" for="{{master().id()}}-{{id()}}-select"></label>
   </div>
 `,
 imports: [  
   FormsModule
 ]
 })
-export class ItemCheckboxComponent {
+export class SlaveCheckboxComponent {
   readonly id = input.required<string>();
-  readonly master = input.required<SelectAllCheckboxComponent>();
+  readonly master = input.required<MasterCheckboxComponent>();
   readonly checkable = input.required<Checkable>();
 }

ui/src/app/interfaces/download.ts

@@ -3,8 +3,6 @@ export interface Download {
   id: string;
   title: string;
   url: string;
-  download_type: string;
-  codec?: string;
   quality: string;
   format: string;
   folder: string;
@@ -12,12 +10,9 @@ export interface Download {
   playlist_item_limit: number;
   split_by_chapters?: boolean;
   chapter_template?: string;
+  subtitle_format?: string;
   subtitle_language?: string;
   subtitle_mode?: string;
-  ytdl_options_presets?: string[];
-  ytdl_options_overrides?: Record<string, unknown>;
-  clip_start?: number;
-  clip_end?: number;
   status: string;
   msg: string;
   percent: number;
@@ -25,9 +20,8 @@ export interface Download {
   eta: number;
   filename: string;
   checked: boolean;
-  timestamp?: number;
   size?: number;
   error?: string;
   deleting?: boolean;
-  chapter_files?: { filename: string, size: number }[];
+  chapter_files?: Array<{ filename: string, size: number }>;
 }

ui/src/app/interfaces/formats.ts

@@ -1,77 +1,81 @@
-import { Quality } from "./quality";
+import { Format } from "./format";
 
-export interface Option {
-  id: string;
-  text: string;
-}
 
-export interface AudioFormatOption extends Option {
-  qualities: Quality[];
-}
-
-export const DOWNLOAD_TYPES: Option[] = [
-  { id: "video", text: "Video" },
-  { id: "audio", text: "Audio" },
-  { id: "captions", text: "Captions" },
-  { id: "thumbnail", text: "Thumbnail" },
-];
-
-export const VIDEO_CODECS: Option[] = [
-  { id: "auto", text: "Auto" },
-  { id: "h264", text: "H.264" },
-  { id: "h265", text: "H.265 (HEVC)" },
-  { id: "av1", text: "AV1" },
-  { id: "vp9", text: "VP9" },
-];
-
-export const VIDEO_FORMATS: Option[] = [
-  { id: "any", text: "Auto" },
-  { id: "mp4", text: "MP4" },
-  { id: "ios", text: "iOS Compatible" },
-];
-
-export const VIDEO_QUALITIES: Quality[] = [
-  { id: "best", text: "Best" },
-  { id: "2160", text: "2160p" },
-  { id: "1440", text: "1440p" },
-  { id: "1080", text: "1080p" },
-  { id: "720", text: "720p" },
-  { id: "480", text: "480p" },
-  { id: "360", text: "360p" },
-  { id: "240", text: "240p" },
-  { id: "worst", text: "Worst" },
-];
-
-export const AUDIO_FORMATS: AudioFormatOption[] = [
+export const Formats: Format[] = [
   {
-    id: "m4a",
-    text: "M4A",
+    id: 'any',
+    text: 'Any',
     qualities: [
-      { id: "best", text: "Best" },
-      { id: "192", text: "192 kbps" },
-      { id: "128", text: "128 kbps" },
+      { id: 'best', text: 'Best' },
+      { id: '2160', text: '2160p' },
+      { id: '1440', text: '1440p' },
+      { id: '1080', text: '1080p' },
+      { id: '720', text: '720p' },
+      { id: '480', text: '480p' },
+      { id: '360', text: '360p' },
+      { id: '240', text: '240p' },
+      { id: 'worst', text: 'Worst' },
+      { id: 'audio', text: 'Audio Only' },
     ],
   },
   {
-    id: "mp3",
-    text: "MP3",
+    id: 'mp4',
+    text: 'MP4',
     qualities: [
-      { id: "best", text: "Best" },
-      { id: "320", text: "320 kbps" },
-      { id: "192", text: "192 kbps" },
-      { id: "128", text: "128 kbps" },
+      { id: 'best', text: 'Best' },
+      { id: 'best_ios', text: 'Best (iOS)' },
+      { id: '2160', text: '2160p' },
+      { id: '1440', text: '1440p' },
+      { id: '1080', text: '1080p' },
+      { id: '720', text: '720p' },
+      { id: '480', text: '480p' },
+      { id: '360', text: '360p' },
+      { id: '240', text: '240p' },
+      { id: 'worst', text: 'Worst' },
     ],
   },
-  { id: "opus", text: "OPUS", qualities: [{ id: "best", text: "Best" }] },
-  { id: "wav", text: "WAV", qualities: [{ id: "best", text: "Best" }] },
-  { id: "flac", text: "FLAC", qualities: [{ id: "best", text: "Best" }] },
+  {
+    id: 'm4a',
+    text: 'M4A',
+    qualities: [
+      { id: 'best', text: 'Best' },
+      { id: '192', text: '192 kbps' },
+      { id: '128', text: '128 kbps' },
+    ],
+  },
+  {
+    id: 'mp3',
+    text: 'MP3',
+    qualities: [
+      { id: 'best', text: 'Best' },
+      { id: '320', text: '320 kbps' },
+      { id: '192', text: '192 kbps' },
+      { id: '128', text: '128 kbps' },
+    ],
+  },
+  {
+    id: 'opus',
+    text: 'OPUS',
+    qualities: [{ id: 'best', text: 'Best' }],
+  },
+  {
+    id: 'wav',
+    text: 'WAV',
+    qualities: [{ id: 'best', text: 'Best' }],
+  },
+  {
+    id: 'flac',
+    text: 'FLAC',
+    qualities: [{ id: 'best', text: 'Best' }],
+  },
+  {
+    id: 'thumbnail',
+    text: 'Thumbnail',
+    qualities: [{ id: 'best', text: 'Best' }],
+  },
+  {
+    id: 'captions',
+    text: 'Captions',
+    qualities: [{ id: 'best', text: 'Best' }],
+  },
 ];
-
-export const CAPTION_FORMATS: Option[] = [
-  { id: "srt", text: "SRT" },
-  { id: "txt", text: "TXT (Text only)" },
-  { id: "vtt", text: "VTT" },
-  { id: "ttml", text: "TTML" },
-];
-
-export const THUMBNAIL_FORMATS: Option[] = [{ id: "jpg", text: "JPG" }];

ui/src/app/interfaces/index.ts

@@ -6,4 +6,4 @@ export * from './download';
 export * from './checkable';
 export * from './format';
 export * from './formats';
-export * from './subscription';
+

ui/src/app/interfaces/subscription.ts

@@ -1,17 +0,0 @@
-export interface SubscriptionRow {
-  id: string;
-  name: string;
-  url: string;
-  enabled: boolean;
-  check_interval_minutes: number;
-  download_type: string;
-  codec: string;
-  format: string;
-  quality: string;
-  folder: string;
-  title_regex?: string;
-  skip_subscriber_only?: boolean;
-  last_checked: number | null;
-  seen_count: number;
-  error: string | null;
-}

ui/src/app/pipes/eta.pipe.spec.ts

@@ -1,26 +0,0 @@
-import { EtaPipe } from './eta.pipe';
-
-describe('EtaPipe', () => {
-  it('returns null for null input', () => {
-    const pipe = new EtaPipe();
-    expect(pipe.transform(null as unknown as number)).toBeNull();
-  });
-
-  it('formats seconds under one minute', () => {
-    const pipe = new EtaPipe();
-    expect(pipe.transform(0)).toBe('0s');
-    expect(pipe.transform(59)).toBe('59s');
-  });
-
-  it('formats minutes and seconds', () => {
-    const pipe = new EtaPipe();
-    expect(pipe.transform(60)).toBe('1m 0s');
-    expect(pipe.transform(90)).toBe('1m 30s');
-  });
-
-  it('formats hours', () => {
-    const pipe = new EtaPipe();
-    expect(pipe.transform(3600)).toBe('1h 0m 0s');
-    expect(pipe.transform(3661)).toBe('1h 1m 1s');
-  });
-});

ui/src/app/pipes/file-size.pipe.spec.ts

@@ -1,24 +0,0 @@
-import { FileSizePipe } from './file-size.pipe';
-
-describe('FileSizePipe', () => {
-  it('returns 0 Bytes for zero or NaN', () => {
-    const pipe = new FileSizePipe();
-    expect(pipe.transform(0)).toBe('0 Bytes');
-    expect(pipe.transform(Number.NaN)).toBe('0 Bytes');
-  });
-
-  it('formats bytes and larger units', () => {
-    const pipe = new FileSizePipe();
-    expect(pipe.transform(500)).toContain('Bytes');
-    expect(pipe.transform(1000)).toContain('KB');
-    expect(pipe.transform(1000 * 1000)).toContain('MB');
-    expect(pipe.transform(1000 ** 3)).toContain('GB');
-  });
-
-  it('handles boundaries between units', () => {
-    const pipe = new FileSizePipe();
-    expect(pipe.transform(999)).toContain('Bytes');
-    expect(pipe.transform(1000)).toContain('KB');
-    expect(pipe.transform(1001)).toContain('KB');
-  });
-});

ui/src/app/pipes/speed.pipe.spec.ts

@@ -1,21 +0,0 @@
-import { SpeedPipe } from './speed.pipe';
-
-describe('SpeedPipe', () => {
-  it('returns empty string for non-positive speed values', () => {
-    const pipe = new SpeedPipe();
-    expect(pipe.transform(0)).toBe('');
-    expect(pipe.transform(-1)).toBe('');
-  });
-
-  it('formats bytes per second values', () => {
-    const pipe = new SpeedPipe();
-    expect(pipe.transform(1024)).toBe('1 KB/s');
-    expect(pipe.transform(1536)).toBe('1.5 KB/s');
-  });
-
-  it('formats MB/s and GB/s', () => {
-    const pipe = new SpeedPipe();
-    expect(pipe.transform(1024 * 1024)).toBe('1 MB/s');
-    expect(pipe.transform(1024 * 1024 * 1024)).toBe('1 GB/s');
-  });
-});

ui/src/app/pipes/speed.pipe.ts

@@ -1,19 +1,43 @@
 import { Pipe, PipeTransform } from "@angular/core";
+import { BehaviorSubject, throttleTime } from "rxjs";
 
 @Pipe({
     name: 'speed',
-    pure: true
+    pure: false // Make the pipe impure so it can handle async updates
 })
 export class SpeedPipe implements PipeTransform {
+  private speedSubject = new BehaviorSubject<number>(0);
+  private formattedSpeed = '';
+
+  constructor() {
+    // Throttle updates to once per second
+    this.speedSubject.pipe(
+      throttleTime(1000)
+    ).subscribe(speed => {
+      // If speed is invalid or 0, return empty string
+      if (speed === null || speed === undefined || isNaN(speed) || speed <= 0) {
+        this.formattedSpeed = '';
+        return;
+      }
+      
+      const k = 1024;
+      const dm = 2;
+      const sizes = ['B/s', 'KB/s', 'MB/s', 'GB/s', 'TB/s', 'PB/s', 'EB/s', 'ZB/s', 'YB/s'];
+      const i = Math.floor(Math.log(speed) / Math.log(k));
+      this.formattedSpeed = parseFloat((speed / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+    });
+  }
+
   transform(value: number): string {
+    // If speed is invalid or 0, return empty string
     if (value === null || value === undefined || isNaN(value) || value <= 0) {
       return '';
     }
-
-    const k = 1024;
-    const decimals = 2;
-    const sizes = ['B/s', 'KB/s', 'MB/s', 'GB/s', 'TB/s', 'PB/s', 'EB/s', 'ZB/s', 'YB/s'];
-    const i = Math.floor(Math.log(value) / Math.log(k));
-    return `${parseFloat((value / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
+    
+    // Update the speed subject
+    this.speedSubject.next(value);
+    
+    // Return the last formatted speed
+    return this.formattedSpeed;
   }
 }

ui/src/app/services/downloads.service.spec.ts

@@ -1,312 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { provideHttpClient, HttpErrorResponse } from '@angular/common/http';
-import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';
-import { Subject } from 'rxjs';
-import { DownloadsService, AddDownloadPayload } from './downloads.service';
-import { MeTubeSocket } from './metube-socket.service';
-import { Download } from '../interfaces';
-
-class MeTubeSocketStub {
-  private subjects: Record<string, Subject<string>> = {};
-
-  fromEvent(event: string) {
-    if (!this.subjects[event]) {
-      this.subjects[event] = new Subject<string>();
-    }
-    return this.subjects[event].asObservable();
-  }
-
-  emit(event: string, data: string) {
-    if (!this.subjects[event]) {
-      this.subjects[event] = new Subject<string>();
-    }
-    this.subjects[event].next(data);
-  }
-}
-
-function basePayload(): AddDownloadPayload {
-  return {
-    url: 'https://example.com/v',
-    downloadType: 'video',
-    codec: 'auto',
-    quality: 'best',
-    format: 'any',
-    folder: '',
-    customNamePrefix: '',
-    playlistItemLimit: 0,
-    autoStart: true,
-    splitByChapters: false,
-    chapterTemplate: '',
-    subtitleLanguage: 'en',
-    subtitleMode: 'prefer_manual',
-    ytdlOptionsPresets: [],
-    ytdlOptionsOverrides: '',
-    clipStart: '',
-    clipEnd: '',
-  };
-}
-
-describe('DownloadsService', () => {
-  let socket: MeTubeSocketStub;
-  let httpMock: HttpTestingController;
-  let service: DownloadsService;
-
-  beforeEach(async () => {
-    socket = new MeTubeSocketStub();
-    await TestBed.configureTestingModule({
-      providers: [
-        DownloadsService,
-        provideHttpClient(),
-        provideHttpClientTesting(),
-        { provide: MeTubeSocket, useValue: socket },
-      ],
-    }).compileComponents();
-
-    service = TestBed.inject(DownloadsService);
-    httpMock = TestBed.inject(HttpTestingController);
-  });
-
-  it('add() posts snake_case fields matching backend', () => {
-    service.add(basePayload()).subscribe();
-    const req = httpMock.expectOne('add');
-    expect(req.request.method).toBe('POST');
-    expect(req.request.body).toEqual(
-      expect.objectContaining({
-        url: 'https://example.com/v',
-        download_type: 'video',
-        codec: 'auto',
-        quality: 'best',
-        format: 'any',
-        playlist_item_limit: 0,
-        auto_start: true,
-        split_by_chapters: false,
-        chapter_template: '',
-        subtitle_language: 'en',
-        subtitle_mode: 'prefer_manual',
-        ytdl_options_presets: [],
-        ytdl_options_overrides: '',
-      }),
-    );
-    req.flush({ status: 'ok' });
-  });
-
-  it('add() sends clip_start and clip_end when set', () => {
-    service
-      .add({
-        ...basePayload(),
-        clipStart: '1:00',
-        clipEnd: '2:00',
-      })
-      .subscribe();
-    const req = httpMock.expectOne('add');
-    expect(req.request.body).toEqual(
-      expect.objectContaining({
-        clip_start: '1:00',
-        clip_end: '2:00',
-      }),
-    );
-    req.flush({ status: 'ok' });
-  });
-
-  it('getPresets() fetches configured preset names', () => {
-    service.getPresets().subscribe((result) => {
-      expect(result).toEqual({ presets: ['Preset A'] });
-    });
-    const req = httpMock.expectOne('presets');
-    expect(req.request.method).toBe('GET');
-    req.flush({ presets: ['Preset A'] });
-  });
-
-  it('cancelAdd posts to cancel-add', () => {
-    service.cancelAdd().subscribe();
-    const req = httpMock.expectOne('cancel-add');
-    expect(req.request.method).toBe('POST');
-    req.flush({ status: 'ok' });
-  });
-
-  it('startById posts ids', () => {
-    service.startById(['a', 'b']).subscribe();
-    const req = httpMock.expectOne('start');
-    expect(req.request.body).toEqual({ ids: ['a', 'b'] });
-    req.flush({});
-  });
-
-  it('delById marks items deleting and posts delete', () => {
-    const dl: Download = {
-      id: '1',
-      title: 't',
-      url: 'u1',
-      download_type: 'video',
-      quality: 'best',
-      format: 'any',
-      folder: '',
-      custom_name_prefix: '',
-      playlist_item_limit: 0,
-      status: 'finished',
-      msg: '',
-      percent: 0,
-      speed: 0,
-      eta: 0,
-      filename: '',
-      checked: false,
-      deleting: false,
-    };
-    service.queue.set('u1', dl);
-    service.delById('queue', ['u1']).subscribe();
-    expect(dl.deleting).toBe(true);
-    const req = httpMock.expectOne('delete');
-    expect(req.request.body).toEqual({ where: 'queue', ids: ['u1'] });
-    req.flush({});
-  });
-
-  it('handleHTTPError extracts msg from object body', async () => {
-    const err = new HttpErrorResponse({
-      error: { msg: 'bad' },
-      status: 400,
-    });
-    const res = await new Promise((resolve) => {
-      service.handleHTTPError(err).subscribe(resolve);
-    });
-    expect((res as { status: string }).status).toBe('error');
-    expect((res as { msg?: string }).msg).toBe('bad');
-  });
-
-  it('socket all updates queue and done', () => {
-    const row: Download = {
-      id: '1',
-      title: 't',
-      url: 'u1',
-      download_type: 'video',
-      quality: 'best',
-      format: 'any',
-      folder: '',
-      custom_name_prefix: '',
-      playlist_item_limit: 0,
-      status: 'pending',
-      msg: '',
-      percent: 0,
-      speed: 0,
-      eta: 0,
-      filename: '',
-      checked: false,
-    };
-    const q: [string, Download][] = [['u1', row]];
-    const d: [string, Download][] = [];
-    socket.emit('all', JSON.stringify([q, d]));
-    expect(service.loading).toBe(false);
-    expect(service.queue.has('u1')).toBe(true);
-  });
-
-  it('socket updated preserves checked and deleting', () => {
-    service.queue.set('u1', {
-      id: '1',
-      title: 't',
-      url: 'u1',
-      download_type: 'video',
-      quality: 'best',
-      format: 'any',
-      folder: '',
-      custom_name_prefix: '',
-      playlist_item_limit: 0,
-      status: 'pending',
-      msg: '',
-      percent: 0,
-      speed: 0,
-      eta: 0,
-      filename: '',
-      checked: true,
-      deleting: true,
-    });
-    socket.emit(
-      'updated',
-      JSON.stringify({ url: 'u1', title: 't', status: 'downloading' }),
-    );
-    const updated = service.queue.get('u1');
-    expect(updated?.checked).toBe(true);
-    expect(updated?.deleting).toBe(true);
-  });
-
-  it('socket completed moves entry to done', () => {
-    service.queue.set('u1', {
-      id: '1',
-      title: 't',
-      url: 'u1',
-      download_type: 'video',
-      quality: 'best',
-      format: 'any',
-      folder: '',
-      custom_name_prefix: '',
-      playlist_item_limit: 0,
-      status: 'pending',
-      msg: '',
-      percent: 0,
-      speed: 0,
-      eta: 0,
-      filename: '',
-      checked: false,
-    });
-    socket.emit('completed', JSON.stringify({ url: 'u1', title: 't', status: 'finished' }));
-    expect(service.queue.has('u1')).toBe(false);
-    expect(service.done.has('u1')).toBe(true);
-  });
-
-  it('socket canceled removes from queue', () => {
-    service.queue.set('u1', {
-      id: '1',
-      title: 't',
-      url: 'u1',
-      download_type: 'video',
-      quality: 'best',
-      format: 'any',
-      folder: '',
-      custom_name_prefix: '',
-      playlist_item_limit: 0,
-      status: 'pending',
-      msg: '',
-      percent: 0,
-      speed: 0,
-      eta: 0,
-      filename: '',
-      checked: false,
-    });
-    socket.emit('canceled', JSON.stringify('u1'));
-    expect(service.queue.has('u1')).toBe(false);
-  });
-
-  it('socket cleared removes from done', () => {
-    service.done.set('u1', {
-      id: '1',
-      title: 't',
-      url: 'u1',
-      download_type: 'video',
-      quality: 'best',
-      format: 'any',
-      folder: '',
-      custom_name_prefix: '',
-      playlist_item_limit: 0,
-      status: 'finished',
-      msg: '',
-      percent: 0,
-      speed: 0,
-      eta: 0,
-      filename: '',
-      checked: false,
-    });
-    socket.emit('cleared', JSON.stringify('u1'));
-    expect(service.done.has('u1')).toBe(false);
-  });
-
-  it('socket configuration updates configuration', () => {
-    socket.emit('configuration', JSON.stringify({ CUSTOM_DIRS: true }));
-    expect(service.configuration['CUSTOM_DIRS']).toBe(true);
-  });
-
-  it('socket custom_dirs updates customDirs', () => {
-    socket.emit('custom_dirs', JSON.stringify({ download_dir: [''] }));
-    expect(service.customDirs['download_dir']).toEqual(['']);
-  });
-
-  afterEach(() => {
-    httpMock.verify();
-  });
-});

ui/src/app/services/downloads.service.ts

@@ -5,26 +5,6 @@ import { catchError } from 'rxjs/operators';
 import { MeTubeSocket } from './metube-socket.service';
 import { Download, Status, State } from '../interfaces';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
-
-export interface AddDownloadPayload {
-  url: string;
-  downloadType: string;
-  codec: string;
-  quality: string;
-  format: string;
-  folder: string;
-  customNamePrefix: string;
-  playlistItemLimit: number;
-  autoStart: boolean;
-  splitByChapters: boolean;
-  chapterTemplate: string;
-  subtitleLanguage: string;
-  subtitleMode: string;
-  ytdlOptionsPresets: string[];
-  ytdlOptionsOverrides: string;
-  clipStart?: string;
-  clipEnd?: string;
-}
 @Injectable({
   providedIn: 'root'
 })
@@ -34,15 +14,16 @@ export class DownloadsService {
   loading = true;
   queue = new Map<string, Download>();
   done = new Map<string, Download>();
-  queueChanged = new Subject<void>();
-  doneChanged = new Subject<void>();
-  customDirsChanged = new Subject<Record<string, string[]>>();
-  ytdlOptionsChanged = new Subject<Record<string, unknown>>();
-  configurationChanged = new Subject<Record<string, unknown>>();
-  updated = new Subject<void>();
+  queueChanged = new Subject();
+  doneChanged = new Subject();
+  customDirsChanged = new Subject();
+  ytdlOptionsChanged = new Subject();
+  configurationChanged = new Subject();
+  updated = new Subject();
 
-  configuration: Record<string, unknown> = {};
-  customDirs: Record<string, string[]> = {};
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  configuration: any = {};
+  customDirs = {};
 
   constructor() {
     this.socket.fromEvent('all')
@@ -54,15 +35,15 @@ export class DownloadsService {
       data[0].forEach(entry => this.queue.set(...entry));
       this.done.clear();
       data[1].forEach(entry => this.done.set(...entry));
-      this.queueChanged.next();
-      this.doneChanged.next();
+      this.queueChanged.next(null);
+      this.doneChanged.next(null);
     });
     this.socket.fromEvent('added')
     .pipe(takeUntilDestroyed())
     .subscribe((strdata: string) => {
       const data: Download = JSON.parse(strdata);
       this.queue.set(data.url, data);
-      this.queueChanged.next();
+      this.queueChanged.next(null);
     });
     this.socket.fromEvent('updated')
     .pipe(takeUntilDestroyed())
@@ -72,7 +53,7 @@ export class DownloadsService {
       data.checked = !!dl?.checked;
       data.deleting = !!dl?.deleting;
       this.queue.set(data.url, data);
-      this.updated.next();
+      this.updated.next(null);
     });
     this.socket.fromEvent('completed')
     .pipe(takeUntilDestroyed())
@@ -80,22 +61,22 @@ export class DownloadsService {
       const data: Download = JSON.parse(strdata);
       this.queue.delete(data.url);
       this.done.set(data.url, data);
-      this.queueChanged.next();
-      this.doneChanged.next();
+      this.queueChanged.next(null);
+      this.doneChanged.next(null);
     });
     this.socket.fromEvent('canceled')
     .pipe(takeUntilDestroyed())
     .subscribe((strdata: string) => {
       const data: string = JSON.parse(strdata);
       this.queue.delete(data);
-      this.queueChanged.next();
+      this.queueChanged.next(null);
     });
     this.socket.fromEvent('cleared')
     .pipe(takeUntilDestroyed())
     .subscribe((strdata: string) => {
       const data: string = JSON.parse(strdata);
       this.done.delete(data);
-      this.doneChanged.next();
+      this.doneChanged.next(null);
     });
     this.socket.fromEvent('configuration')
     .pipe(takeUntilDestroyed())
@@ -122,47 +103,42 @@ export class DownloadsService {
   }
 
   handleHTTPError(error: HttpErrorResponse) {
-    const msg = error.error instanceof ErrorEvent
-      ? error.error.message
-      : (typeof error.error === 'string'
-          ? error.error
-          : (error.error?.msg || error.message || 'Request failed'));
-    return of({ status: 'error', msg });
+    const msg = error.error instanceof ErrorEvent ? error.error.message : error.error;
+    return of({status: 'error', msg: msg})
   }
 
-  public add(payload: AddDownloadPayload) {
-    const body: Record<string, unknown> = {
-      url: payload.url,
-      download_type: payload.downloadType,
-      codec: payload.codec,
-      quality: payload.quality,
-      format: payload.format,
-      folder: payload.folder,
-      custom_name_prefix: payload.customNamePrefix,
-      playlist_item_limit: payload.playlistItemLimit,
-      auto_start: payload.autoStart,
-      split_by_chapters: payload.splitByChapters,
-      chapter_template: payload.chapterTemplate,
-      subtitle_language: payload.subtitleLanguage,
-      subtitle_mode: payload.subtitleMode,
-      ytdl_options_presets: payload.ytdlOptionsPresets,
-      ytdl_options_overrides: payload.ytdlOptionsOverrides,
-    };
-    const cs = payload.clipStart?.trim();
-    const ce = payload.clipEnd?.trim();
-    if (cs) body['clip_start'] = cs;
-    if (ce) body['clip_end'] = ce;
-    return this.http.post<Status>('add', body).pipe(
+  public add(
+    url: string,
+    quality: string,
+    format: string,
+    folder: string,
+    customNamePrefix: string,
+    playlistItemLimit: number,
+    autoStart: boolean,
+    splitByChapters: boolean,
+    chapterTemplate: string,
+    subtitleFormat: string,
+    subtitleLanguage: string,
+    subtitleMode: string,
+  ) {
+    return this.http.post<Status>('add', {
+      url: url,
+      quality: quality,
+      format: format,
+      folder: folder,
+      custom_name_prefix: customNamePrefix,
+      playlist_item_limit: playlistItemLimit,
+      auto_start: autoStart,
+      split_by_chapters: splitByChapters,
+      chapter_template: chapterTemplate,
+      subtitle_format: subtitleFormat,
+      subtitle_language: subtitleLanguage,
+      subtitle_mode: subtitleMode
+    }).pipe(
       catchError(this.handleHTTPError)
     );
   }
 
-  public getPresets() {
-    return this.http.get<{ presets: string[] }>('presets').pipe(
-      catchError(() => of({ presets: [] }))
-    );
-  }
-
   public startById(ids: string[]) {
     return this.http.post('start', {ids: ids});
   }
@@ -191,6 +167,47 @@ export class DownloadsService {
     this[where].forEach((dl: Download) => { if (filter(dl)) ids.push(dl.url) });
     return this.delById(where, ids);
   }
+  public addDownloadByUrl(url: string): Promise<{
+    response: Status} | {
+    status: string;
+    msg?: string;
+  }> {
+    const defaultQuality = 'best';
+    const defaultFormat = 'mp4';
+    const defaultFolder = ''; 
+    const defaultCustomNamePrefix = '';
+    const defaultPlaylistItemLimit = 0;
+    const defaultAutoStart = true;
+    const defaultSplitByChapters = false;
+    const defaultChapterTemplate = this.configuration['OUTPUT_TEMPLATE_CHAPTER'];
+    const defaultSubtitleFormat = 'srt';
+    const defaultSubtitleLanguage = 'en';
+    const defaultSubtitleMode = 'prefer_manual';
+
+    return new Promise((resolve, reject) => {
+      this.add(
+        url,
+        defaultQuality,
+        defaultFormat,
+        defaultFolder,
+        defaultCustomNamePrefix,
+        defaultPlaylistItemLimit,
+        defaultAutoStart,
+        defaultSplitByChapters,
+        defaultChapterTemplate,
+        defaultSubtitleFormat,
+        defaultSubtitleLanguage,
+        defaultSubtitleMode,
+      )
+        .subscribe({
+          next: (response) => resolve(response),
+          error: (error) => reject(error)
+        });
+    });
+  }
+  public exportQueueUrls(): string[] {
+    return Array.from(this.queue.values()).map(download => download.url);
+  }
   public cancelAdd() {
     return this.http.post<Status>('cancel-add', {}).pipe(
       catchError(this.handleHTTPError)
@@ -200,19 +217,19 @@ export class DownloadsService {
   uploadCookies(file: File) {
     const formData = new FormData();
     formData.append('cookies', file);
-    return this.http.post<{ status: string; msg?: string }>('upload-cookies', formData).pipe(
+    return this.http.post<any>('upload-cookies', formData).pipe(
       catchError(this.handleHTTPError)
     );
   }
 
   deleteCookies() {
-    return this.http.post<{ status: string; msg?: string }>('delete-cookies', {}).pipe(
+    return this.http.post<any>('delete-cookies', {}).pipe(
       catchError(this.handleHTTPError)
     );
   }
 
   getCookieStatus() {
-    return this.http.get<{ status: string; has_cookies: boolean }>('cookie-status').pipe(
+    return this.http.get<any>('cookie-status').pipe(
       catchError(this.handleHTTPError)
     );
   }

ui/src/app/services/index.ts

@@ -1,2 +1,3 @@
 export { DownloadsService } from './downloads.service';
+export { SpeedService } from './speed.service';
 export { MeTubeSocket } from './metube-socket.service';

ui/src/app/services/speed.service.ts

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable, interval } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SpeedService {
+  private speedBuffer = new BehaviorSubject<number[]>([]);
+  private readonly BUFFER_SIZE = 10; // Keep last 10 measurements (1 second at 100ms intervals)
+
+  // Observable that emits the mean speed every second
+  public meanSpeed$: Observable<number>;
+
+  constructor() {
+    // Calculate mean speed every second
+    this.meanSpeed$ = interval(1000).pipe(
+      map(() => {
+        const speeds = this.speedBuffer.value;
+        if (speeds.length === 0) return 0;
+        return speeds.reduce((sum, speed) => sum + speed, 0) / speeds.length;
+      })
+    );
+  }
+
+  // Add a new speed measurement
+  public addSpeedMeasurement(speed: number) {
+    const currentBuffer = this.speedBuffer.value;
+    const newBuffer = [...currentBuffer, speed].slice(-this.BUFFER_SIZE);
+    this.speedBuffer.next(newBuffer);
+  }
+
+  // Get the current mean speed
+  public getCurrentMeanSpeed(): number {
+    const speeds = this.speedBuffer.value;
+    if (speeds.length === 0) return 0;
+    return speeds.reduce((sum, speed) => sum + speed, 0) / speeds.length;
+  }
+} 

ui/src/app/services/subscriptions.service.ts

@@ -1,142 +0,0 @@
-import { DestroyRef, inject, Injectable } from '@angular/core';
-import { HttpClient, HttpErrorResponse } from '@angular/common/http';
-import { of, Subject } from 'rxjs';
-import { catchError, tap } from 'rxjs/operators';
-import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
-import { MeTubeSocket } from './metube-socket.service';
-import { SubscriptionRow } from '../interfaces/subscription';
-import { Status } from '../interfaces';
-import { AddDownloadPayload } from './downloads.service';
-
-export interface SubscribePayload extends AddDownloadPayload {
-  checkIntervalMinutes: number;
-  titleRegex: string;
-  skipSubscriberOnly: boolean;
-}
-
-@Injectable({
-  providedIn: 'root',
-})
-export class SubscriptionsService {
-  private http = inject(HttpClient);
-  private socket = inject(MeTubeSocket);
-  private destroyRef = inject(DestroyRef);
-
-  subscriptions = new Map<string, SubscriptionRow>();
-  subscriptionsChanged = new Subject<void>();
-
-  private publishList(rows: SubscriptionRow[]) {
-    this.subscriptions.clear();
-    for (const row of rows) {
-      this.subscriptions.set(row.id, row);
-    }
-    this.subscriptionsChanged.next();
-  }
-
-  constructor() {
-    this.socket
-      .fromEvent('subscriptions_all')
-      .pipe(takeUntilDestroyed(this.destroyRef))
-      .subscribe((strdata: string) => {
-        const data: SubscriptionRow[] = JSON.parse(strdata);
-        this.publishList(data);
-      });
-
-    this.socket
-      .fromEvent('subscription_added')
-      .pipe(takeUntilDestroyed(this.destroyRef))
-      .subscribe((strdata: string) => {
-        const row: SubscriptionRow = JSON.parse(strdata);
-        this.subscriptions.set(row.id, row);
-        this.subscriptionsChanged.next();
-      });
-
-    this.socket
-      .fromEvent('subscription_updated')
-      .pipe(takeUntilDestroyed(this.destroyRef))
-      .subscribe((strdata: string) => {
-        const row: SubscriptionRow = JSON.parse(strdata);
-        this.subscriptions.set(row.id, row);
-        this.subscriptionsChanged.next();
-      });
-
-    this.socket
-      .fromEvent('subscription_removed')
-      .pipe(takeUntilDestroyed(this.destroyRef))
-      .subscribe((strdata: string) => {
-        const id: string = JSON.parse(strdata);
-        this.subscriptions.delete(id);
-        this.subscriptionsChanged.next();
-      });
-  }
-
-  handleHTTPError(error: HttpErrorResponse) {
-    const msg =
-      error.error instanceof ErrorEvent
-        ? error.error.message
-        : typeof error.error === 'string'
-          ? error.error
-          : error.error?.msg || error.message || 'Request failed';
-    return of({ status: 'error' as const, msg });
-  }
-
-  subscribe(payload: SubscribePayload) {
-    return this.http
-      .post<Status>('subscribe', {
-        url: payload.url,
-        download_type: payload.downloadType,
-        codec: payload.codec,
-        quality: payload.quality,
-        format: payload.format,
-        folder: payload.folder,
-        custom_name_prefix: payload.customNamePrefix,
-        playlist_item_limit: payload.playlistItemLimit,
-        auto_start: payload.autoStart,
-        split_by_chapters: payload.splitByChapters,
-        chapter_template: payload.chapterTemplate,
-        subtitle_language: payload.subtitleLanguage,
-        subtitle_mode: payload.subtitleMode,
-        ytdl_options_presets: payload.ytdlOptionsPresets,
-        ytdl_options_overrides: payload.ytdlOptionsOverrides,
-        check_interval_minutes: payload.checkIntervalMinutes,
-        title_regex: payload.titleRegex,
-        skip_subscriber_only: payload.skipSubscriberOnly,
-      })
-      .pipe(catchError((err) => this.handleHTTPError(err)));
-  }
-
-  delete(ids: string[]) {
-    return this.http.post('subscriptions/delete', { ids }).pipe(catchError((err) => this.handleHTTPError(err)));
-  }
-
-  update(
-    id: string,
-    changes: Partial<
-      Pick<
-        SubscriptionRow,
-        'enabled' | 'check_interval_minutes' | 'name' | 'title_regex' | 'skip_subscriber_only'
-      >
-    >,
-  ) {
-    return this.http
-      .post('subscriptions/update', { id, ...changes })
-      .pipe(catchError((err) => this.handleHTTPError(err)));
-  }
-
-  checkNow(ids?: string[]) {
-    return this.http
-      .post('subscriptions/check', ids?.length ? { ids } : {})
-      .pipe(catchError((err) => this.handleHTTPError(err)));
-  }
-
-  fetchList() {
-    return this.http.get<SubscriptionRow[]>('subscriptions').pipe(catchError(() => of([])));
-  }
-
-  refreshList() {
-    return this.http.get<SubscriptionRow[]>('subscriptions').pipe(
-      tap((rows) => this.publishList(rows)),
-      catchError((err) => this.handleHTTPError(err)),
-    );
-  }
-}

ui/src/styles.sass

@@ -5,22 +5,3 @@
 
     [data-bs-theme="dark"] &
         background-color: var(--bs-dark-bg-subtle) !important
-
-.ng-select
-    flex: 1
-
-    .ng-select-container
-        min-height: 38px
-
-    .ng-value
-        white-space: nowrap
-        overflow: visible
-
-    .ng-dropdown-panel
-        .ng-dropdown-panel-items
-            max-height: 300px
-
-            .ng-option
-                white-space: nowrap
-                overflow: visible
-                text-overflow: ellipsis

uv.lock

@@ -13,7 +13,7 @@ wheels = [
 
 [[package]]
 name = "aiohttp"
-version = "3.13.5"
+version = "3.13.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohappyeyeballs" },
@@ -24,59 +24,59 @@ dependencies = [
     { name = "propcache" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/77/9a/152096d4808df8e4268befa55fba462f440f14beab85e8ad9bf990516918/aiohttp-3.13.5.tar.gz", hash = "sha256:9d98cc980ecc96be6eb4c1994ce35d28d8b1f5e5208a23b421187d1209dbb7d1", size = 7858271, upload-time = "2026-03-31T22:01:03.343Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/50/42/32cf8e7704ceb4481406eb87161349abb46a57fee3f008ba9cb610968646/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88", size = 7844556, upload-time = "2026-01-03T17:33:05.204Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/e9/d76bf503005709e390122d34e15256b88f7008e246c4bdbe915cd4f1adce/aiohttp-3.13.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5029cc80718bbd545123cd8fe5d15025eccaaaace5d0eeec6bd556ad6163d61", size = 742930, upload-time = "2026-03-31T21:58:13.155Z" },
-    { url = "https://files.pythonhosted.org/packages/57/00/4b7b70223deaebd9bb85984d01a764b0d7bd6526fcdc73cca83bcbe7243e/aiohttp-3.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4bb6bf5811620003614076bdc807ef3b5e38244f9d25ca5fe888eaccea2a9832", size = 496927, upload-time = "2026-03-31T21:58:15.073Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/f5/0fb20fb49f8efdcdce6cd8127604ad2c503e754a8f139f5e02b01626523f/aiohttp-3.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a84792f8631bf5a94e52d9cc881c0b824ab42717165a5579c760b830d9392ac9", size = 497141, upload-time = "2026-03-31T21:58:17.009Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/86/b7c870053e36a94e8951b803cb5b909bfbc9b90ca941527f5fcafbf6b0fa/aiohttp-3.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:57653eac22c6a4c13eb22ecf4d673d64a12f266e72785ab1c8b8e5940d0e8090", size = 1732476, upload-time = "2026-03-31T21:58:18.925Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/e5/4e161f84f98d80c03a238671b4136e6530453d65262867d989bbe78244d0/aiohttp-3.13.5-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5e5f7debc7a57af53fdf5c5009f9391d9f4c12867049d509bf7bb164a6e295b", size = 1706507, upload-time = "2026-03-31T21:58:21.094Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/56/ea11a9f01518bd5a2a2fcee869d248c4b8a0cfa0bb13401574fa31adf4d4/aiohttp-3.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c719f65bebcdf6716f10e9eff80d27567f7892d8988c06de12bbbd39307c6e3a", size = 1773465, upload-time = "2026-03-31T21:58:23.159Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/40/333ca27fb74b0383f17c90570c748f7582501507307350a79d9f9f3c6eb1/aiohttp-3.13.5-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d97f93fdae594d886c5a866636397e2bcab146fd7a132fd6bb9ce182224452f8", size = 1873523, upload-time = "2026-03-31T21:58:25.59Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/d2/e2f77eef1acb7111405433c707dc735e63f67a56e176e72e9e7a2cd3f493/aiohttp-3.13.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3df334e39d4c2f899a914f1dba283c1aadc311790733f705182998c6f7cae665", size = 1754113, upload-time = "2026-03-31T21:58:27.624Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/56/3f653d7f53c89669301ec9e42c95233e2a0c0a6dd051269e6e678db4fdb0/aiohttp-3.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe6970addfea9e5e081401bcbadf865d2b6da045472f58af08427e108d618540", size = 1562351, upload-time = "2026-03-31T21:58:29.918Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/a6/9b3e91eb8ae791cce4ee736da02211c85c6f835f1bdfac0594a8a3b7018c/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7becdf835feff2f4f335d7477f121af787e3504b48b449ff737afb35869ba7bb", size = 1693205, upload-time = "2026-03-31T21:58:32.214Z" },
-    { url = "https://files.pythonhosted.org/packages/98/fc/bfb437a99a2fcebd6b6eaec609571954de2ed424f01c352f4b5504371dd3/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:676e5651705ad5d8a70aeb8eb6936c436d8ebbd56e63436cb7dd9bb36d2a9a46", size = 1730618, upload-time = "2026-03-31T21:58:34.728Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/b6/c8534862126191a034f68153194c389addc285a0f1347d85096d349bbc15/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:9b16c653d38eb1a611cc898c41e76859ca27f119d25b53c12875fd0474ae31a8", size = 1745185, upload-time = "2026-03-31T21:58:36.909Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/93/4ca8ee2ef5236e2707e0fd5fecb10ce214aee1ff4ab307af9c558bda3b37/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:999802d5fa0389f58decd24b537c54aa63c01c3219ce17d1214cbda3c2b22d2d", size = 1557311, upload-time = "2026-03-31T21:58:39.38Z" },
-    { url = "https://files.pythonhosted.org/packages/57/ae/76177b15f18c5f5d094f19901d284025db28eccc5ae374d1d254181d33f4/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ec707059ee75732b1ba130ed5f9580fe10ff75180c812bc267ded039db5128c6", size = 1773147, upload-time = "2026-03-31T21:58:41.476Z" },
-    { url = "https://files.pythonhosted.org/packages/01/a4/62f05a0a98d88af59d93b7fcac564e5f18f513cb7471696ac286db970d6a/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2d6d44a5b48132053c2f6cd5c8cb14bc67e99a63594e336b0f2af81e94d5530c", size = 1730356, upload-time = "2026-03-31T21:58:44.049Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/85/fc8601f59dfa8c9523808281f2da571f8b4699685f9809a228adcc90838d/aiohttp-3.13.5-cp313-cp313-win32.whl", hash = "sha256:329f292ed14d38a6c4c435e465f48bebb47479fd676a0411936cc371643225cc", size = 432637, upload-time = "2026-03-31T21:58:46.167Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/1b/ac685a8882896acf0f6b31d689e3792199cfe7aba37969fa91da63a7fa27/aiohttp-3.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:69f571de7500e0557801c0b51f4780482c0ec5fe2ac851af5a92cfce1af1cb83", size = 458896, upload-time = "2026-03-31T21:58:48.119Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/ce/46572759afc859e867a5bc8ec3487315869013f59281ce61764f76d879de/aiohttp-3.13.5-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:eb4639f32fd4a9904ab8fb45bf3383ba71137f3d9d4ba25b3b3f3109977c5b8c", size = 745721, upload-time = "2026-03-31T21:58:50.229Z" },
-    { url = "https://files.pythonhosted.org/packages/13/fe/8a2efd7626dbe6049b2ef8ace18ffda8a4dfcbe1bcff3ac30c0c7575c20b/aiohttp-3.13.5-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:7e5dc4311bd5ac493886c63cbf76ab579dbe4641268e7c74e48e774c74b6f2be", size = 497663, upload-time = "2026-03-31T21:58:52.232Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/91/cc8cc78a111826c54743d88651e1687008133c37e5ee615fee9b57990fac/aiohttp-3.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:756c3c304d394977519824449600adaf2be0ccee76d206ee339c5e76b70ded25", size = 499094, upload-time = "2026-03-31T21:58:54.566Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/33/a8362cb15cf16a3af7e86ed11962d5cd7d59b449202dc576cdc731310bde/aiohttp-3.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecc26751323224cf8186efcf7fbcbc30f4e1d8c7970659daf25ad995e4032a56", size = 1726701, upload-time = "2026-03-31T21:58:56.864Z" },
-    { url = "https://files.pythonhosted.org/packages/45/0c/c091ac5c3a17114bd76cbf85d674650969ddf93387876cf67f754204bd77/aiohttp-3.13.5-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10a75acfcf794edf9d8db50e5a7ec5fc818b2a8d3f591ce93bc7b1210df016d2", size = 1683360, upload-time = "2026-03-31T21:58:59.072Z" },
-    { url = "https://files.pythonhosted.org/packages/23/73/bcee1c2b79bc275e964d1446c55c54441a461938e70267c86afaae6fba27/aiohttp-3.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0f7a18f258d124cd678c5fe072fe4432a4d5232b0657fca7c1847f599233c83a", size = 1773023, upload-time = "2026-03-31T21:59:01.776Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/ef/720e639df03004fee2d869f771799d8c23046dec47d5b81e396c7cda583a/aiohttp-3.13.5-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:df6104c009713d3a89621096f3e3e88cc323fd269dbd7c20afe18535094320be", size = 1853795, upload-time = "2026-03-31T21:59:04.568Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/c9/989f4034fb46841208de7aeeac2c6d8300745ab4f28c42f629ba77c2d916/aiohttp-3.13.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:241a94f7de7c0c3b616627aaad530fe2cb620084a8b144d3be7b6ecfe95bae3b", size = 1730405, upload-time = "2026-03-31T21:59:07.221Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/75/ee1fd286ca7dc599d824b5651dad7b3be7ff8d9a7e7b3fe9820d9180f7db/aiohttp-3.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c974fb66180e58709b6fc402846f13791240d180b74de81d23913abe48e96d94", size = 1558082, upload-time = "2026-03-31T21:59:09.484Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/20/1e9e6650dfc436340116b7aa89ff8cb2bbdf0abc11dfaceaad8f74273a10/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:6e27ea05d184afac78aabbac667450c75e54e35f62238d44463131bd3f96753d", size = 1692346, upload-time = "2026-03-31T21:59:12.068Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/40/8ebc6658d48ea630ac7903912fe0dd4e262f0e16825aa4c833c56c9f1f56/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a79a6d399cef33a11b6f004c67bb07741d91f2be01b8d712d52c75711b1e07c7", size = 1698891, upload-time = "2026-03-31T21:59:14.552Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/78/ea0ae5ec8ba7a5c10bdd6e318f1ba5e76fcde17db8275188772afc7917a4/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c632ce9c0b534fbe25b52c974515ed674937c5b99f549a92127c85f771a78772", size = 1742113, upload-time = "2026-03-31T21:59:17.068Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/66/9d308ed71e3f2491be1acb8769d96c6f0c47d92099f3bc9119cada27b357/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fceedde51fbd67ee2bcc8c0b33d0126cc8b51ef3bbde2f86662bd6d5a6f10ec5", size = 1553088, upload-time = "2026-03-31T21:59:19.541Z" },
-    { url = "https://files.pythonhosted.org/packages/da/a6/6cc25ed8dfc6e00c90f5c6d126a98e2cf28957ad06fa1036bd34b6f24a2c/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f92995dfec9420bb69ae629abf422e516923ba79ba4403bc750d94fb4a6c68c1", size = 1757976, upload-time = "2026-03-31T21:59:22.311Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/2b/cce5b0ffe0de99c83e5e36d8f828e4161e415660a9f3e58339d07cce3006/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:20ae0ff08b1f2c8788d6fb85afcb798654ae6ba0b747575f8562de738078457b", size = 1712444, upload-time = "2026-03-31T21:59:24.635Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/cf/9e1795b4160c58d29421eafd1a69c6ce351e2f7c8d3c6b7e4ca44aea1a5b/aiohttp-3.13.5-cp314-cp314-win32.whl", hash = "sha256:b20df693de16f42b2472a9c485e1c948ee55524786a0a34345511afdd22246f3", size = 438128, upload-time = "2026-03-31T21:59:27.291Z" },
-    { url = "https://files.pythonhosted.org/packages/22/4d/eaedff67fc805aeba4ba746aec891b4b24cebb1a7d078084b6300f79d063/aiohttp-3.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:f85c6f327bf0b8c29da7d93b1cabb6363fb5e4e160a32fa241ed2dce21b73162", size = 464029, upload-time = "2026-03-31T21:59:29.429Z" },
-    { url = "https://files.pythonhosted.org/packages/79/11/c27d9332ee20d68dd164dc12a6ecdef2e2e35ecc97ed6cf0d2442844624b/aiohttp-3.13.5-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:1efb06900858bb618ff5cee184ae2de5828896c448403d51fb633f09e109be0a", size = 778758, upload-time = "2026-03-31T21:59:31.547Z" },
-    { url = "https://files.pythonhosted.org/packages/04/fb/377aead2e0a3ba5f09b7624f702a964bdf4f08b5b6728a9799830c80041e/aiohttp-3.13.5-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:fee86b7c4bd29bdaf0d53d14739b08a106fdda809ca5fe032a15f52fae5fe254", size = 512883, upload-time = "2026-03-31T21:59:34.098Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/a6/aa109a33671f7a5d3bd78b46da9d852797c5e665bfda7d6b373f56bff2ec/aiohttp-3.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:20058e23909b9e65f9da62b396b77dfa95965cbe840f8def6e572538b1d32e36", size = 516668, upload-time = "2026-03-31T21:59:36.497Z" },
-    { url = "https://files.pythonhosted.org/packages/79/b3/ca078f9f2fa9563c36fb8ef89053ea2bb146d6f792c5104574d49d8acb63/aiohttp-3.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cf20a8d6868cb15a73cab329ffc07291ba8c22b1b88176026106ae39aa6df0f", size = 1883461, upload-time = "2026-03-31T21:59:38.723Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/e3/a7ad633ca1ca497b852233a3cce6906a56c3225fb6d9217b5e5e60b7419d/aiohttp-3.13.5-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:330f5da04c987f1d5bdb8ae189137c77139f36bd1cb23779ca1a354a4b027800", size = 1747661, upload-time = "2026-03-31T21:59:41.187Z" },
-    { url = "https://files.pythonhosted.org/packages/33/b9/cd6fe579bed34a906d3d783fe60f2fa297ef55b27bb4538438ee49d4dc41/aiohttp-3.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6f1cbf0c7926d315c3c26c2da41fd2b5d2fe01ac0e157b78caefc51a782196cf", size = 1863800, upload-time = "2026-03-31T21:59:43.84Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/3f/2c1e2f5144cefa889c8afd5cf431994c32f3b29da9961698ff4e3811b79a/aiohttp-3.13.5-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:53fc049ed6390d05423ba33103ded7281fe897cf97878f369a527070bd95795b", size = 1958382, upload-time = "2026-03-31T21:59:46.187Z" },
-    { url = "https://files.pythonhosted.org/packages/66/1d/f31ec3f1013723b3babe3609e7f119c2c2fb6ef33da90061a705ef3e1bc8/aiohttp-3.13.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:898703aa2667e3c5ca4c54ca36cd73f58b7a38ef87a5606414799ebce4d3fd3a", size = 1803724, upload-time = "2026-03-31T21:59:48.656Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/b4/57712dfc6f1542f067daa81eb61da282fab3e6f1966fca25db06c4fc62d5/aiohttp-3.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0494a01ca9584eea1e5fbd6d748e61ecff218c51b576ee1999c23db7066417d8", size = 1640027, upload-time = "2026-03-31T21:59:51.284Z" },
-    { url = "https://files.pythonhosted.org/packages/25/3c/734c878fb43ec083d8e31bf029daae1beafeae582d1b35da234739e82ee7/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6cf81fe010b8c17b09495cbd15c1d35afbc8fb405c0c9cf4738e5ae3af1d65be", size = 1806644, upload-time = "2026-03-31T21:59:53.753Z" },
-    { url = "https://files.pythonhosted.org/packages/20/a5/f671e5cbec1c21d044ff3078223f949748f3a7f86b14e34a365d74a5d21f/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:c564dd5f09ddc9d8f2c2d0a301cd30a79a2cc1b46dd1a73bef8f0038863d016b", size = 1791630, upload-time = "2026-03-31T21:59:56.239Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/63/fb8d0ad63a0b8a99be97deac8c04dacf0785721c158bdf23d679a87aa99e/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2994be9f6e51046c4f864598fd9abeb4fba6e88f0b2152422c9666dcd4aea9c6", size = 1809403, upload-time = "2026-03-31T21:59:59.103Z" },
-    { url = "https://files.pythonhosted.org/packages/59/0c/bfed7f30662fcf12206481c2aac57dedee43fe1c49275e85b3a1e1742294/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:157826e2fa245d2ef46c83ea8a5faf77ca19355d278d425c29fda0beb3318037", size = 1634924, upload-time = "2026-03-31T22:00:02.116Z" },
-    { url = "https://files.pythonhosted.org/packages/17/d6/fd518d668a09fd5a3319ae5e984d4d80b9a4b3df4e21c52f02251ef5a32e/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a8aca50daa9493e9e13c0f566201a9006f080e7c50e5e90d0b06f53146a54500", size = 1836119, upload-time = "2026-03-31T22:00:04.756Z" },
-    { url = "https://files.pythonhosted.org/packages/78/b7/15fb7a9d52e112a25b621c67b69c167805cb1f2ab8f1708a5c490d1b52fe/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3b13560160d07e047a93f23aaa30718606493036253d5430887514715b67c9d9", size = 1772072, upload-time = "2026-03-31T22:00:07.494Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/df/57ba7f0c4a553fc2bd8b6321df236870ec6fd64a2a473a8a13d4f733214e/aiohttp-3.13.5-cp314-cp314t-win32.whl", hash = "sha256:9a0f4474b6ea6818b41f82172d799e4b3d29e22c2c520ce4357856fced9af2f8", size = 471819, upload-time = "2026-03-31T22:00:10.277Z" },
-    { url = "https://files.pythonhosted.org/packages/62/29/2f8418269e46454a26171bfdd6a055d74febf32234e474930f2f60a17145/aiohttp-3.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:18a2f6c1182c51baa1d28d68fea51513cb2a76612f038853c0ad3c145423d3d9", size = 505441, upload-time = "2026-03-31T22:00:12.791Z" },
+    { url = "https://files.pythonhosted.org/packages/97/8a/12ca489246ca1faaf5432844adbfce7ff2cc4997733e0af120869345643a/aiohttp-3.13.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5dff64413671b0d3e7d5918ea490bdccb97a4ad29b3f311ed423200b2203e01c", size = 734190, upload-time = "2026-01-03T17:30:45.832Z" },
+    { url = "https://files.pythonhosted.org/packages/32/08/de43984c74ed1fca5c014808963cc83cb00d7bb06af228f132d33862ca76/aiohttp-3.13.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:87b9aab6d6ed88235aa2970294f496ff1a1f9adcd724d800e9b952395a80ffd9", size = 491783, upload-time = "2026-01-03T17:30:47.466Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f8/8dd2cf6112a5a76f81f81a5130c57ca829d101ad583ce57f889179accdda/aiohttp-3.13.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:425c126c0dc43861e22cb1c14ba4c8e45d09516d0a3ae0a3f7494b79f5f233a3", size = 490704, upload-time = "2026-01-03T17:30:49.373Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/40/a46b03ca03936f832bc7eaa47cfbb1ad012ba1be4790122ee4f4f8cba074/aiohttp-3.13.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f9120f7093c2a32d9647abcaf21e6ad275b4fbec5b55969f978b1a97c7c86bf", size = 1720652, upload-time = "2026-01-03T17:30:50.974Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/7e/917fe18e3607af92657e4285498f500dca797ff8c918bd7d90b05abf6c2a/aiohttp-3.13.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:697753042d57f4bf7122cab985bf15d0cef23c770864580f5af4f52023a56bd6", size = 1692014, upload-time = "2026-01-03T17:30:52.729Z" },
+    { url = "https://files.pythonhosted.org/packages/71/b6/cefa4cbc00d315d68973b671cf105b21a609c12b82d52e5d0c9ae61d2a09/aiohttp-3.13.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6de499a1a44e7de70735d0b39f67c8f25eb3d91eb3103be99ca0fa882cdd987d", size = 1759777, upload-time = "2026-01-03T17:30:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/e3/e06ee07b45e59e6d81498b591fc589629be1553abb2a82ce33efe2a7b068/aiohttp-3.13.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37239e9f9a7ea9ac5bf6b92b0260b01f8a22281996da609206a84df860bc1261", size = 1861276, upload-time = "2026-01-03T17:30:56.512Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/24/75d274228acf35ceeb2850b8ce04de9dd7355ff7a0b49d607ee60c29c518/aiohttp-3.13.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f76c1e3fe7d7c8afad7ed193f89a292e1999608170dcc9751a7462a87dfd5bc0", size = 1743131, upload-time = "2026-01-03T17:30:58.256Z" },
+    { url = "https://files.pythonhosted.org/packages/04/98/3d21dde21889b17ca2eea54fdcff21b27b93f45b7bb94ca029c31ab59dc3/aiohttp-3.13.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fc290605db2a917f6e81b0e1e0796469871f5af381ce15c604a3c5c7e51cb730", size = 1556863, upload-time = "2026-01-03T17:31:00.445Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/84/da0c3ab1192eaf64782b03971ab4055b475d0db07b17eff925e8c93b3aa5/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4021b51936308aeea0367b8f006dc999ca02bc118a0cc78c303f50a2ff6afb91", size = 1682793, upload-time = "2026-01-03T17:31:03.024Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0f/5802ada182f575afa02cbd0ec5180d7e13a402afb7c2c03a9aa5e5d49060/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:49a03727c1bba9a97d3e93c9f93ca03a57300f484b6e935463099841261195d3", size = 1716676, upload-time = "2026-01-03T17:31:04.842Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/8c/714d53bd8b5a4560667f7bbbb06b20c2382f9c7847d198370ec6526af39c/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3d9908a48eb7416dc1f4524e69f1d32e5d90e3981e4e37eb0aa1cd18f9cfa2a4", size = 1733217, upload-time = "2026-01-03T17:31:06.868Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/79/e2176f46d2e963facea939f5be2d26368ce543622be6f00a12844d3c991f/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2712039939ec963c237286113c68dbad80a82a4281543f3abf766d9d73228998", size = 1552303, upload-time = "2026-01-03T17:31:08.958Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/6a/28ed4dea1759916090587d1fe57087b03e6c784a642b85ef48217b0277ae/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:7bfdc049127717581866fa4708791220970ce291c23e28ccf3922c700740fdc0", size = 1763673, upload-time = "2026-01-03T17:31:10.676Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/35/4a3daeb8b9fab49240d21c04d50732313295e4bd813a465d840236dd0ce1/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8057c98e0c8472d8846b9c79f56766bcc57e3e8ac7bfd510482332366c56c591", size = 1721120, upload-time = "2026-01-03T17:31:12.575Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/9f/d643bb3c5fb99547323e635e251c609fbbc660d983144cfebec529e09264/aiohttp-3.13.3-cp313-cp313-win32.whl", hash = "sha256:1449ceddcdbcf2e0446957863af03ebaaa03f94c090f945411b61269e2cb5daf", size = 427383, upload-time = "2026-01-03T17:31:14.382Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/f1/ab0395f8a79933577cdd996dd2f9aa6014af9535f65dddcf88204682fe62/aiohttp-3.13.3-cp313-cp313-win_amd64.whl", hash = "sha256:693781c45a4033d31d4187d2436f5ac701e7bbfe5df40d917736108c1cc7436e", size = 453899, upload-time = "2026-01-03T17:31:15.958Z" },
+    { url = "https://files.pythonhosted.org/packages/99/36/5b6514a9f5d66f4e2597e40dea2e3db271e023eb7a5d22defe96ba560996/aiohttp-3.13.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:ea37047c6b367fd4bd632bff8077449b8fa034b69e812a18e0132a00fae6e808", size = 737238, upload-time = "2026-01-03T17:31:17.909Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/49/459327f0d5bcd8c6c9ca69e60fdeebc3622861e696490d8674a6d0cb90a6/aiohttp-3.13.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6fc0e2337d1a4c3e6acafda6a78a39d4c14caea625124817420abceed36e2415", size = 492292, upload-time = "2026-01-03T17:31:19.919Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/0b/b97660c5fd05d3495b4eb27f2d0ef18dc1dc4eff7511a9bf371397ff0264/aiohttp-3.13.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c685f2d80bb67ca8c3837823ad76196b3694b0159d232206d1e461d3d434666f", size = 493021, upload-time = "2026-01-03T17:31:21.636Z" },
+    { url = "https://files.pythonhosted.org/packages/54/d4/438efabdf74e30aeceb890c3290bbaa449780583b1270b00661126b8aae4/aiohttp-3.13.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e377758516d262bde50c2584fc6c578af272559c409eecbdd2bae1601184d6", size = 1717263, upload-time = "2026-01-03T17:31:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/71/f2/7bddc7fd612367d1459c5bcf598a9e8f7092d6580d98de0e057eb42697ad/aiohttp-3.13.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:34749271508078b261c4abb1767d42b8d0c0cc9449c73a4df494777dc55f0687", size = 1669107, upload-time = "2026-01-03T17:31:25.334Z" },
+    { url = "https://files.pythonhosted.org/packages/00/5a/1aeaecca40e22560f97610a329e0e5efef5e0b5afdf9f857f0d93839ab2e/aiohttp-3.13.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82611aeec80eb144416956ec85b6ca45a64d76429c1ed46ae1b5f86c6e0c9a26", size = 1760196, upload-time = "2026-01-03T17:31:27.394Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/f8/0ff6992bea7bd560fc510ea1c815f87eedd745fe035589c71ce05612a19a/aiohttp-3.13.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2fff83cfc93f18f215896e3a190e8e5cb413ce01553901aca925176e7568963a", size = 1843591, upload-time = "2026-01-03T17:31:29.238Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d1/e30e537a15f53485b61f5be525f2157da719819e8377298502aebac45536/aiohttp-3.13.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbe7d4cecacb439e2e2a8a1a7b935c25b812af7a5fd26503a66dadf428e79ec1", size = 1720277, upload-time = "2026-01-03T17:31:31.053Z" },
+    { url = "https://files.pythonhosted.org/packages/84/45/23f4c451d8192f553d38d838831ebbc156907ea6e05557f39563101b7717/aiohttp-3.13.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b928f30fe49574253644b1ca44b1b8adbd903aa0da4b9054a6c20fc7f4092a25", size = 1548575, upload-time = "2026-01-03T17:31:32.87Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ed/0a42b127a43712eda7807e7892c083eadfaf8429ca8fb619662a530a3aab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b5e8fe4de30df199155baaf64f2fcd604f4c678ed20910db8e2c66dc4b11603", size = 1679455, upload-time = "2026-01-03T17:31:34.76Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b5/c05f0c2b4b4fe2c9d55e73b6d3ed4fd6c9dc2684b1d81cbdf77e7fad9adb/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:8542f41a62bcc58fc7f11cf7c90e0ec324ce44950003feb70640fc2a9092c32a", size = 1687417, upload-time = "2026-01-03T17:31:36.699Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/6b/915bc5dad66aef602b9e459b5a973529304d4e89ca86999d9d75d80cbd0b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5e1d8c8b8f1d91cd08d8f4a3c2b067bfca6ec043d3ff36de0f3a715feeedf926", size = 1729968, upload-time = "2026-01-03T17:31:38.622Z" },
+    { url = "https://files.pythonhosted.org/packages/11/3b/e84581290a9520024a08640b63d07673057aec5ca548177a82026187ba73/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:90455115e5da1c3c51ab619ac57f877da8fd6d73c05aacd125c5ae9819582aba", size = 1545690, upload-time = "2026-01-03T17:31:40.57Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/04/0c3655a566c43fd647c81b895dfe361b9f9ad6d58c19309d45cff52d6c3b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:042e9e0bcb5fba81886c8b4fbb9a09d6b8a00245fd8d88e4d989c1f96c74164c", size = 1746390, upload-time = "2026-01-03T17:31:42.857Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/71165b26978f719c3419381514c9690bd5980e764a09440a10bb816ea4ab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2eb752b102b12a76ca02dff751a801f028b4ffbbc478840b473597fc91a9ed43", size = 1702188, upload-time = "2026-01-03T17:31:44.984Z" },
+    { url = "https://files.pythonhosted.org/packages/29/a7/cbe6c9e8e136314fa1980da388a59d2f35f35395948a08b6747baebb6aa6/aiohttp-3.13.3-cp314-cp314-win32.whl", hash = "sha256:b556c85915d8efaed322bf1bdae9486aa0f3f764195a0fb6ee962e5c71ef5ce1", size = 433126, upload-time = "2026-01-03T17:31:47.463Z" },
+    { url = "https://files.pythonhosted.org/packages/de/56/982704adea7d3b16614fc5936014e9af85c0e34b58f9046655817f04306e/aiohttp-3.13.3-cp314-cp314-win_amd64.whl", hash = "sha256:9bf9f7a65e7aa20dd764151fb3d616c81088f91f8df39c3893a536e279b4b984", size = 459128, upload-time = "2026-01-03T17:31:49.2Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/2a/3c79b638a9c3d4658d345339d22070241ea341ed4e07b5ac60fb0f418003/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:05861afbbec40650d8a07ea324367cb93e9e8cc7762e04dd4405df99fa65159c", size = 769512, upload-time = "2026-01-03T17:31:51.134Z" },
+    { url = "https://files.pythonhosted.org/packages/29/b9/3e5014d46c0ab0db8707e0ac2711ed28c4da0218c358a4e7c17bae0d8722/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2fc82186fadc4a8316768d61f3722c230e2c1dcab4200d52d2ebdf2482e47592", size = 506444, upload-time = "2026-01-03T17:31:52.85Z" },
+    { url = "https://files.pythonhosted.org/packages/90/03/c1d4ef9a054e151cd7839cdc497f2638f00b93cbe8043983986630d7a80c/aiohttp-3.13.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0add0900ff220d1d5c5ebbf99ed88b0c1bbf87aa7e4262300ed1376a6b13414f", size = 510798, upload-time = "2026-01-03T17:31:54.91Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/76/8c1e5abbfe8e127c893fe7ead569148a4d5a799f7cf958d8c09f3eedf097/aiohttp-3.13.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:568f416a4072fbfae453dcf9a99194bbb8bdeab718e08ee13dfa2ba0e4bebf29", size = 1868835, upload-time = "2026-01-03T17:31:56.733Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/ac/984c5a6f74c363b01ff97adc96a3976d9c98940b8969a1881575b279ac5d/aiohttp-3.13.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:add1da70de90a2569c5e15249ff76a631ccacfe198375eead4aadf3b8dc849dc", size = 1720486, upload-time = "2026-01-03T17:31:58.65Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/9a/b7039c5f099c4eb632138728828b33428585031a1e658d693d41d07d89d1/aiohttp-3.13.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b47b7ba335d2e9b1239fa571131a87e2d8ec96b333e68b2a305e7a98b0bae2", size = 1847951, upload-time = "2026-01-03T17:32:00.989Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/02/3bec2b9a1ba3c19ff89a43a19324202b8eb187ca1e928d8bdac9bbdddebd/aiohttp-3.13.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4dce1c718e38081c8f35f323209d4c1df7d4db4bab1b5c88a6b4d12b74587", size = 1941001, upload-time = "2026-01-03T17:32:03.122Z" },
+    { url = "https://files.pythonhosted.org/packages/37/df/d879401cedeef27ac4717f6426c8c36c3091c6e9f08a9178cc87549c537f/aiohttp-3.13.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34bac00a67a812570d4a460447e1e9e06fae622946955f939051e7cc895cfab8", size = 1797246, upload-time = "2026-01-03T17:32:05.255Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/15/be122de1f67e6953add23335c8ece6d314ab67c8bebb3f181063010795a7/aiohttp-3.13.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19884d2ee70b06d9204b2727a7b9f983d0c684c650254679e716b0b77920632", size = 1627131, upload-time = "2026-01-03T17:32:07.607Z" },
+    { url = "https://files.pythonhosted.org/packages/12/12/70eedcac9134cfa3219ab7af31ea56bc877395b1ac30d65b1bc4b27d0438/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ca7f2bb6ba8348a3614c7918cc4bb73268c5ac2a207576b7afea19d3d9f64", size = 1795196, upload-time = "2026-01-03T17:32:09.59Z" },
+    { url = "https://files.pythonhosted.org/packages/32/11/b30e1b1cd1f3054af86ebe60df96989c6a414dd87e27ad16950eee420bea/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b0d95340658b9d2f11d9697f59b3814a9d3bb4b7a7c20b131df4bcef464037c0", size = 1782841, upload-time = "2026-01-03T17:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/88/0d/d98a9367b38912384a17e287850f5695c528cff0f14f791ce8ee2e4f7796/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1e53262fd202e4b40b70c3aff944a8155059beedc8a89bba9dc1f9ef06a1b56", size = 1795193, upload-time = "2026-01-03T17:32:13.705Z" },
+    { url = "https://files.pythonhosted.org/packages/43/a5/a2dfd1f5ff5581632c7f6a30e1744deda03808974f94f6534241ef60c751/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d60ac9663f44168038586cab2157e122e46bdef09e9368b37f2d82d354c23f72", size = 1621979, upload-time = "2026-01-03T17:32:15.965Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f0/12973c382ae7c1cccbc4417e129c5bf54c374dfb85af70893646e1f0e749/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:90751b8eed69435bac9ff4e3d2f6b3af1f57e37ecb0fbeee59c0174c9e2d41df", size = 1822193, upload-time = "2026-01-03T17:32:18.219Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/5f/24155e30ba7f8c96918af1350eb0663e2430aad9e001c0489d89cd708ab1/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fc353029f176fd2b3ec6cfc71be166aba1936fe5d73dd1992ce289ca6647a9aa", size = 1769801, upload-time = "2026-01-03T17:32:20.25Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/f8/7314031ff5c10e6ece114da79b338ec17eeff3a079e53151f7e9f43c4723/aiohttp-3.13.3-cp314-cp314t-win32.whl", hash = "sha256:2e41b18a58da1e474a057b3d35248d8320029f61d70a37629535b16a0c8f3767", size = 466523, upload-time = "2026-01-03T17:32:22.215Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/63/278a98c715ae467624eafe375542d8ba9b4383a016df8fdefe0ae28382a7/aiohttp-3.13.3-cp314-cp314t-win_amd64.whl", hash = "sha256:44531a36aa2264a1860089ffd4dce7baf875ee5a6079d5fb42e261c704ef7344", size = 499694, upload-time = "2026-01-03T17:32:24.546Z" },
 ]
 
 [[package]]
@@ -93,14 +93,14 @@ wheels = [
 
 [[package]]
 name = "anyio"
-version = "4.13.0"
+version = "4.12.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
+    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
 ]
 
 [[package]]
@@ -114,11 +114,11 @@ wheels = [
 
 [[package]]
 name = "attrs"
-version = "26.1.0"
+version = "25.4.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" },
 ]
 
 [[package]]
@@ -160,23 +160,18 @@ wheels = [
 
 [[package]]
 name = "brotlicffi"
-version = "1.2.0.1"
+version = "1.2.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cffi" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/8a/b6/017dc5f852ed9b8735af77774509271acbf1de02d238377667145fcee01d/brotlicffi-1.2.0.1.tar.gz", hash = "sha256:c20d5c596278307ad06414a6d95a892377ea274a5c6b790c2548c009385d621c", size = 478156, upload-time = "2026-03-05T19:54:11.547Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/84/85/57c314a6b35336efbbdc13e5fc9ae13f6b60a0647cfa7c1221178ac6d8ae/brotlicffi-1.2.0.0.tar.gz", hash = "sha256:34345d8d1f9d534fcac2249e57a4c3c8801a33c9942ff9f8574f67a175e17adb", size = 476682, upload-time = "2025-11-21T18:17:57.334Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ef/f9/dfa56316837fa798eac19358351e974de8e1e2ca9475af4cb90293cd6576/brotlicffi-1.2.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c85e65913cf2b79c57a3fdd05b98d9731d9255dc0cb696b09376cc091b9cddd", size = 433046, upload-time = "2026-03-05T19:53:46.209Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/f5/f8f492158c76b0d940388801f04f747028971ad5774287bded5f1e53f08d/brotlicffi-1.2.0.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:535f2d05d0273408abc13fc0eebb467afac17b0ad85090c8913690d40207dac5", size = 1541126, upload-time = "2026-03-05T19:53:48.248Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/e1/ff87af10ac419600c63e9287a0649c673673ae6b4f2bcf48e96cb2f89f60/brotlicffi-1.2.0.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce17eb798ca59ecec67a9bb3fd7a4304e120d1cd02953ce522d959b9a84d58ac", size = 1541983, upload-time = "2026-03-05T19:53:50.317Z" },
-    { url = "https://files.pythonhosted.org/packages/47/c0/80ecd9bd45776109fab14040e478bf63e456967c9ddee2353d8330ed8de1/brotlicffi-1.2.0.1-cp314-cp314t-win32.whl", hash = "sha256:3c9544f83cb715d95d7eab3af4adbbef8b2093ad6382288a83b3a25feb1a57ec", size = 349047, upload-time = "2026-03-05T19:53:52.215Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/98/13e5b250236a281b6cd9e92a01ee1ae231029fa78faee932ef3766e1cb24/brotlicffi-1.2.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:625f8115d32ae9c0740d01ea51518437c3fbaa3e78d41cb18459f6f7ac326000", size = 385652, upload-time = "2026-03-05T19:53:53.892Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/9f/b98dcd4af47994cee97aebac866996a006a2e5fc1fd1e2b82a8ad95cf09c/brotlicffi-1.2.0.1-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:91ba5f0ccc040f6ff8f7efaf839f797723d03ed46acb8ae9408f99ffd2572cf4", size = 432608, upload-time = "2026-03-05T19:53:56.736Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/7a/ac4ee56595a061e3718a6d1ea7e921f4df156894acffb28ed88a1fd52022/brotlicffi-1.2.0.1-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be9a670c6811af30a4bd42d7116dc5895d3b41beaa8ed8a89050447a0181f5ce", size = 1534257, upload-time = "2026-03-05T19:53:58.667Z" },
-    { url = "https://files.pythonhosted.org/packages/99/39/e7410db7f6f56de57744ea52a115084ceb2735f4d44973f349bb92136586/brotlicffi-1.2.0.1-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3314a3476f59e5443f9f72a6dff16edc0c3463c9b318feaef04ae3e4683f5a", size = 1536838, upload-time = "2026-03-05T19:54:00.705Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/75/6e7977d1935fc3fbb201cbd619be8f2c7aea25d40a096967132854b34708/brotlicffi-1.2.0.1-cp38-abi3-win32.whl", hash = "sha256:82ea52e2b5d3145b6c406ebd3efb0d55db718b7ad996bd70c62cec0439de1187", size = 343337, upload-time = "2026-03-05T19:54:02.446Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/ef/e7e485ce5e4ba3843a0a92feb767c7b6098fd6e65ce752918074d175ae71/brotlicffi-1.2.0.1-cp38-abi3-win_amd64.whl", hash = "sha256:da2e82a08e7778b8bc539d27ca03cdd684113e81394bfaaad8d0dfc6a17ddede", size = 379026, upload-time = "2026-03-05T19:54:04.322Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/df/a72b284d8c7bef0ed5756b41c2eb7d0219a1dd6ac6762f1c7bdbc31ef3af/brotlicffi-1.2.0.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:9458d08a7ccde8e3c0afedbf2c70a8263227a68dea5ab13590593f4c0a4fd5f4", size = 432340, upload-time = "2025-11-21T18:17:42.277Z" },
+    { url = "https://files.pythonhosted.org/packages/74/2b/cc55a2d1d6fb4f5d458fba44a3d3f91fb4320aa14145799fd3a996af0686/brotlicffi-1.2.0.0-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:84e3d0020cf1bd8b8131f4a07819edee9f283721566fe044a20ec792ca8fd8b7", size = 1534002, upload-time = "2025-11-21T18:17:43.746Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/9c/d51486bf366fc7d6735f0e46b5b96ca58dc005b250263525a1eea3cd5d21/brotlicffi-1.2.0.0-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:33cfb408d0cff64cd50bef268c0fed397c46fbb53944aa37264148614a62e990", size = 1536547, upload-time = "2025-11-21T18:17:45.729Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/37/293a9a0a7caf17e6e657668bebb92dfe730305999fe8c0e2703b8888789c/brotlicffi-1.2.0.0-cp38-abi3-win32.whl", hash = "sha256:23e5c912fdc6fd37143203820230374d24babd078fc054e18070a647118158f6", size = 343085, upload-time = "2025-11-21T18:17:48.887Z" },
+    { url = "https://files.pythonhosted.org/packages/07/6b/6e92009df3b8b7272f85a0992b306b61c34b7ea1c4776643746e61c380ac/brotlicffi-1.2.0.0-cp38-abi3-win_amd64.whl", hash = "sha256:f139a7cdfe4ae7859513067b736eb44d19fae1186f9e99370092f6915216451b", size = 378586, upload-time = "2025-11-21T18:17:50.531Z" },
 ]
 
 [[package]]
@@ -235,59 +230,43 @@ wheels = [
 
 [[package]]
 name = "charset-normalizer"
-version = "3.4.7"
+version = "3.4.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c1/3b/66777e39d3ae1ddc77ee606be4ec6d8cbd4c801f65e5a1b6f2b11b8346dd/charset_normalizer-3.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f496c9c3cc02230093d8330875c4c3cdfc3b73612a5fd921c65d39cbcef08063", size = 309627, upload-time = "2026-04-02T09:26:45.198Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/4e/b7f84e617b4854ade48a1b7915c8ccfadeba444d2a18c291f696e37f0d3b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea948db76d31190bf08bd371623927ee1339d5f2a0b4b1b4a4439a65298703c", size = 207008, upload-time = "2026-04-02T09:26:46.824Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/bb/ec73c0257c9e11b268f018f068f5d00aa0ef8c8b09f7753ebd5f2880e248/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a277ab8928b9f299723bc1a2dabb1265911b1a76341f90a510368ca44ad9ab66", size = 228303, upload-time = "2026-04-02T09:26:48.397Z" },
-    { url = "https://files.pythonhosted.org/packages/85/fb/32d1f5033484494619f701e719429c69b766bfc4dbc61aa9e9c8c166528b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3bec022aec2c514d9cf199522a802bd007cd588ab17ab2525f20f9c34d067c18", size = 224282, upload-time = "2026-04-02T09:26:49.684Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/07/330e3a0dda4c404d6da83b327270906e9654a24f6c546dc886a0eb0ffb23/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e044c39e41b92c845bc815e5ae4230804e8e7bc29e399b0437d64222d92809dd", size = 215595, upload-time = "2026-04-02T09:26:50.915Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/7c/fc890655786e423f02556e0216d4b8c6bcb6bdfa890160dc66bf52dee468/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:f495a1652cf3fbab2eb0639776dad966c2fb874d79d87ca07f9d5f059b8bd215", size = 201986, upload-time = "2026-04-02T09:26:52.197Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/97/bfb18b3db2aed3b90cf54dc292ad79fdd5ad65c4eae454099475cbeadd0d/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e712b419df8ba5e42b226c510472b37bd57b38e897d3eca5e8cfd410a29fa859", size = 211711, upload-time = "2026-04-02T09:26:53.49Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/a5/a581c13798546a7fd557c82614a5c65a13df2157e9ad6373166d2a3e645d/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7804338df6fcc08105c7745f1502ba68d900f45fd770d5bdd5288ddccb8a42d8", size = 210036, upload-time = "2026-04-02T09:26:54.975Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/bf/b3ab5bcb478e4193d517644b0fb2bf5497fbceeaa7a1bc0f4d5b50953861/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:481551899c856c704d58119b5025793fa6730adda3571971af568f66d2424bb5", size = 202998, upload-time = "2026-04-02T09:26:56.303Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/4e/23efd79b65d314fa320ec6017b4b5834d5c12a58ba4610aa353af2e2f577/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f59099f9b66f0d7145115e6f80dd8b1d847176df89b234a5a6b3f00437aa0832", size = 230056, upload-time = "2026-04-02T09:26:57.554Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/9f/1e1941bc3f0e01df116e68dc37a55c4d249df5e6fa77f008841aef68264f/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:f59ad4c0e8f6bba240a9bb85504faa1ab438237199d4cce5f622761507b8f6a6", size = 211537, upload-time = "2026-04-02T09:26:58.843Z" },
-    { url = "https://files.pythonhosted.org/packages/80/0f/088cbb3020d44428964a6c97fe1edfb1b9550396bf6d278330281e8b709c/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:3dedcc22d73ec993f42055eff4fcfed9318d1eeb9a6606c55892a26964964e48", size = 226176, upload-time = "2026-04-02T09:27:00.437Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/9f/130394f9bbe06f4f63e22641d32fc9b202b7e251c9aef4db044324dac493/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:64f02c6841d7d83f832cd97ccf8eb8a906d06eb95d5276069175c696b024b60a", size = 217723, upload-time = "2026-04-02T09:27:02.021Z" },
-    { url = "https://files.pythonhosted.org/packages/73/55/c469897448a06e49f8fa03f6caae97074fde823f432a98f979cc42b90e69/charset_normalizer-3.4.7-cp313-cp313-win32.whl", hash = "sha256:4042d5c8f957e15221d423ba781e85d553722fc4113f523f2feb7b188cc34c5e", size = 148085, upload-time = "2026-04-02T09:27:03.192Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/78/1b74c5bbb3f99b77a1715c91b3e0b5bdb6fe302d95ace4f5b1bec37b0167/charset_normalizer-3.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:3946fa46a0cf3e4c8cb1cc52f56bb536310d34f25f01ca9b6c16afa767dab110", size = 158819, upload-time = "2026-04-02T09:27:04.454Z" },
-    { url = "https://files.pythonhosted.org/packages/68/86/46bd42279d323deb8687c4a5a811fd548cb7d1de10cf6535d099877a9a9f/charset_normalizer-3.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:80d04837f55fc81da168b98de4f4b797ef007fc8a79ab71c6ec9bc4dd662b15b", size = 147915, upload-time = "2026-04-02T09:27:05.971Z" },
-    { url = "https://files.pythonhosted.org/packages/97/c8/c67cb8c70e19ef1960b97b22ed2a1567711de46c4ddf19799923adc836c2/charset_normalizer-3.4.7-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c36c333c39be2dbca264d7803333c896ab8fa7d4d6f0ab7edb7dfd7aea6e98c0", size = 309234, upload-time = "2026-04-02T09:27:07.194Z" },
-    { url = "https://files.pythonhosted.org/packages/99/85/c091fdee33f20de70d6c8b522743b6f831a2f1cd3ff86de4c6a827c48a76/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2aed2e5e41f24ea8ef1590b8e848a79b56f3a5564a65ceec43c9d692dc7d8a", size = 208042, upload-time = "2026-04-02T09:27:08.749Z" },
-    { url = "https://files.pythonhosted.org/packages/87/1c/ab2ce611b984d2fd5d86a5a8a19c1ae26acac6bad967da4967562c75114d/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:54523e136b8948060c0fa0bc7b1b50c32c186f2fceee897a495406bb6e311d2b", size = 228706, upload-time = "2026-04-02T09:27:09.951Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/29/2b1d2cb00bf085f59d29eb773ce58ec2d325430f8c216804a0a5cd83cbca/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:715479b9a2802ecac752a3b0efa2b0b60285cf962ee38414211abdfccc233b41", size = 224727, upload-time = "2026-04-02T09:27:11.175Z" },
-    { url = "https://files.pythonhosted.org/packages/47/5c/032c2d5a07fe4d4855fea851209cca2b6f03ebeb6d4e3afdb3358386a684/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bd6c2a1c7573c64738d716488d2cdd3c00e340e4835707d8fdb8dc1a66ef164e", size = 215882, upload-time = "2026-04-02T09:27:12.446Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/c2/356065d5a8b78ed04499cae5f339f091946a6a74f91e03476c33f0ab7100/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:c45e9440fb78f8ddabcf714b68f936737a121355bf59f3907f4e17721b9d1aae", size = 200860, upload-time = "2026-04-02T09:27:13.721Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/cd/a32a84217ced5039f53b29f460962abb2d4420def55afabe45b1c3c7483d/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3534e7dcbdcf757da6b85a0bbf5b6868786d5982dd959b065e65481644817a18", size = 211564, upload-time = "2026-04-02T09:27:15.272Z" },
-    { url = "https://files.pythonhosted.org/packages/44/86/58e6f13ce26cc3b8f4a36b94a0f22ae2f00a72534520f4ae6857c4b81f89/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e8ac484bf18ce6975760921bb6148041faa8fef0547200386ea0b52b5d27bf7b", size = 211276, upload-time = "2026-04-02T09:27:16.834Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/fe/d17c32dc72e17e155e06883efa84514ca375f8a528ba2546bee73fc4df81/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a5fe03b42827c13cdccd08e6c0247b6a6d4b5e3cdc53fd1749f5896adcdc2356", size = 201238, upload-time = "2026-04-02T09:27:18.229Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/29/f33daa50b06525a237451cdb6c69da366c381a3dadcd833fa5676bc468b3/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2d6eb928e13016cea4f1f21d1e10c1cebd5a421bc57ddf5b1142ae3f86824fab", size = 230189, upload-time = "2026-04-02T09:27:19.445Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/6e/52c84015394a6a0bdcd435210a7e944c5f94ea1055f5cc5d56c5fe368e7b/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e74327fb75de8986940def6e8dee4f127cc9752bee7355bb323cc5b2659b6d46", size = 211352, upload-time = "2026-04-02T09:27:20.79Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/d7/4353be581b373033fb9198bf1da3cf8f09c1082561e8e922aa7b39bf9fe8/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d6038d37043bced98a66e68d3aa2b6a35505dc01328cd65217cefe82f25def44", size = 227024, upload-time = "2026-04-02T09:27:22.063Z" },
-    { url = "https://files.pythonhosted.org/packages/30/45/99d18aa925bd1740098ccd3060e238e21115fffbfdcb8f3ece837d0ace6c/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7579e913a5339fb8fa133f6bbcfd8e6749696206cf05acdbdca71a1b436d8e72", size = 217869, upload-time = "2026-04-02T09:27:23.486Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/05/5ee478aa53f4bb7996482153d4bfe1b89e0f087f0ab6b294fcf92d595873/charset_normalizer-3.4.7-cp314-cp314-win32.whl", hash = "sha256:5b77459df20e08151cd6f8b9ef8ef1f961ef73d85c21a555c7eed5b79410ec10", size = 148541, upload-time = "2026-04-02T09:27:25.146Z" },
-    { url = "https://files.pythonhosted.org/packages/48/77/72dcb0921b2ce86420b2d79d454c7022bf5be40202a2a07906b9f2a35c97/charset_normalizer-3.4.7-cp314-cp314-win_amd64.whl", hash = "sha256:92a0a01ead5e668468e952e4238cccd7c537364eb7d851ab144ab6627dbbe12f", size = 159634, upload-time = "2026-04-02T09:27:26.642Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/a3/c2369911cd72f02386e4e340770f6e158c7980267da16af8f668217abaa0/charset_normalizer-3.4.7-cp314-cp314-win_arm64.whl", hash = "sha256:67f6279d125ca0046a7fd386d01b311c6363844deac3e5b069b514ba3e63c246", size = 148384, upload-time = "2026-04-02T09:27:28.271Z" },
-    { url = "https://files.pythonhosted.org/packages/94/09/7e8a7f73d24dba1f0035fbbf014d2c36828fc1bf9c88f84093e57d315935/charset_normalizer-3.4.7-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:effc3f449787117233702311a1b7d8f59cba9ced946ba727bdc329ec69028e24", size = 330133, upload-time = "2026-04-02T09:27:29.474Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/da/96975ddb11f8e977f706f45cddd8540fd8242f71ecdb5d18a80723dcf62c/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbccdc05410c9ee21bbf16a35f4c1d16123dcdeb8a1d38f33654fa21d0234f79", size = 216257, upload-time = "2026-04-02T09:27:30.793Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/e8/1d63bf8ef2d388e95c64b2098f45f84758f6d102a087552da1485912637b/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:733784b6d6def852c814bce5f318d25da2ee65dd4839a0718641c696e09a2960", size = 234851, upload-time = "2026-04-02T09:27:32.44Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/40/e5ff04233e70da2681fa43969ad6f66ca5611d7e669be0246c4c7aaf6dc8/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a89c23ef8d2c6b27fd200a42aa4ac72786e7c60d40efdc76e6011260b6e949c4", size = 233393, upload-time = "2026-04-02T09:27:34.03Z" },
-    { url = "https://files.pythonhosted.org/packages/be/c1/06c6c49d5a5450f76899992f1ee40b41d076aee9279b49cf9974d2f313d5/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c114670c45346afedc0d947faf3c7f701051d2518b943679c8ff88befe14f8e", size = 223251, upload-time = "2026-04-02T09:27:35.369Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/9f/f2ff16fb050946169e3e1f82134d107e5d4ae72647ec8a1b1446c148480f/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:a180c5e59792af262bf263b21a3c49353f25945d8d9f70628e73de370d55e1e1", size = 206609, upload-time = "2026-04-02T09:27:36.661Z" },
-    { url = "https://files.pythonhosted.org/packages/69/d5/a527c0cd8d64d2eab7459784fb4169a0ac76e5a6fc5237337982fd61347e/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3c9a494bc5ec77d43cea229c4f6db1e4d8fe7e1bbffa8b6f0f0032430ff8ab44", size = 220014, upload-time = "2026-04-02T09:27:38.019Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/80/8a7b8104a3e203074dc9aa2c613d4b726c0e136bad1cc734594b02867972/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8d828b6667a32a728a1ad1d93957cdf37489c57b97ae6c4de2860fa749b8fc1e", size = 218979, upload-time = "2026-04-02T09:27:39.37Z" },
-    { url = "https://files.pythonhosted.org/packages/02/9a/b759b503d507f375b2b5c153e4d2ee0a75aa215b7f2489cf314f4541f2c0/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cf1493cd8607bec4d8a7b9b004e699fcf8f9103a9284cc94962cb73d20f9d4a3", size = 209238, upload-time = "2026-04-02T09:27:40.722Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/4e/0f3f5d47b86bdb79256e7290b26ac847a2832d9a4033f7eb2cd4bcf4bb5b/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0c96c3b819b5c3e9e165495db84d41914d6894d55181d2d108cc1a69bfc9cce0", size = 236110, upload-time = "2026-04-02T09:27:42.33Z" },
-    { url = "https://files.pythonhosted.org/packages/96/23/bce28734eb3ed2c91dcf93abeb8a5cf393a7b2749725030bb630e554fdd8/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:752a45dc4a6934060b3b0dab47e04edc3326575f82be64bc4fc293914566503e", size = 219824, upload-time = "2026-04-02T09:27:43.924Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/6f/6e897c6984cc4d41af319b077f2f600fc8214eb2fe2d6bcb79141b882400/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:8778f0c7a52e56f75d12dae53ae320fae900a8b9b4164b981b9c5ce059cd1fcb", size = 233103, upload-time = "2026-04-02T09:27:45.348Z" },
-    { url = "https://files.pythonhosted.org/packages/76/22/ef7bd0fe480a0ae9b656189ec00744b60933f68b4f42a7bb06589f6f576a/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ce3412fbe1e31eb81ea42f4169ed94861c56e643189e1e75f0041f3fe7020abe", size = 225194, upload-time = "2026-04-02T09:27:46.706Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/a7/0e0ab3e0b5bc1219bd80a6a0d4d72ca74d9250cb2382b7c699c147e06017/charset_normalizer-3.4.7-cp314-cp314t-win32.whl", hash = "sha256:c03a41a8784091e67a39648f70c5f97b5b6a37f216896d44d2cdcb82615339a0", size = 159827, upload-time = "2026-04-02T09:27:48.053Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/1d/29d32e0fb40864b1f878c7f5a0b343ae676c6e2b271a2d55cc3a152391da/charset_normalizer-3.4.7-cp314-cp314t-win_amd64.whl", hash = "sha256:03853ed82eeebbce3c2abfdbc98c96dc205f32a79627688ac9a27370ea61a49c", size = 174168, upload-time = "2026-04-02T09:27:49.795Z" },
-    { url = "https://files.pythonhosted.org/packages/de/32/d92444ad05c7a6e41fb2036749777c163baf7a0301a040cb672d6b2b1ae9/charset_normalizer-3.4.7-cp314-cp314t-win_arm64.whl", hash = "sha256:c35abb8bfff0185efac5878da64c45dafd2b37fb0383add1be155a763c1f083d", size = 153018, upload-time = "2026-04-02T09:27:51.116Z" },
-    { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" },
+    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },
+    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },
+    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },
+    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },
+    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },
+    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },
+    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
 ]
 
 [[package]]
@@ -324,15 +303,15 @@ wheels = [
 
 [[package]]
 name = "deno"
-version = "2.7.12"
+version = "2.7.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5c/ac/39b45b51e7aaf9cad1de36f91bd58677818a7d7a867fa0721faff43b67c4/deno-2.7.12.tar.gz", hash = "sha256:7ef413693b4a9d86837a6f4991738429908f6f42f6f3ed85254ab0e679438049", size = 8167, upload-time = "2026-04-09T20:39:50.505Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/29/b2941d53d94094e20e52def86956528140dbe60b49d715803f7e9799d42f/deno-2.7.2.tar.gz", hash = "sha256:3dc9461ac4dd0d6661769f03460861709e17c4e516dfce14676e6a3146824b7b", size = 8167, upload-time = "2026-03-03T16:10:51.429Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/77/f0/0be717182294e9b61e58cd89b88d1b711c7e9c134e53890474b8d1e95704/deno-2.7.12-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:74677d1be23426b1f16ce33c1a96868bc7554e1d41a12fb4d446017bb1955d1d", size = 47683364, upload-time = "2026-04-09T20:39:35.086Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/44/ca1de5368b193c9819c57d505ff8ceb86dc38e2e87856b23c23b58abd234/deno-2.7.12-py3-none-macosx_11_0_arm64.whl", hash = "sha256:acf94fa815ac84a948b196f53a7e088ed126ec2e390a25d92cdfdc8c5d8a851e", size = 44460697, upload-time = "2026-04-09T20:39:38.5Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/68/ce111604f5877220e53fb10c5180ffaa484f829f20fcbc7f7115a90afadd/deno-2.7.12-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:ab7c12ee0e10cd232dbb8f7cf5802bfdbcc3462c0b1453726b158d8a27d4185f", size = 48237362, upload-time = "2026-04-09T20:39:41.555Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/07/d8ba3284e098128076cd9f84e85d2e62d12fa1e5b8e5c47681983017af1a/deno-2.7.12-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:b396675fef296530c386387990d26d118398452bac47541e739b353b9ff8809f", size = 50247653, upload-time = "2026-04-09T20:39:44.956Z" },
-    { url = "https://files.pythonhosted.org/packages/07/b0/c6c215eca2aa54b700a95867901832245518b2f217edfc78e733401bf8b3/deno-2.7.12-py3-none-win_amd64.whl", hash = "sha256:ddeeb03427d7ce0979a395ae2d1aa5ebcddeb97ab0fd9e7dfa56a08e0e5b817c", size = 49200604, upload-time = "2026-04-09T20:39:48.218Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/a0/9e6f45c25ef36db827e75bd35bf9378c196a6bed2804a8259d1d63bab84f/deno-2.7.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:67509919fa9df639d9375e441648ae5a3ab9bb1ce6fcddc21c49c08368af4d68", size = 46325714, upload-time = "2026-03-03T16:10:35.82Z" },
+    { url = "https://files.pythonhosted.org/packages/83/ce/085c3002cdfc0d33b30896b3d1469024c23e3971cba4a15ae3983c48d2e4/deno-2.7.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a19f75d7a148a2d030543db88734f03648e31dc7385a9c62aa1d975e2b0df8d9", size = 43264279, upload-time = "2026-03-03T16:10:39.011Z" },
+    { url = "https://files.pythonhosted.org/packages/38/f0/c415c08ca30fb084887a96b88df7f6511c98575b365db87b0fac76a82773/deno-2.7.2-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:f7b63f13c9fdeb18d0435e80aa4677878ac1b9ac23a49c7570958b9d81772e06", size = 47024484, upload-time = "2026-03-03T16:10:42.619Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/14/bfac1928082f78f120aaff7608f211a8beab8f66e72defc0ac85d6f52f84/deno-2.7.2-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:bded39ebc9d19748a13a4c046a715f12c445a3e15c0b4cde6d42cc47793efcf0", size = 48981918, upload-time = "2026-03-03T16:10:45.822Z" },
+    { url = "https://files.pythonhosted.org/packages/79/07/b332f98969937d435ba2905195a0b3dd2162f192659595dde88c615b04e1/deno-2.7.2-py3-none-win_amd64.whl", hash = "sha256:5d525d270e16d5ea22ad90a65e1ebc0dff8b83068d698f6bad138bfa857e4d28", size = 48330774, upload-time = "2026-03-03T16:10:49.209Z" },
 ]
 
 [[package]]
@@ -435,15 +414,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
 ]
 
-[[package]]
-name = "iniconfig"
-version = "2.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
-]
-
 [[package]]
 name = "isort"
 version = "8.0.1"
@@ -478,9 +448,6 @@ dependencies = [
 [package.dev-dependencies]
 dev = [
     { name = "pylint" },
-    { name = "pytest" },
-    { name = "pytest-aiohttp" },
-    { name = "pytest-asyncio" },
 ]
 
 [package.metadata]
@@ -494,12 +461,7 @@ requires-dist = [
 ]
 
 [package.metadata.requires-dev]
-dev = [
-    { name = "pylint" },
-    { name = "pytest", specifier = ">=8.0" },
-    { name = "pytest-aiohttp", specifier = ">=1.0" },
-    { name = "pytest-asyncio", specifier = ">=0.24" },
-]
+dev = [{ name = "pylint" }]
 
 [[package]]
 name = "multidict"
@@ -591,31 +553,13 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b0/7a/620f945b96be1f6ee357d211d5bf74ab1b7fe72a9f1525aafbfe3aee6875/mutagen-1.47.0-py3-none-any.whl", hash = "sha256:edd96f50c5907a9539d8e5bba7245f62c9f520aef333d13392a79a4f70aca719", size = 194391, upload-time = "2023-09-03T16:33:29.955Z" },
 ]
 
-[[package]]
-name = "packaging"
-version = "26.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/df/de/0d2b39fb4af88a0258f3bac87dfcbb48e73fbdea4a2ed0e2213f9a4c2f9a/packaging-26.1.tar.gz", hash = "sha256:f042152b681c4bfac5cae2742a55e103d27ab2ec0f3d88037136b6bfe7c9c5de", size = 215519, upload-time = "2026-04-14T21:12:49.362Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7a/c2/920ef838e2f0028c8262f16101ec09ebd5969864e5a64c4c05fad0617c56/packaging-26.1-py3-none-any.whl", hash = "sha256:5d9c0669c6285e491e0ced2eee587eaf67b670d94a19e94e3984a481aba6802f", size = 95831, upload-time = "2026-04-14T21:12:47.56Z" },
-]
-
 [[package]]
 name = "platformdirs"
-version = "4.9.6"
+version = "4.9.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", hash = "sha256:3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a", size = 29400, upload-time = "2026-04-09T00:04:10.812Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/04/fea538adf7dbbd6d186f551d595961e564a3b6715bdf276b477460858672/platformdirs-4.9.2.tar.gz", hash = "sha256:9a33809944b9db043ad67ca0db94b14bf452cc6aeaac46a88ea55b26e2e9d291", size = 28394, upload-time = "2026-02-16T03:56:10.574Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" },
-]
-
-[[package]]
-name = "pluggy"
-version = "1.6.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+    { url = "https://files.pythonhosted.org/packages/48/31/05e764397056194206169869b50cf2fee4dbbbc71b344705b9c0d878d4d8/platformdirs-4.9.2-py3-none-any.whl", hash = "sha256:9170634f126f8efdae22fb58ae8a0eaa86f38365bc57897a6c4f781d1f5875bd", size = 21168, upload-time = "2026-02-16T03:56:08.891Z" },
 ]
 
 [[package]]
@@ -726,15 +670,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f9/93/45c1cdcbeb182ccd2e144c693eaa097763b08b38cded279f0053ed53c553/pycryptodomex-3.23.0-cp37-abi3-win_arm64.whl", hash = "sha256:02d87b80778c171445d67e23d1caef279bf4b25c3597050ccd2e13970b57fd51", size = 1707161, upload-time = "2025-05-17T17:23:11.414Z" },
 ]
 
-[[package]]
-name = "pygments"
-version = "2.20.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
-]
-
 [[package]]
 name = "pylint"
 version = "4.0.5"
@@ -753,48 +688,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d5/6f/9ac2548e290764781f9e7e2aaf0685b086379dabfb29ca38536985471eaf/pylint-4.0.5-py3-none-any.whl", hash = "sha256:00f51c9b14a3b3ae08cff6b2cdd43f28165c78b165b628692e428fb1f8dc2cf2", size = 536694, upload-time = "2026-02-20T09:07:31.028Z" },
 ]
 
-[[package]]
-name = "pytest"
-version = "9.0.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-    { name = "iniconfig" },
-    { name = "packaging" },
-    { name = "pluggy" },
-    { name = "pygments" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
-]
-
-[[package]]
-name = "pytest-aiohttp"
-version = "1.1.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "aiohttp" },
-    { name = "pytest" },
-    { name = "pytest-asyncio" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/72/4b/d326890c153f2c4ce1bf45d07683c08c10a1766058a22934620bc6ac6592/pytest_aiohttp-1.1.0.tar.gz", hash = "sha256:147de8cb164f3fc9d7196967f109ab3c0b93ea3463ab50631e56438eab7b5adc", size = 12842, upload-time = "2025-01-23T12:44:04.465Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ba/0f/e6af71c02e0f1098eaf7d2dbf3ffdf0a69fc1e0ef174f96af05cef161f1b/pytest_aiohttp-1.1.0-py3-none-any.whl", hash = "sha256:f39a11693a0dce08dd6c542d241e199dd8047a6e6596b2bcfa60d373f143456d", size = 8932, upload-time = "2025-01-23T12:44:03.27Z" },
-]
-
-[[package]]
-name = "pytest-asyncio"
-version = "1.3.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pytest" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
-]
-
 [[package]]
 name = "python-engineio"
 version = "4.13.1"
@@ -822,7 +715,7 @@ wheels = [
 
 [[package]]
 name = "requests"
-version = "2.33.1"
+version = "2.32.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -830,9 +723,9 @@ dependencies = [
     { name = "idna" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", hash = "sha256:18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517", size = 134120, upload-time = "2026-03-30T16:09:15.531Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
 ]
 
 [[package]]
@@ -1058,11 +951,11 @@ wheels = [
 
 [[package]]
 name = "yt-dlp"
-version = "2026.3.17"
+version = "2026.3.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/8b/34/7c6b4e3f89cb6416d2cd7ab6dab141a1df97ab0fb22d15816db2c92148c9/yt_dlp-2026.3.17.tar.gz", hash = "sha256:ba7aa31d533f1ffccfe70e421596d7ca8ff0bf1398dc6bb658b7d9dec057d2c9", size = 3119221, upload-time = "2026-03-17T23:43:00.244Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/6f/7427d23609353e5ef3470ff43ef551b8bd7b166dd4fef48957f0d0e040fe/yt_dlp-2026.3.3.tar.gz", hash = "sha256:3db7969e3a8964dc786bdebcffa2653f31123bf2a630f04a17bdafb7bbd39952", size = 3118658, upload-time = "2026-03-03T16:54:53.909Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cd/13/5093bcb954878e50f7217fd2ab94282b53934022e4e4a03265582da83bf5/yt_dlp-2026.3.17-py3-none-any.whl", hash = "sha256:32992db94303a8a5d211a183f2174834fe7f8c29d83ed2e7a324eae97a8f26d8", size = 3315134, upload-time = "2026-03-17T23:42:57.863Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/a4/8b5cd28ab87aef48ef15e74241befec3445496327db028f34147a9e0f14f/yt_dlp-2026.3.3-py3-none-any.whl", hash = "sha256:166c6e68c49ba526474bd400e0129f58aa522c2896204aa73be669c3d2f15e63", size = 3315599, upload-time = "2026-03-03T16:54:51.899Z" },
 ]
 
 [package.optional-dependencies]
@@ -1086,9 +979,9 @@ deno = [
 
 [[package]]
 name = "yt-dlp-ejs"
-version = "0.8.0"
+version = "0.5.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d3/e6/cceb9530e8f4e5940f6f7822d90e9d94f1b85343329a16baaf47bbbb3de1/yt_dlp_ejs-0.8.0.tar.gz", hash = "sha256:d5fa1639f63b5c4af8d932495f60689d5370f1a095782c944f7f62a303eb104e", size = 96571, upload-time = "2026-03-17T22:49:19.299Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/0d/b9e4ab1b47cdeba0842df634b74b3c0144307640ad5b632a5e189c4ab7ce/yt_dlp_ejs-0.5.0.tar.gz", hash = "sha256:8dfae59e418232f485253dcf8e197fefa232423c3af7824fe19e4517b173293b", size = 98925, upload-time = "2026-02-21T19:29:16.844Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e3/bd/520769863744b669440a924271a6159ddd82ad5ae26b4ac4d4b69e9f8d44/yt_dlp_ejs-0.8.0-py3-none-any.whl", hash = "sha256:79300e5fca7f937a1eeede11f0456862c1b41107ce1d726871e0207424f4bdb4", size = 53443, upload-time = "2026-03-17T22:49:17.736Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/5b/1283356b70d4893a8a050cee15092e1b08ea15310b94365f88067146721b/yt_dlp_ejs-0.5.0-py3-none-any.whl", hash = "sha256:674fc0efea741d3100cdf3f0f9e123150715ee41edf47ea7a62fbdeda204bdec", size = 54032, upload-time = "2026-02-21T19:29:15.408Z" },
 ]