Merge pull request #1 from unshackle-dl/Hybrid-HDR

Hybrid HDR

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,32 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: Sp5rky
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Run command uv run [...]
+2. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. Windows/Unix]
+ - Version [e.g. 1.0.1]
+ - Shaka-packager Version [e.g. 2.6.1]
+ - n_m3u8dl-re Version [e.g. 0.3.0 beta]
+ - Any additional software, such as subby/ccextractor/aria2c
+
+**Additional context**
+Add any other context about the problem here, if you're reporting issues with services not running or working, please try to expand on where in your service it breaks but don't include service code (unless you have rights to do so.)

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,21 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: Sp5rky
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+Other tools like Devine/VT had this function [...]
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.gitignore

@@ -18,7 +18,6 @@ device_cert
 device_client_id_blob
 device_private_key
 device_vmp_blob
-binaries/
 unshackle/cache/
 unshackle/cookies/
 unshackle/certs/

CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.1.0] - 2025-07-29
+
+### Added
+
+- **HDR10+DV Hybrid Processing**: New `-r HYBRID` command for processing HDR10 and Dolby Vision tracks
+  - Support for hybrid HDR processing and injection using dovi_tool
+  - New hybrid track processing module for seamless HDR10/DV conversion
+  - Automatic detection and handling of HDR10 and DV metadata
+- Support for HDR10 and DV tracks in hybrid mode for EXAMPLE service
+- Binary availability check for dovi_tool in hybrid mode operations
+- Enhanced track processing capabilities for HDR content
+
+### Fixed
+
+- Import order issues and missing json import in hybrid processing
+- UV installation process and error handling improvements
+- Binary search functionality updated to use `binaries.find`
+
+### Changed
+
+- Updated package version from 1.0.2 to 1.1.0
+- Enhanced dl.py command processing for hybrid mode support
+- Improved core titles (episode/movie) processing for HDR content
+- Extended tracks module with hybrid processing capabilities

README.md

@@ -14,6 +14,7 @@ unshackle is a fork of [Devine](https://github.com/devine-dl/devine/), a powerfu
 - 🎥 **Multi-Media Support** - Movies, TV episodes, and music
 - 🛠️ **Built-in Parsers** - DASH/HLS and ISM manifest support
 - 🔒 **DRM Support** - Widevine and PlayReady integration
+- 🌈 **HDR10+DV Hybrid** - Hybrid Dolby Vision injection via [dovi_tool](https://github.com/quietvoid/dovi_tool)
 - 💾 **Flexible Storage** - Local and remote key vaults
 - 👥 **Multi-Profile Auth** - Support for cookies and credentials
 - 🤖 **Smart Naming** - Automatic P2P-style filename structure
@@ -54,12 +55,11 @@ docker run --rm ghcr.io/unshackle-dl/unshackle:latest env check
 
 # Download content (mount directories for persistent data)
 docker run --rm \
-  -v "$(pwd)/downloads:/downloads" \
+  -v "$(pwd)/unshackle/downloads:/app/downloads" \
   -v "$(pwd)/unshackle/cookies:/app/unshackle/cookies" \
   -v "$(pwd)/unshackle/services:/app/unshackle/services" \
   -v "$(pwd)/unshackle/WVDs:/app/unshackle/WVDs" \
   -v "$(pwd)/unshackle/PRDs:/app/unshackle/PRDs" \
-  -v "$(pwd)/temp:/app/temp" \
   -v "$(pwd)/unshackle/unshackle.yaml:/app/unshackle.yaml" \
   ghcr.io/unshackle-dl/unshackle:latest dl SERVICE_NAME CONTENT_ID
 
@@ -88,7 +88,6 @@ docker run --rm unshackle env check
 
 ## Planned Features
 
-- 🌈 **HDR10+DV Hybrid Support** - Allow support for hybrid HDR10+ and Dolby Vision.
 - 🖥️ **Web UI Access & Control** - Manage and control unshackle from a modern web interface.
 - 🔄 **Sonarr/Radarr Interactivity** - Direct integration for automated personal downloads.
 - ⚙️ **Better ISM Support** - Improve on ISM support for multiple services

install.bat

@@ -1,47 +1,61 @@
 @echo off
-echo Installing unshackle dependencies...
+setlocal EnableExtensions EnableDelayedExpansion
+
+echo.
+echo === Unshackle setup (Windows) ===
 echo.
 
-REM Check if UV is already installed
-uv --version >nul 2>&1
+where uv >nul 2>&1
 if %errorlevel% equ 0 (
-    echo UV is already installed.
+    echo [OK] uv is already installed.
     goto install_deps
 )
 
-echo UV not found. Installing UV...
-echo.
+echo [..] uv not found. Installing...
 
-REM Install UV using the official installer
-powershell -Command "irm https://astral.sh/uv/install.ps1 | iex"
+powershell -NoProfile -ExecutionPolicy Bypass -Command "irm https://astral.sh/uv/install.ps1 | iex"
 if %errorlevel% neq 0 (
-    echo Failed to install UV. Please install UV manually from https://docs.astral.sh/uv/getting-started/installation/
+    echo [ERR] Failed to install uv.
+    echo PowerShell may be blocking scripts. Try:
+    echo   Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
+    echo or install manually: https://docs.astral.sh/uv/getting-started/installation/
     pause
     exit /b 1
 )
 
-REM Add UV to PATH for current session
-set "PATH=%USERPROFILE%\.cargo\bin;%PATH%"
+set "UV_BIN="
+for %%D in ("%USERPROFILE%\.local\bin" "%LOCALAPPDATA%\Programs\uv\bin" "%USERPROFILE%\.cargo\bin") do (
+    if exist "%%~fD\uv.exe" set "UV_BIN=%%~fD"
+)
 
-echo UV installed successfully.
-echo.
+if not defined UV_BIN (
+    echo [WARN] Could not locate uv.exe. You may need to reopen your terminal.
+) else (
+    set "PATH=%UV_BIN%;%PATH%"
+)
+
+:: Verify
+uv --version >nul 2>&1
+if %errorlevel% neq 0 (
+    echo [ERR] uv still not reachable in this shell. Open a new terminal and re-run this script.
+    pause
+    exit /b 1
+)
+echo [OK] uv installed and reachable.
 
 :install_deps
-echo Installing project dependencies in editable mode with dev dependencies...
 echo.
-
-REM Install the project in editable mode with dev dependencies
 uv sync
 if %errorlevel% neq 0 (
-    echo Failed to install dependencies. Please check the error messages above.
+    echo [ERR] Dependency install failed. See errors above.
     pause
     exit /b 1
 )
 
 echo.
 echo Installation completed successfully!
-echo.
-echo You can now run unshackle using:
+echo Try:
 echo   uv run unshackle --help
 echo.
 pause
+endlocal

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "unshackle"
-version = "1.0.1"
+version = "1.1.0"
 description = "Modular Movie, TV, and Music Archival Software."
 authors = [{ name = "unshackle team" }]
 requires-python = ">=3.10,<3.13"
@@ -57,6 +57,7 @@ dependencies = [
     "pyplayready>=0.6.0,<0.7",
     "httpx>=0.28.1,<0.29",
     "cryptography>=45.0.0",
+    "subby",
 ]
 
 [project.urls]
@@ -112,3 +113,4 @@ no_implicit_optional = true
 
 [tool.uv.sources]
 unshackle = { workspace = true }
+subby = { git = "https://github.com/vevv/subby.git" }

unshackle/commands/cfg.py

@@ -65,7 +65,7 @@ def cfg(ctx: click.Context, key: str, value: str, unset: bool, list_: bool) -> N
 
     if not is_write and not is_delete:
         data = data.mlget(key_items, default=KeyError)
-        if data == KeyError:
+        if data is KeyError:
             raise click.ClickException(f"Key '{key}' does not exist in the config.")
         yaml.dump(data, sys.stdout)
     else:

unshackle/commands/dl.py

@@ -48,13 +48,14 @@ from unshackle.core.constants import DOWNLOAD_LICENCE_ONLY, AnyTrack, context_se
 from unshackle.core.credential import Credential
 from unshackle.core.drm import DRM_T, PlayReady, Widevine
 from unshackle.core.events import events
-from unshackle.core.proxies import Basic, Hola, NordVPN
+from unshackle.core.proxies import Basic, Hola, NordVPN, SurfsharkVPN
 from unshackle.core.service import Service
 from unshackle.core.services import Services
 from unshackle.core.titles import Movie, Movies, Series, Song, Title_T
 from unshackle.core.titles.episode import Episode
 from unshackle.core.tracks import Audio, Subtitle, Tracks, Video
 from unshackle.core.tracks.attachment import Attachment
+from unshackle.core.tracks.hybrid import Hybrid
 from unshackle.core.utilities import get_system_fonts, is_close_match, time_elapsed_since
 from unshackle.core.utils import tags
 from unshackle.core.utils.click_types import (LANGUAGE_RANGE, QUALITY_LIST, SEASON_RANGE, ContextData, MultipleChoice,
@@ -309,6 +310,8 @@ class dl:
                     self.proxy_providers.append(Basic(**config.proxy_providers["basic"]))
                 if config.proxy_providers.get("nordvpn"):
                     self.proxy_providers.append(NordVPN(**config.proxy_providers["nordvpn"]))
+                if config.proxy_providers.get("surfsharkvpn"):
+                    self.proxy_providers.append(SurfsharkVPN(**config.proxy_providers["surfsharkvpn"]))
                 if binaries.HolaProxy:
                     self.proxy_providers.append(Hola())
                 for proxy_provider in self.proxy_providers:
@@ -397,6 +400,14 @@ class dl:
         self.tmdb_searched = False
         start_time = time.time()
 
+        # Check if dovi_tool is available when hybrid mode is requested
+        if any(r == Video.Range.HYBRID for r in range_):
+            from unshackle.core.binaries import DoviTool
+            if not DoviTool:
+                self.log.error("Unable to run hybrid mode: dovi_tool not detected")
+                self.log.error("Please install dovi_tool from https://github.com/quietvoid/dovi_tool")
+                sys.exit(1)
+
         if cdm_only is None:
             vaults_only = None
         else:
@@ -537,10 +548,12 @@ class dl:
                             sys.exit(1)
 
                     if range_:
-                        title.tracks.select_video(lambda x: x.range in range_)
-                        missing_ranges = [r for r in range_ if not any(x.range == r for x in title.tracks.videos)]
-                        for color_range in missing_ranges:
-                            self.log.warning(f"Skipping {color_range.name} video tracks as none are available.")
+                        # Special handling for HYBRID - don't filter, keep all HDR10 and DV tracks
+                        if Video.Range.HYBRID not in range_:
+                            title.tracks.select_video(lambda x: x.range in range_)
+                            missing_ranges = [r for r in range_ if not any(x.range == r for x in title.tracks.videos)]
+                            for color_range in missing_ranges:
+                                self.log.warning(f"Skipping {color_range.name} video tracks as none are available.")
 
                     if vbitrate:
                         title.tracks.select_video(lambda x: x.bitrate and x.bitrate // 1000 == vbitrate)
@@ -557,38 +570,60 @@ class dl:
                             sys.exit(1)
 
                     if quality:
-                        title.tracks.by_resolutions(quality)
                         missing_resolutions = []
-                        for resolution in quality:
-                            if any(video.height == resolution for video in title.tracks.videos):
-                                continue
-                            if any(int(video.width * (9 / 16)) == resolution for video in title.tracks.videos):
-                                continue
-                            missing_resolutions.append(resolution)
+                        if any(r == Video.Range.HYBRID for r in range_):
+                            title.tracks.select_video(title.tracks.select_hybrid(title.tracks.videos, quality))
+                        else:
+                            title.tracks.by_resolutions(quality)
+
+                            for resolution in quality:
+                                if any(v.height == resolution for v in title.tracks.videos):
+                                    continue
+                                if any(int(v.width * 9 / 16) == resolution for v in title.tracks.videos):
+                                    continue
+                                missing_resolutions.append(resolution)
+
                         if missing_resolutions:
                             res_list = ""
                             if len(missing_resolutions) > 1:
-                                res_list = (", ".join([f"{x}p" for x in missing_resolutions[:-1]])) + " or "
+                                res_list = ", ".join([f"{x}p" for x in missing_resolutions[:-1]]) + " or "
                             res_list = f"{res_list}{missing_resolutions[-1]}p"
                             plural = "s" if len(missing_resolutions) > 1 else ""
                             self.log.error(f"There's no {res_list} Video Track{plural}...")
                             sys.exit(1)
 
                     # choose best track by range and quality
-                    selected_videos: list[Video] = []
-                    for resolution, color_range in product(quality or [None], range_ or [None]):
-                        match = next(
-                            (
-                                t
-                                for t in title.tracks.videos
-                                if (not resolution or t.height == resolution or int(t.width * (9 / 16)) == resolution)
-                                and (not color_range or t.range == color_range)
-                            ),
-                            None,
-                        )
-                        if match and match not in selected_videos:
-                            selected_videos.append(match)
-                    title.tracks.videos = selected_videos
+                    if any(r == Video.Range.HYBRID for r in range_):
+                        # For hybrid mode, always apply hybrid selection
+                        # If no quality specified, use only the best (highest) resolution
+                        if not quality:
+                            # Get the highest resolution available
+                            best_resolution = max((v.height for v in title.tracks.videos), default=None)
+                            if best_resolution:
+                                # Use the hybrid selection logic with only the best resolution
+                                title.tracks.select_video(
+                                    title.tracks.select_hybrid(title.tracks.videos, [best_resolution])
+                                )
+                        # If quality was specified, hybrid selection was already applied above
+                    else:
+                        selected_videos: list[Video] = []
+                        for resolution, color_range in product(quality or [None], range_ or [None]):
+                            match = next(
+                                (
+                                    t
+                                    for t in title.tracks.videos
+                                    if (
+                                        not resolution
+                                        or t.height == resolution
+                                        or int(t.width * (9 / 16)) == resolution
+                                    )
+                                    and (not color_range or t.range == color_range)
+                                ),
+                                None,
+                            )
+                            if match and match not in selected_videos:
+                                selected_videos.append(match)
+                        title.tracks.videos = selected_videos
 
                     # filter subtitle tracks
                     if s_lang and "all" not in s_lang:
@@ -869,21 +904,52 @@ class dl:
                     )
 
                     multiplex_tasks: list[tuple[TaskID, Tracks]] = []
-                    for video_track in title.tracks.videos or [None]:
-                        task_description = "Multiplexing"
-                        if video_track:
-                            if len(quality) > 1:
-                                task_description += f" {video_track.height}p"
-                            if len(range_) > 1:
-                                task_description += f" {video_track.range.name}"
 
+                    # Check if we're in hybrid mode
+                    if any(r == Video.Range.HYBRID for r in range_) and title.tracks.videos:
+                        # Hybrid mode: process DV and HDR10 tracks together
+                        self.log.info("Processing Hybrid HDR10+DV tracks...")
+
+                        # Run the hybrid processing
+                        Hybrid(title.tracks.videos, self.service)
+
+                        # After hybrid processing, the output file should be in temp directory
+                        hybrid_output_path = config.directories.temp / "HDR10-DV.hevc"
+
+                        # Create a single mux task for the hybrid output
+                        task_description = "Multiplexing Hybrid HDR10+DV"
                         task_id = progress.add_task(f"{task_description}...", total=None, start=False)
 
+                        # Create tracks with the hybrid video output
                         task_tracks = Tracks(title.tracks) + title.tracks.chapters + title.tracks.attachments
-                        if video_track:
-                            task_tracks.videos = [video_track]
+
+                        # Create a new video track for the hybrid output
+                        # Use the HDR10 track as a template but update its path
+                        hdr10_track = next((v for v in title.tracks.videos if v.range == Video.Range.HDR10), None)
+                        if hdr10_track:
+                            hybrid_track = deepcopy(hdr10_track)
+                            hybrid_track.path = hybrid_output_path
+                            hybrid_track.range = Video.Range.DV  # It's now a DV track
+                            task_tracks.videos = [hybrid_track]
 
                         multiplex_tasks.append((task_id, task_tracks))
+                    else:
+                        # Normal mode: process each video track separately
+                        for video_track in title.tracks.videos or [None]:
+                            task_description = "Multiplexing"
+                            if video_track:
+                                if len(quality) > 1:
+                                    task_description += f" {video_track.height}p"
+                                if len(range_) > 1:
+                                    task_description += f" {video_track.range.name}"
+
+                            task_id = progress.add_task(f"{task_description}...", total=None, start=False)
+
+                            task_tracks = Tracks(title.tracks) + title.tracks.chapters + title.tracks.attachments
+                            if video_track:
+                                task_tracks.videos = [video_track]
+
+                            multiplex_tasks.append((task_id, task_tracks))
 
                     with Live(Padding(progress, (0, 5, 1, 5)), console=console):
                         for task_id, task_tracks in multiplex_tasks:

unshackle/commands/env.py

@@ -10,11 +10,11 @@ from rich.padding import Padding
 from rich.table import Table
 from rich.tree import Tree
 
+from unshackle.core import binaries
 from unshackle.core.config import POSSIBLE_CONFIG_PATHS, config, config_path
 from unshackle.core.console import console
 from unshackle.core.constants import context_settings
 from unshackle.core.services import Services
-from unshackle.core.utils.osenvironment import get_os_arch
 
 
 @click.group(short_help="Manage and configure the project environment.", context_settings=context_settings)
@@ -27,40 +27,47 @@ def check() -> None:
     """Checks environment for the required dependencies."""
     table = Table(title="Dependencies", expand=True)
     table.add_column("Name", no_wrap=True)
+    table.add_column("Required", justify="center")
     table.add_column("Installed", justify="center")
     table.add_column("Path", no_wrap=False, overflow="fold")
 
-    # builds shaka-packager based on os, arch
-    packager_dep = get_os_arch("packager")
-
-    # Helper function to find binary with multiple possible names
-    def find_binary(*names):
-        for name in names:
-            if shutil.which(name):
-                return name
-        return names[0]  # Return first name as fallback for display
-
+    # Define all dependencies with their binary objects and required status
     dependencies = [
-        {"name": "CCExtractor", "binary": "ccextractor"},
-        {"name": "FFMpeg", "binary": "ffmpeg"},
-        {"name": "MKVToolNix", "binary": "mkvmerge"},
-        {"name": "Shaka-Packager", "binary": packager_dep},
-        {"name": "N_m3u8DL-RE", "binary": find_binary("N_m3u8DL-RE", "n-m3u8dl-re")},
-        {"name": "Aria2(c)", "binary": "aria2c"},
+        {"name": "FFMpeg", "binary": binaries.FFMPEG, "required": True},
+        {"name": "FFProbe", "binary": binaries.FFProbe, "required": True},
+        {"name": "shaka-packager", "binary": binaries.ShakaPackager, "required": True},
+        {"name": "MKVToolNix", "binary": binaries.MKVToolNix, "required": True},
+        {"name": "Mkvpropedit", "binary": binaries.Mkvpropedit, "required": True},
+        {"name": "CCExtractor", "binary": binaries.CCExtractor, "required": False},
+        {"name": "FFPlay", "binary": binaries.FFPlay, "required": False},
+        {"name": "SubtitleEdit", "binary": binaries.SubtitleEdit, "required": False},
+        {"name": "Aria2(c)", "binary": binaries.Aria2, "required": False},
+        {"name": "HolaProxy", "binary": binaries.HolaProxy, "required": False},
+        {"name": "MPV", "binary": binaries.MPV, "required": False},
+        {"name": "Caddy", "binary": binaries.Caddy, "required": False},
+        {"name": "N_m3u8DL-RE", "binary": binaries.N_m3u8DL_RE, "required": False},
+        {"name": "dovi_tool", "binary": binaries.DoviTool, "required": False},
     ]
 
     for dep in dependencies:
-        path = shutil.which(dep["binary"])
+        path = dep["binary"]
 
+        # Required column
+        if dep["required"]:
+            required = "[red]Yes[/red]"
+        else:
+            required = "No"
+
+        # Installed column
         if path:
             installed = "[green]:heavy_check_mark:[/green]"
-            path_output = path.lower()
+            path_output = str(path)
         else:
             installed = "[red]:x:[/red]"
             path_output = "Not Found"
 
         # Add to the table
-        table.add_row(dep["name"], installed, path_output)
+        table.add_row(dep["name"], required, installed, path_output)
 
     # Display the result
     console.print(Padding(table, (1, 5)))
@@ -92,12 +99,21 @@ def info() -> None:
     for name in sorted(dir(config.directories)):
         if name.startswith("__") or name == "app_dirs":
             continue
-        path = getattr(config.directories, name).resolve()
-        for var, var_path in path_vars.items():
-            if path.is_relative_to(var_path):
-                path = rf"%{var}%\{path.relative_to(var_path)}"
-                break
-        table.add_row(name.title(), str(path))
+        attr_value = getattr(config.directories, name)
+
+        # Handle both single Path objects and lists of Path objects
+        if isinstance(attr_value, list):
+            # For lists, show each path on a separate line
+            paths_str = "\n".join(str(path.resolve()) for path in attr_value)
+            table.add_row(name.title(), paths_str)
+        else:
+            # For single Path objects, use the original logic
+            path = attr_value.resolve()
+            for var, var_path in path_vars.items():
+                if path.is_relative_to(var_path):
+                    path = rf"%{var}%\{path.relative_to(var_path)}"
+                    break
+            table.add_row(name.title(), str(path))
 
     console.print(Padding(table, (1, 5)))
 

unshackle/commands/search.py

@@ -16,7 +16,7 @@ from unshackle.core import binaries
 from unshackle.core.config import config
 from unshackle.core.console import console
 from unshackle.core.constants import context_settings
-from unshackle.core.proxies import Basic, Hola, NordVPN
+from unshackle.core.proxies import Basic, Hola, NordVPN, SurfsharkVPN
 from unshackle.core.service import Service
 from unshackle.core.services import Services
 from unshackle.core.utils.click_types import ContextData
@@ -69,6 +69,8 @@ def search(ctx: click.Context, no_proxy: bool, profile: Optional[str] = None, pr
                 proxy_providers.append(Basic(**config.proxy_providers["basic"]))
             if config.proxy_providers.get("nordvpn"):
                 proxy_providers.append(NordVPN(**config.proxy_providers["nordvpn"]))
+            if config.proxy_providers.get("surfsharkvpn"):
+                proxy_providers.append(SurfsharkVPN(**config.proxy_providers["surfsharkvpn"]))
             if binaries.HolaProxy:
                 proxy_providers.append(Hola())
             for proxy_provider in proxy_providers:

unshackle/core/__init__.py

@@ -1 +1 @@
-__version__ = "1.0.1"
+__version__ = "1.1.0"

unshackle/core/__main__.py

@@ -1,6 +1,5 @@
 import atexit
 import logging
-from datetime import datetime
 from pathlib import Path
 
 import click
@@ -69,7 +68,7 @@ def main(version: bool, debug: bool, log_path: Path) -> None:
                     r" ▀▀▀ ▀▀ █▪ ▀▀▀▀ ▀▀▀ · ▀  ▀ ·▀▀▀ ·▀  ▀.▀▀▀  ▀▀▀ ",
                     style="ascii.art",
                 ),
-                f"v[repr.number]{__version__}[/]",
+                "v 3.3.3 Copyright © 2019-2025 rlaphoenix" + f"\nv [repr.number]{__version__}[/] - unshackle",
             ),
             (1, 11, 1, 10),
             expand=True,

unshackle/core/binaries.py

@@ -8,7 +8,24 @@ __shaka_platform = {"win32": "win", "darwin": "osx"}.get(sys.platform, sys.platf
 
 def find(*names: str) -> Optional[Path]:
     """Find the path of the first found binary name."""
+    # Get the directory containing this file to find the local binaries folder
+    current_dir = Path(__file__).parent.parent
+    local_binaries_dir = current_dir / "binaries"
+
     for name in names:
+        # First check local binaries folder
+        if local_binaries_dir.exists():
+            local_path = local_binaries_dir / name
+            if local_path.is_file() and local_path.stat().st_mode & 0o111:  # Check if executable
+                return local_path
+
+            # Also check with .exe extension on Windows
+            if sys.platform == "win32":
+                local_path_exe = local_binaries_dir / f"{name}.exe"
+                if local_path_exe.is_file():
+                    return local_path_exe
+
+        # Fall back to system PATH
         path = shutil.which(name)
         if path:
             return Path(path)
@@ -32,6 +49,9 @@ HolaProxy = find("hola-proxy")
 MPV = find("mpv")
 Caddy = find("caddy")
 N_m3u8DL_RE = find("N_m3u8DL-RE", "n-m3u8dl-re")
+MKVToolNix = find("mkvmerge")
+Mkvpropedit = find("mkvpropedit")
+DoviTool = find("dovi_tool")
 
 
 __all__ = (
@@ -46,5 +66,8 @@ __all__ = (
     "MPV",
     "Caddy",
     "N_m3u8DL_RE",
+    "MKVToolNix",
+    "Mkvpropedit",
+    "DoviTool",
     "find",
 )

unshackle/core/config.py

@@ -14,7 +14,7 @@ class Config:
         core_dir = Path(__file__).resolve().parent
         namespace_dir = core_dir.parent
         commands = namespace_dir / "commands"
-        services = namespace_dir / "services"
+        services = [namespace_dir / "services"]
         vaults = namespace_dir / "vaults"
         fonts = namespace_dir / "fonts"
         user_configs = core_dir.parent
@@ -45,13 +45,17 @@ class Config:
         self.curl_impersonate: dict = kwargs.get("curl_impersonate") or {}
         self.remote_cdm: list[dict] = kwargs.get("remote_cdm") or []
         self.credentials: dict = kwargs.get("credentials") or {}
+        self.subtitle: dict = kwargs.get("subtitle") or {}
 
         self.directories = self._Directories()
         for name, path in (kwargs.get("directories") or {}).items():
             if name.lower() in ("app_dirs", "core_dir", "namespace_dir", "user_configs", "data"):
                 # these must not be modified by the user
                 continue
-            setattr(self.directories, name, Path(path).expanduser())
+            if name == "services" and isinstance(path, list):
+                setattr(self.directories, name, [Path(p).expanduser() for p in path])
+            else:
+                setattr(self.directories, name, Path(path).expanduser())
 
         downloader_cfg = kwargs.get("downloader") or "requests"
         if isinstance(downloader_cfg, dict):
@@ -68,7 +72,6 @@ class Config:
         self.headers: dict = kwargs.get("headers") or {}
         self.key_vaults: list[dict[str, Any]] = kwargs.get("key_vaults", [])
         self.muxing: dict = kwargs.get("muxing") or {}
-        self.nordvpn: dict = kwargs.get("nordvpn") or {}
         self.proxy_providers: dict = kwargs.get("proxy_providers") or {}
         self.serve: dict = kwargs.get("serve") or {}
         self.services: dict = kwargs.get("services") or {}

unshackle/core/constants.py

@@ -7,7 +7,7 @@ DOWNLOAD_LICENCE_ONLY = Event()
 DRM_SORT_MAP = ["ClearKey", "Widevine"]
 LANGUAGE_MAX_DISTANCE = 5  # this is max to be considered "same", e.g., en, en-US, en-AU
 VIDEO_CODEC_MAP = {"AVC": "H.264", "HEVC": "H.265"}
-DYNAMIC_RANGE_MAP = {"HDR10": "HDR", "HDR10+": "HDR", "Dolby Vision": "DV"}
+DYNAMIC_RANGE_MAP = {"HDR10": "HDR", "HDR10+": "HDR10P", "Dolby Vision": "DV", "HDR10 / HDR10+": "HDR10P", "HDR10 / HDR10": "HDR"}
 AUDIO_CODEC_MAP = {"E-AC-3": "DDP", "AC-3": "DD"}
 
 context_settings = dict(

unshackle/core/downloaders/curl_impersonate.py

@@ -76,6 +76,11 @@ def download(url: str, save_path: Path, session: Session, **kwargs: Any) -> Gene
 
                 try:
                     content_length = int(stream.headers.get("Content-Length", "0"))
+
+                    # Skip Content-Length validation for compressed responses since
+                    # curl_impersonate automatically decompresses but Content-Length shows compressed size
+                    if stream.headers.get("Content-Encoding", "").lower() in ["gzip", "deflate", "br"]:
+                        content_length = 0
                 except ValueError:
                     content_length = 0
 

unshackle/core/downloaders/requests.py

@@ -90,6 +90,11 @@ def download(
                 if not segmented:
                     try:
                         content_length = int(stream.headers.get("Content-Length", "0"))
+
+                        # Skip Content-Length validation for compressed responses since
+                        # requests automatically decompresses but Content-Length shows compressed size
+                        if stream.headers.get("Content-Encoding", "").lower() in ["gzip", "deflate", "br"]:
+                            content_length = 0
                     except ValueError:
                         content_length = 0
 

unshackle/core/proxies/__init__.py

@@ -1,5 +1,6 @@
 from .basic import Basic
 from .hola import Hola
 from .nordvpn import NordVPN
+from .surfsharkvpn import SurfsharkVPN
 
-__all__ = ("Basic", "Hola", "NordVPN")
+__all__ = ("Basic", "Hola", "NordVPN", "SurfsharkVPN")

unshackle/core/proxies/surfsharkvpn.py

@@ -0,0 +1,124 @@
+import json
+import random
+import re
+from typing import Optional
+
+import requests
+
+from unshackle.core.proxies.proxy import Proxy
+
+
+class SurfsharkVPN(Proxy):
+    def __init__(self, username: str, password: str, server_map: Optional[dict[str, int]] = None):
+        """
+        Proxy Service using SurfsharkVPN Service Credentials.
+
+        A username and password must be provided. These are Service Credentials, not your Login Credentials.
+        The Service Credentials can be found here: https://my.surfshark.com/vpn/manual-setup/main/openvpn
+        """
+        if not username:
+            raise ValueError("No Username was provided to the SurfsharkVPN Proxy Service.")
+        if not password:
+            raise ValueError("No Password was provided to the SurfsharkVPN Proxy Service.")
+        if not re.match(r"^[a-z0-9]{48}$", username + password, re.IGNORECASE) or "@" in username:
+            raise ValueError(
+                "The Username and Password must be SurfsharkVPN Service Credentials, not your Login Credentials. "
+                "The Service Credentials can be found here: https://my.surfshark.com/vpn/manual-setup/main/openvpn"
+            )
+
+        if server_map is not None and not isinstance(server_map, dict):
+            raise TypeError(f"Expected server_map to be a dict mapping a region to a server ID, not '{server_map!r}'.")
+
+        self.username = username
+        self.password = password
+        self.server_map = server_map or {}
+
+        self.countries = self.get_countries()
+
+    def __repr__(self) -> str:
+        countries = len(set(x.get("country") for x in self.countries if x.get("country")))
+        servers = sum(1 for x in self.countries if x.get("connectionName"))
+
+        return f"{countries} Countr{['ies', 'y'][countries == 1]} ({servers} Server{['s', ''][servers == 1]})"
+
+    def get_proxy(self, query: str) -> Optional[str]:
+        """
+        Get an HTTP(SSL) proxy URI for a SurfsharkVPN server.
+        """
+        query = query.lower()
+        if re.match(r"^[a-z]{2}\d+$", query):
+            # country and surfsharkvpn server id, e.g., au-per, be-anr, us-bos
+            hostname = f"{query}.prod.surfshark.com"
+        else:
+            if query.isdigit():
+                # country id
+                country = self.get_country(by_id=int(query))
+            elif re.match(r"^[a-z]+$", query):
+                # country code
+                country = self.get_country(by_code=query)
+            else:
+                raise ValueError(f"The query provided is unsupported and unrecognized: {query}")
+            if not country:
+                # SurfsharkVPN doesnt have servers in this region
+                return
+
+            server_mapping = self.server_map.get(country["countryCode"].lower())
+            if server_mapping:
+                # country was set to a specific server ID in config
+                hostname = f"{country['code'].lower()}{server_mapping}.prod.surfshark.com"
+            else:
+                # get the random server ID
+                random_server = self.get_random_server(country["countryCode"])
+                if not random_server:
+                    raise ValueError(
+                        f"The SurfsharkVPN Country {query} currently has no random servers. "
+                        "Try again later. If the issue persists, double-check the query."
+                    )
+                hostname = random_server
+
+        return f"https://{self.username}:{self.password}@{hostname}:443"
+
+    def get_country(self, by_id: Optional[int] = None, by_code: Optional[str] = None) -> Optional[dict]:
+        """Search for a Country and it's metadata."""
+        if all(x is None for x in (by_id, by_code)):
+            raise ValueError("At least one search query must be made.")
+
+        for country in self.countries:
+            if all(
+                [
+                    by_id is None or country["id"] == int(by_id),
+                    by_code is None or country["countryCode"] == by_code.upper(),
+                ]
+            ):
+                return country
+
+    def get_random_server(self, country_id: str):
+        """
+        Get the list of random Server for a Country.
+
+        Note: There may not always be more than one recommended server.
+        """
+        country = [x["connectionName"] for x in self.countries if x["countryCode"].lower() == country_id.lower()]
+        try:
+            country = random.choice(country)
+            return country
+        except Exception:
+            raise ValueError("Could not get random countrycode from the countries list.")
+
+    @staticmethod
+    def get_countries() -> list[dict]:
+        """Get a list of available Countries and their metadata."""
+        res = requests.get(
+            url="https://api.surfshark.com/v3/server/clusters/all",
+            headers={
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+                "Content-Type": "application/json",
+            },
+        )
+        if not res.ok:
+            raise ValueError(f"Failed to get a list of SurfsharkVPN countries [{res.status_code}]")
+
+        try:
+            return res.json()
+        except json.JSONDecodeError:
+            raise ValueError("Could not decode list of SurfsharkVPN countries, not JSON data.")

unshackle/core/services.py

@@ -6,7 +6,14 @@ from unshackle.core.config import config
 from unshackle.core.service import Service
 from unshackle.core.utilities import import_module_by_path
 
-_SERVICES = sorted((path for path in config.directories.services.glob("*/__init__.py")), key=lambda x: x.parent.stem)
+_service_dirs = config.directories.services
+if not isinstance(_service_dirs, list):
+    _service_dirs = [_service_dirs]
+
+_SERVICES = sorted(
+    (path for service_dir in _service_dirs for path in service_dir.glob("*/__init__.py")),
+    key=lambda x: x.parent.stem,
+)
 
 _MODULES = {path.parent.stem: getattr(import_module_by_path(path), path.parent.stem) for path in _SERVICES}
 

unshackle/core/titles/episode.py

@@ -107,10 +107,6 @@ class Episode(Title):
                 name=self.name or "",
             ).strip()
 
-        # MULTi
-        if unique_audio_languages > 1:
-            name += " MULTi"
-
         # Resolution
         if primary_video_track:
             resolution = primary_video_track.height
@@ -135,6 +131,14 @@ class Episode(Title):
         # 'WEB-DL'
         name += " WEB-DL"
 
+        # DUAL
+        if unique_audio_languages == 2:
+            name += " DUAL"
+
+        # MULTi
+        if unique_audio_languages > 2:
+            name += " MULTi"
+
         # Audio Codec + Channels (+ feature)
         if primary_audio_track:
             codec = primary_audio_track.format
@@ -157,7 +161,11 @@ class Episode(Title):
             trc = primary_video_track.transfer_characteristics or primary_video_track.transfer_characteristics_original
             frame_rate = float(primary_video_track.frame_rate)
             if hdr_format:
-                name += f" {DYNAMIC_RANGE_MAP.get(hdr_format)} "
+                if (primary_video_track.hdr_format or "").startswith("Dolby Vision"):
+                    if (primary_video_track.hdr_format_commercial) != "Dolby Vision":
+                        name += f" DV {DYNAMIC_RANGE_MAP.get(hdr_format)} "
+                else:
+                    name += f" {DYNAMIC_RANGE_MAP.get(hdr_format)} "
             elif trc and "HLG" in trc:
                 name += " HLG"
             if frame_rate > 30:

unshackle/core/titles/movie.py

@@ -58,10 +58,6 @@ class Movie(Title):
         # Name (Year)
         name = str(self).replace("$", "S")  # e.g., Arli$$
 
-        # MULTi
-        if unique_audio_languages > 1:
-            name += " MULTi"
-
         # Resolution
         if primary_video_track:
             resolution = primary_video_track.height
@@ -86,6 +82,14 @@ class Movie(Title):
         # 'WEB-DL'
         name += " WEB-DL"
 
+        # DUAL
+        if unique_audio_languages == 2:
+            name += " DUAL"
+
+        # MULTi
+        if unique_audio_languages > 2:
+            name += " MULTi"
+
         # Audio Codec + Channels (+ feature)
         if primary_audio_track:
             codec = primary_audio_track.format
@@ -108,7 +112,11 @@ class Movie(Title):
             trc = primary_video_track.transfer_characteristics or primary_video_track.transfer_characteristics_original
             frame_rate = float(primary_video_track.frame_rate)
             if hdr_format:
-                name += f" {DYNAMIC_RANGE_MAP.get(hdr_format)} "
+                if (primary_video_track.hdr_format or "").startswith("Dolby Vision"):
+                    if (primary_video_track.hdr_format_commercial) != "Dolby Vision":
+                        name += f" DV {DYNAMIC_RANGE_MAP.get(hdr_format)} "
+                else:
+                    name += f" {DYNAMIC_RANGE_MAP.get(hdr_format)} "
             elif trc and "HLG" in trc:
                 name += " HLG"
             if frame_rate > 30:

unshackle/core/tracks/__init__.py

@@ -2,9 +2,10 @@ from .attachment import Attachment
 from .audio import Audio
 from .chapter import Chapter
 from .chapters import Chapters
+from .hybrid import Hybrid
 from .subtitle import Subtitle
 from .track import Track
 from .tracks import Tracks
 from .video import Video
 
-__all__ = ("Audio", "Attachment", "Chapter", "Chapters", "Subtitle", "Track", "Tracks", "Video")
+__all__ = ("Audio", "Attachment", "Chapter", "Chapters", "Hybrid", "Subtitle", "Track", "Tracks", "Video")

unshackle/core/tracks/hybrid.py

@@ -0,0 +1,369 @@
+import json
+import logging
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from rich.padding import Padding
+from rich.rule import Rule
+
+from unshackle.core.binaries import DoviTool
+from unshackle.core.config import config
+from unshackle.core.console import console
+
+
+class Hybrid:
+    def __init__(self, videos, source) -> None:
+        self.log = logging.getLogger("hybrid")
+
+        """
+            Takes the Dolby Vision and HDR10(+) streams out of the VideoTracks.
+            It will then attempt to inject the Dolby Vision metadata layer to the HDR10(+) stream.
+            """
+        global directories
+        from unshackle.core.tracks import Video
+
+        self.videos = videos
+        self.source = source
+        self.rpu_file = "RPU.bin"
+        self.hdr_type = "HDR10"
+        self.hevc_file = f"{self.hdr_type}-DV.hevc"
+
+        console.print(Padding(Rule("[rule.text]HDR10+DV Hybrid"), (1, 2)))
+
+        for video in self.videos:
+            if not video.path or not os.path.exists(video.path):
+                self.log.exit(f" - Video track {video.id} was not downloaded before injection.")
+
+        if not any(video.range == Video.Range.DV for video in self.videos) or not any(
+            video.range == Video.Range.HDR10 for video in self.videos
+        ):
+            self.log.exit(" - Two VideoTracks available but one of them is not DV nor HDR10(+).")
+
+        if os.path.isfile(config.directories.temp / self.hevc_file):
+            self.log.info("✓ Already Injected")
+            return
+
+        for video in videos:
+            # Use the actual path from the video track
+            save_path = video.path
+            if not save_path or not os.path.exists(save_path):
+                self.log.exit(f" - Video track {video.id} was not downloaded or path not found: {save_path}")
+
+            if video.range == Video.Range.HDR10:
+                self.extract_stream(save_path, "HDR10")
+            elif video.range == Video.Range.DV:
+                self.extract_stream(save_path, "DV")
+                # self.extract_dv_stream(video, save_path)
+
+        self.extract_rpu([video for video in videos if video.range == Video.Range.DV][0])
+        if os.path.isfile(config.directories.temp / "RPU_UNT.bin"):
+            self.rpu_file = "RPU_UNT.bin"
+            self.level_6()
+            # Mode 3 conversion already done during extraction when not untouched
+        elif os.path.isfile(config.directories.temp / "RPU.bin"):
+            # RPU already extracted with mode 3
+            pass
+
+        self.injecting()
+
+        self.log.info("✓ Injection Completed")
+        if self.source == ("itunes" or "appletvplus"):
+            Path.unlink(config.directories.temp / "hdr10.mkv")
+            Path.unlink(config.directories.temp / "dv.mkv")
+        Path.unlink(config.directories.temp / "DV.hevc")
+        Path.unlink(config.directories.temp / "HDR10.hevc")
+        Path.unlink(config.directories.temp / f"{self.rpu_file}")
+
+    def ffmpeg_simple(self, save_path, output):
+        """Simple ffmpeg execution without progress tracking"""
+        p = subprocess.run(
+            [
+                "ffmpeg",
+                "-nostdin",
+                "-i",
+                str(save_path),
+                "-c:v",
+                "copy",
+                str(output),
+                "-y",  # overwrite output
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        return p.returncode
+
+    def extract_stream(self, save_path, type_):
+        output = Path(config.directories.temp / f"{type_}.hevc")
+
+        self.log.info(f"+ Extracting {type_} stream")
+
+        returncode = self.ffmpeg_simple(save_path, output)
+
+        if returncode:
+            output.unlink(missing_ok=True)
+            self.log.error(f"x Failed extracting {type_} stream")
+            sys.exit(1)
+
+    def ffmpeg_task(self, save_path, output, task_id):
+        p = subprocess.Popen(
+            [
+                "ffmpeg",
+                "-nostdin",
+                "-i",
+                str(save_path),
+                "-c:v",
+                "copy",
+                str(output),
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            bufsize=1,
+            universal_newlines=True,
+        )
+
+        self.progress.start_task(task_id)
+
+        for line in p.stderr:
+            if "frame=" in line:
+                self.progress.update(task_id, advance=0)
+        p.wait()
+
+        return p.returncode
+
+    def extract_hdr10_stream(self, video, save_path):
+        type_ = "HDR10"
+        if os.path.isfile(Path(config.directories.temp / f"{type_}.hevc")):
+            return
+        if self.source == "itunes" or self.source == "appletvplus":
+            self.log.info("+ Muxing HDR10 stream for fixing MP4 file")
+            subprocess.run(
+                [
+                    "mkvmerge",
+                    "-o",
+                    Path(config.directories.temp / "hdr10.mkv"),
+                    save_path,
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            self.log.info(f"+ Extracting {type_} stream")
+            extract_stream = subprocess.run(
+                [
+                    "ffmpeg",
+                    "-nostdin",
+                    "-stats",
+                    "-i",
+                    Path(config.directories.temp / "hdr10.mkv"),
+                    "-c:v",
+                    "copy",
+                    Path(config.directories.temp / f"{type_}.hevc"),
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            if extract_stream.returncode:
+                Path.unlink(Path(config.directories.temp / f"{type_}.hevc"))
+                self.log.error(f"x Failed extracting {type_} stream")
+                sys.exit(1)
+        else:
+            extract_stream = subprocess.run(
+                [
+                    "ffmpeg",
+                    "-nostdin",
+                    "-stats",
+                    "-i",
+                    save_path,
+                    "-c:v",
+                    "copy",
+                    Path(config.directories.temp / f"{type_}.hevc"),
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            if extract_stream.returncode:
+                Path.unlink(Path(config.directories.temp / f"{type_}.hevc"))
+                self.log.error(f"x Failed extracting {type_} stream")
+                sys.exit(1)
+
+    def extract_dv_stream(self, video, save_path):
+        type_ = "DV"
+        if os.path.isfile(Path(config.directories.temp / f"{type_}.hevc")):
+            return
+        if self.source == "itunes" or self.source == "appletvplus":
+            self.log.info("+ Muxing Dolby Vision stream for fixing MP4 file")
+            subprocess.run(
+                [
+                    "mkvmerge",
+                    "-o",
+                    Path(config.directories.temp / "dv.mkv"),
+                    save_path,
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            self.log.info("+ Extracting Dolby Vision stream")
+            extract_stream = subprocess.run(
+                [
+                    "ffmpeg",
+                    "-nostdin",
+                    "-stats",
+                    "-i",
+                    Path(config.directories.temp / "dv.mkv"),
+                    "-an",
+                    "-c:v",
+                    "copy",
+                    "-f",
+                    "hevc",
+                    Path(config.directories.temp / "out_1.h265"),
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            if extract_stream.returncode:
+                Path.unlink(Path(config.directories.temp / f"{type_}.hevc"))
+                self.log.error(f"x Failed extracting {type_} stream")
+                sys.exit(1)
+        else:
+            extract_stream = subprocess.run(
+                [
+                    "mp4demuxer",
+                    "--input-file",
+                    save_path,
+                    "--output-folder",
+                    Path(config.directories.temp),
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            if extract_stream.returncode:
+                Path.unlink(Path(config.directories.temp / f"{type_}.hevc"))
+                self.log.error(f"x Failed extracting {type_} stream")
+                sys.exit(1)
+
+    def extract_rpu(self, video, untouched=False):
+        if os.path.isfile(config.directories.temp / "RPU.bin") or os.path.isfile(
+            config.directories.temp / "RPU_UNT.bin"
+        ):
+            return
+
+        self.log.info(f"+ Extracting{' untouched ' if untouched else ' '}RPU from Dolby Vision stream")
+
+        extraction_args = [str(DoviTool)]
+        if not untouched:
+            extraction_args += ["-m", "3"]
+        extraction_args += [
+            "extract-rpu",
+            config.directories.temp / "DV.hevc",
+            "-o",
+            config.directories.temp / f"{'RPU' if not untouched else 'RPU_UNT'}.bin",
+        ]
+
+        rpu_extraction = subprocess.run(
+            extraction_args,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        if rpu_extraction.returncode:
+            Path.unlink(config.directories.temp / f"{'RPU' if not untouched else 'RPU_UNT'}.bin")
+            if b"MAX_PQ_LUMINANCE" in rpu_extraction.stderr:
+                self.extract_rpu(video, untouched=True)
+            elif b"Invalid PPS index" in rpu_extraction.stderr:
+                self.log.exit("x Dolby Vision VideoTrack seems to be corrupt")
+            else:
+                self.log.exit(f"x Failed extracting{' untouched ' if untouched else ' '}RPU from Dolby Vision stream")
+
+    def level_6(self):
+        """Edit RPU Level 6 values"""
+        with open(config.directories.temp / "L6.json", "w+") as level6_file:
+            level6 = {
+                "cm_version": "V29",
+                "length": 0,
+                "level6": {
+                    "max_display_mastering_luminance": 1000,
+                    "min_display_mastering_luminance": 1,
+                    "max_content_light_level": 0,
+                    "max_frame_average_light_level": 0,
+                },
+            }
+
+            json.dump(level6, level6_file, indent=3)
+
+        if not os.path.isfile(config.directories.temp / "RPU_L6.bin"):
+            self.log.info("+ Editing RPU Level 6 values")
+            level6 = subprocess.run(
+                [
+                    str(DoviTool),
+                    "editor",
+                    "-i",
+                    config.directories.temp / self.rpu_file,
+                    "-j",
+                    config.directories.temp / "L6.json",
+                    "-o",
+                    config.directories.temp / "RPU_L6.bin",
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+
+            if level6.returncode:
+                Path.unlink(config.directories.temp / "RPU_L6.bin")
+                self.log.exit("x Failed editing RPU Level 6 values")
+
+            # Update rpu_file to use the edited version
+            self.rpu_file = "RPU_L6.bin"
+
+    def mode_3(self):
+        """Convert RPU to Mode 3"""
+        with open(config.directories.temp / "M3.json", "w+") as mode3_file:
+            json.dump({"mode": 3}, mode3_file, indent=3)
+
+        if not os.path.isfile(config.directories.temp / "RPU_M3.bin"):
+            self.log.info("+ Converting RPU to Mode 3")
+            mode3 = subprocess.run(
+                [
+                    str(DoviTool),
+                    "editor",
+                    "-i",
+                    config.directories.temp / self.rpu_file,
+                    "-j",
+                    config.directories.temp / "M3.json",
+                    "-o",
+                    config.directories.temp / "RPU_M3.bin",
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+
+            if mode3.returncode:
+                Path.unlink(config.directories.temp / "RPU_M3.bin")
+                self.log.exit("x Failed converting RPU to Mode 3")
+
+        self.rpu_file = "RPU_M3.bin"
+
+    def injecting(self):
+        if os.path.isfile(config.directories.temp / self.hevc_file):
+            return
+
+        self.log.info(f"+ Injecting Dolby Vision metadata into {self.hdr_type} stream")
+
+        inject = subprocess.run(
+            [
+                str(DoviTool),
+                "inject-rpu",
+                "-i",
+                config.directories.temp / f"{self.hdr_type}.hevc",
+                "--rpu-in",
+                config.directories.temp / self.rpu_file,
+                "-o",
+                config.directories.temp / self.hevc_file,
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        if inject.returncode:
+            Path.unlink(config.directories.temp / self.hevc_file)
+            self.log.exit("x Failed injecting Dolby Vision metadata into HDR10 stream")

unshackle/core/tracks/subtitle.py

@@ -15,9 +15,11 @@ from construct import Container
 from pycaption import Caption, CaptionList, CaptionNode, WebVTTReader
 from pycaption.geometry import Layout
 from pymp4.parser import MP4
+from subby import CommonIssuesFixer, SAMIConverter, SDHStripper, WebVTTConverter
 from subtitle_filter import Subtitles
 
 from unshackle.core import binaries
+from unshackle.core.config import config
 from unshackle.core.tracks.track import Track
 from unshackle.core.utilities import try_ensure_utf8
 from unshackle.core.utils.webvtt import merge_segmented_webvtt
@@ -30,6 +32,7 @@ class Subtitle(Track):
         SubStationAlphav4 = "ASS"  # https://wikipedia.org/wiki/SubStation_Alpha#Advanced_SubStation_Alpha=
         TimedTextMarkupLang = "TTML"  # https://wikipedia.org/wiki/Timed_Text_Markup_Language
         WebVTT = "VTT"  # https://wikipedia.org/wiki/WebVTT
+        SAMI = "SMI"  # https://wikipedia.org/wiki/SAMI
         # MPEG-DASH box-encapsulated subtitle formats
         fTTML = "STPP"  # https://www.w3.org/TR/2018/REC-ttml-imsc1.0.1-20180424
         fVTT = "WVTT"  # https://www.w3.org/TR/webvtt1
@@ -51,6 +54,8 @@ class Subtitle(Track):
                 return Subtitle.Codec.TimedTextMarkupLang
             elif mime == "vtt":
                 return Subtitle.Codec.WebVTT
+            elif mime in ("smi", "sami"):
+                return Subtitle.Codec.SAMI
             elif mime == "stpp":
                 return Subtitle.Codec.fTTML
             elif mime == "wvtt":
@@ -306,10 +311,158 @@ class Subtitle(Track):
 
         return "\n".join(sanitized_lines)
 
+    def convert_with_subby(self, codec: Subtitle.Codec) -> Path:
+        """
+        Convert subtitle using subby library for better format support and processing.
+
+        This method leverages subby's advanced subtitle processing capabilities
+        including better WebVTT handling, SDH stripping, and common issue fixing.
+        """
+
+        if not self.path or not self.path.exists():
+            raise ValueError("You must download the subtitle track first.")
+
+        if self.codec == codec:
+            return self.path
+
+        output_path = self.path.with_suffix(f".{codec.value.lower()}")
+        original_path = self.path
+
+        try:
+            # Convert to SRT using subby first
+            srt_subtitles = None
+
+            if self.codec == Subtitle.Codec.WebVTT:
+                converter = WebVTTConverter()
+                srt_subtitles = converter.from_file(str(self.path))
+            elif self.codec == Subtitle.Codec.SAMI:
+                converter = SAMIConverter()
+                srt_subtitles = converter.from_file(str(self.path))
+
+            if srt_subtitles is not None:
+                # Apply common fixes
+                fixer = CommonIssuesFixer()
+                fixed_srt, _ = fixer.from_srt(srt_subtitles)
+
+                # If target is SRT, we're done
+                if codec == Subtitle.Codec.SubRip:
+                    output_path.write_text(str(fixed_srt), encoding="utf8")
+                else:
+                    # Convert from SRT to target format using existing pycaption logic
+                    temp_srt_path = self.path.with_suffix(".temp.srt")
+                    temp_srt_path.write_text(str(fixed_srt), encoding="utf8")
+
+                    # Parse the SRT and convert to target format
+                    caption_set = self.parse(temp_srt_path.read_bytes(), Subtitle.Codec.SubRip)
+                    self.merge_same_cues(caption_set)
+
+                    writer = {
+                        Subtitle.Codec.TimedTextMarkupLang: pycaption.DFXPWriter,
+                        Subtitle.Codec.WebVTT: pycaption.WebVTTWriter,
+                    }.get(codec)
+
+                    if writer:
+                        subtitle_text = writer().write(caption_set)
+                        output_path.write_text(subtitle_text, encoding="utf8")
+                    else:
+                        # Fall back to existing conversion method
+                        temp_srt_path.unlink()
+                        return self._convert_standard(codec)
+
+                    temp_srt_path.unlink()
+
+                if original_path.exists() and original_path != output_path:
+                    original_path.unlink()
+
+                self.path = output_path
+                self.codec = codec
+
+                if callable(self.OnConverted):
+                    self.OnConverted(codec)
+
+                return output_path
+            else:
+                # Fall back to existing conversion method
+                return self._convert_standard(codec)
+
+        except Exception:
+            # Fall back to existing conversion method on any error
+            return self._convert_standard(codec)
+
     def convert(self, codec: Subtitle.Codec) -> Path:
         """
         Convert this Subtitle to another Format.
 
+        The conversion method is determined by the 'conversion_method' setting in config:
+        - 'auto' (default): Uses subby for WebVTT/SAMI, standard for others
+        - 'subby': Always uses subby with CommonIssuesFixer
+        - 'subtitleedit': Uses SubtitleEdit when available, falls back to pycaption
+        - 'pycaption': Uses only pycaption library
+        """
+        # Check configuration for conversion method
+        conversion_method = config.subtitle.get("conversion_method", "auto")
+
+        if conversion_method == "subby":
+            return self.convert_with_subby(codec)
+        elif conversion_method == "subtitleedit":
+            return self._convert_standard(codec)  # SubtitleEdit is used in standard conversion
+        elif conversion_method == "pycaption":
+            return self._convert_pycaption_only(codec)
+        elif conversion_method == "auto":
+            # Use subby for formats it handles better
+            if self.codec in (Subtitle.Codec.WebVTT, Subtitle.Codec.SAMI):
+                return self.convert_with_subby(codec)
+            else:
+                return self._convert_standard(codec)
+        else:
+            return self._convert_standard(codec)
+
+    def _convert_pycaption_only(self, codec: Subtitle.Codec) -> Path:
+        """
+        Convert subtitle using only pycaption library (no SubtitleEdit, no subby).
+
+        This is the original conversion method that only uses pycaption.
+        """
+        if not self.path or not self.path.exists():
+            raise ValueError("You must download the subtitle track first.")
+
+        if self.codec == codec:
+            return self.path
+
+        output_path = self.path.with_suffix(f".{codec.value.lower()}")
+        original_path = self.path
+
+        # Use only pycaption for conversion
+        writer = {
+            Subtitle.Codec.SubRip: pycaption.SRTWriter,
+            Subtitle.Codec.TimedTextMarkupLang: pycaption.DFXPWriter,
+            Subtitle.Codec.WebVTT: pycaption.WebVTTWriter,
+        }.get(codec)
+
+        if writer is None:
+            raise NotImplementedError(f"Cannot convert {self.codec.name} to {codec.name} using pycaption only.")
+
+        caption_set = self.parse(self.path.read_bytes(), self.codec)
+        Subtitle.merge_same_cues(caption_set)
+        subtitle_text = writer().write(caption_set)
+
+        output_path.write_text(subtitle_text, encoding="utf8")
+
+        if original_path.exists() and original_path != output_path:
+            original_path.unlink()
+
+        self.path = output_path
+        self.codec = codec
+
+        if callable(self.OnConverted):
+            self.OnConverted(codec)
+
+        return output_path
+
+    def _convert_standard(self, codec: Subtitle.Codec) -> Path:
+        """
+        Convert this Subtitle to another Format.
+
         The file path location of the Subtitle data will be kept at the same
         location but the file extension will be changed appropriately.
 
@@ -318,6 +471,7 @@ class Subtitle(Track):
         - TimedTextMarkupLang - SubtitleEdit or pycaption.DFXPWriter
         - WebVTT - SubtitleEdit or pycaption.WebVTTWriter
         - SubStationAlphav4 - SubtitleEdit
+        - SAMI - subby.SAMIConverter (when available)
         - fTTML* - custom code using some pycaption functions
         - fVTT* - custom code using some pycaption functions
         *: Can read from format, but cannot convert to format
@@ -416,6 +570,13 @@ class Subtitle(Track):
                 text = Subtitle.sanitize_broken_webvtt(text)
                 text = Subtitle.space_webvtt_headers(text)
                 caption_set = pycaption.WebVTTReader().read(text)
+            elif codec == Subtitle.Codec.SAMI:
+                # Use subby for SAMI parsing
+                converter = SAMIConverter()
+                srt_subtitles = converter.from_bytes(data)
+                # Convert SRT back to CaptionSet for compatibility
+                srt_text = str(srt_subtitles).encode("utf8")
+                caption_set = Subtitle.parse(srt_text, Subtitle.Codec.SubRip)
             else:
                 raise ValueError(f'Unknown Subtitle format "{codec}"...')
         except pycaption.exceptions.CaptionReadSyntaxError as e:
@@ -660,11 +821,45 @@ class Subtitle(Track):
     def strip_hearing_impaired(self) -> None:
         """
         Strip captions for hearing impaired (SDH).
-        It uses SubtitleEdit if available, otherwise filter-subs.
+
+        The SDH stripping method is determined by the 'sdh_method' setting in config:
+        - 'auto' (default): Tries subby first, then SubtitleEdit, then filter-subs
+        - 'subby': Uses subby's SDHStripper
+        - 'subtitleedit': Uses SubtitleEdit when available
+        - 'filter-subs': Uses subtitle-filter library
         """
         if not self.path or not self.path.exists():
             raise ValueError("You must download the subtitle track first.")
 
+        # Check configuration for SDH stripping method
+        sdh_method = config.subtitle.get("sdh_method", "auto")
+
+        if sdh_method == "subby" and self.codec == Subtitle.Codec.SubRip:
+            # Use subby's SDHStripper directly on the file
+            stripper = SDHStripper()
+            stripped_srt, _ = stripper.from_file(str(self.path))
+            self.path.write_text(str(stripped_srt), encoding="utf8")
+            return
+        elif sdh_method == "subtitleedit" and binaries.SubtitleEdit:
+            # Force use of SubtitleEdit
+            pass  # Continue to SubtitleEdit section below
+        elif sdh_method == "filter-subs":
+            # Force use of filter-subs
+            sub = Subtitles(self.path)
+            sub.filter(rm_fonts=True, rm_ast=True, rm_music=True, rm_effects=True, rm_names=True, rm_author=True)
+            sub.save()
+            return
+        elif sdh_method == "auto":
+            # Try subby first for SRT files, then fall back
+            if self.codec == Subtitle.Codec.SubRip:
+                try:
+                    stripper = SDHStripper()
+                    stripped_srt, _ = stripper.from_file(str(self.path))
+                    self.path.write_text(str(stripped_srt), encoding="utf8")
+                    return
+                except Exception:
+                    pass  # Fall through to other methods
+
         if binaries.SubtitleEdit:
             if self.codec == Subtitle.Codec.SubStationAlphav4:
                 output_format = "AdvancedSubStationAlpha"

unshackle/core/tracks/tracks.py

@@ -11,6 +11,7 @@ from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeRe
 from rich.table import Table
 from rich.tree import Tree
 
+from unshackle.core import binaries
 from unshackle.core.config import config
 from unshackle.core.console import console
 from unshackle.core.constants import LANGUAGE_MAX_DISTANCE, AnyTrack, TrackT
@@ -253,6 +254,31 @@ class Tracks:
     def select_subtitles(self, x: Callable[[Subtitle], bool]) -> None:
         self.subtitles = list(filter(x, self.subtitles))
 
+    def select_hybrid(self, tracks, quality):
+        hdr10_tracks = [
+            v
+            for v in tracks
+            if v.range == Video.Range.HDR10 and (v.height in quality or int(v.width * 9 / 16) in quality)
+        ]
+        hdr10 = []
+        for res in quality:
+            candidates = [v for v in hdr10_tracks if v.height == res or int(v.width * 9 / 16) == res]
+            if candidates:
+                best = max(candidates, key=lambda v: v.bitrate)  # assumes .bitrate exists
+                hdr10.append(best)
+
+        dv_tracks = [v for v in tracks if v.range == Video.Range.DV]
+        lowest_dv = min(dv_tracks, key=lambda v: v.height) if dv_tracks else None
+
+        def select(x):
+            if x in hdr10:
+                return True
+            if lowest_dv and x is lowest_dv:
+                return True
+            return False
+
+        return select
+
     def by_resolutions(self, resolutions: list[int], per_resolution: int = 0) -> None:
         # Note: Do not merge these list comprehensions. They must be done separately so the results
         # from the 16:9 canvas check is only used if there's no exact height resolution match.
@@ -290,8 +316,11 @@ class Tracks:
             progress: Update a rich progress bar via `completed=...`. This must be the
                 progress object's update() func, pre-set with task id via functools.partial.
         """
+        if not binaries.MKVToolNix:
+            raise RuntimeError("MKVToolNix (mkvmerge) is required for muxing but was not found")
+
         cl = [
-            "mkvmerge",
+            str(binaries.MKVToolNix),
             "--no-date",  # remove dates from the output for security
         ]
 

unshackle/core/tracks/video.py

@@ -94,6 +94,7 @@ class Video(Track):
         HDR10 = "HDR10"  # https://en.wikipedia.org/wiki/HDR10
         HDR10P = "HDR10+"  # https://en.wikipedia.org/wiki/HDR10%2B
         DV = "DV"  # https://en.wikipedia.org/wiki/Dolby_Vision
+        HYBRID = "HYBRID"  # Selects both HDR10 and DV tracks for hybrid processing with DoviTool
 
         @staticmethod
         def from_cicp(primaries: int, transfer: int, matrix: int) -> Video.Range:

unshackle/core/utils/tags.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import logging
 import os
 import re
-import shutil
 import subprocess
 import tempfile
 from difflib import SequenceMatcher
@@ -12,6 +11,7 @@ from typing import Optional, Tuple
 
 import requests
 
+from unshackle.core import binaries
 from unshackle.core.config import config
 from unshackle.core.titles.episode import Episode
 from unshackle.core.titles.movie import Movie
@@ -175,8 +175,7 @@ def external_ids(tmdb_id: int, kind: str) -> dict:
 def _apply_tags(path: Path, tags: dict[str, str]) -> None:
     if not tags:
         return
-    mkvpropedit = shutil.which("mkvpropedit")
-    if not mkvpropedit:
+    if not binaries.Mkvpropedit:
         log.debug("mkvpropedit not found on PATH; skipping tags")
         return
     log.debug("Applying tags to %s: %s", path, tags)
@@ -189,7 +188,7 @@ def _apply_tags(path: Path, tags: dict[str, str]) -> None:
         tmp_path = Path(f.name)
     try:
         subprocess.run(
-            [mkvpropedit, str(path), "--tags", f"global:{tmp_path}"],
+            [str(binaries.Mkvpropedit), str(path), "--tags", f"global:{tmp_path}"],
             check=False,
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,

unshackle/services/EXAMPLE/__init__.py

@@ -16,7 +16,7 @@ from unshackle.core.manifests import DASH
 from unshackle.core.search_result import SearchResult
 from unshackle.core.service import Service
 from unshackle.core.titles import Episode, Movie, Movies, Series, Title_T, Titles_T
-from unshackle.core.tracks import Chapter, Subtitle, Tracks
+from unshackle.core.tracks import Chapter, Subtitle, Tracks, Video
 
 
 class EXAMPLE(Service):
@@ -49,6 +49,11 @@ class EXAMPLE(Service):
         self.title = title
         self.movie = movie
         self.device = device
+        self.cdm = ctx.obj.cdm
+
+        # Get range parameter for HDR support
+        range_param = ctx.parent.params.get("range_")
+        self.range = range_param[0].name if range_param else "SDR"
 
         if self.config is None:
             raise Exception("Config is missing!")
@@ -160,15 +165,54 @@ class EXAMPLE(Service):
             return Series(episodes)
 
     def get_tracks(self, title: Title_T) -> Tracks:
+        # Handle HYBRID mode by fetching both HDR10 and DV tracks separately
+        if self.range == "HYBRID" and self.cdm.security_level != 3:
+            tracks = Tracks()
+
+            # Get HDR10 tracks
+            hdr10_tracks = self._get_tracks_for_range(title, "HDR10")
+            tracks.add(hdr10_tracks, warn_only=True)
+
+            # Get DV tracks
+            dv_tracks = self._get_tracks_for_range(title, "DV")
+            tracks.add(dv_tracks, warn_only=True)
+
+            return tracks
+        else:
+            # Normal single-range behavior
+            return self._get_tracks_for_range(title, self.range)
+
+    def _get_tracks_for_range(self, title: Title_T, range_override: str = None) -> Tracks:
+        # Use range_override if provided, otherwise use self.range
+        current_range = range_override if range_override else self.range
+
+        # Build API request parameters
+        params = {
+            "token": self.token,
+            "guid": title.id,
+        }
+
+        data = {
+            "type": self.config["client"][self.device]["type"],
+        }
+
+        # Add range-specific parameters
+        if current_range == "HDR10":
+            data["video_format"] = "hdr10"
+        elif current_range == "DV":
+            data["video_format"] = "dolby_vision"
+        else:
+            data["video_format"] = "sdr"
+
+        # Only request high-quality HDR content with L1 CDM
+        if current_range in ("HDR10", "DV") and self.cdm.security_level == 3:
+            # L3 CDM - skip HDR content
+            return Tracks()
+
         streams = self.session.post(
             url=self.config["endpoints"]["streams"],
-            params={
-                "token": self.token,
-                "guid": title.id,
-            },
-            data={
-                "type": self.config["client"][self.device]["type"],
-            },
+            params=params,
+            data=data,
         ).json()["media"]
 
         self.license = {
@@ -182,6 +226,15 @@ class EXAMPLE(Service):
         self.log.debug(f"Manifest URL: {manifest_url}")
         tracks = DASH.from_url(url=manifest_url, session=self.session).to_tracks(language=title.language)
 
+        # Set range attributes on video tracks
+        for video in tracks.videos:
+            if current_range == "HDR10":
+                video.range = Video.Range.HDR10
+            elif current_range == "DV":
+                video.range = Video.Range.DV
+            else:
+                video.range = Video.Range.SDR
+
         # Remove DRM-free ("clear") audio tracks
         tracks.audio = [
             track for track in tracks.audio if "clear" not in track.data["dash"]["representation"].get("id")

unshackle/unshackle.yaml

@@ -25,7 +25,9 @@ directories:
   prds: PRDs
   # Additional directories that can be configured:
   # commands: Commands
-  # services: Services
+  services:
+    - /path/to/services
+    - /other/path/to/services
   # vaults: Vaults
   # fonts: Fonts
 
@@ -143,13 +145,6 @@ services:
   # EXAMPLE:
   #   api_key: "service_specific_key"
 
-# Legacy NordVPN configuration (use proxy_providers instead)
-nordvpn:
-  username: ""
-  password: ""
-  servers:
-    - us: 12
-
 # External proxy provider services
 proxy_providers:
   nordvpn:
@@ -157,6 +152,13 @@ proxy_providers:
     password: password_from_service_credentials
     servers:
       - us: 12 # force US server #12 for US proxies
+  surfsharkvpn:
+    username: your_surfshark_service_username # Service credentials from https://my.surfshark.com/vpn/manual-setup/main/openvpn
+    password: your_surfshark_service_password # Service credentials (not your login password)
+    servers:
+      - us: 3844 # force US server #3844 for US proxies
+      - gb: 2697 # force GB server #2697 for GB proxies
+      - au: 4621 # force AU server #4621 for AU proxies
   basic:
     GB:
       - "socks5://username:password@bhx.socks.ipvanish.com:1080" # 1 (Birmingham)

uv.lock

@@ -1391,6 +1391,26 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e7/9c/0e6afc12c269578be5c0c1c9f4b49a8d32770a080260c333ac04cc1c832d/soupsieve-2.7-py3-none-any.whl", hash = "sha256:6e60cc5c1ffaf1cebcc12e8188320b72071e922c2e897f737cadce79ad5d30c4", size = 36677, upload-time = "2025-04-20T18:50:07.196Z" },
 ]
 
+[[package]]
+name = "srt"
+version = "3.5.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/b7/4a1bc231e0681ebf339337b0cd05b91dc6a0d701fa852bb812e244b7a030/srt-3.5.3.tar.gz", hash = "sha256:4884315043a4f0740fd1f878ed6caa376ac06d70e135f306a6dc44632eed0cc0", size = 28296, upload-time = "2023-03-28T02:35:44.007Z" }
+
+[[package]]
+name = "subby"
+version = "0.3.21"
+source = { git = "https://github.com/vevv/subby.git#390cb2f4a55e98057cdd65314d8cbffd5d0a11f1" }
+dependencies = [
+    { name = "beautifulsoup4" },
+    { name = "click" },
+    { name = "langcodes" },
+    { name = "lxml" },
+    { name = "pymp4" },
+    { name = "srt" },
+    { name = "tinycss" },
+]
+
 [[package]]
 name = "subtitle-filter"
 version = "1.5.0"
@@ -1400,6 +1420,12 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/10/40/c5d138e1f302b25240678943422a646feea52bab1f594c669c101c5e5070/subtitle_filter-1.5.0-py3-none-any.whl", hash = "sha256:6b506315be64870fba2e6894a70d76389407ce58c325fdf05129e0530f0a0f5b", size = 8346, upload-time = "2024-08-01T22:42:47.787Z" },
 ]
 
+[[package]]
+name = "tinycss"
+version = "0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/59/af583fff6236c7d2f94f8175c40ce501dcefb8d1b42e4bb7a2622dff689e/tinycss-0.4.tar.gz", hash = "sha256:12306fb50e5e9e7eaeef84b802ed877488ba80e35c672867f548c0924a76716e", size = 87759, upload-time = "2016-09-23T16:30:14.894Z" }
+
 [[package]]
 name = "tomli"
 version = "2.2.1"
@@ -1479,7 +1505,7 @@ wheels = [
 
 [[package]]
 name = "unshackle"
-version = "1.0.1"
+version = "1.1.0"
 source = { editable = "." }
 dependencies = [
     { name = "appdirs" },
@@ -1510,6 +1536,7 @@ dependencies = [
     { name = "rlaphoenix-m3u8" },
     { name = "ruamel-yaml" },
     { name = "sortedcontainers" },
+    { name = "subby" },
     { name = "subtitle-filter" },
     { name = "unidecode" },
     { name = "urllib3" },
@@ -1558,6 +1585,7 @@ requires-dist = [
     { name = "rlaphoenix-m3u8", specifier = ">=3.4.0,<4" },
     { name = "ruamel-yaml", specifier = ">=0.18.6,<0.19" },
     { name = "sortedcontainers", specifier = ">=2.4.0,<3" },
+    { name = "subby", git = "https://github.com/vevv/subby.git" },
     { name = "subtitle-filter", specifier = ">=1.4.9,<2" },
     { name = "unidecode", specifier = ">=1.3.8,<2" },
     { name = "urllib3", specifier = ">=2.2.1,<3" },