tasktree 0.0.22__py3-none-any.whl → 0.0.23__py3-none-any.whl

tasktree/docker.py

@@ -21,6 +21,7 @@ except ImportError:
 
 if TYPE_CHECKING:
     from tasktree.parser import Environment
+    from tasktree.process_runner import ProcessRunner
 
 
 class DockerError(Exception):
@@ -35,7 +36,7 @@ class DockerError(Exception):
 class DockerManager:
     """
     Manages Docker image building and container execution.
-    @athena: 1a8a919eb05d
+    @athena: f8f5c2693d84
     """
 
     def __init__(self, project_root: Path):
@@ -70,12 +71,15 @@ class DockerManager:
         # Check if os.getuid() and os.getgid() are available (Linux/macOS)
         return hasattr(os, "getuid") and hasattr(os, "getgid")
 
-    def ensure_image_built(self, env: Environment) -> tuple[str, str]:
+    def ensure_image_built(
+        self, env: Environment, process_runner: ProcessRunner
+    ) -> tuple[str, str]:
         """
         Build Docker image if not already built this invocation.
 
         Args:
         env: Environment definition with dockerfile and context
+        process_runner: ProcessRunner instance for subprocess execution
 
         Returns:
         Tuple of (image_tag, image_id)
@@ -84,7 +88,7 @@ class DockerManager:
 
         Raises:
         DockerError: If docker command not available or build fails
-        @athena: 9b3c11c29fbb
+        @athena: 42b53d2685e0
         """
         # Check if already built this invocation
         if env.name in self._built_images:
@@ -119,7 +123,7 @@ class DockerManager:
 
             docker_build_cmd.append(str(context_path))
 
-            subprocess.run(
+            process_runner.run(
                 docker_build_cmd,
                 check=True,
                 capture_output=False,  # Show build output to user
@@ -147,6 +151,7 @@ class DockerManager:
         cmd: str,
         working_dir: Path,
         container_working_dir: str,
+        process_runner: ProcessRunner,
     ) -> subprocess.CompletedProcess:
         """
         Execute command inside Docker container.
@@ -156,16 +161,17 @@ class DockerManager:
         cmd: Command to execute
         working_dir: Host working directory (for resolving relative volume paths)
         container_working_dir: Working directory inside container
+        process_runner: ProcessRunner instance to use for subprocess execution
 
         Returns:
         CompletedProcess from subprocess.run
 
         Raises:
         DockerError: If docker run fails
-        @athena: f24fc9c27f81
+        @athena: ef024ea2c182
         """
         # Ensure image is built (returns tag and ID)
-        image_tag, image_id = self.ensure_image_built(env)
+        image_tag, image_id = self.ensure_image_built(env, process_runner)
 
         # Build docker run command
         docker_cmd = ["docker", "run", "--rm"]
@@ -208,7 +214,7 @@ class DockerManager:
 
         # Execute
         try:
-            result = subprocess.run(
+            result = process_runner.run(
                 docker_cmd,
                 cwd=working_dir,
                 check=True,
@@ -361,7 +367,7 @@ def parse_dockerignore(dockerignore_path: Path) -> PathSpec | None:
 
     Returns:
     PathSpec object for matching, or None if file doesn't exist or pathspec not available
-    @athena: 62bc07a3c6d0
+    @athena: 13fca9ee5a73
     """
     if pathspec is None:
         # pathspec library not available - can't parse .dockerignore

tasktree/executor.py

@@ -2,16 +2,18 @@
 
 from __future__ import annotations
 
+import io
 import os
 import platform
 import stat
 import subprocess
+import sys
 import tempfile
 import time
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 
 from tasktree import docker as docker_module
 from tasktree.graph import (
@@ -21,7 +23,9 @@ from tasktree.graph import (
     resolve_self_references,
 )
 from tasktree.hasher import hash_args, hash_task, make_cache_key
+from tasktree.logging import Logger, LogLevel
 from tasktree.parser import Recipe, Task, Environment
+from tasktree.process_runner import ProcessRunner, TaskOutputTypes
 from tasktree.state import StateManager, TaskState
 from tasktree.hasher import hash_environment_definition
 
@@ -53,7 +57,7 @@ class ExecutionError(Exception):
 class Executor:
     """
     Executes tasks with incremental execution logic.
-    @athena: 88e82151721d
+    @athena: 779b12944194
     """
 
     # Protected environment variables that cannot be overridden by exported args
@@ -68,17 +72,27 @@ class Executor:
         "LOGNAME",
     }
 
-    def __init__(self, recipe: Recipe, state_manager: StateManager):
+    def __init__(
+        self,
+        recipe: Recipe,
+        state_manager: StateManager,
+        logger: Logger,
+        process_runner_factory: Callable[[TaskOutputTypes, Logger], ProcessRunner]
+    ):
         """
         Initialize executor.
 
         Args:
         recipe: Parsed recipe containing all tasks
         state_manager: State manager for tracking task execution
-        @athena: 21b65db48bca
+        logger_fn: Logger function for output (matches Console.print signature)
+        process_runner_factory: Factory function for creating ProcessRunner instances
+        @athena: d09e6a537c99
         """
         self.recipe = recipe
         self.state = state_manager
+        self.logger = logger
+        self._process_runner_factory = process_runner_factory
         self.docker_manager = docker_module.DockerManager(recipe.project_root)
 
     @staticmethod
@@ -91,7 +105,7 @@ class Executor:
 
         Returns:
         True if task has at least one regular (non-exported) argument, False otherwise
-        @athena: a4c7816bfe61
+        @athena: c529cda63cce
         """
         if not task.args:
             return False
@@ -123,7 +137,7 @@ class Executor:
 
         Returns:
         Dictionary containing only regular (non-exported) arguments
-        @athena: 974e5e32bbd7
+        @athena: 1ae863406335
         """
         if not task.args or not task_args:
             return {}
@@ -160,7 +174,7 @@ class Executor:
 
         Raises:
         ExecutionError: If any built-in variable fails to resolve
-        @athena: 3b4c0ec70ad7
+        @athena: a0c1316fd713
         """
         import os
 
@@ -214,7 +228,7 @@ class Executor:
 
         Raises:
         ExecutionError: If any built-in variable fails to resolve
-        @athena: bb8c385cb0a5
+        @athena: 7f6203e8d617
         """
         # Get early builtin vars (those that don't depend on working_dir)
         builtin_vars = self._collect_early_builtin_variables(task, timestamp)
@@ -343,6 +357,7 @@ class Executor:
         self,
         task: Task,
         args_dict: dict[str, Any],
+        process_runner: ProcessRunner,
         force: bool = False,
     ) -> TaskStatus:
         """
@@ -361,11 +376,12 @@ class Executor:
         Args:
         task: Task to check
         args_dict: Arguments for this task execution
+        process_runner: ProcessRunner instance for subprocess execution
         force: If True, ignore freshness and force execution
 
         Returns:
         TaskStatus indicating whether task will run and why
-        @athena: 7252f5db8a4d
+        @athena: 03922de1bd23
         """
         # If force flag is set, always run
         if force:
@@ -406,8 +422,9 @@ class Executor:
                 reason="never_run",
             )
 
-        # Check if environment definition has changed
-        env_changed = self._check_environment_changed(task, cached_state, effective_env)
+        env_changed = self._check_environment_changed(
+            task, cached_state, effective_env, process_runner
+        )
         if env_changed:
             return TaskStatus(
                 task_name=task.name,
@@ -446,9 +463,21 @@ class Executor:
             last_run=datetime.fromtimestamp(cached_state.last_run),
         )
 
+    @staticmethod
+    def _get_task_output_type(user_inputted_value: TaskOutputTypes | None, task: Task) -> TaskOutputTypes:
+        if user_inputted_value is None:
+            if task.task_output is not None:
+                return task.task_output
+
+            return TaskOutputTypes.ALL
+
+        return user_inputted_value
+
+
     def execute_task(
         self,
         task_name: str,
+        user_inputted_task_output_types: TaskOutputTypes | None,
         args_dict: dict[str, Any] | None = None,
         force: bool = False,
         only: bool = False,
@@ -458,6 +487,7 @@ class Executor:
 
         Args:
         task_name: Name of task to execute
+        task_output_type: TaskOutputTypes enum value for controlling subprocess output
         args_dict: Arguments to pass to the task
         force: If True, ignore freshness and re-run all tasks
         only: If True, run only the specified task without dependencies (implies force=True)
@@ -467,7 +497,7 @@ class Executor:
 
         Raises:
         ExecutionError: If task execution fails
-        @athena: 1c293ee6a6fa
+        @athena: 4773fc590d9a
         """
         if args_dict is None:
             args_dict = {}
@@ -500,8 +530,12 @@ class Executor:
             # Convert None to {} for internal use (None is used to distinguish simple deps in graph)
             args_dict_for_execution = task_args if task_args is not None else {}
 
+            process_runner = self._process_runner_factory(self._get_task_output_type(user_inputted_task_output_types, task), self.logger)
+
             # Check if task needs to run (based on CURRENT filesystem state)
-            status = self.check_task_status(task, args_dict_for_execution, force=force)
+            status = self.check_task_status(
+                task, args_dict_for_execution, process_runner, force=force
+            )
 
             # Use a key that includes args for status tracking
             # Only include regular (non-exported) args in status key for parameterized dependencies
@@ -532,28 +566,29 @@ class Executor:
             if status.will_run:
                 # Warn if re-running due to missing outputs
                 if status.reason == "outputs_missing":
-                    import sys
-
-                    print(
+                    self.logger.log(
+                        LogLevel.WARN,
                         f"Warning: Re-running task '{name}' because declared outputs are missing",
-                        file=sys.stderr,
                     )
 
-                self._run_task(task, args_dict_for_execution)
+                self._run_task(task, args_dict_for_execution, process_runner)
 
         return statuses
 
-    def _run_task(self, task: Task, args_dict: dict[str, Any]) -> None:
+    def _run_task(
+        self, task: Task, args_dict: dict[str, Any], process_runner: ProcessRunner
+    ) -> None:
         """
         Execute a single task.
 
         Args:
         task: Task to execute
         args_dict: Arguments to substitute in command
+        process_runner: ProcessRunner instance for subprocess execution
 
         Raises:
         ExecutionError: If task execution fails
-        @athena: 4b49652a7afd
+        @athena: b5abffeef10a
         """
         # Capture timestamp at task start for consistency (in UTC)
         task_start_time = datetime.now(timezone.utc)
@@ -611,17 +646,30 @@ class Executor:
             env = self.recipe.get_environment(env_name)
 
         # Execute command
-        print(f"Running: {task.name}")
+        self.logger.log(LogLevel.INFO, f"Running: {task.name}")
 
         # Route to Docker execution or regular execution
         if env and env.dockerfile:
             # Docker execution path
-            self._run_task_in_docker(task, env, cmd, working_dir, exported_env_vars)
+            self._run_task_in_docker(
+                task,
+                env,
+                cmd,
+                working_dir,
+                process_runner,
+                exported_env_vars,
+            )
         else:
             # Regular execution path - use unified script-based execution
             shell, preamble = self._resolve_environment(task)
             self._run_command_as_script(
-                cmd, working_dir, task.name, shell, preamble, exported_env_vars
+                cmd,
+                working_dir,
+                task.name,
+                shell,
+                preamble,
+                process_runner,
+                exported_env_vars,
             )
 
         # Update state
@@ -634,6 +682,7 @@ class Executor:
         task_name: str,
         shell: str,
         preamble: str,
+        process_runner: ProcessRunner,
         exported_env_vars: dict[str, str] | None = None,
     ) -> None:
         """
@@ -649,12 +698,13 @@ class Executor:
         task_name: Task name (for error messages)
         shell: Shell to use for script execution
         preamble: Preamble text to prepend to script
+        process_runner: ProcessRunner instance to use for subprocess execution
         exported_env_vars: Exported arguments to set as environment variables
 
         Raises:
         ExecutionError: If command execution fails
         @athena: TBD
-        @athena: 96e85dc15b5c
+        @athena: 228cc00e7665
         """
         # Prepare environment with exported args
         env = self._prepare_env_with_exports(exported_env_vars)
@@ -694,13 +744,56 @@ class Executor:
 
             # Execute script file
             try:
-                subprocess.run(
-                    [script_path],
-                    cwd=working_dir,
-                    check=True,
-                    capture_output=False,
-                    env=env,
-                )
+                # Check if stdout/stderr support fileno() (real file descriptors)
+                # CliRunner uses StringIO which has fileno() method but raises when called
+                def supports_fileno(stream):
+                    """Check if a stream has a working fileno() method."""
+                    try:
+                        stream.fileno()
+                        return True
+                    except (AttributeError, OSError, io.UnsupportedOperation):
+                        return False
+
+                # Determine output targets based on task_output mode
+                # For "all" mode: show everything
+                # Future modes: use subprocess.DEVNULL for suppression
+                should_suppress = False  # Will be: self.task_output == "none", etc.
+
+                if should_suppress:
+                    stdout_target = subprocess.DEVNULL
+                    stderr_target = subprocess.DEVNULL
+                else:
+                    stdout_target = sys.stdout
+                    stderr_target = sys.stderr
+
+                # If streams support fileno, pass target streams directly (most efficient)
+                # Otherwise capture and manually write (CliRunner compatibility)
+                if not should_suppress and not (
+                    supports_fileno(sys.stdout) and supports_fileno(sys.stderr)
+                ):
+                    # CliRunner path: capture and write manually
+                    result = process_runner.run(
+                        [script_path],
+                        cwd=working_dir,
+                        check=True,
+                        capture_output=True,
+                        text=True,
+                        env=env,
+                    )
+                    if result.stdout:
+                        sys.stdout.write(result.stdout)
+                    if result.stderr:
+                        sys.stderr.write(result.stderr)
+                else:
+                    # Normal execution path: use target streams (including DEVNULL when suppressing)
+                    process_runner.run(
+                        [script_path],
+                        cwd=working_dir,
+                        check=True,
+                        stdout=stdout_target,
+                        stderr=stderr_target,
+                        env=env,
+                    )
             except subprocess.CalledProcessError as e:
                 raise ExecutionError(
                     f"Task '{task_name}' failed with exit code {e.returncode}"
@@ -727,7 +820,7 @@ class Executor:
 
         Raises:
         ValueError: If builtin variable or environment variable is not defined
-        @athena: 21e2ccd27dbb
+        @athena: eba6e3d62062
         """
         from dataclasses import replace
 
@@ -798,6 +891,7 @@ class Executor:
         env: Any,
         cmd: str,
         working_dir: Path,
+        process_runner: ProcessRunner,
         exported_env_vars: dict[str, str] | None = None,
     ) -> None:
         """
@@ -808,11 +902,13 @@ class Executor:
         env: Docker environment configuration
         cmd: Command to execute
         working_dir: Host working directory
+        process_runner: ProcessRunner instance to use for subprocess execution
         exported_env_vars: Exported arguments to set as environment variables
+        task_output: Control task subprocess output (all, out, err, on-err, none)
 
         Raises:
         ExecutionError: If Docker execution fails
-        @athena: fe972e4c97a3
+        @athena: 61725a57e304
         """
         # Get builtin variables for substitution in environment fields
         task_start_time = datetime.now(timezone.utc)
@@ -852,6 +948,7 @@ class Executor:
                 cmd=cmd,
                 working_dir=working_dir,
                 container_working_dir=container_working_dir,
+                process_runner=process_runner,
             )
         except docker_module.DockerError as e:
             raise ExecutionError(str(e)) from e
@@ -868,7 +965,7 @@ class Executor:
 
         Raises:
         ExecutionError: If {{ tt.working_dir }} placeholder is found
-        @athena: 617a0c609f4d
+        @athena: 82822f02716a
         """
         import re
 
@@ -977,7 +1074,11 @@ class Executor:
 
     # TODO: Understand why task isn't used
     def _check_environment_changed(
-        self, task: Task, cached_state: TaskState, env_name: str
+        self,
+        task: Task,
+        cached_state: TaskState,
+        env_name: str,
+        process_runner: ProcessRunner,
     ) -> bool:
         """
         Check if environment definition has changed since last run.
@@ -989,10 +1090,11 @@ class Executor:
         task: Task to check
         cached_state: Cached state from previous run
         env_name: Effective environment name (from _get_effective_env_name)
+        process_runner: ProcessRunner instance for subprocess execution
 
         Returns:
         True if environment definition changed, False otherwise
-        @athena: 052561b75455
+        @athena: e206e104150a
         """
         # If using platform default (no environment), no definition to track
         if not env_name:
@@ -1023,13 +1125,19 @@ class Executor:
 
         # For Docker environments, also check if image ID changed
         if env.dockerfile:
-            return self._check_docker_image_changed(env, cached_state, env_name)
+            return self._check_docker_image_changed(
+                env, cached_state, env_name, process_runner
+            )
 
         # Shell environment with unchanged hash
         return False
 
     def _check_docker_image_changed(
-        self, env: Environment, cached_state: TaskState, env_name: str
+        self,
+        env: Environment,
+        cached_state: TaskState,
+        env_name: str,
+        process_runner: ProcessRunner,
     ) -> bool:
         """
         Check if Docker image ID has changed.
@@ -1041,14 +1149,17 @@ class Executor:
         env: Docker environment definition
         cached_state: Cached state from previous run
         env_name: Environment name
+        process_runner: ProcessRunner instance for subprocess execution
 
         Returns:
         True if image ID changed, False otherwise
-        @athena: 0443710cf356
+        @athena: bc954288e4ad
         """
         # Build/ensure image is built and get its ID
         try:
-            image_tag, current_image_id = self.docker_manager.ensure_image_built(env)
+            image_tag, current_image_id = self.docker_manager.ensure_image_built(
+                env, process_runner
+            )
         except Exception:
             # If we can't build, treat as changed (will fail later with better error)
             return True
@@ -1243,7 +1354,7 @@ class Executor:
     def _update_state(self, task: Task, args_dict: dict[str, Any]) -> None:
         """
         Update state after task execution.
-        @athena: 1fcfdfcb9be9
+        @athena: f4d3efdaac7c
         """
         cache_key = self._cache_key(task, args_dict)
         input_state = self._input_files_to_modified_times(task)
@@ -1261,6 +1372,9 @@ class Executor:
         self.state.save()
 
     def _cache_key(self, task: Task, args_dict: dict[str, Any]) -> str:
+        """
+        @athena: d20ce4090741
+        """
         effective_env = self._get_effective_env_name(task)
         task_hash = hash_task(
             task.cmd,
@@ -1274,6 +1388,9 @@ class Executor:
         return make_cache_key(task_hash, args_hash)
 
     def _input_files_to_modified_times(self, task: Task) -> dict[str, float]:
+        """
+        @athena: 7e5ba779a41f
+        """
         input_files = self._expand_globs(self._get_all_inputs(task), task.working_dir)
 
         input_state = {}
@@ -1291,6 +1408,9 @@ class Executor:
     def _docker_inputs_to_modified_times(
         self, env_name: str, env: Environment
     ) -> dict[str, float]:
+        """
+        @athena: bfe53b0d56cd
+        """
         input_state = dict()
         # Record Dockerfile mtime
         dockerfile_path = self.recipe.project_root / env.dockerfile

tasktree/graph.py

@@ -98,7 +98,7 @@ def resolve_dependency_invocation(
     ...     recipe
     ... )
     DependencyInvocation("build", {"mode": "production"})
-    @athena: 968bae796809
+    @athena: dd9a84821159
     """
     # Simple string case - no args to substitute
     if isinstance(dep_spec, str):
@@ -260,7 +260,7 @@ def resolve_execution_order(
     Raises:
     TaskNotFoundError: If target task or any dependency doesn't exist
     CycleError: If a dependency cycle is detected
-    @athena: b4443e1cb45d
+    @athena: 687f627efc75
     """
     if target_task not in recipe.tasks:
         raise TaskNotFoundError(f"Task not found: {target_task}")
@@ -607,7 +607,7 @@ def build_dependency_tree(
 
     Returns:
     Nested dictionary representing the dependency tree
-    @athena: 570e5c663887
+    @athena: 8c853b393bdb
     """
     if target_task not in recipe.tasks:
         raise TaskNotFoundError(f"Task not found: {target_task}")

tasktree/hasher.py

@@ -35,12 +35,12 @@ def _normalize_choices_lists(
     Normalize argument choices lists by sorting them for deterministic hashing.
 
     Args:
-        args: List of argument specifications (strings or dicts)
+    args: List of argument specifications (strings or dicts)
 
     Returns:
-        List of argument specs with sorted choices lists
+    List of argument specs with sorted choices lists
 
-    @athena: 7512379275e3
+    @athena: dc34b6fb09a6
     """
     normalized_args = []
     for arg in args:
@@ -114,7 +114,7 @@ def hash_task(
 
     Returns:
     8-character hash of task definition
-    @athena: 7a461d51a8bb
+    @athena: 815a47cf1af0
     """
     data = {
         "cmd": cmd,
@@ -173,7 +173,7 @@ def hash_environment_definition(env) -> str:
 
     Returns:
     16-character hash of environment definition
-    @athena: 2de34f1a0b4a
+    @athena: a54f6c171ba9
     """
     # Import inside function to avoid circular dependency