tasktree 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

tasktree/graph.py

@@ -1,6 +1,7 @@
 """Dependency resolution using topological sorting."""
 
 from graphlib import TopologicalSorter
+from pathlib import Path
 
 from tasktree.parser import Recipe, Task
 
@@ -71,16 +72,21 @@ def get_implicit_inputs(recipe: Recipe, task: Task) -> list[str]:
     Tasks automatically inherit inputs from dependencies:
     1. All outputs from dependency tasks become implicit inputs
     2. All inputs from dependency tasks that don't declare outputs are inherited
+    3. If task uses a Docker environment, Docker artifacts become implicit inputs:
+       - Dockerfile
+       - .dockerignore (if present)
+       - Special markers for context directory and base image digests
 
     Args:
         recipe: Parsed recipe containing all tasks
         task: Task to get implicit inputs for
 
     Returns:
-        List of glob patterns for implicit inputs
+        List of glob patterns for implicit inputs, including Docker-specific markers
     """
     implicit_inputs = []
 
+    # Inherit from dependencies
     for dep_name in task.deps:
         dep_task = recipe.tasks.get(dep_name)
         if dep_task is None:
@@ -93,6 +99,29 @@ def get_implicit_inputs(recipe: Recipe, task: Task) -> list[str]:
         elif dep_task.inputs:
             implicit_inputs.extend(dep_task.inputs)
 
+    # Add Docker-specific implicit inputs if task uses Docker environment
+    env_name = task.env or recipe.default_env
+    if env_name:
+        env = recipe.get_environment(env_name)
+        if env and env.dockerfile:
+            # Add Dockerfile as input
+            implicit_inputs.append(env.dockerfile)
+
+            # Add .dockerignore if it exists in context directory
+            context_path = recipe.project_root / env.context
+            dockerignore_path = context_path / ".dockerignore"
+            if dockerignore_path.exists():
+                relative_dockerignore = str(
+                    dockerignore_path.relative_to(recipe.project_root)
+                )
+                implicit_inputs.append(relative_dockerignore)
+
+            # Add special markers for context directory and digest tracking
+            # These are tracked differently in state management (not file paths)
+            # The executor will handle these specially
+            implicit_inputs.append(f"_docker_context_{env.context}")
+            implicit_inputs.append(f"_docker_dockerfile_{env.dockerfile}")
+
     return implicit_inputs
 
 

tasktree/hasher.py

@@ -3,12 +3,46 @@ 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 = "") -> str:
     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,
     }
 
@@ -21,6 +55,33 @@ def hash_args(args_dict: dict[str, Any]) -> str:
     return hashlib.sha256(serialized.encode()).hexdigest()[:8]
 
 
+def hash_environment_definition(env) -> str:
+    """Hash environment definition fields that affect task execution.
+
+    Args:
+        env: Environment to hash
+
+    Returns:
+        16-character hash of environment definition
+    """
+    # Import inside function to avoid circular dependency
+    from tasktree.parser import Environment
+
+    data = {
+        "shell": env.shell,
+        "args": sorted(env.args),  # Sort for determinism
+        "preamble": env.preamble,
+        "dockerfile": env.dockerfile,
+        "context": env.context,
+        "volumes": sorted(env.volumes),
+        "ports": sorted(env.ports),
+        "env_vars": dict(sorted(env.env_vars.items())),
+        "working_dir": env.working_dir,
+    }
+    serialized = json.dumps(data, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(serialized.encode()).hexdigest()[:16]
+
+
 def make_cache_key(task_hash: str, args_hash: Optional[str] = None) -> str:
     if args_hash:
         return f"{task_hash}__{args_hash}"