tasktree 0.0.19__py3-none-any.whl → 0.0.20__py3-none-any.whl

tasktree/__init__.py

@@ -15,6 +15,7 @@ from tasktree.graph import (
     get_implicit_inputs,
     resolve_dependency_output_references,
     resolve_execution_order,
+    resolve_self_references,
 )
 from tasktree.hasher import hash_args, hash_task, make_cache_key
 from tasktree.parser import Recipe, Task, find_recipe_file, parse_arg_spec, parse_recipe
@@ -31,6 +32,7 @@ __all__ = [
     "get_implicit_inputs",
     "resolve_dependency_output_references",
     "resolve_execution_order",
+    "resolve_self_references",
     "hash_args",
     "hash_task",
     "make_cache_key",

tasktree/cli.py

@@ -14,7 +14,7 @@ from rich.tree import Tree
 
 from tasktree import __version__
 from tasktree.executor import Executor
-from tasktree.graph import build_dependency_tree, resolve_execution_order, resolve_dependency_output_references
+from tasktree.graph import build_dependency_tree, resolve_execution_order, resolve_dependency_output_references, resolve_self_references
 from tasktree.hasher import hash_task, hash_args
 from tasktree.parser import Recipe, find_recipe_file, parse_arg_spec, parse_recipe
 from tasktree.state import StateManager
@@ -464,9 +464,17 @@ def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = Fal
     # This is important for correct state pruning after template substitution
     execution_order = resolve_execution_order(recipe, task_name, args_dict)
 
-    # Resolve dependency output references in topological order
-    # This substitutes {{ dep.*.outputs.* }} templates before execution
-    resolve_dependency_output_references(recipe, execution_order)
+    try:
+        # Resolve dependency output references in topological order
+        # This substitutes {{ dep.*.outputs.* }} templates before execution
+        resolve_dependency_output_references(recipe, execution_order)
+
+        # Resolve self-references in topological order
+        # This substitutes {{ self.inputs.* }} and {{ self.outputs.* }} templates
+        resolve_self_references(recipe, execution_order)
+    except ValueError as e:
+        console.print(f"[red]Error in task template: {e}[/red]")
+        raise typer.Exit(1)
 
     # Prune state based on tasks that will actually execute (with their specific arguments)
     # This ensures template-substituted dependencies are handled correctly

tasktree/executor.py

@@ -14,7 +14,7 @@ from pathlib import Path
 from typing import Any
 
 from tasktree import docker as docker_module
-from tasktree.graph import get_implicit_inputs, resolve_execution_order, resolve_dependency_output_references
+from tasktree.graph import get_implicit_inputs, resolve_execution_order, resolve_dependency_output_references, resolve_self_references
 from tasktree.hasher import hash_args, hash_task, make_cache_key
 from tasktree.parser import Recipe, Task, Environment
 from tasktree.state import StateManager, TaskState
@@ -437,6 +437,10 @@ class Executor:
         # This substitutes {{ dep.*.outputs.* }} templates before execution
         resolve_dependency_output_references(self.recipe, execution_order)
 
+        # Resolve self-references in topological order
+        # This substitutes {{ self.inputs.* }} and {{ self.outputs.* }} templates
+        resolve_self_references(self.recipe, execution_order)
+
         # Single phase: Check and execute incrementally
         statuses: dict[str, TaskStatus] = {}
         for name, task_args in execution_order:
@@ -861,7 +865,15 @@ class Executor:
         Returns:
             List of input glob patterns
         """
-        all_inputs = list(task.inputs)
+        # Extract paths from inputs (handle both anonymous strings and named dicts)
+        all_inputs = []
+        for inp in task.inputs:
+            if isinstance(inp, str):
+                all_inputs.append(inp)
+            elif isinstance(inp, dict):
+                # Named input - extract the path value(s)
+                all_inputs.extend(inp.values())
+
         implicit_inputs = get_implicit_inputs(self.recipe, task)
         all_inputs.extend(implicit_inputs)
         return all_inputs

tasktree/graph.py

@@ -414,6 +414,67 @@ def resolve_dependency_output_references(
         resolved_tasks[task_name] = task
 
 
+def resolve_self_references(
+    recipe: Recipe,
+    ordered_tasks: list[tuple[str, dict[str, Any]]],
+) -> None:
+    """Resolve {{ self.inputs.name }} and {{ self.outputs.name }} references.
+
+    This function walks through tasks and resolves self-references to task's own
+    inputs/outputs. Must be called AFTER resolve_dependency_output_references()
+    so that dependency outputs are already resolved in output paths.
+
+    Args:
+        recipe: Recipe containing task definitions
+        ordered_tasks: List of (task_name, args) tuples in topological order
+
+    Raises:
+        ValueError: If self-reference cannot be resolved (missing name, etc.)
+
+    Example:
+        If task.cmd contains "{{ self.inputs.src }}" and task has input {src: "*.txt"},
+        it will be resolved to "*.txt" (literal string, no glob expansion).
+    """
+    from tasktree.substitution import substitute_self_references
+
+    for task_name, task_args in ordered_tasks:
+        task = recipe.tasks.get(task_name)
+        if task is None:
+            continue
+
+        # Resolve self-references in command
+        if task.cmd:
+            task.cmd = substitute_self_references(
+                task.cmd,
+                task_name,
+                task._input_map,
+                task._output_map,
+            )
+
+        # Resolve self-references in working_dir
+        if task.working_dir:
+            task.working_dir = substitute_self_references(
+                task.working_dir,
+                task_name,
+                task._input_map,
+                task._output_map,
+            )
+
+        # Resolve self-references in argument defaults
+        if task.args:
+            for arg_spec in task.args:
+                if isinstance(arg_spec, dict):
+                    for arg_name, arg_details in arg_spec.items():
+                        if isinstance(arg_details, dict) and "default" in arg_details:
+                            if isinstance(arg_details["default"], str):
+                                arg_details["default"] = substitute_self_references(
+                                    arg_details["default"],
+                                    task_name,
+                                    task._input_map,
+                                    task._output_map,
+                                )
+
+
 def get_implicit_inputs(recipe: Recipe, task: Task) -> list[str]:
     """Get implicit inputs for a task based on its dependencies.
 

tasktree/parser.py

@@ -57,7 +57,7 @@ class Task:
     cmd: str
     desc: str = ""
     deps: list[str | dict[str, Any]] = field(default_factory=list)  # Can be strings or dicts with args
-    inputs: list[str] = field(default_factory=list)
+    inputs: list[str | dict[str, str]] = field(default_factory=list)  # Can be strings or dicts with named inputs
     outputs: list[str | dict[str, str]] = field(default_factory=list)  # Can be strings or dicts with named outputs
     working_dir: str = ""
     args: list[str | dict[str, Any]] = field(default_factory=list)  # Can be strings or dicts (each dict has single key: arg name)
@@ -69,6 +69,10 @@ class Task:
     _output_map: dict[str, str] = field(init=False, default_factory=dict, repr=False)  # name → path mapping
     _anonymous_outputs: list[str] = field(init=False, default_factory=list, repr=False)  # unnamed outputs
 
+    # Internal fields for efficient input lookup (built in __post_init__)
+    _input_map: dict[str, str] = field(init=False, default_factory=dict, repr=False)  # name → path mapping
+    _anonymous_inputs: list[str] = field(init=False, default_factory=list, repr=False)  # unnamed inputs
+
     def __post_init__(self):
         """Ensure lists are always lists and build output maps."""
         if isinstance(self.deps, str):
@@ -132,6 +136,45 @@ class Task:
                     f"Task '{self.name}': Output at index {idx} must be a string or dict, got {type(output).__name__}: {output}"
                 )
 
+        # Build input maps for efficient lookup
+        self._input_map = {}
+        self._anonymous_inputs = []
+
+        for idx, input_item in enumerate(self.inputs):
+            if isinstance(input_item, dict):
+                # Named input: validate and store
+                if len(input_item) != 1:
+                    raise ValueError(
+                        f"Task '{self.name}': Named input at index {idx} must have exactly one key-value pair, got {len(input_item)}: {input_item}"
+                    )
+
+                name, path = next(iter(input_item.items()))
+
+                if not isinstance(path, str):
+                    raise ValueError(
+                        f"Task '{self.name}': Named input '{name}' must have a string path, got {type(path).__name__}: {path}"
+                    )
+
+                if not re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', name):
+                    raise ValueError(
+                        f"Task '{self.name}': Named input '{name}' must be a valid identifier "
+                        f"(letters, numbers, underscores, cannot start with number)"
+                    )
+
+                if name in self._input_map:
+                    raise ValueError(
+                        f"Task '{self.name}': Duplicate input name '{name}' at index {idx}"
+                    )
+
+                self._input_map[name] = path
+            elif isinstance(input_item, str):
+                # Anonymous input: just store
+                self._anonymous_inputs.append(input_item)
+            else:
+                raise ValueError(
+                    f"Task '{self.name}': Input at index {idx} must be a string or dict, got {type(input_item).__name__}: {input_item}"
+                )
+
 
 @dataclass
 class DependencySpec:
@@ -309,7 +352,21 @@ class Recipe:
             task.cmd = substitute_variables(task.cmd, self.evaluated_variables)
             task.desc = substitute_variables(task.desc, self.evaluated_variables)
             task.working_dir = substitute_variables(task.working_dir, self.evaluated_variables)
-            task.inputs = [substitute_variables(inp, self.evaluated_variables) for inp in task.inputs]
+
+            # Substitute variables in inputs (handle both string and dict inputs)
+            resolved_inputs = []
+            for inp in task.inputs:
+                if isinstance(inp, str):
+                    resolved_inputs.append(substitute_variables(inp, self.evaluated_variables))
+                elif isinstance(inp, dict):
+                    # Named input: substitute the path value
+                    resolved_dict = {}
+                    for name, path in inp.items():
+                        resolved_dict[name] = substitute_variables(path, self.evaluated_variables)
+                    resolved_inputs.append(resolved_dict)
+                else:
+                    resolved_inputs.append(inp)
+            task.inputs = resolved_inputs
 
             # Substitute variables in outputs (handle both string and dict outputs)
             resolved_outputs = []
@@ -1473,8 +1530,15 @@ def collect_reachable_variables(
         # Search in inputs
         if task.inputs:
             for input_pattern in task.inputs:
-                for match in var_pattern.finditer(input_pattern):
-                    variables.add(match.group(1))
+                if isinstance(input_pattern, str):
+                    for match in var_pattern.finditer(input_pattern):
+                        variables.add(match.group(1))
+                elif isinstance(input_pattern, dict):
+                    # Named input - check the path value
+                    for input_path in input_pattern.values():
+                        if isinstance(input_path, str):
+                            for match in var_pattern.finditer(input_path):
+                                variables.add(match.group(1))
 
         # Search in outputs
         if task.outputs:

tasktree/substitution.py

@@ -12,13 +12,19 @@ from typing import Any
 # Pattern matches: {{ prefix.name }} with optional whitespace
 # Groups: (1) prefix (var|arg|env|tt), (2) name (identifier)
 PLACEHOLDER_PATTERN = re.compile(
-    r'\{\{\s*(var|arg|env|tt)\s*\.\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}'
+    r'\{\{\s*(var|arg|env|tt)\.([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}'
 )
 
 # Pattern matches: {{ dep.task_name.outputs.output_name }} with optional whitespace
 # Groups: (1) task_name (can include dots for namespacing), (2) output_name (identifier)
 DEP_OUTPUT_PATTERN = re.compile(
-    r'\{\{\s*dep\s*\.\s*([a-zA-Z_][a-zA-Z0-9_.-]*)\s*\.\s*outputs\s*\.\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}'
+    r'\{\{\s*dep\.([a-zA-Z_][a-zA-Z0-9_.-]*)\.outputs\.([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}'
+)
+
+# Pattern matches: {{ self.(inputs|outputs).name }} with optional whitespace
+# Groups: (1) field (inputs|outputs), (2) name (identifier)
+SELF_REFERENCE_PATTERN = re.compile(
+    r'\{\{\s*self\.(inputs|outputs)\.([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}'
 )
 
 
@@ -372,3 +378,70 @@ def substitute_dependency_outputs(
         return dep_task._output_map[output_name]
 
     return DEP_OUTPUT_PATTERN.sub(replacer, text)
+
+
+def substitute_self_references(
+    text: str,
+    task_name: str,
+    input_map: dict[str, str],
+    output_map: dict[str, str],
+) -> str:
+    """Substitute {{ self.inputs.name }} and {{ self.outputs.name }} placeholders.
+
+    This function resolves references to the task's own named inputs and outputs.
+    Only named entries are accessible; anonymous inputs/outputs cannot be referenced.
+    The substitution is literal string replacement - no glob expansion or path resolution.
+
+    Args:
+        text: Text containing {{ self.* }} placeholders
+        task_name: Name of current task (for error messages)
+        input_map: Dictionary mapping input names to path strings
+        output_map: Dictionary mapping output names to path strings
+
+    Returns:
+        Text with all {{ self.* }} placeholders replaced with literal path strings
+
+    Raises:
+        ValueError: If referenced name doesn't exist in input_map or output_map
+
+    Example:
+        >>> input_map = {"src": "*.txt"}
+        >>> output_map = {"dest": "out/result.txt"}
+        >>> substitute_self_references(
+        ...     "cp {{ self.inputs.src }} {{ self.outputs.dest }}",
+        ...     "copy",
+        ...     input_map,
+        ...     output_map
+        ... )
+        'cp *.txt out/result.txt'
+    """
+    def replacer(match: re.Match) -> str:
+        field = match.group(1)  # "inputs" or "outputs"
+        name = match.group(2)
+
+        # Select appropriate map
+        if field == "inputs":
+            name_map = input_map
+            field_display = "input"
+        else:  # field == "outputs"
+            name_map = output_map
+            field_display = "output"
+
+        # Check if name exists in map
+        if name not in name_map:
+            available = list(name_map.keys())
+            if available:
+                available_msg = ", ".join(available)
+            else:
+                available_msg = f"(none - all {field} are anonymous)"
+
+            raise ValueError(
+                f"Task '{task_name}' references {field_display} '{name}' "
+                f"but has no {field_display} named '{name}'.\n"
+                f"Available named {field}: {available_msg}\n"
+                f"Hint: Define named {field} like: {field}: [{{ {name}: 'path/to/file' }}]"
+            )
+
+        return name_map[name]
+
+    return SELF_REFERENCE_PATTERN.sub(replacer, text)

{tasktree-0.0.19.dist-info → tasktree-0.0.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.19
+Version: 0.0.20
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0
@@ -833,6 +833,241 @@ Hint: Define named outputs like: outputs: [{ missing: 'path/to/file' }]
 - **Deployment pipelines**: Reference exact artifacts to deploy
 - **Configuration propagation**: Pass generated config files through build stages
 
+### Self-References
+
+Tasks can reference their own named inputs and outputs using `{{ self.inputs.name }}` and `{{ self.outputs.name }}` templates. This eliminates repetition when paths contain variables or when tasks have multiple inputs/outputs.
+
+**Named Inputs and Outputs:**
+
+Just like dependency output references, inputs and outputs can have names:
+
+```yaml
+tasks:
+  process:
+    inputs:
+      - src: "data/input.json"      # Named input
+      - config: "config.yaml"        # Named input
+    outputs:
+      - result: "output/result.json" # Named output
+      - log: "output/process.log"    # Named output
+    cmd: |
+      process-tool \
+        --input {{ self.inputs.src }} \
+        --config {{ self.inputs.config }} \
+        --output {{ self.outputs.result }} \
+        --log {{ self.outputs.log }}
+```
+
+**Syntax:**
+
+- **Defining named inputs**: `inputs: [{ name: "path/to/file" }]`
+- **Defining named outputs**: `outputs: [{ name: "path/to/file" }]`
+- **Referencing inputs**: `{{ self.inputs.input_name }}`
+- **Referencing outputs**: `{{ self.outputs.output_name }}`
+- **Mixed format**: Can combine named and anonymous inputs/outputs in the same task
+
+**Why Use Self-References?**
+
+Self-references follow the DRY (Don't Repeat Yourself) principle:
+
+```yaml
+# Without self-references - repetitive
+tasks:
+  build:
+    inputs: [src/app-{{ var.version }}.c]
+    outputs: [build/app-{{ var.version }}.o]
+    cmd: gcc src/app-{{ var.version }}.c -o build/app-{{ var.version }}.o
+
+# With self-references - DRY
+tasks:
+  build:
+    inputs:
+      - source: src/app-{{ var.version }}.c
+    outputs:
+      - object: build/app-{{ var.version }}.o
+    cmd: gcc {{ self.inputs.source }} -o {{ self.outputs.object }}
+```
+
+**Working with Variables:**
+
+Self-references work seamlessly with variables:
+
+```yaml
+variables:
+  platform: linux
+  arch: x86_64
+
+tasks:
+  compile:
+    inputs:
+      - src: src/{{ var.platform }}/main.c
+      - header: include/{{ var.arch }}/defs.h
+    outputs:
+      - binary: build/{{ var.platform }}-{{ var.arch }}/app
+    cmd: |
+      gcc {{ self.inputs.src }} \
+        -include {{ self.inputs.header }} \
+        -o {{ self.outputs.binary }}
+```
+
+Variables are evaluated first, then self-references substitute the expanded paths.
+
+**Working with Arguments:**
+
+Self-references work with parameterized tasks:
+
+```yaml
+tasks:
+  deploy:
+    args: [environment]
+    inputs:
+      - config: configs/{{ arg.environment }}/app.yaml
+    outputs:
+      - deployed: deployed-{{ arg.environment }}.yaml
+    cmd: |
+      validate {{ self.inputs.config }}
+      deploy {{ self.inputs.config }} > {{ self.outputs.deployed }}
+```
+
+```bash
+tt deploy production  # Uses configs/production/app.yaml
+tt deploy staging     # Uses configs/staging/app.yaml
+```
+
+**Working with Dependency Outputs:**
+
+Self-references and dependency references can be used together:
+
+```yaml
+tasks:
+  build:
+    outputs:
+      - artifact: dist/app.js
+    cmd: webpack build
+
+  package:
+    deps: [build]
+    inputs:
+      - manifest: package.json
+    outputs:
+      - tarball: release.tar.gz
+    cmd: tar czf {{ self.outputs.tarball }} \
+           {{ self.inputs.manifest }} \
+           {{ dep.build.outputs.artifact }}
+```
+
+**Mixed Named and Anonymous:**
+
+Tasks can mix named and anonymous inputs/outputs:
+
+```yaml
+tasks:
+  build:
+    inputs:
+      - config: build.yaml  # Named - can reference
+      - src/**/*.c          # Anonymous - tracked but not referenceable
+    outputs:
+      - binary: bin/app     # Named - can reference
+      - bin/app.debug       # Anonymous - tracked but not referenceable
+    cmd: build-tool --config {{ self.inputs.config }} --output {{ self.outputs.binary }}
+```
+
+**Error Messages:**
+
+If you reference a non-existent input or output:
+
+```yaml
+tasks:
+  build:
+    inputs:
+      - src: input.txt
+    cmd: cat {{ self.inputs.missing }}  # Error!
+```
+
+You'll get a clear error before execution:
+
+```
+Task 'build' references input 'missing' but has no input named 'missing'.
+Available named inputs: src
+Hint: Define named inputs like: inputs: [{ missing: 'path/to/file' }]
+```
+
+Similarly, if you try to reference an anonymous input:
+
+```yaml
+tasks:
+  build:
+    inputs: [file.txt]  # Anonymous input
+    cmd: cat {{ self.inputs.src }}  # Error!
+```
+
+You'll get:
+
+```
+Task 'build' references input 'src' but has no input named 'src'.
+Available named inputs: (none - all inputs are anonymous)
+Hint: Define named inputs like: inputs: [{ src: 'file.txt' }]
+```
+
+**Key Behaviors:**
+
+- **Template resolution**: Self-references are resolved during dependency graph planning
+- **Substitution order**: Variables → Dependency outputs → Self-references → Arguments/Environment
+- **Fail-fast validation**: Errors are caught before execution begins
+- **Clear error messages**: Lists available names if reference doesn't exist
+- **Backward compatible**: Existing anonymous inputs/outputs work unchanged
+- **State tracking**: Works correctly with incremental execution and freshness checks
+
+**Limitations:**
+
+- **Anonymous not referenceable**: Only named inputs/outputs can be referenced
+- **Case sensitive**: `{{ self.inputs.Src }}` and `{{ self.inputs.src }}` are different
+- **Argument defaults**: Self-references in argument defaults are not supported (arguments are evaluated before self-references)
+
+**Use Cases:**
+
+- **Eliminate repetition**: Define complex paths once, use them multiple times
+- **Variable composition**: Combine variables with self-references for clean commands
+- **Multiple inputs/outputs**: Reference specific files when tasks have many
+- **Complex build pipelines**: Keep commands readable with named artifacts
+- **Glob patterns**: Use self-references with glob patterns for dynamic inputs
+
+**Example: Multi-Stage Build:**
+
+```yaml
+variables:
+  version: "2.1.0"
+  platform: "linux"
+
+tasks:
+  prepare:
+    outputs:
+      - builddir: build/{{ var.platform }}-{{ var.version }}
+    cmd: mkdir -p {{ self.outputs.builddir }}
+
+  compile:
+    deps: [prepare]
+    inputs:
+      - source: src/main.c
+      - headers: include/*.h
+    outputs:
+      - object: build/{{ var.platform }}-{{ var.version }}/main.o
+    cmd: |
+      gcc -c {{ self.inputs.source }} \
+        -I include \
+        -o {{ self.outputs.object }}
+
+  link:
+    deps: [compile]
+    outputs:
+      - executable: build/{{ var.platform }}-{{ var.version }}/app
+      - symbols: build/{{ var.platform }}-{{ var.version }}/app.sym
+    cmd: |
+      gcc build/{{ var.platform }}-{{ var.version }}/main.o \
+        -o {{ self.outputs.executable }}
+      objcopy --only-keep-debug {{ self.outputs.executable }} {{ self.outputs.symbols }}
+```
+
 
 ### Private Tasks
 

tasktree-0.0.20.dist-info/RECORD

@@ -0,0 +1,14 @@
+tasktree/__init__.py,sha256=m7fLsPUft99oB_XXr4dOu2yUWu74zVutkw1-3zGrG5Y,1227
+tasktree/cli.py,sha256=S5ypqQlvCxdAvlBfO8TJZhvMoc086wqgvmOm8220678,21220
+tasktree/docker.py,sha256=qvja8G63uAcC73YMVY739egda1_CcBtoqzm0qIJU_Q8,14443
+tasktree/executor.py,sha256=g4mHtoO3wVIxyqNALIdJOEwlEqRkSY0eY-6sl2jF-IA,46463
+tasktree/graph.py,sha256=T78JH0whP7VquEvtOVN-8ePyHNcseTQoEouijDrgmkw,22663
+tasktree/hasher.py,sha256=o7Akd_AgGkAsnv9biK0AcbhlcqUQ9ne5y_6r4zoFaw0,5493
+tasktree/parser.py,sha256=R0swEkKBPGeijLHxD1CbQjtoKVn2gRJadsZuyKj1sdM,97922
+tasktree/state.py,sha256=Cktl4D8iDZVd55aO2LqVyPrc-BnljkesxxkcMcdcfOY,3541
+tasktree/substitution.py,sha256=FhtFI0ciK9bQxPdORvpf1coa59XxizKiBiUwHJp0PtI,16811
+tasktree/types.py,sha256=R_YAyO5bMLB6XZnkMRT7VAtlkA_Xx6xu0aIpzQjrBXs,4357
+tasktree-0.0.20.dist-info/METADATA,sha256=C8cdZtyz-dgiVoN1H2hy7wQNAA-K784WYFfqlZEOXnA,50237
+tasktree-0.0.20.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tasktree-0.0.20.dist-info/entry_points.txt,sha256=lQINlvRYnimvteBbnhH84A9clTg8NnpEjCWqWkqg8KE,40
+tasktree-0.0.20.dist-info/RECORD,,

tasktree-0.0.19.dist-info/RECORD

@@ -1,14 +0,0 @@
-tasktree/__init__.py,sha256=N-dZcggJDe4WaloC1MdEh0oMTHlUpBN9AEcAm6leDf4,1167
-tasktree/cli.py,sha256=_GzqQIk2z2Hz17bkTOWhtNW4X4_Ijxn-uEL-WZGt8LM,20858
-tasktree/docker.py,sha256=qvja8G63uAcC73YMVY739egda1_CcBtoqzm0qIJU_Q8,14443
-tasktree/executor.py,sha256=7pzcH2wLWMZPk3hwhzWgz18RVkIPFCKdu23MboWUQs4,45914
-tasktree/graph.py,sha256=9O5LByzMYa8ccedznqKBTb0Xe9N_aajSR1cAcb8zGQE,20366
-tasktree/hasher.py,sha256=o7Akd_AgGkAsnv9biK0AcbhlcqUQ9ne5y_6r4zoFaw0,5493
-tasktree/parser.py,sha256=PVgtGORCpnkb8wcXHFfsyVqDhJ3PwzwCqO3VWiuLQl4,94777
-tasktree/state.py,sha256=Cktl4D8iDZVd55aO2LqVyPrc-BnljkesxxkcMcdcfOY,3541
-tasktree/substitution.py,sha256=3-gdvHbBwPkQPflx3GVSpEEa0vTL_ivdcMIba77gtJc,14225
-tasktree/types.py,sha256=R_YAyO5bMLB6XZnkMRT7VAtlkA_Xx6xu0aIpzQjrBXs,4357
-tasktree-0.0.19.dist-info/METADATA,sha256=KTLp0p1Mkzzvah-Hy15KrXnTcKju5dlQyvDvEdnDOmg,43609
-tasktree-0.0.19.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-tasktree-0.0.19.dist-info/entry_points.txt,sha256=lQINlvRYnimvteBbnhH84A9clTg8NnpEjCWqWkqg8KE,40
-tasktree-0.0.19.dist-info/RECORD,,