[FEATURE] disect feature to debug subscriptions

src/ytdl_sub/config/preset.py

@@ -194,7 +194,7 @@ class Preset(_PresetShell):
         self.plugins: PresetPlugins = self._validate_and_get_plugins()
         self.overrides = self._validate_key(key="overrides", validator=Overrides, default={})
 
-        VariableValidation(
+        self.validated_dict = VariableValidation(
             downloader_options=self.downloader_options,
             output_options=self.output_options,
             plugins=self.plugins,

src/ytdl_sub/config/validators/variable_validation.py

@@ -176,12 +176,14 @@ class VariableValidation:
         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()
 
@@ -200,16 +202,17 @@ 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[plugin_options.__class__.__name__] = validate_formatters(
                 script=self.script,
                 unresolved_variables=self.unresolved_variables,
                 validator=plugin_options,
             )
 
-        validate_formatters(
+        resolved_subscription["output_options"] = validate_formatters(
             script=self.script,
             unresolved_variables=self.unresolved_variables,
             validator=self.output_options,
         )
 
         assert not self.unresolved_variables
+        return resolved_subscription

src/ytdl_sub/validators/string_formatter_validators.py

@@ -210,7 +210,7 @@ def _validate_formatter(
     mock_script: Script,
     unresolved_variables: Set[str],
     formatter_validator: Union[StringFormatterValidator, OverridesStringFormatterValidator],
-) -> None:
+) -> str:
     is_static_formatter = False
     unresolvable = unresolved_variables
     if isinstance(formatter_validator, OverridesStringFormatterValidator):
@@ -239,15 +239,14 @@ def _validate_formatter(
             f"formatter: {', '.join(sorted(unresolved))}"
         )
     try:
-        mock_script.resolve_once(
+        out = mock_script.resolve_once(
             {
-                "tmp_var": to_variable_dependency_format_string(
+                "tmp_var": formatter_validator.format_string
-                    script=mock_script, parsed_format_string=parsed
-                )
             },
             unresolvable=unresolvable,
             update=True,
         )
+        return out['tmp_var'].native
     except RuntimeException as exc:
         if isinstance(exc, ScriptVariableNotResolved) and is_static_formatter:
             raise StringFormattingVariableNotFoundException(
@@ -261,39 +260,45 @@ 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):
+        resolved_dict[validator._name] = {}
         # pylint: disable=protected-access
         # 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():
+        for key, validator_value in validator._validator_dict.items():
-            validate_formatters(
+            resolved_dict[validator._name][key] = validate_formatters(
                 script=script,
                 unresolved_variables=unresolved_variables,
                 validator=validator_value,
             )
         # pylint: enable=protected-access
     elif isinstance(validator, ListValidator):
+        resolved_dict[validator._name] = []
         for list_value in validator.list:
-            validate_formatters(
+            resolved_dict[validator._name].append(validate_formatters(
                 script=script,
                 unresolved_variables=unresolved_variables,
                 validator=list_value,
-            )
+            ))
     elif isinstance(validator, (StringFormatterValidator, OverridesStringFormatterValidator)):
-        _validate_formatter(
+        resolved_dict[validator._name] = _validate_formatter(
             mock_script=script,
             unresolved_variables=unresolved_variables,
             formatter_validator=validator,
         )
     elif isinstance(validator, (DictFormatterValidator, OverridesDictFormatterValidator)):
-        for validator_value in validator.dict.values():
+        resolved_dict[validator._name] = {}
-            _validate_formatter(
+        for key, validator_value in validator.dict.items():
+            resolved_dict[validator._name][key] = _validate_formatter(
                 mock_script=script,
                 unresolved_variables=unresolved_variables,
                 formatter_validator=validator_value,
             )
+
+    return resolved_dict