ytdl-sub 2025.12.30__py3-none-any.whl → 2025.12.31.post1__py3-none-any.whl

ytdl_sub/__init__.py

@@ -1 +1 @@
-__pypi_version__ = "2025.12.30";__local_version__ = "2025.12.30+344753c"
+__pypi_version__ = "2025.12.31.post1";__local_version__ = "2025.12.31+d373935"

ytdl_sub/config/overrides.py

@@ -4,15 +4,16 @@ from typing import Iterable
 from typing import Optional
 from typing import Set
 
-import mergedeep
-
 from ytdl_sub.entries.entry import Entry
 from ytdl_sub.entries.script.variable_definitions import VARIABLES
 from ytdl_sub.entries.variables.override_variables import REQUIRED_OVERRIDE_VARIABLE_NAMES
 from ytdl_sub.entries.variables.override_variables import OverrideHelpers
 from ytdl_sub.script.parser import parse
 from ytdl_sub.script.script import Script
+from ytdl_sub.script.types.function import BuiltInFunction
 from ytdl_sub.script.types.resolvable import Resolvable
+from ytdl_sub.script.types.resolvable import String
+from ytdl_sub.script.types.syntax_tree import SyntaxTree
 from ytdl_sub.script.utils.exceptions import ScriptVariableNotResolved
 from ytdl_sub.utils.exceptions import InvalidVariableNameException
 from ytdl_sub.utils.exceptions import StringFormattingException
@@ -134,29 +135,35 @@ class Overrides(UnstructuredDictFormatterValidator, Scriptable):
             )
 
     def initial_variables(
-        self, unresolved_variables: Optional[Dict[str, str]] = None
-    ) -> Dict[str, str]:
+        self, unresolved_variables: Optional[Dict[str, SyntaxTree]] = None
+    ) -> Dict[str, SyntaxTree]:
         """
         Returns
         -------
         Variables and format strings for all Override variables + additional variables (Optional)
         """
-        initial_variables: Dict[str, str] = {}
-        mergedeep.merge(
-            initial_variables,
-            self.dict_with_format_strings,
-            unresolved_variables if unresolved_variables else {},
-        )
-        return ScriptUtils.add_sanitized_variables(initial_variables)
+        initial_variables: Dict[str, SyntaxTree] = self.dict_with_parsed_format_strings
+        if unresolved_variables:
+            initial_variables |= unresolved_variables
+        return ScriptUtils.add_sanitized_parsed_variables(initial_variables)
 
     def initialize_script(self, unresolved_variables: Set[str]) -> "Overrides":
         """
         Initialize the override script with any unresolved variables
         """
-        self.script.add(
+        self.script.add_parsed(
             self.initial_variables(
                 unresolved_variables={
-                    var_name: f"{{%throw('Plugin variable {var_name} has not been created yet')}}"
+                    var_name: SyntaxTree(
+                        ast=[
+                            BuiltInFunction(
+                                name="throw",
+                                args=[
+                                    String(f"Plugin variable {var_name} has not been created yet")
+                                ],
+                            )
+                        ]
+                    )
                     for var_name in unresolved_variables
                 }
             )

ytdl_sub/config/plugin/preset_plugins.py

@@ -1,5 +1,7 @@
+from typing import Iterable
 from typing import List
 from typing import Optional
+from typing import Set
 from typing import Tuple
 from typing import Type
 
@@ -44,3 +46,34 @@ class PresetPlugins:
         if plugin_type in plugin_option_types:
             return self.plugin_options[plugin_option_types.index(plugin_type)]
         return None
+
+    def get_added_and_modified_variables(
+        self, additional_options: List[OptionsValidator]
+    ) -> Iterable[Tuple[OptionsValidator, Set[str], Set[str]]]:
+        """
+        Iterates and returns the plugin options, added variables, modified variables
+        """
+        for plugin_options in self.plugin_options + additional_options:
+            added_variables: Set[str] = set()
+            modified_variables: Set[str] = set()
+
+            for plugin_added_variables in plugin_options.added_variables(
+                unresolved_variables=set(),
+            ).values():
+                added_variables |= set(plugin_added_variables)
+
+            for plugin_modified_variables in plugin_options.modified_variables().values():
+                modified_variables = plugin_modified_variables
+
+            yield plugin_options, added_variables, modified_variables
+
+    def get_all_variables(self, additional_options: List[OptionsValidator]) -> Set[str]:
+        """
+        Returns set of all added and modified variables' names.
+        """
+        all_variables: Set[str] = set()
+        for _, added, modified in self.get_added_and_modified_variables(additional_options):
+            all_variables.update(added)
+            all_variables.update(modified)
+
+        return all_variables

ytdl_sub/config/preset.py

@@ -2,6 +2,7 @@ import copy
 from typing import Any
 from typing import Dict
 from typing import List
+from typing import Set
 
 from mergedeep import mergedeep
 
@@ -11,7 +12,6 @@ from ytdl_sub.config.plugin.plugin_mapping import PluginMapping
 from ytdl_sub.config.plugin.preset_plugins import PresetPlugins
 from ytdl_sub.config.preset_options import OutputOptions
 from ytdl_sub.config.preset_options import YTDLOptions
-from ytdl_sub.config.validators.variable_validation import VariableValidation
 from ytdl_sub.downloaders.url.validators import MultiUrlValidator
 from ytdl_sub.prebuilt_presets import PREBUILT_PRESET_NAMES
 from ytdl_sub.prebuilt_presets import PUBLISHED_PRESET_NAMES
@@ -172,6 +172,37 @@ class Preset(_PresetShell):
             mergedeep.merge({}, *reversed(presets_to_merge), strategy=mergedeep.Strategy.ADDITIVE)
         )
 
+    def _initialize_overrides_script(self, overrides: Overrides) -> Overrides:
+        """
+        Do some gymnastics to initialize the Overrides script.
+        """
+        unresolved_variables: Set[str] = set()
+
+        for (
+            plugin_options,
+            added_variables,
+            modified_variables,
+        ) in self.plugins.get_added_and_modified_variables(
+            additional_options=[self.downloader_options, self.output_options]
+        ):
+            for added_variable in added_variables:
+                if not overrides.ensure_added_plugin_variable_valid(added_variable=added_variable):
+                    # pylint: disable=protected-access
+                    raise plugin_options._validation_exception(
+                        f"Cannot use the variable name {added_variable} because it exists as a"
+                        " built-in ytdl-sub variable name."
+                    )
+                    # pylint: enable=protected-access
+
+            # Set unresolved as variables that are added but do not exist as
+            # entry/override variables since they are created at run-time
+            unresolved_variables |= added_variables | modified_variables
+
+        # Initialize overrides with unresolved variables + modified variables to throw an error.
+        # For modified variables, this is to prevent a resolve(update=True) to setting any
+        # dependencies until it has been explicitly added
+        return overrides.initialize_script(unresolved_variables=unresolved_variables)
+
     def __init__(self, config: ConfigValidator, name: str, value: Any):
         super().__init__(name=name, value=value)
 
@@ -192,16 +223,11 @@ class Preset(_PresetShell):
         )
 
         self.plugins: PresetPlugins = self._validate_and_get_plugins()
-        self.overrides = self._validate_key(key="overrides", validator=Overrides, default={})
-
+        self.overrides = self._initialize_overrides_script(
+            overrides=self._validate_key(key="overrides", validator=Overrides, default={})
+        )
         self.overrides.ensure_variable_names_not_a_plugin(plugin_names=PRESET_KEYS)
 
-        VariableValidation(
-            downloader_options=self.downloader_options,
-            output_options=self.output_options,
-            plugins=self.plugins,
-        ).initialize_preset_overrides(overrides=self.overrides).ensure_proper_usage()
-
     @property
     def name(self) -> str:
         """

ytdl_sub/config/validators/variable_validation.py

@@ -1,10 +1,4 @@
-import copy
 from typing import Dict
-from typing import Iterable
-from typing import List
-from typing import Optional
-from typing import Set
-from typing import Tuple
 
 from ytdl_sub.config.overrides import Overrides
 from ytdl_sub.config.plugin.plugin_mapping import PluginMapping
@@ -13,155 +7,27 @@ 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.variables.override_variables import REQUIRED_OVERRIDE_VARIABLE_NAMES
-from ytdl_sub.script.script import Script
-from ytdl_sub.script.script import _is_function
-from ytdl_sub.utils.scriptable import BASE_SCRIPT
-from ytdl_sub.validators.string_formatter_validators import to_variable_dependency_format_string
 from ytdl_sub.validators.string_formatter_validators import validate_formatters
 
-# Entry variables to mock during validation
-_DUMMY_ENTRY_VARIABLES: Dict[str, str] = {
-    name: to_variable_dependency_format_string(
-        # pylint: disable=protected-access
-        script=BASE_SCRIPT,
-        parsed_format_string=BASE_SCRIPT._variables[name],
-        # pylint: enable=protected-access
-    )
-    for name in BASE_SCRIPT.variable_names
-}
-
-
-def _add_dummy_variables(variables: Iterable[str]) -> Dict[str, str]:
-    dummy_variables: Dict[str, str] = {}
-    for var in variables:
-        dummy_variables[var] = ""
-        dummy_variables[f"{var}_sanitized"] = ""
-
-    return dummy_variables
-
-
-def _add_dummy_overrides(overrides: Overrides) -> Dict[str, str]:
-    # Have the dummy override variable contain all variable deps that it uses in the string
-    dummy_overrides: Dict[str, str] = {}
-    for override_name in _override_variables(overrides):
-        if _is_function(override_name):
-            continue
-
-        # pylint: disable=protected-access
-        dummy_overrides[override_name] = to_variable_dependency_format_string(
-            script=overrides.script, parsed_format_string=overrides.script._variables[override_name]
-        )
-        # pylint: enable=protected-access
-    return dummy_overrides
-
-
-def _get_added_and_modified_variables(
-    plugins: PresetPlugins, downloader_options: MultiUrlValidator, output_options: OutputOptions
-) -> Iterable[Tuple[OptionsValidator, Set[str], Set[str]]]:
-    """
-    Iterates and returns the plugin options, added variables, modified variables
-    """
-    options: List[OptionsValidator] = plugins.plugin_options
-    options.append(downloader_options)
-    options.append(output_options)
-
-    for plugin_options in options:
-        added_variables: Set[str] = set()
-        modified_variables: Set[str] = set()
-
-        for plugin_added_variables in plugin_options.added_variables(
-            unresolved_variables=set(),
-        ).values():
-            added_variables |= set(plugin_added_variables)
-
-        for plugin_modified_variables in plugin_options.modified_variables().values():
-            modified_variables = plugin_modified_variables
-
-        yield plugin_options, added_variables, modified_variables
-
-
-def _override_variables(overrides: Overrides) -> Set[str]:
-    return set(list(overrides.initial_variables().keys()))
-
 
 class VariableValidation:
     def __init__(
         self,
+        overrides: Overrides,
         downloader_options: MultiUrlValidator,
         output_options: OutputOptions,
         plugins: PresetPlugins,
     ):
+        self.overrides = overrides
         self.downloader_options = downloader_options
         self.output_options = output_options
         self.plugins = plugins
 
-        self.script: Optional[Script] = None
-        self.resolved_variables: Set[str] = set()
-        self.unresolved_variables: Set[str] = set()
-
-    def initialize_preset_overrides(self, overrides: Overrides) -> "VariableValidation":
-        """
-        Do some gymnastics to initialize the Overrides script.
-        """
-        override_variables = set(list(overrides.initial_variables().keys()))
-
-        # Set resolved variables as all entry + override variables
-        # at this point to generate every possible added/modified variable
-        self.resolved_variables = set(_DUMMY_ENTRY_VARIABLES.keys()) | override_variables
-        plugin_variables: Set[str] = set()
-
-        for (
-            plugin_options,
-            added_variables,
-            modified_variables,
-        ) in _get_added_and_modified_variables(
-            plugins=self.plugins,
-            downloader_options=self.downloader_options,
-            output_options=self.output_options,
-        ):
-
-            for added_variable in added_variables:
-                if not overrides.ensure_added_plugin_variable_valid(added_variable=added_variable):
-                    # pylint: disable=protected-access
-                    raise plugin_options._validation_exception(
-                        f"Cannot use the variable name {added_variable} because it exists as a"
-                        " built-in ytdl-sub variable name."
-                    )
-                    # pylint: enable=protected-access
-
-            # Set unresolved as variables that are added but do not exist as
-            # entry/override variables since they are created at run-time
-            self.unresolved_variables |= added_variables | modified_variables
-            plugin_variables |= added_variables | modified_variables
-
-        # Then update resolved variables to reflect that
-        self.resolved_variables -= self.unresolved_variables
-
-        # Initialize overrides with unresolved variables + modified variables to throw an error.
-        # For modified variables, this is to prevent a resolve(update=True) to setting any
-        # dependencies until it has been explicitly added
-        overrides = overrides.initialize_script(unresolved_variables=self.unresolved_variables)
-
-        # copy the script and mock entry variables
-        self.script = copy.deepcopy(overrides.script)
-        self.script.add(
-            variables=_add_dummy_overrides(overrides=overrides)
-            | _add_dummy_variables(variables=plugin_variables)
-            | _DUMMY_ENTRY_VARIABLES
+        self.script = self.overrides.script
+        self.unresolved_variables = self.plugins.get_all_variables(
+            additional_options=[self.output_options, self.downloader_options]
         )
 
-        return self
-
-    def _update_script(self) -> None:
-        _ = self.script.resolve(unresolvable=self.unresolved_variables, update=True)
-
-    def _add_subscription_override_variables(self) -> None:
-        """
-        Add dummy subscription variables for script validation
-        """
-        self.resolved_variables |= REQUIRED_OVERRIDE_VARIABLE_NAMES
-
     def _add_variables(self, plugin_op: PluginOperation, options: OptionsValidator) -> None:
         """
         Add dummy variables for script validation
@@ -171,19 +37,17 @@ class VariableValidation:
         ).get(plugin_op, set())
         modified_variables = options.modified_variables().get(plugin_op, set())
 
-        resolved_variables = added_variables | modified_variables
+        self.unresolved_variables -= added_variables | modified_variables
 
-        self.resolved_variables |= resolved_variables
-        self.unresolved_variables -= resolved_variables
-
-    def ensure_proper_usage(self) -> None:
+    def ensure_proper_usage(self) -> 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_variables(PluginOperation.DOWNLOADER, options=self.downloader_options)
-        self._add_subscription_override_variables()
 
         # Always add output options first
         self._add_variables(PluginOperation.MODIFY_ENTRY_METADATA, options=self.output_options)
@@ -200,16 +64,28 @@ class VariableValidation:
             self._add_variables(PluginOperation.MODIFY_ENTRY, options=plugin_options)
 
             # Validate that any formatter in the plugin options can resolve
-            validate_formatters(
+            resolved_subscription |= validate_formatters(
                 script=self.script,
                 unresolved_variables=self.unresolved_variables,
                 validator=plugin_options,
             )
 
-        validate_formatters(
+        resolved_subscription |= validate_formatters(
             script=self.script,
             unresolved_variables=self.unresolved_variables,
             validator=self.output_options,
         )
 
+        # TODO: make this a function
+        raw_download_output = validate_formatters(
+            script=self.script,
+            unresolved_variables=self.unresolved_variables,
+            validator=self.downloader_options.urls,
+        )
+        resolved_subscription["download"] = []
+        for url_output in raw_download_output["download"]:
+            if url_output["url"]:
+                resolved_subscription["download"].append(url_output)
+
         assert not self.unresolved_variables
+        return resolved_subscription

ytdl_sub/downloaders/url/validators.py

@@ -21,7 +21,7 @@ class UrlThumbnailValidator(StrictDictValidator):
     def __init__(self, name, value):
         super().__init__(name, value)
 
-        self._name = self._validate_key(key="name", validator=StringFormatterValidator)
+        self._thumb_name = self._validate_key(key="name", validator=StringFormatterValidator)
         self._uid = self._validate_key(key="uid", validator=OverridesStringFormatterValidator)
 
     @property
@@ -29,7 +29,7 @@ class UrlThumbnailValidator(StrictDictValidator):
         """
         File name for the thumbnail
         """
-        return self._name
+        return self._thumb_name
 
     @property
     def uid(self) -> OverridesStringFormatterValidator:

ytdl_sub/script/parser.py

@@ -31,6 +31,8 @@ from ytdl_sub.script.utils.exceptions import InvalidSyntaxException
 from ytdl_sub.script.utils.exceptions import InvalidVariableName
 from ytdl_sub.script.utils.exceptions import UserException
 from ytdl_sub.script.utils.exceptions import VariableDoesNotExist
+from ytdl_sub.script.utils.name_validation import is_function
+from ytdl_sub.script.utils.name_validation import to_function_name
 from ytdl_sub.script.utils.name_validation import validate_variable_name
 
 # pylint: disable=invalid-name
@@ -144,6 +146,9 @@ class _Parser:
     ):
         self._text = text
         self._name = name
+        if name and is_function(name):
+            self._name = to_function_name(name)
+
         self._custom_function_names = custom_function_names
         self._variable_names = variable_names
         self._pos = 0

ytdl_sub/script/script.py

@@ -20,28 +20,13 @@ from ytdl_sub.script.utils.exceptions import IncompatibleFunctionArguments
 from ytdl_sub.script.utils.exceptions import InvalidCustomFunctionArguments
 from ytdl_sub.script.utils.exceptions import RuntimeException
 from ytdl_sub.script.utils.exceptions import ScriptVariableNotResolved
+from ytdl_sub.script.utils.name_validation import is_function
+from ytdl_sub.script.utils.name_validation import to_function_definition_name
+from ytdl_sub.script.utils.name_validation import to_function_name
 from ytdl_sub.script.utils.name_validation import validate_variable_name
 from ytdl_sub.script.utils.type_checking import FunctionSpec
 
 
-def _is_function(override_name: str):
-    return override_name.startswith("%")
-
-
-def _function_name(function_key: str) -> str:
-    """
-    Drop the % in %custom_function
-    """
-    return function_key[1:]
-
-
-def _to_function_definition_name(function_key: str) -> str:
-    """
-    Add % in %custom_function
-    """
-    return f"%{function_key}"
-
-
 class Script:
     """
     Takes a dictionary of both
@@ -241,23 +226,23 @@ class Script:
 
     def __init__(self, script: Dict[str, str]):
         function_names: Set[str] = {
-            _function_name(name) for name in script.keys() if _is_function(name)
+            to_function_name(name) for name in script.keys() if is_function(name)
         }
         variable_names: Set[str] = {
-            validate_variable_name(name) for name in script.keys() if not _is_function(name)
+            validate_variable_name(name) for name in script.keys() if not is_function(name)
         }
 
         self._functions: Dict[str, SyntaxTree] = {
             # custom_function_name must be passed to properly type custom function
             # arguments uniquely if they're nested (i.e. $0 to $custom_func___0)
-            _function_name(function_key): parse(
+            to_function_name(function_key): parse(
                 text=function_value,
-                name=_function_name(function_key),
+                name=to_function_name(function_key),
                 custom_function_names=function_names,
                 variable_names=variable_names,
             )
             for function_key, function_value in script.items()
-            if _is_function(function_key)
+            if is_function(function_key)
         }
 
         self._variables: Dict[str, SyntaxTree] = {
@@ -268,7 +253,7 @@ class Script:
                 variable_names=variable_names,
             )
             for variable_key, variable_value in script.items()
-            if not _is_function(variable_key)
+            if not is_function(variable_key)
         }
         self._validate()
 
@@ -485,12 +470,12 @@ class Script:
         added_variables_to_validate: Set[str] = set()
 
         functions_to_add = {
-            _function_name(name): definition
+            to_function_name(name): definition
             for name, definition in variables.items()
-            if _is_function(name)
+            if is_function(name)
         }
         variables_to_add = {
-            name: definition for name, definition in variables.items() if not _is_function(name)
+            name: definition for name, definition in variables.items() if not is_function(name)
         }
 
         custom_function_names = set(self._functions.keys()) | functions_to_add.keys()
@@ -520,6 +505,46 @@ class Script:
 
         return self
 
+    def add_parsed(self, variables: Dict[str, SyntaxTree]) -> "Script":
+        """
+        Adds already parsed, new variables to the script.
+
+        Parameters
+        ----------
+        variables
+            Mapping containing variable name to definition.
+
+        Returns
+        -------
+        Script
+            self
+        """
+        added_variables_to_validate: Set[str] = set()
+
+        functions_to_add = {
+            to_function_name(name): definition
+            for name, definition in variables.items()
+            if is_function(name)
+        }
+        variables_to_add = {
+            name: definition for name, definition in variables.items() if not is_function(name)
+        }
+
+        for definitions in [functions_to_add, variables_to_add]:
+            for name, parsed in definitions.items():
+                if parsed.maybe_resolvable is None:
+                    added_variables_to_validate.add(name)
+
+                if name in functions_to_add:
+                    self._functions[name] = parsed
+                else:
+                    self._variables[name] = parsed
+
+        if added_variables_to_validate:
+            self._validate(added_variables=added_variables_to_validate)
+
+        return self
+
     def resolve_once(
         self,
         variable_definitions: Dict[str, str],
@@ -560,6 +585,46 @@ class Script:
             for name in variable_definitions.keys():
                 self._variables.pop(name, None)
 
+    def resolve_once_parsed(
+        self,
+        variable_definitions: Dict[str, SyntaxTree],
+        resolved: Optional[Dict[str, Resolvable]] = None,
+        unresolvable: Optional[Set[str]] = None,
+        update: bool = False,
+    ) -> Dict[str, Resolvable]:
+        """
+        Given a new set of variable definitions, resolve them using the Script, but do not
+        add them to the Script itself.
+
+        Parameters
+        ----------
+        variable_definitions
+            Variables to resolve, but not store in the Script
+        resolved
+            Optional. Pre-resolved variables that should be used instead of what is in the script.
+        unresolvable
+            Optional. Unresolvable variables that will be ignored in resolution, including all
+            variables with a dependency to them.
+        update
+            Whether to update the script's state with resolved variables. Defaults to False.
+
+        Returns
+        -------
+        Dict[str, Resolvable]
+            Dict containing the variable names to their resolved values.
+        """
+        try:
+            self.add_parsed(variable_definitions)
+            return self._resolve(
+                pre_resolved=resolved,
+                unresolvable=unresolvable,
+                output_filter=set(list(variable_definitions.keys())),
+                update=update,
+            ).output
+        finally:
+            for name in variable_definitions.keys():
+                self._variables.pop(name, None)
+
     def get(self, variable_name: str) -> Resolvable:
         """
         Parameters
@@ -605,4 +670,4 @@ class Script:
         Set[str]
             Names of all functions within the Script.
         """
-        return set(_to_function_definition_name(name) for name in self._functions.keys())
+        return set(to_function_definition_name(name) for name in self._functions.keys())

ytdl_sub/script/types/variable_dependency.py

@@ -114,6 +114,7 @@ class VariableDependency(ABC):
                 output.add(ParsedCustomFunction(name=arg.name, num_input_args=len(arg.args)))
             if isinstance(arg, VariableDependency):
                 output.update(arg.custom_functions)
+            # if isinstance(arg, Lambda)
 
         return output
 
@@ -189,7 +190,17 @@ class VariableDependency(ABC):
         -------
         True if it contains any of the input variables. False otherwise.
         """
-        for custom_function in self.custom_functions:
+        # If there are lambdas, see if they are custom functions. If so, check them
+        custom_functions_to_check = self.custom_functions
+        for lambda_func in self.lambdas:
+            if lambda_func.value in custom_function_definitions:
+                custom_functions_to_check.add(
+                    ParsedCustomFunction(
+                        name=lambda_func.value, num_input_args=lambda_func.num_input_args()
+                    )
+                )
+
+        for custom_function in custom_functions_to_check:
             if custom_function_definitions[custom_function.name].contains(
                 variables=variables, custom_function_definitions=custom_function_definitions
             ):

ytdl_sub/script/utils/name_validation.py

@@ -58,3 +58,24 @@ def validate_custom_function_name(custom_function_name: str) -> None:
             f"Custom function name '%{custom_function_name}' is invalid:"
             " The name is used by a built-in function and cannot be overwritten."
         )
+
+
+def is_function(override_name: str):
+    """
+    Whether the definition is a function or not.
+    """
+    return override_name.startswith("%")
+
+
+def to_function_name(function_key: str) -> str:
+    """
+    Drop the % in %custom_function
+    """
+    return function_key[1:]
+
+
+def to_function_definition_name(function_key: str) -> str:
+    """
+    Add % in %custom_function
+    """
+    return f"%{function_key}"

ytdl_sub/subscriptions/base_subscription.py

@@ -8,12 +8,14 @@ from ytdl_sub.config.plugin.preset_plugins import PresetPlugins
 from ytdl_sub.config.preset import Preset
 from ytdl_sub.config.preset_options import OutputOptions
 from ytdl_sub.config.preset_options import YTDLOptions
+from ytdl_sub.config.validators.variable_validation import VariableValidation
 from ytdl_sub.downloaders.url.validators import MultiUrlValidator
 from ytdl_sub.entries.variables.override_variables import SubscriptionVariables
 from ytdl_sub.utils.exceptions import SubscriptionPermissionError
 from ytdl_sub.utils.file_handler import FileHandler
 from ytdl_sub.utils.file_handler import FileHandlerTransactionLog
 from ytdl_sub.utils.logger import Logger
+from ytdl_sub.utils.yaml import dump_yaml
 from ytdl_sub.ytdl_additions.enhanced_download_archive import EnhancedDownloadArchive
 
 logger = Logger.get("subscription")
@@ -76,6 +78,14 @@ class BaseSubscription(ABC):
             }
         )
 
+        # Validate after adding the subscription name
+        self._validated_dict = VariableValidation(
+            overrides=self.overrides,
+            downloader_options=self.downloader_options,
+            output_options=self.output_options,
+            plugins=self.plugins,
+        ).ensure_proper_usage()
+
         self._enhanced_download_archive: Optional[EnhancedDownloadArchive] = (
             _initialize_download_archive(
                 output_options=self.output_options,
@@ -88,9 +98,9 @@ class BaseSubscription(ABC):
         # Add post-archive variables
         self.overrides.add(
             {
-                SubscriptionVariables.subscription_has_download_archive(): f"""{{
-                        %bool({self.download_archive.num_entries > 0})
-                    }}""",
+                SubscriptionVariables.subscription_has_download_archive(): (
+                    f"{{%bool({self.download_archive.num_entries > 0})}}"
+                ),
             }
         )
 
@@ -245,3 +255,11 @@ class BaseSubscription(ABC):
         Subscription in yaml format
         """
         return self._preset_options.yaml
+
+    def resolved_yaml(self) -> str:
+        """
+        Returns
+        -------
+        Human-readable, condensed YAML definition of the subscription.
+        """
+        return dump_yaml(self._validated_dict)

ytdl_sub/utils/script.py

@@ -4,7 +4,6 @@ from typing import Any
 from typing import Dict
 
 from ytdl_sub.script.parser import parse
-from ytdl_sub.script.script import _is_function
 from ytdl_sub.script.types.array import UnresolvedArray
 from ytdl_sub.script.types.function import BuiltInFunction
 from ytdl_sub.script.types.function import Function
@@ -15,8 +14,10 @@ from ytdl_sub.script.types.resolvable import Float
 from ytdl_sub.script.types.resolvable import Integer
 from ytdl_sub.script.types.resolvable import Lambda
 from ytdl_sub.script.types.resolvable import String
+from ytdl_sub.script.types.syntax_tree import SyntaxTree
 from ytdl_sub.script.types.variable import Variable
 from ytdl_sub.script.utils.exceptions import UNREACHABLE
+from ytdl_sub.script.utils.name_validation import is_function
 
 # pylint: disable=too-many-return-statements
 
@@ -30,10 +31,26 @@ class ScriptUtils:
         sanitized_variables = {
             f"{name}_sanitized": f"{{%sanitize({name})}}"
             for name in variables.keys()
-            if not _is_function(name)
+            if not is_function(name)
         }
         return dict(variables, **sanitized_variables)
 
+    @classmethod
+    def add_sanitized_parsed_variables(
+        cls, variables: Dict[str, SyntaxTree]
+    ) -> Dict[str, SyntaxTree]:
+        """
+        Helper to add sanitized variables to a Script
+        """
+        sanitized_variables = {
+            f"{name}_sanitized": SyntaxTree(
+                ast=[BuiltInFunction(name="sanitize", args=[Variable(name)])]
+            )
+            for name in variables.keys()
+            if not is_function(name)
+        }
+        return variables | sanitized_variables
+
     @classmethod
     def to_script(cls, value: Any, sort_keys: bool = True) -> str:
         """

ytdl_sub/validators/string_formatter_validators.py

@@ -11,6 +11,7 @@ from ytdl_sub.script.types.syntax_tree import SyntaxTree
 from ytdl_sub.script.utils.exceptions import RuntimeException
 from ytdl_sub.script.utils.exceptions import ScriptVariableNotResolved
 from ytdl_sub.script.utils.exceptions import UserException
+from ytdl_sub.script.utils.exceptions import UserThrownRuntimeError
 from ytdl_sub.utils.exceptions import StringFormattingVariableNotFoundException
 from ytdl_sub.utils.script import ScriptUtils
 from ytdl_sub.validators.validators import DictValidator
@@ -19,6 +20,8 @@ from ytdl_sub.validators.validators import LiteralDictValidator
 from ytdl_sub.validators.validators import StringValidator
 from ytdl_sub.validators.validators import Validator
 
+# pylint: disable=protected-access
+
 
 class StringFormatterValidator(StringValidator):
     """
@@ -51,7 +54,10 @@ class StringFormatterValidator(StringValidator):
     def __init__(self, name, value: str):
         super().__init__(name=name, value=value)
         try:
-            _ = parse(str(value))
+            self._parsed = parse(
+                text=str(value),
+                name=self.leaf_name,
+            )
         except UserException as exc:
             raise self._validation_exception(exc) from exc
 
@@ -65,6 +71,16 @@ class StringFormatterValidator(StringValidator):
         """
         return self._value
 
+    @property
+    @final
+    def parsed(self) -> SyntaxTree:
+        """
+        Returns
+        -------
+        The parsed format string.
+        """
+        return self._parsed
+
     def post_process(self, resolved: str) -> str:
         """
         Returns
@@ -167,9 +183,14 @@ class DictFormatterValidator(LiteralDictValidator):
 
     @property
     def dict_with_format_strings(self) -> Dict[str, str]:
-        """Returns dict with the format strings themselves"""
+        """Returns dict with the format strings themselves."""
         return {key: string_formatter.format_string for key, string_formatter in self.dict.items()}
 
+    @property
+    def dict_with_parsed_format_strings(self) -> Dict[str, SyntaxTree]:
+        """Returns dict with the parsed format strings."""
+        return {key: string_formatter.parsed for key, string_formatter in self.dict.items()}
+
 
 class OverridesDictFormatterValidator(DictFormatterValidator):
     """
@@ -199,10 +220,8 @@ def to_variable_dependency_format_string(script: Script, parsed_format_string: S
     dummy_format_string = ""
     for var in parsed_format_string.variables:
         dummy_format_string += f"{{ {var.name} }}"
-        # pylint: disable=protected-access
         for variable_dependency in script._variables[var.name].variables:
             dummy_format_string += f"{{ {variable_dependency.name} }}"
-        # pylint: enable=protected-access
     return dummy_format_string
 
 
@@ -210,16 +229,15 @@ def _validate_formatter(
     mock_script: Script,
     unresolved_variables: Set[str],
     formatter_validator: Union[StringFormatterValidator, OverridesStringFormatterValidator],
-) -> None:
-    is_static_formatter = False
-    unresolvable = unresolved_variables
-    if isinstance(formatter_validator, OverridesStringFormatterValidator):
-        is_static_formatter = True
-        unresolvable = unresolved_variables.union({VARIABLES.entry_metadata.variable_name})
-
-    parsed = parse(
-        text=formatter_validator.format_string,
-    )
+) -> str:
+    parsed = formatter_validator.parsed
+    if resolved := parsed.maybe_resolvable:
+        return resolved.native
+
+    is_static_formatter = isinstance(formatter_validator, OverridesStringFormatterValidator)
+    if is_static_formatter:
+        unresolved_variables = unresolved_variables.union({VARIABLES.entry_metadata.variable_name})
+
     variable_names = {var.name for var in parsed.variables}
     custom_function_names = {f"%{func.name}" for func in parsed.custom_functions}
 
@@ -233,21 +251,20 @@ def _validate_formatter(
             "contains the following custom functions that do not exist: "
             f"{', '.join(sorted(custom_function_names - mock_script.function_names))}"
         )
-    if unresolved := variable_names.intersection(unresolvable):
+    if unresolved := variable_names.intersection(unresolved_variables):
         raise StringFormattingVariableNotFoundException(
             "contains the following variables that are unresolved when executing this "
             f"formatter: {', '.join(sorted(unresolved))}"
         )
     try:
-        mock_script.resolve_once(
-            {
-                "tmp_var": to_variable_dependency_format_string(
-                    script=mock_script, parsed_format_string=parsed
-                )
-            },
-            unresolvable=unresolvable,
-            update=True,
-        )
+        if is_static_formatter:
+            return mock_script.resolve_once_parsed(
+                {"tmp_var": formatter_validator.parsed},
+                unresolvable=unresolved_variables,
+                update=True,
+            )["tmp_var"].native
+
+        return formatter_validator.format_string
     except RuntimeException as exc:
         if isinstance(exc, ScriptVariableNotResolved) and is_static_formatter:
             raise StringFormattingVariableNotFoundException(
@@ -255,45 +272,60 @@ def _validate_formatter(
                 "entry variables"
             ) from exc
         raise StringFormattingVariableNotFoundException(exc) from exc
+    except UserThrownRuntimeError as exc:
+        # Errors are expected for non-static formatters due to missing entry
+        # data. Raise otherwise.
+        if not is_static_formatter:
+            return formatter_validator.format_string
+        raise exc
 
 
 def validate_formatters(
     script: Script,
     unresolved_variables: Set[str],
     validator: Validator,
-) -> None:
+) -> Dict:
     """
     Ensure all OverridesStringFormatterValidator's only contain variables from the overrides
     and resolve.
     """
+    resolved_dict: Dict = {}
+
     if isinstance(validator, DictValidator):
-        # pylint: disable=protected-access
+        resolved_dict[validator.leaf_name] = {}
         # Usage of protected variables in other validators is fine. The reason to keep
         # them protected is for readability when using them in subscriptions.
         for validator_value in validator._validator_dict.values():
-            validate_formatters(
+            resolved_dict[validator.leaf_name] |= validate_formatters(
                 script=script,
                 unresolved_variables=unresolved_variables,
                 validator=validator_value,
             )
-        # pylint: enable=protected-access
     elif isinstance(validator, ListValidator):
+        resolved_dict[validator.leaf_name] = []
         for list_value in validator.list:
-            validate_formatters(
+            list_output = validate_formatters(
                 script=script,
                 unresolved_variables=unresolved_variables,
                 validator=list_value,
             )
+            assert len(list_output) == 1
+            resolved_dict[validator.leaf_name].append(list(list_output.values())[0])
     elif isinstance(validator, (StringFormatterValidator, OverridesStringFormatterValidator)):
-        _validate_formatter(
+        resolved_dict[validator.leaf_name] = _validate_formatter(
             mock_script=script,
             unresolved_variables=unresolved_variables,
             formatter_validator=validator,
         )
     elif isinstance(validator, (DictFormatterValidator, OverridesDictFormatterValidator)):
+        resolved_dict[validator.leaf_name] = {}
         for validator_value in validator.dict.values():
-            _validate_formatter(
+            resolved_dict[validator.leaf_name] |= _validate_formatter(
                 mock_script=script,
                 unresolved_variables=unresolved_variables,
                 formatter_validator=validator_value,
             )
+    else:
+        resolved_dict[validator.leaf_name] = validator._value
+
+    return resolved_dict

ytdl_sub/validators/validators.py

@@ -95,21 +95,11 @@ class Validator(ABC):
 
     @final
     @property
-    def _root_name(self) -> str:
+    def leaf_name(self) -> str:
         """
         Returns
         -------
-        "first" from the first.element.of.the.name
-        """
-        return self._name.split(".")[0]
-
-    @final
-    @property
-    def _leaf_name(self) -> str:
-        """
-        Returns
-        -------
-        "first" from the first.element.of.the.name
+        "name" from the first.element.of.the.name
         """
         return self._name.split(".")[-1]
 
@@ -274,7 +264,7 @@ class DictValidator(Validator):
             value=self._dict.get(key, default),
         )
 
-        self.__validator_dict[validator_name] = validator_instance
+        self.__validator_dict[key] = validator_instance
         return validator_instance
 
     @final

{ytdl_sub-2025.12.30.dist-info → ytdl_sub-2025.12.31.post1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytdl-sub
-Version: 2025.12.30
+Version: 2025.12.31.post1
 Summary: Automate downloading metadata generation with YoutubeDL
 Author: Jesse Bannon
 License:                     GNU GENERAL PUBLIC LICENSE

{ytdl_sub-2025.12.30.dist-info → ytdl_sub-2025.12.31.post1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ytdl_sub/__init__.py,sha256=-TEMMN5C78roSqtIzCzV1QpBG296lmhcvghcr997QKY,73
+ytdl_sub/__init__.py,sha256=WrW7vK-7xEGvZMFgyjkq_NA4CjXzPSZv3q1IzcatKCI,79
 ytdl_sub/main.py,sha256=4Rf9wXxSKW7IPnWqG5YtTZ814PjP1n9WtoFDivaainE,1004
 ytdl_sub/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/cli/entrypoint.py,sha256=XXjUH4HiOP_BB2ZA_bNcyt5-o6YLAdZmj0EP3xtOtD8,9496
@@ -12,17 +12,17 @@ ytdl_sub/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/config/config_file.py,sha256=SQtVrMIUq2z3WwJVOed4y84JBMQ8aa4pbiBB0Y-YY4M,2781
 ytdl_sub/config/config_validator.py,sha256=W1dvQD8wI7VOmGOHyaliu8DC6HOjfoGsgUw2MURTZOM,9797
 ytdl_sub/config/defaults.py,sha256=NTwzlKDkks1LDGNjFMxh91fw5E6T6d_zGsCwODNYJxo,1152
-ytdl_sub/config/overrides.py,sha256=oOMrxXSfmNciooLEUM3-GmBzuPhFNZk-2lv4sjPP-u0,9814
-ytdl_sub/config/preset.py,sha256=kVT81J1yfTRthYIOBeHVk_WUrdvr_2mqyY3qUpHWKjQ,8602
+ytdl_sub/config/overrides.py,sha256=tCW0RvZ7365MIx5jbH4iDu0XhUP0RCRHGgBJiPiXB1s,10260
+ytdl_sub/config/preset.py,sha256=Msacs60TyDWWzSlvkI3PurRil5vWOGQFK__Ev2HG1l0,9887
 ytdl_sub/config/preset_options.py,sha256=PBinBBRLTaO4B5Q9bW2WUHAd0-x8fVIUqodOIm-py-c,14207
 ytdl_sub/config/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/config/plugin/plugin.py,sha256=ugUyDnjLKcBy7lOpTbVKaGSuUMvzyyQx3DIcbv3eTkQ,4721
 ytdl_sub/config/plugin/plugin_mapping.py,sha256=xx9K2EReIU7zdPlogjvIkowy8J2R4TEhMNJyR7_1aE0,7846
 ytdl_sub/config/plugin/plugin_operation.py,sha256=evRLt-m7LI7q4oQvA4YqlCU0x3-i5MWEWdUn0p7UViw,169
-ytdl_sub/config/plugin/preset_plugins.py,sha256=X9_2ZJj7auE-ckL3-biliKO4KV5tCSkn0a1apKtt72o,1530
+ytdl_sub/config/plugin/preset_plugins.py,sha256=AbyYOJwWPK3hy93CfosD4toKJP7yiTVoA1sL4YrppV0,2877
 ytdl_sub/config/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/config/validators/options.py,sha256=IweHvzrMWdCEn4oGItDl-X9PBK7L_CmKfD_wuhNctuI,2608
-ytdl_sub/config/validators/variable_validation.py,sha256=F9ZTeqeSIvwxFeGbp6EAKy8pYBLJ1qNfhCF7QSccDKY,8599
+ytdl_sub/config/validators/variable_validation.py,sha256=oeNgo96XRR_hCB4vXcJujxPkxyoR6ibwJswHcy0pN08,3606
 ytdl_sub/downloaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/downloaders/source_plugin.py,sha256=dqQpHgeFC_kXjUOAiJKzgtrzSzXPoL2Vvn8ez2sR7QA,2508
 ytdl_sub/downloaders/ytdl_options_builder.py,sha256=k3cGBZmLMsdlnOj0PafHLJJofGqor7KQiv-B2TUc6mE,1553
@@ -31,7 +31,7 @@ ytdl_sub/downloaders/info_json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 ytdl_sub/downloaders/info_json/info_json_downloader.py,sha256=_FOvM52GsaLhJy4_D9RkpMhsZZyygXrL62CqcxaO5Co,6619
 ytdl_sub/downloaders/url/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/downloaders/url/downloader.py,sha256=wFtR7368t3-NJO0xM0svW9A272wsJY9ii36pfGpSW5U,20703
-ytdl_sub/downloaders/url/validators.py,sha256=jQRKli5gLIIn2GDEFgbS5wAKfaZIO3jHTEecMnRBe9M,13024
+ytdl_sub/downloaders/url/validators.py,sha256=ckDXzOPcO4oOdjP96dCJVib5ofe41xjOE3Evlq6vr08,13036
 ytdl_sub/entries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/entries/base_entry.py,sha256=x5CByJIMtwmsZkEe8TipBuQUQO8b2bWMYqyYvRlXGag,5403
 ytdl_sub/entries/entry.py,sha256=_U0PryLO1QNLexYHG4bcQ1yMgOY1nxKjRNb99-PXg7A,10008
@@ -92,8 +92,8 @@ ytdl_sub/prebuilt_presets/tv_show/tv_show.yaml,sha256=qmAB3jsXY1VsqmtLnLXXte5rz_
 ytdl_sub/prebuilt_presets/tv_show/tv_show_by_date.yaml,sha256=0OgIOzxSPNVqwcZnL6qT9_azplBhDXePcf0ASNTQJ5Q,7223
 ytdl_sub/prebuilt_presets/tv_show/tv_show_collection.yaml,sha256=XCtt4i4-zAgyfh-p4SXSGd0FI56lWCrPOMmB6mdf-AE,238393
 ytdl_sub/script/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ytdl_sub/script/parser.py,sha256=30SOHkEFi0rxiW_IrC1w6WzPKuyIf766zYEVHDsndtg,21898
-ytdl_sub/script/script.py,sha256=S-H6rYt9lCcxda9tPsElomf48kzCbGwJkdPcTIFahmA,23993
+ytdl_sub/script/parser.py,sha256=LUvmUIxg346njE8-uDx06nOW6ZDX5QS6aUtp4lsgwpk,22115
+ytdl_sub/script/script.py,sha256=4fP5leu1GQdbbOQLzrWGEo_zaIUeZwGY0btFqdpQmpI,26582
 ytdl_sub/script/script_output.py,sha256=5SIamnI-1D3xMA0qQzjf9xrIy8j6BVhGCKrl_Q1d2M8,1381
 ytdl_sub/script/functions/__init__.py,sha256=rzl6O5G0IEqFYHQECIM9bRvcuQj-ytC_p-Xl2TTa6j0,2932
 ytdl_sub/script/functions/array_functions.py,sha256=yg9rcZP67-aVzhu4oZZzUu3-AHiHltbQDWEs8GW1DJ4,7193
@@ -114,14 +114,14 @@ ytdl_sub/script/types/map.py,sha256=Y3zlm__IHcnycGFv0xbU_P7wgiQgtgddatPLQypjCvU,
 ytdl_sub/script/types/resolvable.py,sha256=OinvpfKsVjgU_mnE0uYONQftUxNLa1zY2jA74bywwBQ,5302
 ytdl_sub/script/types/syntax_tree.py,sha256=4xWluTMPJqA6yYuQ4XCcncSFt5cDZ9ZIT2AIOOH4bT0,2336
 ytdl_sub/script/types/variable.py,sha256=aVJ3ocUr3WpDoolOq6y3NV71b3EQQYPAGrIT0FtIqc4,813
-ytdl_sub/script/types/variable_dependency.py,sha256=wgNSdAjntziVdlwqxCT7QKwvm43XCA7qxIoFlmD_Tdg,6281
+ytdl_sub/script/types/variable_dependency.py,sha256=J9XzVVrkyt-Ae2acHbb6xFnl6NIeOcL6wLOH9SvzKcA,6796
 ytdl_sub/script/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/script/utils/exception_formatters.py,sha256=hZDX2w90vU4lY2xiEM-qxQofQz2dmqPwhkSeWaJRsQ4,4645
 ytdl_sub/script/utils/exceptions.py,sha256=cag5ZLM6as1w-RsrOwO-oe4YFpwlFu_8U0QNGv_jQ68,2774
-ytdl_sub/script/utils/name_validation.py,sha256=ckTZqzeC-PTJRfAJbFLTNEgKchPA6YqLMS9Z280WUeQ,1830
+ytdl_sub/script/utils/name_validation.py,sha256=jLdvHK--BAX2AEshydFwo3PAXfmEKqC_92cz1pMTgWU,2241
 ytdl_sub/script/utils/type_checking.py,sha256=9EKWE1mWPOlmXWiWTZw-bCRV0FlYk22tNKlgEM6wU_0,10393
 ytdl_sub/subscriptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ytdl_sub/subscriptions/base_subscription.py,sha256=JRVyJIoHIt0I7NoEMqYd9FsZU3QF9i8HQAjzQeg_CPM,7179
+ytdl_sub/subscriptions/base_subscription.py,sha256=sZH0U9Kp4jOMFR04sC97DFW7GNo7qWDUn23n0-G8gBk,7814
 ytdl_sub/subscriptions/subscription.py,sha256=wfzOYVkzmsSH1KYbAMRi6Nhrb2pRaXdhILle7H0hcas,5127
 ytdl_sub/subscriptions/subscription_download.py,sha256=-eLbClw88tleLdUgP7TtPtnqroE3Zzdx2XLQrgapMDc,18190
 ytdl_sub/subscriptions/subscription_validators.py,sha256=tSN8YPLkIYXQbmWQ3M6U7xHpNjPn8rtNR9wSLIE2kzM,13606
@@ -138,7 +138,7 @@ ytdl_sub/utils/file_lock.py,sha256=VlDl8QjBEUAHDBHsfp7Q0tR1Me0fFYELqzMtlyZ0MO4,2
 ytdl_sub/utils/file_path.py,sha256=7RWc4fGj7HH6srzGJ5ph1l5euJfWpIX-2cyC-03YXEs,2539
 ytdl_sub/utils/logger.py,sha256=g_23ddk1WpQ3-_MOHz-Rlz7xCydK66BbtqkualX1zAQ,8593
 ytdl_sub/utils/retry.py,sha256=eyhtrfmzwph4uGf4Bwk0UThEIGk4cobwLLuWowGHyK4,1313
-ytdl_sub/utils/script.py,sha256=thfjbrWTveJwf7wABBlYw3G8SgT7_JGdAmuv3n5Qty0,5189
+ytdl_sub/utils/script.py,sha256=3sUWCZxVuk5inm6ou3ChFTfeDk7lRnhPSV1wQARj5UI,5777
 ytdl_sub/utils/scriptable.py,sha256=mSMLVOnBzTAQLZXyBozx2spLwNi6llaT_c2zdS2l1rk,3365
 ytdl_sub/utils/subtitles.py,sha256=0ICFw7C9H9BIZvsZf0YhD9ygwR68XCdOQWerspR2g3I,85
 ytdl_sub/utils/system.py,sha256=I9dH46ZhRRpaO0pEPfeOKp968Ub3SAdyZASVavRHrvc,58
@@ -153,14 +153,14 @@ ytdl_sub/validators/regex_validator.py,sha256=jS8No927eg3zcpYEOv5g0gykePV0DCZaIr
 ytdl_sub/validators/source_variable_validator.py,sha256=ziG4PVIyzj5ky-Okle0FB2d2P5DWs3-jYF81hMvBTEQ,922
 ytdl_sub/validators/strict_dict_validator.py,sha256=RduK_3pOEbEQQuugAUeKKqM0Tv5x2vxSSb7vROyo2vQ,1661
 ytdl_sub/validators/string_datetime.py,sha256=GpbBiZH1FHTMeo0Zk134-uMdTMk2JD3Re3TnvuPx2OU,1125
-ytdl_sub/validators/string_formatter_validators.py,sha256=CRwZH_fnA5LabSNf973ELSMtWt2q1vQD9ZSPVGnd4Es,10625
+ytdl_sub/validators/string_formatter_validators.py,sha256=dQ_8l1wl101vPkaOlfJuXprYI5EnfHQ6jLWjGk92raA,11858
 ytdl_sub/validators/string_select_validator.py,sha256=KFXNKWX2J80WGt08m5gVYphPMHYxhHlgfcoXAQMq6zw,1086
-ytdl_sub/validators/validators.py,sha256=X9AkECdngEXcME_C25njHaOjtqbfEJMED2eG9Qy3UPs,9352
+ytdl_sub/validators/validators.py,sha256=JC3-c9fSrozFADUY5jqZEhXpM2q3sfserlooQxT2DK8,9133
 ytdl_sub/ytdl_additions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/ytdl_additions/enhanced_download_archive.py,sha256=Lsc0wjHdx9d8dYJCskZYAUGDAQ_QzQ-_xbQlyrBSzfk,24884
-ytdl_sub-2025.12.30.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-ytdl_sub-2025.12.30.dist-info/METADATA,sha256=iJlju-U5_fduOC8r1k8UBrMMR-i5cvyucuGJj-85ciA,51420
-ytdl_sub-2025.12.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ytdl_sub-2025.12.30.dist-info/entry_points.txt,sha256=K3T5235NlAI-WLmHCg5tzLZHqc33OLN5IY5fOGc9t10,48
-ytdl_sub-2025.12.30.dist-info/top_level.txt,sha256=6z-JWazl6jXspC2DNyxOnGnEqYyGzVbgcBDoXfbkUhI,9
-ytdl_sub-2025.12.30.dist-info/RECORD,,
+ytdl_sub-2025.12.31.post1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+ytdl_sub-2025.12.31.post1.dist-info/METADATA,sha256=aCbLYK2DK2szieUQ05O-SzJc0r5erfgVXBjnTGKrW0k,51426
+ytdl_sub-2025.12.31.post1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ytdl_sub-2025.12.31.post1.dist-info/entry_points.txt,sha256=K3T5235NlAI-WLmHCg5tzLZHqc33OLN5IY5fOGc9t10,48
+ytdl_sub-2025.12.31.post1.dist-info/top_level.txt,sha256=6z-JWazl6jXspC2DNyxOnGnEqYyGzVbgcBDoXfbkUhI,9
+ytdl_sub-2025.12.31.post1.dist-info/RECORD,,