ytdl-sub 2026.1.6__py3-none-any.whl → 2026.1.13__py3-none-any.whl

ytdl_sub/__init__.py

@@ -1 +1 @@
-__pypi_version__ = "2026.01.06";__local_version__ = "2026.01.06+6b99c31"
+__pypi_version__ = "2026.01.13";__local_version__ = "2026.01.13+530d2f7"

ytdl_sub/entries/script/variable_types.py

@@ -22,7 +22,6 @@ VariableT = TypeVar("VariableT", bound="Variable")
 
 
 def _get(
-    cast: str,
     metadata_variable_name: str,
     metadata_key: str,
     variable_name: Optional[str],
@@ -47,7 +46,7 @@ def _get(
     return as_type(
         variable_name=variable_name or metadata_key,
         metadata_key=metadata_key,
-        definition=f"{{ %legacy_bracket_safety(%{cast}({out})) }}",
+        definition=f"{{ {out} }}",
     )
 
 
@@ -182,7 +181,6 @@ class MapMetadataVariable(MetadataVariable, MapVariable):
         Creates a map variable from entry metadata
         """
         return _get(
-            "map",
             metadata_variable_name=ENTRY_METADATA_VARIABLE_NAME,
             metadata_key=metadata_key,
             variable_name=variable_name,
@@ -204,7 +202,6 @@ class ArrayMetadataVariable(MetadataVariable, ArrayVariable):
         Creates an array variable from entry metadata
         """
         return _get(
-            "array",
             metadata_variable_name=ENTRY_METADATA_VARIABLE_NAME,
             metadata_key=metadata_key,
             variable_name=variable_name,
@@ -226,7 +223,6 @@ class StringMetadataVariable(MetadataVariable, StringVariable):
         Creates a string variable from entry metadata
         """
         return _get(
-            "string",
             metadata_variable_name=ENTRY_METADATA_VARIABLE_NAME,
             metadata_key=metadata_key,
             variable_name=variable_name,
@@ -245,7 +241,6 @@ class StringMetadataVariable(MetadataVariable, StringVariable):
         Creates a string variable from playlist metadata
         """
         return _get(
-            "string",
             metadata_variable_name=PLAYLIST_METADATA_VARIABLE_NAME,
             metadata_key=metadata_key,
             variable_name=variable_name,
@@ -264,7 +259,6 @@ class StringMetadataVariable(MetadataVariable, StringVariable):
         Creates a string variable from source metadata
         """
         return _get(
-            "string",
             metadata_variable_name=SOURCE_METADATA_VARIABLE_NAME,
             metadata_key=metadata_key,
             variable_name=variable_name,
@@ -301,7 +295,6 @@ class IntegerMetadataVariable(MetadataVariable, IntegerVariable):
         Creates an int variable from entry metadata
         """
         return _get(
-            "int",
             metadata_variable_name=ENTRY_METADATA_VARIABLE_NAME,
             metadata_key=metadata_key,
             variable_name=variable_name,
@@ -320,7 +313,6 @@ class IntegerMetadataVariable(MetadataVariable, IntegerVariable):
         Creates an int variable from playlist metadata
         """
         return _get(
-            "int",
             metadata_variable_name=PLAYLIST_METADATA_VARIABLE_NAME,
             metadata_key=metadata_key,
             variable_name=variable_name,

ytdl_sub/script/script.py

@@ -1,4 +1,5 @@
 # pylint: disable=missing-raises-doc
+import copy
 from typing import Dict
 from typing import List
 from typing import Optional
@@ -7,6 +8,7 @@ from typing import Set
 from ytdl_sub.script.functions import Functions
 from ytdl_sub.script.parser import parse
 from ytdl_sub.script.script_output import ScriptOutput
+from ytdl_sub.script.types.resolvable import Argument
 from ytdl_sub.script.types.resolvable import BuiltInFunctionType
 from ytdl_sub.script.types.resolvable import Lambda
 from ytdl_sub.script.types.resolvable import Resolvable
@@ -14,6 +16,7 @@ from ytdl_sub.script.types.syntax_tree import ResolvedSyntaxTree
 from ytdl_sub.script.types.syntax_tree import SyntaxTree
 from ytdl_sub.script.types.variable import FunctionArgument
 from ytdl_sub.script.types.variable import Variable
+from ytdl_sub.script.types.variable_dependency import VariableDependency
 from ytdl_sub.script.utils.exceptions import UNREACHABLE
 from ytdl_sub.script.utils.exceptions import CycleDetected
 from ytdl_sub.script.utils.exceptions import IncompatibleFunctionArguments
@@ -695,3 +698,59 @@ class Script:
             Names of all functions within the Script.
         """
         return set(to_function_definition_name(name) for name in self._functions.keys())
+
+    def resolve_partial(
+        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
+        }
+
+        partially_resolved = True
+        while partially_resolved:
+
+            partially_resolved = False
+
+            for variable in list(unresolved.keys()):
+                definition = unresolved[variable]
+
+                maybe_resolved = definition
+                if isinstance(definition, Variable) and definition.name not in unresolvable:
+                    maybe_resolved = resolved.get(definition, unresolved[definition])
+                elif isinstance(definition, VariableDependency):
+                    maybe_resolved = definition.partial_resolve(
+                        resolved_variables=resolved,
+                        unresolved_variables=unresolved,
+                        custom_functions=self._functions,
+                    )
+
+                if isinstance(maybe_resolved, Resolvable):
+                    resolved[variable] = maybe_resolved
+                    del unresolved[variable]
+                    partially_resolved = True
+                else:
+                    unresolved[variable] = maybe_resolved
+
+                # If the definition changed, then the script changed
+                # 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()}
+        )

ytdl_sub/script/types/array.py

@@ -28,7 +28,7 @@ class UnresolvedArray(_Array, VariableDependency, FutureResolvable):
     value: List[Argument]
 
     @property
-    def _iterable_arguments(self) -> List[Argument]:
+    def iterable_arguments(self) -> List[Argument]:
         return self.value
 
     def resolve(
@@ -47,6 +47,27 @@ class UnresolvedArray(_Array, VariableDependency, FutureResolvable):
             ]
         )
 
+    def partial_resolve(
+        self,
+        resolved_variables: Dict[Variable, Resolvable],
+        unresolved_variables: Dict[Variable, Argument],
+        custom_functions: Dict[str, VariableDependency],
+    ) -> Argument | Resolvable:
+        maybe_resolvable_values, is_resolvable = VariableDependency.try_partial_resolve(
+            args=self.value,
+            resolved_variables=resolved_variables,
+            unresolved_variables=unresolved_variables,
+            custom_functions=custom_functions,
+        )
+
+        out = UnresolvedArray(value=maybe_resolvable_values)
+        if is_resolvable:
+            return out.resolve(
+                resolved_variables=resolved_variables, custom_functions=custom_functions
+            )
+
+        return out
+
     def future_resolvable_type(self) -> Type[Resolvable]:
         return Array
 

ytdl_sub/script/types/function.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass
 from typing import Callable
 from typing import Dict
 from typing import List
+from typing import Optional
 from typing import Type
 from typing import Union
 
@@ -11,9 +12,11 @@ from ytdl_sub.script.functions import Functions
 from ytdl_sub.script.types.array import Array
 from ytdl_sub.script.types.array import UnresolvedArray
 from ytdl_sub.script.types.resolvable import Argument
+from ytdl_sub.script.types.resolvable import Boolean
 from ytdl_sub.script.types.resolvable import BuiltInFunctionType
 from ytdl_sub.script.types.resolvable import FunctionType
 from ytdl_sub.script.types.resolvable import FutureResolvable
+from ytdl_sub.script.types.resolvable import Integer
 from ytdl_sub.script.types.resolvable import Lambda
 from ytdl_sub.script.types.resolvable import NamedCustomFunction
 from ytdl_sub.script.types.resolvable import Resolvable
@@ -35,7 +38,7 @@ from ytdl_sub.script.utils.type_checking import is_union
 @dataclass(frozen=True)
 class Function(FunctionType, VariableDependency, ABC):
     @property
-    def _iterable_arguments(self) -> List[Argument]:
+    def iterable_arguments(self) -> List[Argument]:
         return self.args
 
 
@@ -84,6 +87,52 @@ class CustomFunction(Function, NamedCustomFunction):
         # been checked in the parser with
         raise UNREACHABLE
 
+    def partial_resolve(
+        self,
+        resolved_variables: Dict[Variable, Resolvable],
+        unresolved_variables: Dict[Variable, Argument],
+        custom_functions: Dict[str, VariableDependency],
+    ) -> Argument | Resolvable:
+        maybe_resolvable_args, _ = VariableDependency.try_partial_resolve(
+            args=self.args,
+            resolved_variables=resolved_variables,
+            unresolved_variables=unresolved_variables,
+            custom_functions=custom_functions,
+        )
+
+        for i in range(len(self.args)):
+            function_arg = FunctionArgument.from_idx(idx=i, custom_function_name=self.name)
+            function_value = maybe_resolvable_args[i]
+
+            if isinstance(function_value, Resolvable):
+                resolved_variables[function_arg] = function_value
+            else:
+                unresolved_variables[function_arg] = function_value
+
+        assert len(custom_functions[self.name].iterable_arguments) == 1
+        custom_function_definition = custom_functions[self.name].iterable_arguments[0]
+
+        maybe_resolvable_custom_function, is_resolvable = VariableDependency.try_partial_resolve(
+            args=[custom_function_definition],
+            resolved_variables=resolved_variables,
+            unresolved_variables=unresolved_variables,
+            custom_functions=custom_functions,
+        )
+
+        for i in range(len(self.args)):
+            function_arg = FunctionArgument.from_idx(idx=i, custom_function_name=self.name)
+
+            if isinstance(maybe_resolvable_args[i], Resolvable):
+                del resolved_variables[function_arg]
+            else:
+                del unresolved_variables[function_arg]
+
+        if is_resolvable:
+            return maybe_resolvable_custom_function[0]
+
+        # Did not resolve custom function arguments, do not proceed
+        return CustomFunction(name=self.name, args=maybe_resolvable_args)
+
 
 class BuiltInFunction(Function, BuiltInFunctionType):
     def validate_args(self) -> "BuiltInFunction":
@@ -312,5 +361,133 @@ class BuiltInFunction(Function, BuiltInFunctionType):
                 f"Runtime error occurred when executing the function %{self.name}: {str(exc)}"
             ) from exc
 
+    def _partial_resolve_conditional(
+        self,
+        resolved_variables: Dict[Variable, Resolvable],
+        unresolved_variables: Dict[Variable, Argument],
+        custom_functions: Dict[str, "VariableDependency"],
+    ):
+        """
+        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(
+                args=[self.args[0]],
+                resolved_variables=resolved_variables,
+                unresolved_variables=unresolved_variables,
+                custom_functions=custom_functions,
+            )
+            if is_resolvable:
+                boolean_output = maybe_resolvable_arg[0]
+                assert isinstance(boolean_output, Boolean)
+                return self.args[1] if boolean_output.native else self.args[2]
+
+        if self.name == "elif":
+            for idx in range(0, len(self.args), 2):
+                maybe_resolvable_arg, is_resolvable = VariableDependency.try_partial_resolve(
+                    args=[self.args[idx]],
+                    resolved_variables=resolved_variables,
+                    unresolved_variables=unresolved_variables,
+                    custom_functions=custom_functions,
+                )
+                if is_resolvable:
+                    boolean_output = maybe_resolvable_arg[0]
+                    assert isinstance(boolean_output, Boolean)
+                    if boolean_output.native:
+                        return self.args[idx + 1]
+                else:
+                    break
+
+        if self.name == "assert_then":
+            maybe_resolvable_arg, is_resolvable = VariableDependency.try_partial_resolve(
+                args=[self.args[0]],
+                resolved_variables=resolved_variables,
+                unresolved_variables=unresolved_variables,
+                custom_functions=custom_functions,
+            )
+            if is_resolvable:
+                boolean_output = maybe_resolvable_arg[0]
+                assert isinstance(boolean_output, Boolean)
+                if boolean_output.native:
+                    return self.args[1]
+
+        return self
+
+    def _try_optimized_partial_resolve(
+        self,
+        resolved_variables: Dict[Variable, Resolvable],
+        unresolved_variables: Dict[Variable, Argument],
+        custom_functions: Dict[str, "VariableDependency"],
+    ) -> Optional[Argument]:
+        """
+        If a function has enough (but not all) resolved parameters to warrant a return,
+        perform it here.
+        """
+        if self.name == "array_at":
+            if (
+                isinstance(self.args[0], UnresolvedArray)
+                and isinstance(self.args[1], Integer)
+                and len(self.args[0].value) >= self.args[1].value
+            ):
+                maybe_resolvable_values, _ = VariableDependency.try_partial_resolve(
+                    args=[self.args[0].value[self.args[1].value]],
+                    resolved_variables=resolved_variables,
+                    unresolved_variables=unresolved_variables,
+                    custom_functions=custom_functions,
+                )
+
+                return maybe_resolvable_values[0]
+
+        return None
+
+    def partial_resolve(
+        self,
+        resolved_variables: Dict[Variable, Resolvable],
+        unresolved_variables: Dict[Variable, Argument],
+        custom_functions: Dict[str, VariableDependency],
+    ) -> Argument | Resolvable:
+        conditional_return_args = self.function_spec.conditional_arg_indices(
+            num_input_args=len(self.args)
+        )
+
+        if conditional_return_args:
+            return self._partial_resolve_conditional(
+                resolved_variables=resolved_variables,
+                unresolved_variables=unresolved_variables,
+                custom_functions=custom_functions,
+            )
+
+        if partial_resolved := self._try_optimized_partial_resolve(
+            resolved_variables=resolved_variables,
+            unresolved_variables=unresolved_variables,
+            custom_functions=custom_functions,
+        ):
+            return partial_resolved
+
+        maybe_resolvable_values, is_resolvable = VariableDependency.try_partial_resolve(
+            args=self.args,
+            resolved_variables=resolved_variables,
+            unresolved_variables=unresolved_variables,
+            custom_functions=custom_functions,
+        )
+
+        out = BuiltInFunction(name=self.name, args=maybe_resolvable_values)
+        if is_resolvable:
+            return out.resolve(
+                resolved_variables=resolved_variables,
+                custom_functions=custom_functions,
+            )
+
+        return out
+
     def __hash__(self):
         return hash((self.name, *self.args))

ytdl_sub/script/types/map.py

@@ -31,7 +31,7 @@ class UnresolvedMap(_Map, VariableDependency, FutureResolvable):
     value: Dict[Argument, Argument]
 
     @property
-    def _iterable_arguments(self) -> List[Argument]:
+    def iterable_arguments(self) -> List[Argument]:
         return list(itertools.chain(*self.value.items()))
 
     def resolve(
@@ -55,6 +55,35 @@ class UnresolvedMap(_Map, VariableDependency, FutureResolvable):
 
         return Map(output)
 
+    def partial_resolve(
+        self,
+        resolved_variables: Dict[Variable, Resolvable],
+        unresolved_variables: Dict[Variable, Argument],
+        custom_functions: Dict[str, VariableDependency],
+    ) -> Argument | Resolvable:
+        maybe_resolvable_keys, is_keys_resolvable = VariableDependency.try_partial_resolve(
+            args=self.value.keys(),
+            resolved_variables=resolved_variables,
+            unresolved_variables=unresolved_variables,
+            custom_functions=custom_functions,
+        )
+
+        maybe_resolvable_values, is_values_resolvable = VariableDependency.try_partial_resolve(
+            args=self.value.values(),
+            resolved_variables=resolved_variables,
+            unresolved_variables=unresolved_variables,
+            custom_functions=custom_functions,
+        )
+
+        out = UnresolvedMap(value=dict(zip(maybe_resolvable_keys, maybe_resolvable_values)))
+        if is_keys_resolvable and is_values_resolvable:
+            return out.resolve(
+                resolved_variables=resolved_variables,
+                custom_functions=custom_functions,
+            )
+
+        return out
+
     def future_resolvable_type(self) -> Type[Resolvable]:
         return Map
 

ytdl_sub/script/types/syntax_tree.py

@@ -3,6 +3,7 @@ from typing import Dict
 from typing import List
 from typing import Optional
 
+from ytdl_sub.script.types.function import BuiltInFunction
 from ytdl_sub.script.types.resolvable import Argument
 from ytdl_sub.script.types.resolvable import Resolvable
 from ytdl_sub.script.types.resolvable import String
@@ -15,7 +16,7 @@ class SyntaxTree(VariableDependency):
     ast: List[Argument]
 
     @property
-    def _iterable_arguments(self) -> List[Argument]:
+    def iterable_arguments(self) -> List[Argument]:
         return self.ast
 
     def resolve(
@@ -40,6 +41,26 @@ class SyntaxTree(VariableDependency):
         # Otherwise, to concat multiple resolved outputs, we must concat as strings
         return String("".join([str(res) for res in resolved]))
 
+    def partial_resolve(
+        self,
+        resolved_variables: Dict[Variable, Resolvable],
+        unresolved_variables: Dict[Variable, Argument],
+        custom_functions: Dict[str, VariableDependency],
+    ) -> Argument | Resolvable:
+        # Ensure this does not get returned as a SyntaxTree since nesting them is not supported.
+        maybe_resolvable_values, _ = VariableDependency.try_partial_resolve(
+            args=self.ast,
+            resolved_variables=resolved_variables,
+            unresolved_variables=unresolved_variables,
+            custom_functions=custom_functions,
+        )
+
+        # Mimic the above resolve behavior
+        if len(maybe_resolvable_values) > 1:
+            return BuiltInFunction(name="concat", args=maybe_resolvable_values)
+
+        return maybe_resolvable_values[0]
+
     @property
     def maybe_resolvable(self) -> Optional[Resolvable]:
         """
@@ -76,3 +97,11 @@ class ResolvedSyntaxTree(SyntaxTree):
     @property
     def maybe_resolvable(self) -> Optional[Resolvable]:
         return self.ast[0]
+
+    def partial_resolve(
+        self,
+        resolved_variables: Dict[Variable, Resolvable],
+        unresolved_variables: Dict[Variable, Argument],
+        custom_functions: Dict[str, VariableDependency],
+    ) -> Argument | Resolvable:
+        return self.ast[0]

ytdl_sub/script/types/variable_dependency.py

@@ -5,6 +5,7 @@ from typing import Dict
 from typing import Iterable
 from typing import List
 from typing import Set
+from typing import Tuple
 from typing import Type
 from typing import TypeVar
 from typing import final
@@ -27,7 +28,7 @@ TypeT = TypeVar("TypeT")
 class VariableDependency(ABC):
     @property
     @abstractmethod
-    def _iterable_arguments(self) -> List[Argument]:
+    def iterable_arguments(self) -> List[Argument]:
         """
         Returns
         -------
@@ -38,7 +39,7 @@ class VariableDependency(ABC):
         self, ttype: Type[TypeT], subclass: bool = False, instance: bool = True
     ) -> List[TypeT]:
         output: List[TypeT] = []
-        for arg in self._iterable_arguments:
+        for arg in self.iterable_arguments:
             if subclass and issubclass(type(arg), ttype):
                 output.append(arg)
             elif instance and isinstance(arg, ttype):
@@ -104,7 +105,7 @@ class VariableDependency(ABC):
         All CustomFunctions that this depends on.
         """
         output: Set[ParsedCustomFunction] = set()
-        for arg in self._iterable_arguments:
+        for arg in self.iterable_arguments:
             if isinstance(arg, NamedCustomFunction):
                 if not isinstance(arg, FunctionType):
                     # A NamedCustomFunction should also always be a FunctionType
@@ -138,6 +139,28 @@ class VariableDependency(ABC):
         Resolved value
         """
 
+    @abstractmethod
+    def partial_resolve(
+        self,
+        resolved_variables: Dict[Variable, Resolvable],
+        unresolved_variables: Dict[Variable, Argument],
+        custom_functions: Dict[str, "VariableDependency"],
+    ) -> Argument | Resolvable:
+        """
+        Parameters
+        ----------
+        resolved_variables
+            Lookup of variables that have been resolved
+        unresolved_variables
+            Lookup of variables that have not been resolved
+        custom_functions
+            Lookup of any custom functions that have been parsed
+
+        Returns
+        -------
+        Either a fully resolved value or partially resolved value of the same type.
+        """
+
     @classmethod
     def _resolve_argument_type(
         cls,
@@ -222,3 +245,43 @@ class VariableDependency(ABC):
             ):
                 return True
         return len(self.variables.intersection(variables)) > 0
+
+    @classmethod
+    def try_partial_resolve(
+        cls,
+        args: Iterable[Argument],
+        resolved_variables: Dict[Variable, Resolvable],
+        unresolved_variables: Dict[Variable, Argument],
+        custom_functions: Dict[str, "VariableDependency"],
+    ) -> Tuple[List[Argument], bool]:
+        """
+        Attempts to resolve a list of arguments. Returns a tuple of them post partially resolved,
+        and a boolean indicating whether all of them are fully resolved.
+        """
+        maybe_resolvable_args: List[Argument] = []
+        is_resolvable = True
+        for arg in args:
+            maybe_resolvable_args.append(arg)
+
+            if isinstance(arg, Lambda) and arg.value in custom_functions:
+                if not custom_functions[arg.value].is_subset_of(
+                    variables=resolved_variables,
+                    custom_function_definitions=custom_functions,
+                ):
+                    is_resolvable = False
+            elif isinstance(arg, VariableDependency):
+                maybe_resolvable_args[-1] = arg.partial_resolve(
+                    resolved_variables=resolved_variables,
+                    unresolved_variables=unresolved_variables,
+                    custom_functions=custom_functions,
+                )
+
+                if not isinstance(maybe_resolvable_args[-1], Resolvable):
+                    is_resolvable = False
+            elif isinstance(arg, Variable):
+                if arg not in resolved_variables:
+                    is_resolvable = False
+                    if arg in unresolved_variables:
+                        maybe_resolvable_args[-1] = unresolved_variables[arg]
+
+        return maybe_resolvable_args, is_resolvable

ytdl_sub/utils/script.py

@@ -2,11 +2,14 @@ import json
 import re
 from typing import Any
 from typing import Dict
+from typing import Optional
 
 from ytdl_sub.script.parser import parse
+from ytdl_sub.script.types.array import Array
 from ytdl_sub.script.types.array import UnresolvedArray
 from ytdl_sub.script.types.function import BuiltInFunction
 from ytdl_sub.script.types.function import Function
+from ytdl_sub.script.types.map import Map
 from ytdl_sub.script.types.map import UnresolvedMap
 from ytdl_sub.script.types.resolvable import Argument
 from ytdl_sub.script.types.resolvable import Boolean
@@ -137,9 +140,9 @@ class ScriptUtils:
             out = f"%bool({arg.native})"
         elif isinstance(arg, Float):
             out = f"%float({arg.native})"
-        elif isinstance(arg, UnresolvedArray):
+        elif isinstance(arg, (Array, UnresolvedArray)):
             out = f"[ {', '.join(cls._to_script_code(val) for val in arg.value)} ]"
-        elif isinstance(arg, UnresolvedMap):
+        elif isinstance(arg, (Map, UnresolvedMap)):
             kv_list = (
                 f"{cls._to_script_code(key)}: {cls._to_script_code(val)}"
                 for key, val in arg.value.items()
@@ -155,11 +158,43 @@ class ScriptUtils:
             raise UNREACHABLE
         return f"{{ {out} }}" if top_level else out
 
+    @classmethod
+    def _is_top_level_string(cls, tree: SyntaxTree) -> Optional[str]:
+        if not (
+            len(tree.ast) == 1
+            and isinstance(tree.ast[0], BuiltInFunction)
+            and tree.ast[0].name == "concat"
+        ):
+            return None
+
+        output = ""
+        for arg in tree.ast[0].args:
+            if isinstance(arg, BuiltInFunction) and arg.name == "string" and len(arg.args) == 1:
+                output += cls._to_script_code(arg.args[0], top_level=True)
+            else:
+                output += cls._to_script_code(arg, top_level=True)
+
+        return output
+
+    @classmethod
+    def _syntax_tree_to_native_script(cls, tree: SyntaxTree) -> str:
+
+        if (output := cls._is_top_level_string(tree)) is not None:
+            return output
+
+        output = ""
+        for arg in tree.ast:
+            output += cls._to_script_code(arg, top_level=True)
+        return output
+
     @classmethod
     def to_native_script(cls, value: Any) -> str:
         """
         Converts any JSON-compatible value into equivalent script syntax
         """
+        if isinstance(value, SyntaxTree):
+            return cls._syntax_tree_to_native_script(value)
+
         return cls._to_script_code(cls._to_script_argument(value), top_level=True)
 
     @classmethod

{ytdl_sub-2026.1.6.dist-info → ytdl_sub-2026.1.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytdl-sub
-Version: 2026.1.6
+Version: 2026.1.13
 Summary: Automate downloading metadata generation with YoutubeDL
 Author: Jesse Bannon
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -703,7 +703,7 @@ Requires-Dist: black==24.10.0; extra == "lint"
 Requires-Dist: isort==7.0.0; extra == "lint"
 Requires-Dist: pylint==4.0.1; extra == "lint"
 Provides-Extra: docs
-Requires-Dist: sphinx<9,>=7; extra == "docs"
+Requires-Dist: sphinx<10,>=7; extra == "docs"
 Requires-Dist: sphinx-rtd-theme<4,>=2; extra == "docs"
 Requires-Dist: sphinx-book-theme~=1.0; extra == "docs"
 Requires-Dist: sphinx-copybutton~=0.5; extra == "docs"

{ytdl_sub-2026.1.6.dist-info → ytdl_sub-2026.1.13.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ytdl_sub/__init__.py,sha256=nLml9KZHf1Nc577PKf16c0ZGjsSoLjrMPVHCbI69wBw,73
+ytdl_sub/__init__.py,sha256=gB8fvSniQWtSTiQbvgSB9n_Ing5ceOHUg-DjaWhecp0,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
@@ -40,7 +40,7 @@ ytdl_sub/entries/script/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 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_types.py,sha256=6urKgOIOKYjScM5yZu-gF8sYi1HaVrTwaYJkJJg9hi8,9826
+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
 ytdl_sub/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -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=ufW-Zr0amTh0vkdW63oOca6MndojgaTaXxpOFk25U48,27688
+ytdl_sub/script/script.py,sha256=r5QJOt0Dw1GE9qy8hHr5-bjr2HWs1rv9g-dsHrSBZrc,29998
 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
@@ -108,13 +108,13 @@ ytdl_sub/script/functions/print_functions.py,sha256=s-EhqdUvDcH3zIkt95LIDGxvlACY
 ytdl_sub/script/functions/regex_functions.py,sha256=d6omjhD9FjkP0BVjUaMsJfXVt-reh-MI52cUhXdL4S4,6744
 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=1yEJEWtwS6T4W8KZN2IdNAGpi3SUa1qqzCXQfjo-P2M,1711
-ytdl_sub/script/types/function.py,sha256=rnKb5L8frQ6sG95lMFj_AS6qQw7tt88z26tyWrCWPhY,12341
-ytdl_sub/script/types/map.py,sha256=Y3zlm__IHcnycGFv0xbU_P7wgiQgtgddatPLQypjCvU,2254
+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/map.py,sha256=Hw053W-2kxqqW0ece2QsBu_xs7HmsKlNkZwYoBiYlc0,3405
 ytdl_sub/script/types/resolvable.py,sha256=YeMEhPTRTDSr5AVmK4NRpUbqxh1YQT6a2dGUIPKoFkI,5482
-ytdl_sub/script/types/syntax_tree.py,sha256=4xWluTMPJqA6yYuQ4XCcncSFt5cDZ9ZIT2AIOOH4bT0,2336
+ytdl_sub/script/types/syntax_tree.py,sha256=bkZqKLOj_yKUFBq8uLQ2i4Rcre01aD1_A-yOrHQt_9w,3479
 ytdl_sub/script/types/variable.py,sha256=aVJ3ocUr3WpDoolOq6y3NV71b3EQQYPAGrIT0FtIqc4,813
-ytdl_sub/script/types/variable_dependency.py,sha256=w0NrgSoom9joLaLMWHbma0zekmljYVXdhYW-k_g1n0I,7419
+ytdl_sub/script/types/variable_dependency.py,sha256=ZKDDY9AeYhH_kVJgY-Td-cmt3USDkmMEBLpcn0-8pLs,9861
 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
@@ -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=M0EagR15LNkP0lg0NLAvGkBXLRfprCofj8SLcaLz0_g,6277
+ytdl_sub/utils/script.py,sha256=g-Jrfm4WHOhll9QYVx3vuOFJmiQnG2dvbdCbf80kbTI,7439
 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
@@ -158,9 +158,9 @@ ytdl_sub/validators/string_select_validator.py,sha256=KFXNKWX2J80WGt08m5gVYphPMH
 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.6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-ytdl_sub-2026.1.6.dist-info/METADATA,sha256=gVJGeZNSYZ_Cq1wnwVdwkQkJsnVAnYNM-scbVs1zttw,51418
-ytdl_sub-2026.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ytdl_sub-2026.1.6.dist-info/entry_points.txt,sha256=K3T5235NlAI-WLmHCg5tzLZHqc33OLN5IY5fOGc9t10,48
-ytdl_sub-2026.1.6.dist-info/top_level.txt,sha256=6z-JWazl6jXspC2DNyxOnGnEqYyGzVbgcBDoXfbkUhI,9
-ytdl_sub-2026.1.6.dist-info/RECORD,,
+ytdl_sub-2026.1.13.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+ytdl_sub-2026.1.13.dist-info/METADATA,sha256=5_cVGotelpxrRCV6DMgOUjKdFQvd71CxxjkMm9jUtkE,51420
+ytdl_sub-2026.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ytdl_sub-2026.1.13.dist-info/entry_points.txt,sha256=K3T5235NlAI-WLmHCg5tzLZHqc33OLN5IY5fOGc9t10,48
+ytdl_sub-2026.1.13.dist-info/top_level.txt,sha256=6z-JWazl6jXspC2DNyxOnGnEqYyGzVbgcBDoXfbkUhI,9
+ytdl_sub-2026.1.13.dist-info/RECORD,,