Merge branch 'j/tmp1' into j/resolution-level

src/ytdl_sub/config/validators/variable_validation.py

@@ -60,21 +60,24 @@ class VariableValidation:
         self.script: Script = self.overrides.script
         self.unresolved_variables = self.plugins.get_all_variables(
             additional_options=[self.output_options, self.downloader_options]
+        ) | {VARIABLES.entry_metadata.variable_name}
+        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:
@@ -84,32 +87,38 @@ class VariableValidation:
         """
         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,
             )
 
         resolved_subscription |= validate_formatters(
             script=self.script,
             unresolved_variables=self.unresolved_variables,
+            unresolved_runtime_variables=self.unresolved_runtime_variables,
             validator=self.output_options,
         )
 
@@ -117,6 +126,7 @@ class VariableValidation:
         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,
         )
         resolved_subscription["download"] = []
@@ -139,6 +149,6 @@ class VariableValidation:
             else:
                 resolved_subscription['overrides'][name] = ScriptUtils.to_native_script(value)
 
-        assert not self.unresolved_variables
+        assert not self.unresolved_runtime_variables
         return resolved_subscription
 

src/ytdl_sub/validators/string_formatter_validators.py

@@ -5,7 +5,6 @@ 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
@@ -238,6 +237,7 @@ def to_variable_dependency_format_string(script: Script, parsed_format_string: S
 def _validate_formatter(
     mock_script: Script,
     unresolved_variables: Set[str],
+    unresolved_runtime_variables: Set[str],
     formatter_validator: Union[StringFormatterValidator, OverridesStringFormatterValidator],
     resolve_partial: bool = True
 ) -> str:
@@ -246,8 +246,6 @@ def _validate_formatter(
         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}
@@ -273,7 +271,7 @@ 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))}"
@@ -305,6 +303,7 @@ def _validate_formatter(
 def validate_formatters(
     script: Script,
     unresolved_variables: Set[str],
+    unresolved_runtime_variables: Set[str],
     validator: Validator,
 ) -> Dict:
     """
@@ -321,6 +320,7 @@ 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,
             )
     elif isinstance(validator, ListValidator):
@@ -329,6 +329,7 @@ def validate_formatters(
             list_output = validate_formatters(
                 script=script,
                 unresolved_variables=unresolved_variables,
+                unresolved_runtime_variables=unresolved_runtime_variables,
                 validator=list_value,
             )
             assert len(list_output) == 1
@@ -337,6 +338,7 @@ 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,
         )
     elif isinstance(validator, (DictFormatterValidator, OverridesDictFormatterValidator)):
@@ -345,6 +347,7 @@ 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,
             )
     else: