ytdl-sub 2026.1.30__py3-none-any.whl → 2026.2.2__py3-none-any.whl

ytdl_sub/__init__.py

@@ -1 +1 @@
-__pypi_version__ = "2026.01.30";__local_version__ = "2026.01.30+6b7805c"
+__pypi_version__ = "2026.02.02";__local_version__ = "2026.02.02+c163f97"

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/config/validators/variable_validation.py

@@ -1,4 +1,6 @@
 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
@@ -7,80 +9,166 @@ 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 = self.overrides.script
-        self.unresolved_variables = self.plugins.get_all_variables(
+        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_variables(self, plugin_op: PluginOperation, options: OptionsValidator) -> None:
+    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_variables,
+            unresolved_variables=self.unresolved_runtime_variables,
         ).get(plugin_op, set())
         modified_variables = options.modified_variables().get(plugin_op, set())
 
-        self.unresolved_variables -= added_variables | modified_variables
+        self.unresolved_runtime_variables -= added_variables | modified_variables
 
-    def ensure_proper_usage(self) -> Dict:
+    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_variables(PluginOperation.DOWNLOADER, options=self.downloader_options)
+        self._add_runtime_variables(PluginOperation.DOWNLOADER, options=self.downloader_options)
 
         # Always add output options first
-        self._add_variables(PluginOperation.MODIFY_ENTRY_METADATA, options=self.output_options)
+        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_variables(PluginOperation.MODIFY_ENTRY_METADATA, options=plugin_options)
+            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_variables(PluginOperation.MODIFY_ENTRY, options=plugin_options)
+            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"]:
@@ -90,5 +178,19 @@ class VariableValidation:
             if url_output["url"]:
                 resolved_subscription["download"].append(url_output)
 
-        assert not self.unresolved_variables
+        # 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/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/script/script.py

@@ -1,5 +1,4 @@
 # pylint: disable=missing-raises-doc
-import copy
 from collections import defaultdict
 from typing import Dict
 from typing import List
@@ -693,6 +692,18 @@ class Script:
 
         raise RuntimeException(f"Tried to get unresolved variable {variable_name}")
 
+    def definition_of(self, name: str) -> SyntaxTree:
+        """
+        Returns
+        -------
+        The definition of the variable or function.
+        """
+        if name.startswith("%") and name[1:] in self._functions:
+            return self._functions[name[1:]]
+        if name in self._variables:
+            return self._variables[name]
+        raise RuntimeException(f"Tried to get non-existent definition with name {name}")
+
     @property
     def variable_names(self) -> Set[str]:
         """
@@ -713,35 +724,33 @@ class Script:
         """
         return set(to_function_definition_name(name) for name in self._functions.keys())
 
-    def resolve_partial(
+    def _resolve_partial_loop(
         self,
-        unresolvable: Optional[Set[str]] = None,
-    ) -> "Script":
-        """
-        Returns
-        -------
-        New (deep-copied) script that resolves inner variables as much
-        as possible.
-        """
-        unresolvable: Set[str] = unresolvable or {}
-        resolved: Dict[Variable, Resolvable] = {}
-        unresolved: Dict[Variable, Argument] = {
-            Variable(name): definition
-            for name, definition in self._variables.items()
-            if name not in unresolvable
-        }
+        output_filter: Optional[Set[str]],
+        resolved: Dict[Variable, Resolvable],
+        unresolved: Dict[Variable, Argument],
+        unresolvable: Optional[Set[str]],
+    ):
+        to_partially_resolve: Set[Variable] = (
+            {Variable(name) for name in output_filter} if output_filter else set(unresolved.keys())
+        )
 
         partially_resolved = True
         while partially_resolved:
 
             partially_resolved = False
 
-            for variable in list(unresolved.keys()):
+            for variable in list(to_partially_resolve):
                 definition = unresolved[variable]
-
                 maybe_resolved = definition
+
                 if isinstance(definition, Variable) and definition.name not in unresolvable:
-                    maybe_resolved = resolved.get(definition, unresolved[definition])
+                    if definition in resolved:
+                        maybe_resolved = resolved[definition]
+                    elif definition in unresolved:
+                        maybe_resolved = unresolved[definition]
+                    else:
+                        raise UNREACHABLE
                 elif isinstance(definition, VariableDependency):
                     maybe_resolved = definition.partial_resolve(
                         resolved_variables=resolved,
@@ -752,6 +761,7 @@ class Script:
                 if isinstance(maybe_resolved, Resolvable):
                     resolved[variable] = maybe_resolved
                     del unresolved[variable]
+                    to_partially_resolve.remove(variable)
                     partially_resolved = True
                 else:
                     unresolved[variable] = maybe_resolved
@@ -760,11 +770,73 @@ class Script:
                 # which means we can iterate again
                 partially_resolved |= definition != maybe_resolved
 
-        return copy.deepcopy(self).add_parsed(
-            {var_name: self._variables[var_name] for var_name in unresolvable}
-            | {
-                var.name: ResolvedSyntaxTree(ast=[definition])
-                for var, definition in resolved.items()
-            }
-            | {var.name: SyntaxTree(ast=[definition]) for var, definition in unresolved.items()}
+    def _resolve_partial(
+        self,
+        unresolvable: Optional[Set[str]] = None,
+        output_filter: Optional[Set[str]] = None,
+    ) -> Dict[str, SyntaxTree]:
+        """
+        Returns
+        -------
+        New (deep-copied) script that resolves inner variables as much
+        as possible.
+        """
+        unresolvable: Set[str] = unresolvable or {}
+        resolved: Dict[Variable, Resolvable] = {}
+        unresolved: Dict[Variable, Argument] = {
+            Variable(name): definition
+            for name, definition in self._variables.items()
+            if name not in unresolvable
+        }
+
+        self._resolve_partial_loop(
+            output_filter=output_filter,
+            resolved=resolved,
+            unresolved=unresolved,
+            unresolvable=unresolvable,
         )
+
+        if output_filter:
+            out: Dict[str, SyntaxTree] = {}
+            for name in output_filter:
+                variable_name = Variable(name)
+                if variable_name in resolved:
+                    out[name] = ResolvedSyntaxTree(ast=[resolved[variable_name]])
+                else:
+                    out[name] = SyntaxTree(ast=[unresolved[variable_name]])
+
+            return out
+
+        return {
+            var.name: ResolvedSyntaxTree(ast=[definition]) for var, definition in resolved.items()
+        } | {var.name: SyntaxTree(ast=[definition]) for var, definition in unresolved.items()}
+
+    def resolve_partial(
+        self,
+        unresolvable: Optional[Set[str]] = None,
+        output_filter: Optional[Set[str]] = None,
+    ) -> "Script":
+        """
+        Updates the internal script to resolve as much as possible.
+        """
+        out = self._resolve_partial(unresolvable=unresolvable, output_filter=output_filter)
+        for var_name, definition in out.items():
+            self._variables[var_name] = definition
+
+        return self
+
+    def resolve_partial_once(
+        self, variable_definitions: Dict[str, SyntaxTree], unresolvable: Optional[Set[str]] = None
+    ) -> Dict[str, SyntaxTree]:
+        """
+        Partially resolves the input variable definitions as much as possible.
+        """
+        try:
+            self.add_parsed(variable_definitions)
+            return self._resolve_partial(
+                unresolvable=unresolvable,
+                output_filter=set(list(variable_definitions.keys())),
+            )
+        finally:
+            for name in variable_definitions.keys():
+                self._variables.pop(name, None)

ytdl_sub/script/types/function.py

@@ -371,13 +371,6 @@ class BuiltInFunction(Function, BuiltInFunctionType):
         If the conditional partially resolvable enough to warrant evaluation,
         perform it here.
         """
-        if self.is_subset_of(
-            variables=resolved_variables, custom_function_definitions=custom_functions
-        ):
-            return self.resolve(
-                resolved_variables=resolved_variables,
-                custom_functions=custom_functions,
-            )
 
         if self.name == "if":
             maybe_resolvable_arg, is_resolvable = VariableDependency.try_partial_resolve(

ytdl_sub/script/types/syntax_tree.py

@@ -55,6 +55,10 @@ class SyntaxTree(VariableDependency):
             custom_functions=custom_functions,
         )
 
+        # If no arguments, must be empty string
+        if len(maybe_resolvable_values) == 0:
+            return String(value="")
+
         # Mimic the above resolve behavior
         if len(maybe_resolvable_values) > 1:
             return BuiltInFunction(name="concat", args=maybe_resolvable_values)

ytdl_sub/script/types/variable_dependency.py

@@ -279,8 +279,11 @@ class VariableDependency(ABC):
                 if not isinstance(maybe_resolvable_args[-1], Resolvable):
                     is_resolvable = False
             elif isinstance(arg, Variable):
-                if arg not in resolved_variables:
+                if arg in resolved_variables:
+                    maybe_resolvable_args[-1] = resolved_variables[arg]
+                else:
                     is_resolvable = False
+                    # Could be un unresolvable
                     if arg in unresolved_variables:
                         maybe_resolvable_args[-1] = unresolved_variables[arg]
 

ytdl_sub/subscriptions/base_subscription.py

@@ -8,6 +8,7 @@ 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 ResolutionLevel
 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
@@ -79,7 +80,7 @@ class BaseSubscription(ABC):
         )
 
         # Validate after adding the subscription name
-        self._validated_dict = VariableValidation(
+        _ = VariableValidation(
             overrides=self.overrides,
             downloader_options=self.downloader_options,
             output_options=self.output_options,
@@ -254,12 +255,22 @@ class BaseSubscription(ABC):
         -------
         Subscription in yaml format
         """
-        return self._preset_options.yaml
+        return self._preset_options.yaml(subscription_only=False)
 
-    def resolved_yaml(self) -> str:
+    def resolved_yaml(self, resolution_level: int = ResolutionLevel.RESOLVE) -> str:
         """
         Returns
         -------
         Human-readable, condensed YAML definition of the subscription.
         """
-        return dump_yaml(self._validated_dict)
+        if resolution_level == ResolutionLevel.ORIGINAL:
+            return self._preset_options.yaml(subscription_only=True)
+
+        out = VariableValidation(
+            overrides=self.overrides,
+            downloader_options=self.downloader_options,
+            output_options=self.output_options,
+            plugins=self.plugins,
+            resolution_level=resolution_level,
+        ).ensure_proper_usage(partial_resolve_formatters=True)
+        return dump_yaml(out)

ytdl_sub/validators/string_formatter_validators.py

@@ -5,14 +5,12 @@ from typing import Set
 from typing import Union
 from typing import final
 
-from ytdl_sub.entries.script.variable_definitions import VARIABLES
 from ytdl_sub.script.parser import parse
 from ytdl_sub.script.script import Script
 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
@@ -244,15 +242,15 @@ class UnstructuredOverridesDictFormatterValidator(UnstructuredDictFormatterValid
 def _validate_formatter(
     mock_script: Script,
     unresolved_variables: Set[str],
+    unresolved_runtime_variables: Set[str],
     formatter_validator: Union[StringFormatterValidator, OverridesStringFormatterValidator],
-) -> str:
+    partial_resolve_entry_formatters: bool,
+) -> Any:
     parsed = formatter_validator.parsed
     if resolved := parsed.maybe_resolvable:
-        return resolved.native
+        return formatter_validator.post_process(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}
@@ -272,20 +270,32 @@ 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(unresolved_variables):
+    if unresolved := variable_names.intersection(unresolved_runtime_variables):
         raise StringFormattingVariableNotFoundException(
             "contains the following variables that are unresolved when executing this "
             f"formatter: {', '.join(sorted(unresolved))}"
         )
+
+    if partial_resolve_entry_formatters and not is_static_formatter:
+        parsed = mock_script.resolve_partial_once(
+            variable_definitions={"tmp_var": formatter_validator.parsed},
+            unresolvable=unresolved_variables,
+        )["tmp_var"]
+
     try:
         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.post_process(
+                mock_script.resolve_once_parsed(
+                    {"tmp_var": formatter_validator.parsed},
+                    unresolvable=unresolved_variables,
+                    update=True,
+                )["tmp_var"].native
+            )
+
+        if maybe_resolved := parsed.maybe_resolvable:
+            return formatter_validator.post_process(maybe_resolved)
 
-        return formatter_validator.format_string
+        return ScriptUtils.to_native_script(parsed)
     except RuntimeException as exc:
         if isinstance(exc, ScriptVariableNotResolved) and is_static_formatter:
             raise StringFormattingVariableNotFoundException(
@@ -293,18 +303,14 @@ 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],
+    unresolved_runtime_variables: Set[str],
     validator: Validator,
+    partial_resolve_formatters: bool,
 ) -> Dict:
     """
     Ensure all OverridesStringFormatterValidator's only contain variables from the overrides
@@ -320,7 +326,9 @@ def validate_formatters(
             resolved_dict[validator.leaf_name] |= validate_formatters(
                 script=script,
                 unresolved_variables=unresolved_variables,
+                unresolved_runtime_variables=unresolved_runtime_variables,
                 validator=validator_value,
+                partial_resolve_formatters=partial_resolve_formatters,
             )
     elif isinstance(validator, ListValidator):
         resolved_dict[validator.leaf_name] = []
@@ -328,7 +336,9 @@ def validate_formatters(
             list_output = validate_formatters(
                 script=script,
                 unresolved_variables=unresolved_variables,
+                unresolved_runtime_variables=unresolved_runtime_variables,
                 validator=list_value,
+                partial_resolve_formatters=partial_resolve_formatters,
             )
             assert len(list_output) == 1
             resolved_dict[validator.leaf_name].append(list(list_output.values())[0])
@@ -336,7 +346,9 @@ def validate_formatters(
         resolved_dict[validator.leaf_name] = _validate_formatter(
             mock_script=script,
             unresolved_variables=unresolved_variables,
+            unresolved_runtime_variables=unresolved_runtime_variables,
             formatter_validator=validator,
+            partial_resolve_entry_formatters=partial_resolve_formatters,
         )
     elif isinstance(validator, (DictFormatterValidator, OverridesDictFormatterValidator)):
         resolved_dict[validator.leaf_name] = {}
@@ -344,7 +356,9 @@ def validate_formatters(
             resolved_dict[validator.leaf_name] |= _validate_formatter(
                 mock_script=script,
                 unresolved_variables=unresolved_variables,
+                unresolved_runtime_variables=unresolved_runtime_variables,
                 formatter_validator=validator_value,
+                partial_resolve_entry_formatters=partial_resolve_formatters,
             )
     else:
         resolved_dict[validator.leaf_name] = validator._value

{ytdl_sub-2026.1.30.dist-info → ytdl_sub-2026.2.2.dist-info}/METADATA

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

{ytdl_sub-2026.1.30.dist-info → ytdl_sub-2026.2.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ytdl_sub/__init__.py,sha256=XXHIllgmHl3cNKiLMMamhmJlGYYR8FheFbr2yvVOZUg,73
+ytdl_sub/__init__.py,sha256=0fwTHDr6XaKwXXTdbuAQ0QP_VQIpRpjxuILwDho9QF8,73
 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
@@ -13,7 +13,7 @@ ytdl_sub/config/config_file.py,sha256=SQtVrMIUq2z3WwJVOed4y84JBMQ8aa4pbiBB0Y-YY4
 ytdl_sub/config/config_validator.py,sha256=W1dvQD8wI7VOmGOHyaliu8DC6HOjfoGsgUw2MURTZOM,9797
 ytdl_sub/config/defaults.py,sha256=NTwzlKDkks1LDGNjFMxh91fw5E6T6d_zGsCwODNYJxo,1152
 ytdl_sub/config/overrides.py,sha256=kwSsvVACKYq5qjnuFFXrWDfT2DJph9n3XC6uzKFGlVA,9786
-ytdl_sub/config/preset.py,sha256=Msacs60TyDWWzSlvkI3PurRil5vWOGQFK__Ev2HG1l0,9887
+ytdl_sub/config/preset.py,sha256=iGDVNiPilqA8_802kK7d7KE9VFdW7D8fjZNScAfuKqc,10123
 ytdl_sub/config/preset_options.py,sha256=Nl1E148Asi2tak6dNqoXgyKdAtf3-Xa2sERrh9wjiJY,14209
 ytdl_sub/config/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/config/plugin/plugin.py,sha256=gsjTcB8cOO097FhJYJD5zPlfEvoPzL6K5VAAqkM3gYc,4740
@@ -22,7 +22,7 @@ ytdl_sub/config/plugin/plugin_operation.py,sha256=evRLt-m7LI7q4oQvA4YqlCU0x3-i5M
 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=qoFzTyoLJPLr4zYvhVR5UHXSsieFIaTUc9zWN5GtK30,3743
+ytdl_sub/config/validators/variable_validation.py,sha256=rlAM0rZq5DX0v0DYbB-jQJ2KYwNvbjqXQLdcqJ2zKXE,8021
 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
@@ -39,7 +39,7 @@ ytdl_sub/entries/entry_parent.py,sha256=qsj7GracXkq1VyJ3cE9hNum4EJ2bDIAI0p0m_5ql
 ytdl_sub/entries/script/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/entries/script/custom_functions.py,sha256=TyfiZilUKB424NXjDCwgOmYBMyqji_QIyk0TTjPC_zU,6963
 ytdl_sub/entries/script/function_scripts.py,sha256=iPIgTpIzXv5PRnfG8gi42zP6YKUIGPtN9KuMpjHWRTM,719
-ytdl_sub/entries/script/variable_definitions.py,sha256=dz4znpZ4op4ALtnYw2vy7ePW6z76A6TI994BFlBaOmo,43561
+ytdl_sub/entries/script/variable_definitions.py,sha256=ecE1m-oup07zTgaLqOGgbzYPLTiT1X_xAf05G48dKjU,43891
 ytdl_sub/entries/script/variable_types.py,sha256=SMPm52pYbw-c9uFX65pzpIYCecVd0oO0w1htmV6oTTM,9634
 ytdl_sub/entries/variables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/entries/variables/override_variables.py,sha256=LjWtora5FT9hSka3COP6RySBdpQ39ogiwbJgE-Z_X5Y,5923
@@ -93,7 +93,7 @@ ytdl_sub/prebuilt_presets/tv_show/tv_show_by_date.yaml,sha256=0OgIOzxSPNVqwcZnL6
 ytdl_sub/prebuilt_presets/tv_show/tv_show_collection.yaml,sha256=MRAxKnh_MvQFJTisRYGsbsUlDmHNLMuV5tlK6iczmqs,49826
 ytdl_sub/script/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/script/parser.py,sha256=LUvmUIxg346njE8-uDx06nOW6ZDX5QS6aUtp4lsgwpk,22115
-ytdl_sub/script/script.py,sha256=frzZNxx42dIcpB6QGyAAb2uE2fI-pmywEBiYJQVXZG4,30526
+ytdl_sub/script/script.py,sha256=qDZ7GgUdod2qFNDOs1rlHiiDXeamK9NQAJr_y5NQ4Hg,33179
 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
@@ -109,19 +109,19 @@ ytdl_sub/script/functions/regex_functions.py,sha256=d6omjhD9FjkP0BVjUaMsJfXVt-re
 ytdl_sub/script/functions/string_functions.py,sha256=rZbOuP2V9FvoKzMG94R7vsvj-GxHK_hwgVDMa_Yeftw,6095
 ytdl_sub/script/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ytdl_sub/script/types/array.py,sha256=2NQhAzAE5aRtlKh7elSFwDgN6-cQLYK1rteLlQE2GYI,2475
-ytdl_sub/script/types/function.py,sha256=Yq6CL7eZEvJNW4agERwjB8Bmaw-GZFhVsZPn81ai_48,19433
+ytdl_sub/script/types/function.py,sha256=hDMEN_em2aCqUVzkmSVewMvNUSJciKoIoE5tsExXsVc,19152
 ytdl_sub/script/types/map.py,sha256=Hw053W-2kxqqW0ece2QsBu_xs7HmsKlNkZwYoBiYlc0,3405
 ytdl_sub/script/types/resolvable.py,sha256=YeMEhPTRTDSr5AVmK4NRpUbqxh1YQT6a2dGUIPKoFkI,5482
-ytdl_sub/script/types/syntax_tree.py,sha256=bkZqKLOj_yKUFBq8uLQ2i4Rcre01aD1_A-yOrHQt_9w,3479
+ytdl_sub/script/types/syntax_tree.py,sha256=UZg5XaY6DBOZWtCFaV4lNd9-e6xCU-WW_LkN8r_NrGw,3610
 ytdl_sub/script/types/variable.py,sha256=aVJ3ocUr3WpDoolOq6y3NV71b3EQQYPAGrIT0FtIqc4,813
-ytdl_sub/script/types/variable_dependency.py,sha256=ZKDDY9AeYhH_kVJgY-Td-cmt3USDkmMEBLpcn0-8pLs,9861
+ytdl_sub/script/types/variable_dependency.py,sha256=sr0AELRyt2rEWNSBBHo5l9ANmRTRQF4NBcIHlyH6AFg,9998
 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=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=sZH0U9Kp4jOMFR04sC97DFW7GNo7qWDUn23n0-G8gBk,7814
+ytdl_sub/subscriptions/base_subscription.py,sha256=Qf9hf-QP-0GvEap8Pif5vMOLJa_NsGQ3WvtcPyjaJ3g,8374
 ytdl_sub/subscriptions/subscription.py,sha256=wfzOYVkzmsSH1KYbAMRi6Nhrb2pRaXdhILle7H0hcas,5127
 ytdl_sub/subscriptions/subscription_download.py,sha256=2774G3psa38MBhWjrLYtUmV9g_SelVCHctzd7avhxOU,18204
 ytdl_sub/subscriptions/subscription_validators.py,sha256=tSN8YPLkIYXQbmWQ3M6U7xHpNjPn8rtNR9wSLIE2kzM,13606
@@ -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=d4laCipImcfrZlEYbXaJkvr5iRojsDZIIlBSt4w6L4c,12395
+ytdl_sub/validators/string_formatter_validators.py,sha256=FdFaLPVjUjyzRU9_b31AnTd6BNfD59Z3AXBWjZQ6X6w,13143
 ytdl_sub/validators/string_select_validator.py,sha256=KFXNKWX2J80WGt08m5gVYphPMHYxhHlgfcoXAQMq6zw,1086
 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-2026.1.30.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-ytdl_sub-2026.1.30.dist-info/METADATA,sha256=Wm7FPGMnm6o9yMfbZAeD6G9mhJGm0LeqR8nQWZjXwqE,51420
-ytdl_sub-2026.1.30.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ytdl_sub-2026.1.30.dist-info/entry_points.txt,sha256=K3T5235NlAI-WLmHCg5tzLZHqc33OLN5IY5fOGc9t10,48
-ytdl_sub-2026.1.30.dist-info/top_level.txt,sha256=6z-JWazl6jXspC2DNyxOnGnEqYyGzVbgcBDoXfbkUhI,9
-ytdl_sub-2026.1.30.dist-info/RECORD,,
+ytdl_sub-2026.2.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+ytdl_sub-2026.2.2.dist-info/METADATA,sha256=rhyPTeqmuM3eB0rW6JlE5enc428Fx7Zo1OiPh20Kr1g,51419
+ytdl_sub-2026.2.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ytdl_sub-2026.2.2.dist-info/entry_points.txt,sha256=K3T5235NlAI-WLmHCg5tzLZHqc33OLN5IY5fOGc9t10,48
+ytdl_sub-2026.2.2.dist-info/top_level.txt,sha256=6z-JWazl6jXspC2DNyxOnGnEqYyGzVbgcBDoXfbkUhI,9
+ytdl_sub-2026.2.2.dist-info/RECORD,,