ytdl-sub 2026.1.11__tar.gz → 2026.1.13__tar.gz

{ytdl_sub-2026.1.11 → ytdl_sub-2026.1.13}/PKG-INFO

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

ytdl_sub-2026.1.13/src/ytdl_sub/__init__.py

@@ -0,0 +1 @@
+__pypi_version__ = "2026.01.13";__local_version__ = "2026.01.13+530d2f7"

{ytdl_sub-2026.1.11 → ytdl_sub-2026.1.13}/src/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-2026.1.11 → ytdl_sub-2026.1.13}/src/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-2026.1.11 → ytdl_sub-2026.1.13}/src/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-2026.1.11 → ytdl_sub-2026.1.13}/src/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-2026.1.11 → ytdl_sub-2026.1.13}/src/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-2026.1.11 → ytdl_sub-2026.1.13}/src/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-2026.1.11 → ytdl_sub-2026.1.13}/src/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.11 → ytdl_sub-2026.1.13}/src/ytdl_sub.egg-info/PKG-INFO

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

ytdl_sub-2026.1.11/src/ytdl_sub/__init__.py

@@ -1 +0,0 @@
-__pypi_version__ = "2026.01.11";__local_version__ = "2026.01.11+41a5bf6"