tasktree 0.0.21__py3-none-any.whl → 0.0.22__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.
@@ -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.
@@ -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.
 
@@ -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,7 +28,9 @@ 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.
 
@@ -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.
@@ -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]
@@ -168,7 +176,6 @@ def hash_environment_definition(env) -> str:
     @athena: 2de34f1a0b4a
     """
     # 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