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

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

@@ -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 → ytdl_sub-2026.1.13}/pyproject.toml

@@ -52,7 +52,7 @@ lint = [
     "pylint==4.0.1",
 ]
 docs = [
-    "sphinx>=7,<9",
+    "sphinx>=7,<10",
     "sphinx-rtd-theme>=2,<4",
     "sphinx-book-theme~=1.0",
     "sphinx-copybutton~=0.5",

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.6 → ytdl_sub-2026.1.13}/src/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-2026.1.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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