tasktree 0.0.13__tar.gz → 0.0.15__tar.gz

{tasktree-0.0.13 → tasktree-0.0.15}/.github/workflows/validate-pipx-install.yml

@@ -50,6 +50,12 @@ jobs:
           python -m pipx install tasktree
         shell: bash
 
+      - name: Get installed tt version
+        working-directory: example
+        run: |
+          tt --version
+        shell: bash
+
       - name: Test tt --list command
         working-directory: example
         run: |
@@ -103,6 +109,13 @@ jobs:
           pipx install --python python3.12 tasktree
         shell: bash
 
+      - name: Get installed tt version
+        working-directory: example
+        run: |
+          export PATH="$HOME/.local/bin:$PATH"
+          tt --version
+        shell: bash
+
       - name: Test tt --list command
         working-directory: example
         run: |

{tasktree-0.0.13 → tasktree-0.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.13
+Version: 0.0.15
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0

{tasktree-0.0.13 → tasktree-0.0.15}/example/tasktree.yaml

@@ -1,9 +1,13 @@
+variables:
+  log_level: { env: LOG_LEVEL, default: "info" }
+
 tasks:
   build:
     desc: Building outputs (imagine this is a call to Cargo, or gcc, or something)
     args:
       - build_type:
-          choices: [ "debug", "release" ]
+          choices: [ "debug", "release", "{{ var.log_level }}" ]
+          default: "{{ var.log_level }}"
       - target:
            type: str
            choices:

{tasktree-0.0.13 → tasktree-0.0.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tasktree"
-version = "0.0.13"
+version = "0.0.15"
 description = "A task automation tool with incremental execution"
 readme = "README.md"
 requires-python = ">=3.11"

{tasktree-0.0.13 → tasktree-0.0.15}/src/tasktree/cli.py

@@ -14,8 +14,8 @@ from rich.tree import Tree
 
 from tasktree import __version__
 from tasktree.executor import Executor
-from tasktree.graph import build_dependency_tree
-from tasktree.hasher import hash_task
+from tasktree.graph import build_dependency_tree, resolve_execution_order
+from tasktree.hasher import hash_task, hash_args
 from tasktree.parser import Recipe, find_recipe_file, parse_arg_spec, parse_recipe
 from tasktree.state import StateManager
 from tasktree.types import get_click_type
@@ -443,11 +443,34 @@ def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = Fal
     state.load()
     executor = Executor(recipe, state)
 
-    # Prune state before execution (compute hashes with effective environment and dependencies)
-    valid_hashes = {
-        hash_task(t.cmd, t.outputs, t.working_dir, t.args, executor._get_effective_env_name(t), t.deps)
-        for t in recipe.tasks.values()
-    }
+    # Resolve execution order to determine which tasks will actually run
+    # This is important for correct state pruning after template substitution
+    execution_order = resolve_execution_order(recipe, task_name, args_dict)
+
+    # Prune state based on tasks that will actually execute (with their specific arguments)
+    # This ensures template-substituted dependencies are handled correctly
+    valid_hashes = set()
+    for exec_task_name, exec_task_args in execution_order:
+        task = recipe.tasks[exec_task_name]
+        # Compute base task hash
+        task_hash = hash_task(
+            task.cmd,
+            task.outputs,
+            task.working_dir,
+            task.args,
+            executor._get_effective_env_name(task),
+            task.deps
+        )
+
+        # If task has arguments, append args hash to create unique cache key
+        if exec_task_args:
+            args_hash = hash_args(exec_task_args)
+            cache_key = f"{task_hash}__{args_hash}"
+        else:
+            cache_key = task_hash
+
+        valid_hashes.add(cache_key)
+
     state.prune(valid_hashes)
     state.save()
     try:

{tasktree-0.0.13 → tasktree-0.0.15}/src/tasktree/graph.py

@@ -5,7 +5,161 @@ from pathlib import Path
 from typing import Any
 
 from tasktree.hasher import hash_args
-from tasktree.parser import Recipe, Task, DependencyInvocation, parse_dependency_spec
+from tasktree.parser import (
+    Recipe,
+    Task,
+    DependencyInvocation,
+    parse_dependency_spec,
+    parse_arg_spec,
+)
+from tasktree.substitution import substitute_dependency_args
+
+
+def _get_exported_arg_names(task: Task) -> set[str]:
+    """Extract names of exported arguments from a task.
+
+    Exported arguments are identified by the '$' prefix in their definition.
+
+    Args:
+        task: Task to extract exported arg names from
+
+    Returns:
+        Set of exported argument names (without the '$' prefix)
+
+    Example:
+        Task with args: ["$server", "port"]
+        Returns: {"server"}
+    """
+    if not task.args:
+        return set()
+
+    exported = set()
+    for arg_spec in task.args:
+        if isinstance(arg_spec, str):
+            # Simple string format: "$argname" or "argname"
+            if arg_spec.startswith("$"):
+                exported.add(arg_spec[1:])  # Remove '$' prefix
+        elif isinstance(arg_spec, dict):
+            # Dictionary format: {"$argname": {...}} or {"argname": {...}}
+            for arg_name in arg_spec.keys():
+                if arg_name.startswith("$"):
+                    exported.add(arg_name[1:])  # Remove '$' prefix
+
+    return exported
+
+
+def resolve_dependency_invocation(
+    dep_spec: str | dict[str, Any],
+    parent_task_name: str,
+    parent_args: dict[str, Any],
+    parent_exported_args: set[str],
+    recipe: Recipe
+) -> DependencyInvocation:
+    """Parse dependency specification and substitute parent argument templates.
+
+    This function handles template substitution in dependency arguments. It:
+    1. Checks if dependency arguments contain {{ arg.* }} templates
+    2. Substitutes templates using parent task's arguments
+    3. Delegates to parse_dependency_spec for type conversion and validation
+
+    Args:
+        dep_spec: Dependency specification (str or dict with task name and args)
+        parent_task_name: Name of the parent task (for error messages)
+        parent_args: Parent task's argument values (for template substitution)
+        parent_exported_args: Set of parent's exported argument names
+        recipe: Recipe containing task definitions
+
+    Returns:
+        DependencyInvocation with typed, validated arguments
+
+    Raises:
+        ValueError: If template substitution fails, argument validation fails,
+                   or dependency task doesn't exist
+
+    Examples:
+        Simple string (no templates):
+        >>> resolve_dependency_invocation("build", "test", {}, set(), recipe)
+        DependencyInvocation("build", None)
+
+        Literal arguments (no templates):
+        >>> resolve_dependency_invocation({"build": ["debug"]}, "test", {}, set(), recipe)
+        DependencyInvocation("build", {"mode": "debug"})
+
+        Template substitution:
+        >>> resolve_dependency_invocation(
+        ...     {"build": ["{{ arg.env }}"]},
+        ...     "test",
+        ...     {"env": "production"},
+        ...     set(),
+        ...     recipe
+        ... )
+        DependencyInvocation("build", {"mode": "production"})
+    """
+    # Simple string case - no args to substitute
+    if isinstance(dep_spec, str):
+        return parse_dependency_spec(dep_spec, recipe)
+
+    # Dictionary case: {"task_name": args_spec}
+    if not isinstance(dep_spec, dict) or len(dep_spec) != 1:
+        # Invalid format, let parse_dependency_spec handle the error
+        return parse_dependency_spec(dep_spec, recipe)
+
+    task_name, arg_spec = next(iter(dep_spec.items()))
+
+    # Check if any argument values contain templates
+    has_templates = False
+    if isinstance(arg_spec, list):
+        # Positional args: check each value
+        for val in arg_spec:
+            if isinstance(val, str) and "{{ arg." in val:
+                has_templates = True
+                break
+    elif isinstance(arg_spec, dict):
+        # Named args: check each value
+        for val in arg_spec.values():
+            if isinstance(val, str) and "{{ arg." in val:
+                has_templates = True
+                break
+
+    # If no templates, use existing parser (fast path for backward compatibility)
+    if not has_templates:
+        return parse_dependency_spec(dep_spec, recipe)
+
+    # Template substitution path
+    # Substitute {{ arg.* }} in argument values
+    substituted_arg_spec: list[Any] | dict[str, Any]
+
+    if isinstance(arg_spec, list):
+        # Positional args: substitute each value that's a string
+        substituted_arg_spec = []
+        for val in arg_spec:
+            if isinstance(val, str):
+                substituted_val = substitute_dependency_args(
+                    val, parent_task_name, parent_args, parent_exported_args
+                )
+                substituted_arg_spec.append(substituted_val)
+            else:
+                # Non-string values (bool, int, etc.) pass through unchanged
+                substituted_arg_spec.append(val)
+    elif isinstance(arg_spec, dict):
+        # Named args: substitute each string value
+        substituted_arg_spec = {}
+        for arg_name, val in arg_spec.items():
+            if isinstance(val, str):
+                substituted_val = substitute_dependency_args(
+                    val, parent_task_name, parent_args, parent_exported_args
+                )
+                substituted_arg_spec[arg_name] = substituted_val
+            else:
+                # Non-string values pass through unchanged
+                substituted_arg_spec[arg_name] = val
+    else:
+        # Invalid format, let parse_dependency_spec handle it
+        return parse_dependency_spec(dep_spec, recipe)
+
+    # Create new dep_spec with substituted values and parse it
+    substituted_dep_spec = {task_name: substituted_arg_spec}
+    return parse_dependency_spec(substituted_dep_spec, recipe)
 
 
 class CycleError(Exception):
@@ -99,7 +253,7 @@ def resolve_execution_order(
         return seen_invocations[key]
 
     def build_graph(node: TaskNode) -> None:
-        """Recursively build dependency graph."""
+        """Recursively build dependency graph with template substitution."""
         if node in graph:
             # Already processed
             return
@@ -108,11 +262,21 @@ def resolve_execution_order(
         if task is None:
             raise TaskNotFoundError(f"Task not found: {node.task_name}")
 
-        # Parse and normalize dependencies
+        # Get parent task's exported argument names
+        parent_exported_args = _get_exported_arg_names(task)
+
+        # Parse and normalize dependencies with template substitution
         dep_nodes = set()
         for dep_spec in task.deps:
-            # Parse dependency specification
-            dep_inv = parse_dependency_spec(dep_spec, recipe)
+            # Resolve dependency specification with parent context
+            # This handles template substitution if {{ arg.* }} is present
+            dep_inv = resolve_dependency_invocation(
+                dep_spec,
+                parent_task_name=node.task_name,
+                parent_args=node.args or {},
+                parent_exported_args=parent_exported_args,
+                recipe=recipe
+            )
 
             # Create or get node for this dependency invocation
             dep_node = get_or_create_node(dep_inv.task_name, dep_inv.args)

{tasktree-0.0.13 → tasktree-0.0.15}/src/tasktree/parser.py

@@ -89,6 +89,31 @@ class Task:
             )
 
 
+@dataclass
+class DependencySpec:
+    """Parsed dependency specification with potential template placeholders.
+
+    This represents a dependency as defined in the recipe file, before template
+    substitution. Argument values may contain {{ arg.* }} templates that will be
+    substituted with parent task's argument values during graph construction.
+
+    Attributes:
+        task_name: Name of the dependency task
+        arg_templates: Dictionary mapping argument names to string templates
+                      (None if no args specified). All values are strings, even
+                      for numeric types, to preserve template placeholders.
+    """
+    task_name: str
+    arg_templates: dict[str, str] | None = None
+
+    def __str__(self) -> str:
+        """String representation for display."""
+        if not self.arg_templates:
+            return self.task_name
+        args_str = ", ".join(f"{k}={v}" for k, v in self.arg_templates.items())
+        return f"{self.task_name}({args_str})"
+
+
 @dataclass
 class DependencyInvocation:
     """Represents a task dependency invocation with optional arguments.
@@ -992,13 +1017,171 @@ def _parse_file_with_env(
     return tasks, environments, default_env, variables
 
 
-def parse_recipe(recipe_path: Path, project_root: Path | None = None) -> Recipe:
+def collect_reachable_tasks(tasks: dict[str, Task], root_task: str) -> set[str]:
+    """Collect all tasks reachable from the root task via dependencies.
+
+    Uses BFS to traverse the dependency graph and collect all task names
+    that could potentially be executed when running the root task.
+
+    Args:
+        tasks: Dictionary mapping task names to Task objects
+        root_task: Name of the root task to start traversal from
+
+    Returns:
+        Set of task names reachable from root_task (includes root_task itself)
+
+    Raises:
+        ValueError: If root_task doesn't exist
+
+    Example:
+        >>> tasks = {"a": Task("a", deps=["b"]), "b": Task("b", deps=[]), "c": Task("c", deps=[])}
+        >>> collect_reachable_tasks(tasks, "a")
+        {"a", "b"}
+    """
+    if root_task not in tasks:
+        raise ValueError(f"Root task '{root_task}' not found in recipe")
+
+    reachable = set()
+    queue = [root_task]
+
+    while queue:
+        task_name = queue.pop(0)
+
+        if task_name in reachable:
+            continue  # Already processed
+
+        reachable.add(task_name)
+
+        # Get task and process its dependencies
+        task = tasks.get(task_name)
+        if task is None:
+            # Task not found - will be caught during graph construction
+            continue
+
+        # Add dependency task names to queue
+        for dep_spec in task.deps:
+            # Extract task name from dependency specification
+            if isinstance(dep_spec, str):
+                dep_name = dep_spec
+            elif isinstance(dep_spec, dict) and len(dep_spec) == 1:
+                dep_name = next(iter(dep_spec.keys()))
+            else:
+                # Invalid format - will be caught during graph construction
+                continue
+
+            if dep_name not in reachable:
+                queue.append(dep_name)
+
+    return reachable
+
+
+def collect_reachable_variables(
+    tasks: dict[str, Task],
+    reachable_task_names: set[str]
+) -> set[str]:
+    """Extract variable names used by reachable tasks.
+
+    Searches for {{ var.* }} placeholders in task definitions to determine
+    which variables are actually needed for execution.
+
+    Args:
+        tasks: Dictionary mapping task names to Task objects
+        reachable_task_names: Set of task names that will be executed
+
+    Returns:
+        Set of variable names referenced by reachable tasks
+
+    Example:
+        >>> task = Task("build", cmd="echo {{ var.version }}")
+        >>> collect_reachable_variables({"build": task}, {"build"})
+        {"version"}
+    """
+    import re
+
+    # Pattern to match {{ var.name }}
+    var_pattern = re.compile(r'\{\{\s*var\s*\.\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}')
+
+    variables = set()
+
+    for task_name in reachable_task_names:
+        task = tasks.get(task_name)
+        if task is None:
+            continue
+
+        # Search in command
+        if task.cmd:
+            for match in var_pattern.finditer(task.cmd):
+                variables.add(match.group(1))
+
+        # Search in description
+        if task.desc:
+            for match in var_pattern.finditer(task.desc):
+                variables.add(match.group(1))
+
+        # Search in working_dir
+        if task.working_dir:
+            for match in var_pattern.finditer(task.working_dir):
+                variables.add(match.group(1))
+
+        # Search in inputs
+        if task.inputs:
+            for input_pattern in task.inputs:
+                for match in var_pattern.finditer(input_pattern):
+                    variables.add(match.group(1))
+
+        # Search in outputs
+        if task.outputs:
+            for output_pattern in task.outputs:
+                for match in var_pattern.finditer(output_pattern):
+                    variables.add(match.group(1))
+
+        # Search in argument defaults
+        if task.args:
+            for arg_spec in task.args:
+                if isinstance(arg_spec, dict):
+                    for arg_dict in arg_spec.values():
+                        if isinstance(arg_dict, dict) and "default" in arg_dict:
+                            default = arg_dict["default"]
+                            if isinstance(default, str):
+                                for match in var_pattern.finditer(default):
+                                    variables.add(match.group(1))
+
+        # Search in dependency argument templates
+        if task.deps:
+            for dep_spec in task.deps:
+                if isinstance(dep_spec, dict):
+                    for arg_spec in dep_spec.values():
+                        # Positional args (list)
+                        if isinstance(arg_spec, list):
+                            for val in arg_spec:
+                                if isinstance(val, str):
+                                    for match in var_pattern.finditer(val):
+                                        variables.add(match.group(1))
+                        # Named args (dict)
+                        elif isinstance(arg_spec, dict):
+                            for val in arg_spec.values():
+                                if isinstance(val, str):
+                                    for match in var_pattern.finditer(val):
+                                        variables.add(match.group(1))
+
+    return variables
+
+
+def parse_recipe(
+    recipe_path: Path,
+    project_root: Path | None = None,
+    root_task: str | None = None
+) -> Recipe:
     """Parse a recipe file and handle imports recursively.
 
     Args:
         recipe_path: Path to the main recipe file
         project_root: Optional project root directory. If not provided, uses recipe file's parent directory.
                      When using --tasks option, this should be the current working directory.
+        root_task: Optional root task for lazy variable evaluation. If provided, only variables
+                  used by tasks reachable from root_task will be evaluated (optimization).
+                  NOTE: Currently this parameter is accepted but lazy evaluation is not yet
+                  implemented - all variables are still evaluated for backward compatibility.
 
     Returns:
         Recipe object with all tasks (including recursively imported tasks)
@@ -1021,6 +1204,14 @@ def parse_recipe(recipe_path: Path, project_root: Path | None = None) -> Recipe:
         recipe_path, namespace=None, project_root=project_root
     )
 
+    # TODO: Implement lazy variable evaluation when root_task is provided
+    # This would require:
+    # 1. Deferring variable evaluation until after task parsing
+    # 2. Collecting reachable tasks and variables
+    # 3. Evaluating only reachable variables
+    # 4. Re-substituting variables into task definitions
+    # For now, we evaluate all variables eagerly (current behavior)
+
     return Recipe(
         tasks=tasks,
         project_root=project_root,

{tasktree-0.0.13 → tasktree-0.0.15}/src/tasktree/substitution.py

@@ -5,6 +5,7 @@ and {{ env.NAME }} placeholders with their corresponding values.
 """
 
 import re
+from random import choice
 from typing import Any
 
 
@@ -15,11 +16,11 @@ PLACEHOLDER_PATTERN = re.compile(
 )
 
 
-def substitute_variables(text: str, variables: dict[str, str]) -> str:
+def substitute_variables(text: str | dict[str, Any], variables: dict[str, str]) -> str | dict[str, Any]:
     """Substitute {{ var.name }} placeholders with variable values.
 
     Args:
-        text: Text containing {{ var.name }} placeholders
+        text: Text containing {{ var.name }} placeholders, or an argument dict with elements to be substituted
         variables: Dictionary mapping variable names to their string values
 
     Returns:
@@ -28,23 +29,42 @@ def substitute_variables(text: str, variables: dict[str, str]) -> str:
     Raises:
         ValueError: If a referenced variable is not defined
     """
-    def replace_match(match: re.Match) -> str:
-        prefix = match.group(1)
-        name = match.group(2)
+    if isinstance(text, dict):
+        # The dict will only contain a single key, the value of this key should also be a dictionary, which contains
+        # the actual details of the argument.
+        assert len(text.keys()) == 1
 
-        # Only substitute var: placeholders
-        if prefix != "var":
-            return match.group(0)  # Return unchanged
+        for arg_name in text.keys():
+            # Pull out and substitute the individual fields of an argument one at a time
+            for field in  [ "default", "min", "max" ]:
+                if field in text[arg_name]:
+                    text[arg_name][field] = substitute_variables(text[arg_name][field], variables)
 
-        if name not in variables:
-            raise ValueError(
-                f"Variable '{name}' is not defined. "
-                f"Variables must be defined before use."
-            )
+            # choices is a list of things
+            if "choices" in text[arg_name]:
+                text[arg_name]["choices"] = [substitute_variables(c, variables) for c in text[arg_name]["choices"]]
 
-        return variables[name]
+            return text
+        else:
+            raise ValueError("Empty arg dictionary")
+    else:
+        def replace_match(match: re.Match) -> str:
+            prefix = match.group(1)
+            name = match.group(2)
 
-    return PLACEHOLDER_PATTERN.sub(replace_match, text)
+            # Only substitute var: placeholders
+            if prefix != "var":
+                return match.group(0)  # Return unchanged
+
+            if name not in variables:
+                raise ValueError(
+                    f"Variable '{name}' is not defined. "
+                    f"Variables must be defined before use."
+                )
+
+            return variables[name]
+
+        return PLACEHOLDER_PATTERN.sub(replace_match, text)
 
 
 def substitute_arguments(text: str, args: dict[str, Any], exported_args: set[str] | None = None) -> str:
@@ -175,6 +195,75 @@ def substitute_builtin_variables(text: str, builtin_vars: dict[str, str]) -> str
     return PLACEHOLDER_PATTERN.sub(replace_match, text)
 
 
+def substitute_dependency_args(
+    template_value: str,
+    parent_task_name: str,
+    parent_args: dict[str, Any],
+    exported_args: set[str] | None = None
+) -> str:
+    """Substitute {{ arg.* }} templates in dependency argument values.
+
+    This function substitutes parent task's arguments into dependency argument
+    templates. Only {{ arg.* }} placeholders are allowed in dependency arguments.
+
+    Args:
+        template_value: String that may contain {{ arg.* }} placeholders
+        parent_task_name: Name of parent task (for error messages)
+        parent_args: Parent task's argument values
+        exported_args: Set of parent's exported argument names
+
+    Returns:
+        String with {{ arg.* }} placeholders substituted
+
+    Raises:
+        ValueError: If template references undefined arg, uses exported arg,
+                   or contains non-arg placeholders ({{ var.* }}, {{ env.* }}, {{ tt.* }})
+
+    Example:
+        >>> substitute_dependency_args("{{ arg.mode }}", "build", {"mode": "debug"})
+        'debug'
+    """
+    # Check for disallowed placeholder types in dependency args
+    # Only {{ arg.* }} is allowed, not {{ var.* }}, {{ env.* }}, or {{ tt.* }}
+    for match in PLACEHOLDER_PATTERN.finditer(template_value):
+        prefix = match.group(1)
+        name = match.group(2)
+
+        if prefix == "var":
+            raise ValueError(
+                f"Task '{parent_task_name}': dependency argument contains {{ var.{name} }}\n"
+                f"Template: {template_value}\n\n"
+                f"Variables ({{ var.* }}) are not allowed in dependency arguments.\n"
+                f"Variables are substituted at parse time, use them directly in task definitions.\n"
+                f"In dependency arguments, only {{ arg.* }} templates are supported."
+            )
+        elif prefix == "env":
+            raise ValueError(
+                f"Task '{parent_task_name}': dependency argument contains {{ env.{name} }}\n"
+                f"Template: {template_value}\n\n"
+                f"Environment variables ({{ env.* }}) are not allowed in dependency arguments.\n"
+                f"In dependency arguments, only {{ arg.* }} templates are supported."
+            )
+        elif prefix == "tt":
+            raise ValueError(
+                f"Task '{parent_task_name}': dependency argument contains {{ tt.{name} }}\n"
+                f"Template: {template_value}\n\n"
+                f"Built-in variables ({{ tt.* }}) are not allowed in dependency arguments.\n"
+                f"In dependency arguments, only {{ arg.* }} templates are supported."
+            )
+
+    # Substitute {{ arg.* }} using parent's arguments
+    try:
+        return substitute_arguments(template_value, parent_args, exported_args)
+    except ValueError as e:
+        # Re-raise with more context
+        raise ValueError(
+            f"Task '{parent_task_name}': error in dependency argument substitution\n"
+            f"Template: {template_value}\n"
+            f"Error: {str(e)}"
+        ) from e
+
+
 def substitute_all(text: str, variables: dict[str, str], args: dict[str, Any]) -> str:
     """Substitute all placeholder types: variables, arguments, environment.