tasktree 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

tasktree/graph.py

@@ -2,8 +2,10 @@
 
 from graphlib import TopologicalSorter
 from pathlib import Path
+from typing import Any
 
-from tasktree.parser import Recipe, Task
+from tasktree.hasher import hash_args
+from tasktree.parser import Recipe, Task, DependencyInvocation, parse_dependency_spec
 
 
 class CycleError(Exception):
@@ -18,15 +20,61 @@ class TaskNotFoundError(Exception):
     pass
 
 
-def resolve_execution_order(recipe: Recipe, target_task: str) -> list[str]:
+class TaskNode:
+    """Represents a node in the dependency graph (task + arguments).
+
+    Each node represents a unique invocation of a task with specific arguments.
+    Tasks invoked with different arguments are considered different nodes.
+    """
+
+    def __init__(self, task_name: str, args: dict[str, Any] | None = None):
+        self.task_name = task_name
+        self.args = args  # Keep None as None
+
+    def __hash__(self):
+        """Hash based on task name and sorted args."""
+        # Treat None and {} as equivalent for hashing
+        if not self.args:
+            return hash(self.task_name)
+        args_hash = hash_args(self.args)
+        return hash((self.task_name, args_hash))
+
+    def __eq__(self, other):
+        """Equality based on task name and args."""
+        if not isinstance(other, TaskNode):
+            return False
+        # Treat None and {} as equivalent
+        self_args = self.args if self.args else {}
+        other_args = other.args if other.args else {}
+        return self.task_name == other.task_name and self_args == other_args
+
+    def __repr__(self):
+        if not self.args:
+            return f"TaskNode({self.task_name})"
+        args_str = ", ".join(f"{k}={v}" for k, v in sorted(self.args.items()))
+        return f"TaskNode({self.task_name}, {{{args_str}}})"
+
+    def __str__(self):
+        if not self.args:
+            return self.task_name
+        args_str = ", ".join(f"{k}={v}" for k, v in sorted(self.args.items()))
+        return f"{self.task_name}({args_str})"
+
+
+def resolve_execution_order(
+    recipe: Recipe,
+    target_task: str,
+    target_args: dict[str, Any] | None = None
+) -> list[tuple[str, dict[str, Any]]]:
     """Resolve execution order for a task and its dependencies.
 
     Args:
         recipe: Parsed recipe containing all tasks
         target_task: Name of the task to execute
+        target_args: Arguments for the target task (optional)
 
     Returns:
-        List of task names in execution order (dependencies first)
+        List of (task_name, args_dict) tuples in execution order (dependencies first)
 
     Raises:
         TaskNotFoundError: If target task or any dependency doesn't exist
@@ -35,33 +83,61 @@ def resolve_execution_order(recipe: Recipe, target_task: str) -> list[str]:
     if target_task not in recipe.tasks:
         raise TaskNotFoundError(f"Task not found: {target_task}")
 
-    # Build dependency graph
-    graph: dict[str, set[str]] = {}
+    # Build dependency graph using TaskNode objects
+    graph: dict[TaskNode, set[TaskNode]] = {}
+
+    # Track seen nodes to detect duplicates
+    seen_invocations: dict[tuple[str, str], TaskNode] = {}  # (task_name, args_hash) -> node
 
-    def build_graph(task_name: str) -> None:
+    def get_or_create_node(task_name: str, args: dict[str, Any] | None) -> TaskNode:
+        """Get existing node or create new one for this invocation."""
+        args_hash = hash_args(args) if args else ""
+        key = (task_name, args_hash)
+
+        if key not in seen_invocations:
+            seen_invocations[key] = TaskNode(task_name, args)
+        return seen_invocations[key]
+
+    def build_graph(node: TaskNode) -> None:
         """Recursively build dependency graph."""
-        if task_name in graph:
+        if node in graph:
             # Already processed
             return
 
-        task = recipe.tasks.get(task_name)
+        task = recipe.tasks.get(node.task_name)
         if task is None:
-            raise TaskNotFoundError(f"Task not found: {task_name}")
+            raise TaskNotFoundError(f"Task not found: {node.task_name}")
 
-        # Add task to graph with its dependencies
-        graph[task_name] = set(task.deps)
+        # Parse and normalize dependencies
+        dep_nodes = set()
+        for dep_spec in task.deps:
+            # Parse dependency specification
+            dep_inv = parse_dependency_spec(dep_spec, recipe)
+
+            # Create or get node for this dependency invocation
+            dep_node = get_or_create_node(dep_inv.task_name, dep_inv.args)
+            dep_nodes.add(dep_node)
+
+        # Add task to graph with its dependency nodes
+        graph[node] = dep_nodes
 
         # Recursively process dependencies
-        for dep in task.deps:
-            build_graph(dep)
+        for dep_node in dep_nodes:
+            build_graph(dep_node)
+
+    # Create root node for target task
+    root_node = get_or_create_node(target_task, target_args)
 
     # Build graph starting from target task
-    build_graph(target_task)
+    build_graph(root_node)
 
     # Use TopologicalSorter to resolve execution order
     try:
         sorter = TopologicalSorter(graph)
-        return list(sorter.static_order())
+        ordered_nodes = list(sorter.static_order())
+
+        # Convert TaskNode objects to (task_name, args_dict) tuples
+        return [(node.task_name, node.args) for node in ordered_nodes]
     except ValueError as e:
         raise CycleError(f"Dependency cycle detected: {e}")
 
@@ -87,8 +163,10 @@ def get_implicit_inputs(recipe: Recipe, task: Task) -> list[str]:
     implicit_inputs = []
 
     # Inherit from dependencies
-    for dep_name in task.deps:
-        dep_task = recipe.tasks.get(dep_name)
+    for dep_spec in task.deps:
+        # Parse dependency to get task name (ignore args for input inheritance)
+        dep_inv = parse_dependency_spec(dep_spec, recipe)
+        dep_task = recipe.tasks.get(dep_inv.task_name)
         if dep_task is None:
             continue
 
@@ -125,7 +203,7 @@ def get_implicit_inputs(recipe: Recipe, task: Task) -> list[str]:
     return implicit_inputs
 
 
-def build_dependency_tree(recipe: Recipe, target_task: str) -> dict:
+def build_dependency_tree(recipe: Recipe, target_task: str, target_args: dict[str, Any] | None = None) -> dict:
     """Build a tree structure representing dependencies for visualization.
 
     Note: This builds a true tree representation where shared dependencies may
@@ -135,6 +213,7 @@ def build_dependency_tree(recipe: Recipe, target_task: str) -> dict:
     Args:
         recipe: Parsed recipe containing all tasks
         target_task: Name of the task to build tree for
+        target_args: Arguments for the target task (optional)
 
     Returns:
         Nested dictionary representing the dependency tree
@@ -144,25 +223,44 @@ def build_dependency_tree(recipe: Recipe, target_task: str) -> dict:
 
     current_path = set()  # Track current recursion path for cycle detection
 
-    def build_tree(task_name: str) -> dict:
+    def build_tree(task_name: str, args: dict[str, Any] | None) -> dict:
         """Recursively build dependency tree."""
         task = recipe.tasks.get(task_name)
         if task is None:
             raise TaskNotFoundError(f"Task not found: {task_name}")
 
+        # Create node identifier for cycle detection
+        from tasktree.hasher import hash_args
+        args_dict = args or {}
+        node_id = (task_name, hash_args(args_dict) if args_dict else "")
+
         # Detect cycles in current recursion path
-        if task_name in current_path:
-            return {"name": task_name, "deps": [], "cycle": True}
+        if node_id in current_path:
+            display_name = task_name if not args_dict else f"{task_name}({', '.join(f'{k}={v}' for k, v in sorted(args_dict.items()))})"
+            return {"name": display_name, "deps": [], "cycle": True}
+
+        current_path.add(node_id)
+
+        # Parse dependencies
+        dep_trees = []
+        for dep_spec in task.deps:
+            dep_inv = parse_dependency_spec(dep_spec, recipe)
+            dep_tree = build_tree(dep_inv.task_name, dep_inv.args)
+            dep_trees.append(dep_tree)
 
-        current_path.add(task_name)
+        # Create display name (include args if present)
+        display_name = task_name
+        if args_dict:
+            args_str = ", ".join(f"{k}={v}" for k, v in sorted(args_dict.items()))
+            display_name = f"{task_name}({args_str})"
 
         tree = {
-            "name": task_name,
-            "deps": [build_tree(dep) for dep in task.deps],
+            "name": display_name,
+            "deps": dep_trees,
         }
 
-        current_path.remove(task_name)
+        current_path.remove(node_id)
 
         return tree
 
-    return build_tree(target_task)
+    return build_tree(target_task, target_args)

tasktree/hasher.py

@@ -3,15 +3,86 @@ import json
 from typing import Any, Optional
 
 
-def hash_task(cmd: str, outputs: list[str], working_dir: str, args: list[str], env: str = "") -> str:
+def _arg_sort_key(arg: str | dict[str, Any]) -> str:
+    """Extract the sort key from an arg for deterministic hashing.
+
+    Args:
+        arg: Either a string arg or dict arg specification
+
+    Returns:
+        The argument name to use as a sort key
+    """
+    if isinstance(arg, dict):
+        # Dict args have exactly one key - the argument name
+        # This is validated by parse_arg_spec in parser.py
+        return next(iter(arg.keys()))
+    return arg
+
+
+def _normalize_choices_lists(args: list[str | dict[str, Any]]) ->  list[str | dict[str, Any]]:
+    normalized_args = []
+    for arg in args:
+        if isinstance(arg, dict):
+            # Deep copy and sort choices if present
+            normalized = {}
+            for key, value in arg.items():
+                if isinstance(value, dict) and 'choices' in value:
+                    normalized[key] = {**value, 'choices': sorted(value['choices'], key=str)}
+                else:
+                    normalized[key] = value
+            normalized_args.append(normalized)
+        else:
+            normalized_args.append(arg)
+
+    return normalized_args
+
+
+def hash_task(
+    cmd: str,
+    outputs: list[str],
+    working_dir: str,
+    args: list[str | dict[str, Any]],
+    env: str = "",
+    deps: list[str | dict[str, Any]] | None = None
+) -> str:
+    """Hash task definition including dependencies.
+
+    Args:
+        cmd: Task command
+        outputs: Task outputs
+        working_dir: Working directory
+        args: Task argument specifications
+        env: Environment name
+        deps: Dependency specifications (optional, for dependency hash)
+
+    Returns:
+        8-character hash of task definition
+    """
     data = {
         "cmd": cmd,
         "outputs": sorted(outputs),
         "working_dir": working_dir,
-        "args": sorted(args),
+        "args": sorted(_normalize_choices_lists(args), key=_arg_sort_key),
         "env": env,
     }
 
+    # Include dependency invocation signatures if provided
+    if deps is not None:
+        # Normalize deps for hashing using JSON serialization for consistency
+        normalized_deps = []
+        for dep in deps:
+            if isinstance(dep, str):
+                # Simple string dependency
+                normalized_deps.append(dep)
+            elif isinstance(dep, dict):
+                # Dict dependency with args - normalize to canonical form
+                # Sort the dict to ensure consistent hashing
+                normalized_deps.append(dict(sorted(dep.items())))
+            else:
+                normalized_deps.append(dep)
+        # Sort using JSON serialization for consistent ordering
+        data["deps"] = sorted(normalized_deps, key=lambda x: json.dumps(x, sort_keys=True) if isinstance(x, dict) else x)
+
     serialized = json.dumps(data, sort_keys=True, separators=(",", ":"))
     return hashlib.sha256(serialized.encode()).hexdigest()[:8]