ytdl-sub 2026.1.11__tar.gz → 2026.2.3__tar.gz

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytdl-sub
-Version: 2026.1.11
+Version: 2026.2.3
 Summary: Automate downloading metadata generation with YoutubeDL
 Author: Jesse Bannon
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -689,7 +689,7 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: yt-dlp[default]==2025.12.8
+Requires-Dist: yt-dlp[default]==2026.1.31
 Requires-Dist: colorama~=0.4
 Requires-Dist: mergedeep~=1.3
 Requires-Dist: mediafile~=0.12

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/pyproject.toml

@@ -15,7 +15,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
 ]
 dependencies = [
-    "yt-dlp[default]==2025.12.8",
+    "yt-dlp[default]==2026.1.31",
     "colorama~=0.4",
     "mergedeep~=1.3",
     "mediafile~=0.12",

ytdl_sub-2026.2.3/src/ytdl_sub/__init__.py

@@ -0,0 +1 @@
+__pypi_version__ = "2026.02.03";__local_version__ = "2026.02.03+d526545"

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/cli/entrypoint.py

@@ -1,5 +1,6 @@
 import gc
 import os
+import random
 import sys
 from datetime import datetime
 from pathlib import Path
@@ -75,6 +76,7 @@ def _download_subscriptions_from_yaml_files(
     subscription_override_dict: Dict,
     update_with_info_json: bool,
     dry_run: bool,
+    shuffle: bool,
 ) -> List[Subscription]:
     """
     Downloads all subscriptions from one or many subscription yaml files.
@@ -91,6 +93,8 @@ def _download_subscriptions_from_yaml_files(
         Whether to actually download or update using existing info json
     dry_run
         Whether to dry run or not
+    shuffle
+        Whether to shuffle the subscription download order
 
     Returns
     -------
@@ -112,6 +116,10 @@ def _download_subscriptions_from_yaml_files(
             subscription_override_dict=subscription_override_dict,
         )
 
+    if shuffle:
+        logger.info("Shuffling subscriptions")
+        random.shuffle(subscriptions)
+
     for subscription in subscriptions:
         with subscription.exception_handling():
             logger.info(
@@ -253,6 +261,7 @@ def main() -> List[Subscription]:
                 subscription_override_dict=subscription_override_dict,
                 update_with_info_json=args.update_with_info_json,
                 dry_run=args.dry_run,
+                shuffle=args.shuffle,
             )
 
         # One-off download

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/cli/parsers/main.py

@@ -172,6 +172,10 @@ class SubArguments:
         short="-o",
         long="--dl-override",
     )
+    SHUFFLE = CLIArgument(
+        short="-sh",
+        long="--shuffle",
+    )
 
 
 subscription_parser = subparsers.add_parser("sub")
@@ -197,6 +201,13 @@ subscription_parser.add_argument(
     help="override all subscription config values using `dl` syntax, "
     "i.e. --dl-override='--ytdl_options.max_downloads 3'",
 )
+subscription_parser.add_argument(
+    SubArguments.SHUFFLE.short,
+    SubArguments.SHUFFLE.long,
+    action="store_true",
+    help="shuffle subscription order when downloading",
+    default=False,
+)
 
 ###################################################################################################
 # DOWNLOAD PARSER

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/config/overrides.py

@@ -3,6 +3,8 @@ from typing import Dict
 from typing import Iterable
 from typing import Optional
 from typing import Set
+from typing import Type
+from typing import TypeVar
 
 from ytdl_sub.entries.entry import Entry
 from ytdl_sub.entries.script.variable_definitions import VARIABLES
@@ -20,10 +22,11 @@ from ytdl_sub.utils.exceptions import StringFormattingException
 from ytdl_sub.utils.exceptions import ValidationException
 from ytdl_sub.utils.script import ScriptUtils
 from ytdl_sub.utils.scriptable import Scriptable
-from ytdl_sub.validators.string_formatter_validators import OverridesStringFormatterValidator
 from ytdl_sub.validators.string_formatter_validators import StringFormatterValidator
 from ytdl_sub.validators.string_formatter_validators import UnstructuredDictFormatterValidator
 
+ExpectedT = TypeVar("ExpectedT")
+
 
 class Overrides(UnstructuredDictFormatterValidator, Scriptable):
     """
@@ -207,7 +210,8 @@ class Overrides(UnstructuredDictFormatterValidator, Scriptable):
         formatter: StringFormatterValidator,
         entry: Optional[Entry] = None,
         function_overrides: Optional[Dict[str, str]] = None,
-    ) -> str:
+        expected_type: Type[ExpectedT] = str,
+    ) -> ExpectedT:
         """
         Parameters
         ----------
@@ -217,6 +221,8 @@ class Overrides(UnstructuredDictFormatterValidator, Scriptable):
             Optional. Entry to add source variables to the formatter
         function_overrides
             Optional. Explicit values to override the overrides themselves and source variables
+        expected_type
+            The expected type that should return. Defaults to string.
 
         Returns
         -------
@@ -227,42 +233,15 @@ class Overrides(UnstructuredDictFormatterValidator, Scriptable):
         StringFormattingException
             If the formatter that is trying to be resolved cannot
         """
-        return formatter.post_process(
-            str(
-                self._apply_to_resolvable(
-                    formatter=formatter, entry=entry, function_overrides=function_overrides
-                )
-            )
-        )
-
-    def apply_overrides_formatter_to_native(
-        self,
-        formatter: OverridesStringFormatterValidator,
-        function_overrides: Optional[Dict[str, str]] = None,
-    ) -> Any:
-        """
-        Parameters
-        ----------
-        formatter
-            Overrides formatter to apply
-        function_overrides
-            Optional. Explicit values to override the overrides themselves and source variables
-
-        Returns
-        -------
-        The native python form of the resolved variable
-        """
-        return formatter.post_process_native(
+        out = formatter.post_process(
             self._apply_to_resolvable(
-                formatter=formatter, entry=None, function_overrides=function_overrides
+                formatter=formatter, entry=entry, function_overrides=function_overrides
             ).native
         )
 
-    def evaluate_boolean(
-        self, formatter: StringFormatterValidator, entry: Optional[Entry] = None
-    ) -> bool:
-        """
-        Apply a formatter, and evaluate it to a boolean
-        """
-        output = self.apply_formatter(formatter=formatter, entry=entry)
-        return ScriptUtils.bool_formatter_output(output)
+        if not isinstance(out, expected_type):
+            raise StringFormattingException(
+                f"Expected type {expected_type.__name__}, but received '{out.__class__.__name__}'"
+            )
+
+        return out

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/config/plugin/plugin.py

@@ -48,7 +48,7 @@ class Plugin(BasePlugin[OptionsValidatorT], Generic[OptionsValidatorT], ABC):
         Returns True if enabled, False if disabled.
         """
         if isinstance(self.plugin_options, ToggleableOptionsDictValidator):
-            return self.overrides.evaluate_boolean(self.plugin_options.enable)
+            return self.overrides.apply_formatter(self.plugin_options.enable, expected_type=bool)
         return True
 
     def ytdl_options_match_filters(self) -> Tuple[List[str], List[str]]:

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/config/preset.py

@@ -255,11 +255,18 @@ class Preset(_PresetShell):
         """
         return cls(config=config, name=preset_name, value=preset_dict)
 
-    @property
-    def yaml(self) -> str:
+    def yaml(self, subscription_only: bool) -> str:
         """
+        Parameters
+        ----------
+        subscription_only:
+            Only include the subscription contents, not the surrounding boiler-plate.
+
         Returns
         -------
         Preset in YAML format
         """
+        if subscription_only:
+            return dump_yaml(self._value)
+
         return dump_yaml({"presets": {self._name: self._value}})

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/config/preset_options.py

@@ -63,7 +63,7 @@ class YTDLOptions(UnstructuredOverridesDictFormatterValidator):
         native python.
         """
         out = {
-            key: overrides.apply_overrides_formatter_to_native(val)
+            key: overrides.apply_formatter(val, expected_type=object)
             for key, val in self.dict.items()
         }
         if "cookiefile" in out:

ytdl_sub-2026.2.3/src/ytdl_sub/config/validators/variable_validation.py

@@ -0,0 +1,196 @@
+from typing import Dict
+from typing import List
+from typing import Set
+
+from ytdl_sub.config.overrides import Overrides
+from ytdl_sub.config.plugin.plugin_mapping import PluginMapping
+from ytdl_sub.config.plugin.plugin_operation import PluginOperation
+from ytdl_sub.config.plugin.preset_plugins import PresetPlugins
+from ytdl_sub.config.preset_options import OutputOptions
+from ytdl_sub.config.validators.options import OptionsValidator
+from ytdl_sub.downloaders.url.validators import MultiUrlValidator
+from ytdl_sub.entries.script.variable_definitions import UNRESOLVED_VARIABLES
+from ytdl_sub.entries.script.variable_definitions import VARIABLES
+from ytdl_sub.script.script import Script
+from ytdl_sub.script.utils.name_validation import is_function
+from ytdl_sub.utils.script import ScriptUtils
+from ytdl_sub.validators.string_formatter_validators import validate_formatters
+
+
+class ResolutionLevel:
+    ORIGINAL = 0
+    FILL = 1
+    RESOLVE = 2
+    INTERNAL = 3
+
+    @classmethod
+    def name_of(cls, resolution_level: int) -> str:
+        """
+        Name of the resolution level.
+        """
+        if resolution_level == cls.ORIGINAL:
+            return "original"
+        if resolution_level == cls.FILL:
+            return "fill"
+        if resolution_level == cls.RESOLVE:
+            return "resolve"
+        if resolution_level == cls.INTERNAL:
+            return "internal"
+        raise ValueError("Invalid resolution level")
+
+    @classmethod
+    def all(cls) -> List[int]:
+        """
+        All possible resolution levels.
+        """
+        return [cls.ORIGINAL, cls.FILL, cls.RESOLVE, cls.INTERNAL]
+
+
+class VariableValidation:
+
+    def _get_resolve_partial_filter(self) -> Set[str]:
+        # Exclude sanitized variables from partial validation. This lessens the work
+        # and prevents double-evaluation, which can lead to bad behavior like double-prints.
+        return {
+            name
+            for name in self.script.variable_names
+            if name not in self.unresolved_variables and not name.endswith("_sanitized")
+        }
+
+    def _apply_resolution_level(self) -> None:
+        if self._resolution_level == ResolutionLevel.FILL:
+            self.unresolved_variables |= VARIABLES.variable_names(include_sanitized=True)
+            # Only partial resolve definitions that are already resolved
+            self.unresolved_variables |= {
+                name
+                for name in self.overrides.keys
+                if not is_function(name) and not self.script.definition_of(name).maybe_resolvable
+            }
+        elif self._resolution_level == ResolutionLevel.RESOLVE:
+            # Partial resolve everything, but not including internal variables
+            self.unresolved_variables |= VARIABLES.variable_names(include_sanitized=True)
+        elif self._resolution_level == ResolutionLevel.INTERNAL:
+            # Partial resolve everything including internal variables
+            pass
+        else:
+            raise ValueError("Invalid resolution level for validation")
+
+        self.script = self.script.resolve_partial(
+            unresolvable=self.unresolved_variables,
+            output_filter=self._get_resolve_partial_filter(),
+        )
+
+    def __init__(
+        self,
+        overrides: Overrides,
+        downloader_options: MultiUrlValidator,
+        output_options: OutputOptions,
+        plugins: PresetPlugins,
+        resolution_level: int = ResolutionLevel.RESOLVE,
+    ):
+        self.overrides = overrides
+        self.downloader_options = downloader_options
+        self.output_options = output_options
+        self.plugins = plugins
+
+        self.script: Script = self.overrides.script
+        self.unresolved_variables = (
+            self.plugins.get_all_variables(
+                additional_options=[self.output_options, self.downloader_options]
+            )
+            | UNRESOLVED_VARIABLES
+        )
+        self.unresolved_runtime_variables = self.plugins.get_all_variables(
+            additional_options=[self.output_options, self.downloader_options]
+        )
+        self._resolution_level = resolution_level
+
+        self._apply_resolution_level()
+
+    def _add_runtime_variables(self, plugin_op: PluginOperation, options: OptionsValidator) -> None:
+        """
+        Add dummy variables for script validation
+        """
+        added_variables = options.added_variables(
+            unresolved_variables=self.unresolved_runtime_variables,
+        ).get(plugin_op, set())
+        modified_variables = options.modified_variables().get(plugin_op, set())
+
+        self.unresolved_runtime_variables -= added_variables | modified_variables
+
+    def ensure_proper_usage(self, partial_resolve_formatters: bool = False) -> Dict:
+        """
+        Validate variables resolve as plugins are executed, and return
+        a mock script which contains actualized added variables from the plugins
+        """
+        resolved_subscription: Dict = {}
+
+        self._add_runtime_variables(PluginOperation.DOWNLOADER, options=self.downloader_options)
+
+        # Always add output options first
+        self._add_runtime_variables(
+            PluginOperation.MODIFY_ENTRY_METADATA, options=self.output_options
+        )
+
+        # Metadata variables to be added
+        for plugin_options in PluginMapping.order_options_by(
+            self.plugins.zipped(), PluginOperation.MODIFY_ENTRY_METADATA
+        ):
+            self._add_runtime_variables(
+                PluginOperation.MODIFY_ENTRY_METADATA, options=plugin_options
+            )
+
+        for plugin_options in PluginMapping.order_options_by(
+            self.plugins.zipped(), PluginOperation.MODIFY_ENTRY
+        ):
+            self._add_runtime_variables(PluginOperation.MODIFY_ENTRY, options=plugin_options)
+
+            # Validate that any formatter in the plugin options can resolve
+            resolved_subscription |= validate_formatters(
+                script=self.script,
+                unresolved_variables=self.unresolved_variables,
+                unresolved_runtime_variables=self.unresolved_runtime_variables,
+                validator=plugin_options,
+                partial_resolve_formatters=partial_resolve_formatters,
+            )
+
+        resolved_subscription |= validate_formatters(
+            script=self.script,
+            unresolved_variables=self.unresolved_variables,
+            unresolved_runtime_variables=self.unresolved_runtime_variables,
+            validator=self.output_options,
+            partial_resolve_formatters=partial_resolve_formatters,
+        )
+
+        # TODO: make this a function
+        raw_download_output = validate_formatters(
+            script=self.script,
+            unresolved_variables=self.unresolved_variables,
+            unresolved_runtime_variables=self.unresolved_runtime_variables,
+            validator=self.downloader_options.urls,
+            partial_resolve_formatters=partial_resolve_formatters,
+        )
+        resolved_subscription["download"] = []
+        for url_output in raw_download_output["download"]:
+            if isinstance(url_output["url"], list):
+                url_output["url"] = [url for url in url_output["url"] if bool(url)]
+
+            if url_output["url"]:
+                resolved_subscription["download"].append(url_output)
+
+        # TODO: make function
+        resolved_subscription["overrides"] = {}
+        for name in self.overrides.keys:
+            value = self.script.definition_of(name)
+            if name in self.script.function_names:
+                # Keep custom functions as-is
+                resolved_subscription["overrides"][name] = self.overrides.dict_with_format_strings[
+                    name
+                ]
+            elif resolved := value.maybe_resolvable:
+                resolved_subscription["overrides"][name] = resolved.native
+            else:
+                resolved_subscription["overrides"][name] = ScriptUtils.to_native_script(value)
+
+        assert not self.unresolved_runtime_variables
+        return resolved_subscription

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/downloaders/url/downloader.py

@@ -52,12 +52,12 @@ class UrlDownloaderBasePluginExtension(SourcePluginExtension[MultiUrlValidator])
 
         if 0 <= input_url_idx < len(self.plugin_options.urls.list):
             validator = self.plugin_options.urls.list[input_url_idx]
-            if entry_input_url in self.overrides.apply_overrides_formatter_to_native(validator.url):
+            if entry_input_url in self.overrides.apply_formatter(validator.url, expected_type=list):
                 return validator
 
         # Match the first validator based on the URL, if one exists
         for validator in self.plugin_options.urls.list:
-            if entry_input_url in self.overrides.apply_overrides_formatter_to_native(validator.url):
+            if entry_input_url in self.overrides.apply_formatter(validator.url, expected_type=list):
                 return validator
 
         # Return the first validator if none exist
@@ -382,7 +382,7 @@ class MultiUrlDownloader(SourcePlugin[MultiUrlValidator]):
         entries_to_iter: List[Optional[Entry]] = entries
 
         indices = list(range(len(entries_to_iter)))
-        if self.overrides.evaluate_boolean(validator.download_reverse):
+        if self.overrides.apply_formatter(validator.download_reverse, expected_type=bool):
             indices = reversed(indices)
 
         for idx in indices:
@@ -461,8 +461,8 @@ class MultiUrlDownloader(SourcePlugin[MultiUrlValidator]):
             ytdl_option_overrides=validator.ytdl_options.to_native_dict(self.overrides)
         )
 
-        include_sibling_metadata = self.overrides.evaluate_boolean(
-            validator.include_sibling_metadata
+        include_sibling_metadata = self.overrides.apply_formatter(
+            validator.include_sibling_metadata, expected_type=bool
         )
 
         parents, orphan_entries = self._download_url_metadata(
@@ -487,11 +487,9 @@ class MultiUrlDownloader(SourcePlugin[MultiUrlValidator]):
         # download the bottom-most urls first since they are top-priority
         for idx, url_validator in reversed(list(enumerate(self.collection.urls.list))):
             # URLs can be empty. If they are, then skip
-            if not (urls := self.overrides.apply_overrides_formatter_to_native(url_validator.url)):
+            if not (urls := self.overrides.apply_formatter(url_validator.url, expected_type=list)):
                 continue
 
-            assert isinstance(urls, list)
-
             for url in reversed(urls):
                 assert isinstance(url, str)
 

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/downloaders/url/validators.py

@@ -1,5 +1,6 @@
 from typing import Any
 from typing import Dict
+from typing import List
 from typing import Optional
 from typing import Set
 
@@ -44,7 +45,7 @@ class UrlThumbnailListValidator(ListValidator[UrlThumbnailValidator]):
 
 
 class OverridesOneOrManyUrlValidator(OverridesStringFormatterValidator):
-    def post_process_native(self, resolved: Any) -> Any:
+    def post_process(self, resolved: Any) -> List[str]:
         if isinstance(resolved, str):
             return [resolved]
         if isinstance(resolved, list):

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/entries/script/variable_definitions.py

@@ -1135,6 +1135,16 @@ class VariableDefinitions(
             ]
         }
 
+    @cache
+    def variable_names(self, include_sanitized: bool):
+        """
+        Returns all variable names, and can include sanitized.
+        """
+        var_names: Set[str] = self.scripts().keys()
+        if include_sanitized:
+            var_names |= {f"{name}_sanitized" for name in var_names}
+        return var_names
+
     @cache
     def injected_variables(self) -> Set[MetadataVariable]:
         """

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/plugins/date_range.py

@@ -116,7 +116,7 @@ class DateRangePlugin(Plugin[DateRangeOptions]):
                 date_validator=self.plugin_options.after, overrides=self.overrides
             )
             after_filter = f"{date_type} >= {after_str}"
-            if self.overrides.evaluate_boolean(self.plugin_options.breaks):
+            if self.overrides.apply_formatter(self.plugin_options.breaks, expected_type=bool):
                 breaking_match_filters.append(after_filter)
             else:
                 match_filters.append(after_filter)

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/plugins/embed_thumbnail.py

@@ -33,7 +33,7 @@ class EmbedThumbnailPlugin(Plugin[EmbedThumbnailOptions]):
 
     @property
     def _embed_thumbnail(self) -> bool:
-        return self.overrides.evaluate_boolean(self.plugin_options)
+        return self.overrides.apply_formatter(self.plugin_options, expected_type=bool)
 
     @classmethod
     def _embed_video_thumbnail(cls, entry: Entry) -> None:

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/plugins/filter_exclude.py

@@ -7,13 +7,14 @@ from ytdl_sub.config.validators.options import OptionsValidator
 from ytdl_sub.entries.entry import Entry
 from ytdl_sub.utils.exceptions import StringFormattingException
 from ytdl_sub.utils.logger import Logger
-from ytdl_sub.validators.string_formatter_validators import ListFormatterValidator
+from ytdl_sub.validators.string_formatter_validators import BooleanFormatterValidator
+from ytdl_sub.validators.validators import ListValidator
 from ytdl_sub.ytdl_additions.enhanced_download_archive import EnhancedDownloadArchive
 
 logger = Logger.get("filter-exclude")
 
 
-class FilterExcludeOptions(ListFormatterValidator, OptionsValidator):
+class FilterExcludeOptions(ListValidator[BooleanFormatterValidator], OptionsValidator):
     """
     Applies a conditional OR on any number of filters comprised of either variables or scripts.
     If any filter evaluates to True, the entry will be excluded.
@@ -29,6 +30,8 @@ class FilterExcludeOptions(ListFormatterValidator, OptionsValidator):
            { %contains( %lower(description), '#short' ) }
     """
 
+    _inner_list_type = BooleanFormatterValidator
+
 
 class FilterExcludePlugin(Plugin[FilterExcludeOptions]):
     plugin_options_type = FilterExcludeOptions
@@ -52,7 +55,9 @@ class FilterExcludePlugin(Plugin[FilterExcludeOptions]):
             return entry
 
         for formatter in self.plugin_options.list:
-            should_exclude = self.overrides.evaluate_boolean(formatter=formatter, entry=entry)
+            should_exclude = self.overrides.apply_formatter(
+                formatter=formatter, entry=entry, expected_type=bool
+            )
 
             if should_exclude:
                 logger.info(

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/plugins/filter_include.py

@@ -7,14 +7,14 @@ from ytdl_sub.config.validators.options import OptionsValidator
 from ytdl_sub.entries.entry import Entry
 from ytdl_sub.utils.exceptions import StringFormattingException
 from ytdl_sub.utils.logger import Logger
-from ytdl_sub.utils.script import ScriptUtils
-from ytdl_sub.validators.string_formatter_validators import ListFormatterValidator
+from ytdl_sub.validators.string_formatter_validators import BooleanFormatterValidator
+from ytdl_sub.validators.validators import ListValidator
 from ytdl_sub.ytdl_additions.enhanced_download_archive import EnhancedDownloadArchive
 
 logger = Logger.get("filter-include")
 
 
-class FilterIncludeOptions(ListFormatterValidator, OptionsValidator):
+class FilterIncludeOptions(ListValidator[BooleanFormatterValidator], OptionsValidator):
     """
     Applies a conditional AND on any number of filters comprised of either variables or scripts.
     If all filters evaluate to True, the entry will be included.
@@ -38,6 +38,8 @@ class FilterIncludeOptions(ListFormatterValidator, OptionsValidator):
            }
     """
 
+    _inner_list_type = BooleanFormatterValidator
+
 
 class FilterIncludePlugin(Plugin[FilterIncludeOptions]):
     plugin_options_type = FilterIncludeOptions
@@ -61,8 +63,8 @@ class FilterIncludePlugin(Plugin[FilterIncludeOptions]):
             return entry
 
         for formatter in self.plugin_options.list:
-            should_exclude = ScriptUtils.bool_formatter_output(
-                self.overrides.apply_formatter(formatter=formatter, entry=entry)
+            should_exclude = self.overrides.apply_formatter(
+                formatter=formatter, entry=entry, expected_type=bool
             )
             if not should_exclude:
                 logger.info(

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/plugins/nfo_tags.py

@@ -140,7 +140,7 @@ class SharedNfoTagsPlugin(Plugin[SharedNfoTagsOptions], ABC):
         if not nfo_tags:
             return
 
-        if self.overrides.evaluate_boolean(self.plugin_options.kodi_safe):
+        if self.overrides.apply_formatter(self.plugin_options.kodi_safe, expected_type=bool):
             nfo_root = to_max_3_byte_utf8_string(nfo_root)
             nfo_tags = {
                 to_max_3_byte_utf8_string(key): [

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/plugins/square_thumbnail.py

@@ -31,7 +31,7 @@ class SquareThumbnailPlugin(Plugin[SquareThumbnailOptions]):
 
     @property
     def _square_thumbnail(self) -> bool:
-        return self.overrides.evaluate_boolean(self.plugin_options)
+        return self.overrides.apply_formatter(self.plugin_options, expected_type=bool)
 
     @classmethod
     def _convert_to_square_thumbnail(cls, entry: Entry) -> None:

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/plugins/throttle_protection.py

@@ -42,8 +42,8 @@ class _RandomizedRangeValidator(StrictDictValidator, ABC):
         )
 
     def _randomized_float(self, overrides: Overrides, entry: Optional[Entry] = None) -> float:
-        actualized_min = float(overrides.apply_formatter(self._min, entry=entry))
-        actualized_max = float(overrides.apply_formatter(self._max, entry=entry))
+        actualized_min = overrides.apply_formatter(self._min, entry=entry, expected_type=float)
+        actualized_max = overrides.apply_formatter(self._max, entry=entry, expected_type=float)
 
         if actualized_min < 0:
             raise self._validation_exception(
@@ -70,7 +70,7 @@ class _RandomizedRangeValidator(StrictDictValidator, ABC):
         -------
         Max possible value
         """
-        actualized_max = float(overrides.apply_formatter(self._max, entry=entry))
+        actualized_max = overrides.apply_formatter(self._max, entry=entry, expected_type=float)
         if actualized_max < 0:
             raise self._validation_exception(
                 f"max must be greater than zero, received {actualized_max}"

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/plugins/video_tags.py

@@ -34,7 +34,7 @@ class VideoTagsPlugin(Plugin[VideoTagsOptions]):
         Tags the entry's audio file using values defined in the metadata options
         """
         tags_to_write: Dict[str, str] = {}
-        for tag_name, tag_formatter in self.plugin_options.dict.items():
+        for tag_name, tag_formatter in sorted(self.plugin_options.dict.items()):
             tag_value = self.overrides.apply_formatter(formatter=tag_formatter, entry=entry)
             tags_to_write[tag_name] = tag_value
 

{ytdl_sub-2026.1.11 → ytdl_sub-2026.2.3}/src/ytdl_sub/prebuilt_presets/music/soundcloud.yaml

@@ -8,7 +8,7 @@ presets:
       urls:
         # The first URL will be all the artist's tracks.
         # Treat these as singles - an album with a single track
-        - url: "{url}/tracks"
+        - url: "{url}"
           include_sibling_metadata: False
           variables:
             sc_track_album: "{title}"