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

tasktree/graph.py

@@ -4,7 +4,6 @@ Dependency resolution using topological sorting.
 """
 
 from graphlib import TopologicalSorter
-from pathlib import Path
 from typing import Any
 
 from tasktree.hasher import hash_args
@@ -13,7 +12,6 @@ from tasktree.parser import (
     Task,
     DependencyInvocation,
     parse_dependency_spec,
-    parse_arg_spec,
 )
 from tasktree.substitution import substitute_dependency_args
 
@@ -58,7 +56,7 @@ def resolve_dependency_invocation(
     parent_task_name: str,
     parent_args: dict[str, Any],
     parent_exported_args: set[str],
-    recipe: Recipe
+    recipe: Recipe,
 ) -> DependencyInvocation:
     """
     Parse dependency specification and substitute parent argument templates.
@@ -100,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):
@@ -246,9 +244,7 @@ class TaskNode:
 
 
 def resolve_execution_order(
-    recipe: Recipe,
-    target_task: str,
-    target_args: dict[str, Any] | None = None
+    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.
@@ -264,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}")
@@ -273,7 +269,9 @@ def resolve_execution_order(
     graph: dict[TaskNode, set[TaskNode]] = {}
 
     # Track seen nodes to detect duplicates
-    seen_invocations: dict[tuple[str, str], TaskNode] = {}  # (task_name, args_hash) -> node
+    seen_invocations: dict[
+        tuple[str, str], TaskNode
+    ] = {}  # (task_name, args_hash) -> node
 
     def get_or_create_node(task_name: str, args: dict[str, Any] | None) -> TaskNode:
         """Get existing node or create new one for this invocation."""
@@ -307,7 +305,7 @@ def resolve_execution_order(
                 parent_task_name=node.task_name,
                 parent_args=node.args or {},
                 parent_exported_args=parent_exported_args,
-                recipe=recipe
+                recipe=recipe,
             )
 
             # Create or get node for this dependency invocation
@@ -592,7 +590,9 @@ def get_implicit_inputs(recipe: Recipe, task: Task) -> list[str]:
     return implicit_inputs
 
 
-def build_dependency_tree(recipe: Recipe, target_task: str, target_args: dict[str, Any] | None = None) -> 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.
 
@@ -607,7 +607,7 @@ def build_dependency_tree(recipe: Recipe, target_task: str, target_args: dict[st
 
     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}")
@@ -622,12 +622,17 @@ def build_dependency_tree(recipe: Recipe, target_task: str, target_args: dict[st
 
         # 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 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()))})"
+            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)

tasktree/hasher.py

@@ -28,17 +28,19 @@ def _arg_sort_key(arg: str | dict[str, Any]) -> str:
     return arg
 
 
-def _normalize_choices_lists(args: list[str | dict[str, Any]]) ->  list[str | dict[str, Any]]:
+def _normalize_choices_lists(
+    args: list[str | dict[str, Any]],
+) -> list[str | dict[str, Any]]:
     """
     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:
@@ -46,8 +48,11 @@ def _normalize_choices_lists(args: list[str | dict[str, Any]]) ->  list[str | di
             # 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)}
+                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)
@@ -94,7 +99,7 @@ def hash_task(
     working_dir: str,
     args: list[str | dict[str, Any]],
     env: str = "",
-    deps: list[str | dict[str, Any]] | None = None
+    deps: list[str | dict[str, Any]] | None = None,
 ) -> str:
     """
     Hash task definition including dependencies.
@@ -109,7 +114,7 @@ def hash_task(
 
     Returns:
     8-character hash of task definition
-    @athena: 7a461d51a8bb
+    @athena: 815a47cf1af0
     """
     data = {
         "cmd": cmd,
@@ -134,7 +139,10 @@ def hash_task(
             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)
+        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]
@@ -165,10 +173,9 @@ def hash_environment_definition(env) -> str:
 
     Returns:
     16-character hash of environment definition
-    @athena: 2de34f1a0b4a
+    @athena: a54f6c171ba9
     """
     # Import inside function to avoid circular dependency
-    from tasktree.parser import Environment
 
     # Handle args - can be list (shell args) or dict (docker build args)
     args_value = env.args

tasktree/logging.py

@@ -0,0 +1,112 @@
+"""Logging infrastructure for Task Tree.
+
+Provides a Logger interface for dependency injection of logging functionality.
+"""
+
+from __future__ import annotations
+
+import enum
+from abc import abstractmethod
+
+
+class LogLevel(enum.Enum):
+    """
+    Log verbosity levels for tasktree diagnostic messages.
+
+    Lower numeric values represent higher severity / less verbosity.
+    @athena: 3b2d8a378440
+    """
+
+    FATAL = 0  # Only unrecoverable errors (malformed task files, missing dependencies)
+    ERROR = 1  # Fatal errors plus task execution failures
+    WARN = 2  # Errors plus warnings about deprecated features, configuration issues
+    INFO = 3  # Warnings plus normal execution progress (default)
+    DEBUG = 4  # Info plus variable values, resolved paths, environment details
+    TRACE = 5  # Debug plus fine-grained execution tracing
+
+
+class Logger:
+    """
+    Abstract base class for logging implementations.
+
+    Provides a level-based logging interface with stack-based level management.
+    Concrete implementations must define how messages are output (e.g., to console, file, etc.).
+    @athena: fdcd08796011
+    """
+
+    @abstractmethod
+    def log(self, level: LogLevel, *args, **kwargs) -> None:
+        """
+        Log a message at the specified level.
+
+        Args:
+        level: The severity level of the message
+        *args: Positional arguments to log (strings, Rich objects, etc.)
+        **kwargs: Keyword arguments for formatting (e.g., style, justify)
+        @athena: 4563ae920ff4
+        """
+        pass
+
+    @abstractmethod
+    def push_level(self, level: LogLevel) -> None:
+        """
+        Push a new log level onto the level stack.
+
+        Messages below this level will be filtered out until pop_level() is called.
+        Useful for temporarily increasing verbosity in specific code sections.
+
+        Args:
+        level: The new log level to use
+        @athena: c73ac375d30a
+        """
+        pass
+
+    @abstractmethod
+    def pop_level(self) -> LogLevel:
+        """
+        Pop the current log level from the stack and return to the previous level.
+
+        Returns:
+        The log level that was popped
+
+        Raises:
+        RuntimeError: If attempting to pop the base (initial) log level
+        @athena: d4721a34516f
+        """
+        pass
+
+    def fatal(self, *args, **kwargs):
+        """
+        @athena: 951c9c5d4f3b
+        """
+        self.log(LogLevel.FATAL, *args, **kwargs)
+
+    def error(self, *args, **kwargs):
+        """
+        @athena: 7125264a8ce1
+        """
+        self.log(LogLevel.ERROR, *args, **kwargs)
+
+    def warn(self, *args, **kwargs):
+        """
+        @athena: 5a70af1bb5b4
+        """
+        self.log(LogLevel.WARN, *args, **kwargs)
+
+    def info(self, *args, **kwargs):
+        """
+        @athena: cdb5381023a6
+        """
+        self.log(LogLevel.INFO, *args, **kwargs)
+
+    def debug(self, *args, **kwargs):
+        """
+        @athena: ddfd0e359f09
+        """
+        self.log(LogLevel.DEBUG, *args, **kwargs)
+
+    def trace(self, *args, **kwargs):
+        """
+        @athena: 4f615a15562c
+        """
+        self.log(LogLevel.TRACE, *args, **kwargs)