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

tasktree/types.py

@@ -3,14 +3,16 @@
 import re
 from datetime import datetime
 from ipaddress import IPv4Address, IPv6Address, ip_address
-from pathlib import Path
 from typing import Any, Optional
 
 import click
 
 
 class HostnameType(click.ParamType):
-    """Validates hostname format (not DNS resolution)."""
+    """
+    Validates hostname format (not DNS resolution).
+    @athena: 84a721c40458
+    """
 
     name = "hostname"
 
@@ -19,7 +21,12 @@ class HostnameType(click.ParamType):
         r"^(?=.{1,253}$)(?!-)[A-Za-z0-9-]{1,63}(?<!-)(\.[A-Za-z0-9-]{1,63})*\.?$"
     )
 
-    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> str:
+    def convert(
+        self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]
+    ) -> str:
+        """
+        @athena: 8d921e52bcf2
+        """
         if isinstance(value, str):
             if self.HOSTNAME_PATTERN.match(value):
                 return value
@@ -27,16 +34,22 @@ class HostnameType(click.ParamType):
 
 
 class EmailType(click.ParamType):
-    """Validates email format (not deliverability)."""
+    """
+    Validates email format (not deliverability).
+    @athena: 95cfacc3f4cd
+    """
 
     name = "email"
 
     # Basic email validation (RFC 5322 simplified)
-    EMAIL_PATTERN = re.compile(
-        r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
-    )
-
-    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> str:
+    EMAIL_PATTERN = re.compile(r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$")
+
+    def convert(
+        self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]
+    ) -> str:
+        """
+        @athena: 25046aeb6e6f
+        """
         if isinstance(value, str):
             if self.EMAIL_PATTERN.match(value):
                 return value
@@ -44,11 +57,19 @@ class EmailType(click.ParamType):
 
 
 class IPType(click.ParamType):
-    """Validates IP address (IPv4 or IPv6)."""
+    """
+    Validates IP address (IPv4 or IPv6).
+    @athena: dac837bf4894
+    """
 
     name = "ip"
 
-    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> str:
+    def convert(
+        self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]
+    ) -> str:
+        """
+        @athena: d57618e5ad89
+        """
         try:
             ip_address(value)
             return str(value)
@@ -57,11 +78,19 @@ class IPType(click.ParamType):
 
 
 class IPv4Type(click.ParamType):
-    """Validates IPv4 address."""
+    """
+    Validates IPv4 address.
+    @athena: ea5957643fe5
+    """
 
     name = "ipv4"
 
-    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> str:
+    def convert(
+        self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]
+    ) -> str:
+        """
+        @athena: 7ed2d17d1f1a
+        """
         try:
             IPv4Address(value)
             return str(value)
@@ -70,11 +99,19 @@ class IPv4Type(click.ParamType):
 
 
 class IPv6Type(click.ParamType):
-    """Validates IPv6 address."""
+    """
+    Validates IPv6 address.
+    @athena: 9bc5b38d4f23
+    """
 
     name = "ipv6"
 
-    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> str:
+    def convert(
+        self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]
+    ) -> str:
+        """
+        @athena: 4b101e4d54cf
+        """
         try:
             IPv6Address(value)
             return str(value)
@@ -83,18 +120,30 @@ class IPv6Type(click.ParamType):
 
 
 class DateTimeType(click.ParamType):
-    """Validates datetime in format YYYY-MM-DDTHH:MM:SS."""
+    """
+    Validates datetime in format YYYY-MM-DDTHH:MM:SS.
+    @athena: c3bafa3e22e3
+    """
 
     name = "datetime"
 
-    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> str:
+    def convert(
+        self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]
+    ) -> str:
+        """
+        @athena: 13fa66adfe94
+        """
         if isinstance(value, str):
             try:
                 datetime.fromisoformat(value)
                 return value
             except ValueError:
                 pass
-        self.fail(f"{value!r} is not a valid datetime (expected YYYY-MM-DDTHH:MM:SS format)", param, ctx)
+        self.fail(
+            f"{value!r} is not a valid datetime (expected YYYY-MM-DDTHH:MM:SS format)",
+            param,
+            ctx,
+        )
 
 
 # Type registry for dynamic parameter creation
@@ -113,19 +162,25 @@ TYPE_MAPPING = {
 }
 
 
-def get_click_type(type_name: str, min_val: int | float | None = None, max_val: int | float | None = None) -> click.ParamType:
-    """Get Click parameter type by name with optional range constraints.
+def get_click_type(
+    type_name: str,
+    min_val: int | float | None = None,
+    max_val: int | float | None = None,
+) -> click.ParamType:
+    """
+    Get Click parameter type by name with optional range constraints.
 
     Args:
-        type_name: Type name from task definition (e.g., 'str', 'int', 'hostname')
-        min_val: Optional minimum value for numeric types
-        max_val: Optional maximum value for numeric types
+    type_name: Type name from task definition (e.g., 'str', 'int', 'hostname')
+    min_val: Optional minimum value for numeric types
+    max_val: Optional maximum value for numeric types
 
     Returns:
-        Click parameter type instance
+    Click parameter type instance
 
     Raises:
-        ValueError: If type_name is not recognized
+    ValueError: If type_name is not recognized
+    @athena: d0912868676f
     """
     if type_name not in TYPE_MAPPING:
         raise ValueError(f"Unknown type: {type_name}")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.20
+Version: 0.0.22
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0
@@ -10,7 +10,9 @@ Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.9.0
 Provides-Extra: dev
+Requires-Dist: black>=26.1.0; extra == 'dev'
 Requires-Dist: pytest>=9.0.2; extra == 'dev'
+Requires-Dist: ruff>=0.14.14; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Task Tree (tt)
@@ -255,20 +257,19 @@ tasks:
     cmd: go build -o dist/binary           # Command to execute
 ```
 
+**Task name constraints:**
+- Task names cannot contain dots (`.`) - they are reserved for namespacing imported tasks
+- Example: `build.release` is invalid as a task name, but valid as a reference to task `release` in namespace `build`
+
 ### Commands
 
-**Single-line commands** are executed directly via the configured shell:
+All commands are executed by writing them to temporary script files. This provides consistent behavior and better shell syntax support:
 
 ```yaml
 tasks:
   build:
     cmd: cargo build --release
-```
-
-**Multi-line commands** are written to temporary script files for proper execution:
 
-```yaml
-tasks:
   deploy:
     cmd: |
       mkdir -p dist
@@ -276,7 +277,7 @@ tasks:
       rsync -av dist/ server:/opt/app/
 ```
 
-Multi-line commands preserve shell syntax (line continuations, heredocs, etc.) and support shebangs on Unix/macOS.
+Commands preserve shell syntax (line continuations, heredocs, etc.) and support shebangs on Unix/macOS.
 
 Or use folded blocks for long single-line commands:
 
@@ -292,7 +293,7 @@ tasks:
 
 ### Execution Environments
 
-Configure custom shell environments for task execution:
+Configure custom shell environments for task execution. Use the `preamble` field to add initialization code to all commands:
 
 ```yaml
 environments:
@@ -300,17 +301,14 @@ environments:
 
   bash-strict:
     shell: bash
-    args: ['-c']              # For single-line: bash -c "command"
-    preamble: |               # For multi-line: prepended to script
+    preamble: |               # Prepended to all commands
       set -euo pipefail
 
   python:
     shell: python
-    args: ['-c']
 
   powershell:
     shell: powershell
-    args: ['-ExecutionPolicy', 'Bypass', '-Command']
     preamble: |
       $ErrorActionPreference = 'Stop'
 
@@ -339,8 +337,8 @@ tasks:
 4. Platform default (bash on Unix, cmd on Windows)
 
 **Platform defaults** when no environments are configured:
-- **Unix/macOS**: bash with `-c` args
-- **Windows**: cmd with `/c` args
+- **Unix/macOS**: bash
+- **Windows**: cmd
 
 ### Docker Environments
 
@@ -835,7 +833,7 @@ Hint: Define named outputs like: outputs: [{ missing: 'path/to/file' }]
 
 ### 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.
+Tasks can reference their own inputs and outputs using `{{ self.inputs.name }}` (named access) or `{{ self.inputs.0 }}` (positional access) templates. This eliminates repetition when paths contain variables or when tasks have multiple inputs/outputs.
 
 **Named Inputs and Outputs:**
 
@@ -862,8 +860,10 @@ tasks:
 
 - **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 }}`
+- **Defining anonymous inputs**: `inputs: ["path/to/file"]`
+- **Defining anonymous outputs**: `outputs: ["path/to/file"]`
+- **Referencing by name**: `{{ self.inputs.input_name }}` or `{{ self.outputs.output_name }}`
+- **Referencing by index**: `{{ self.inputs.0 }}` or `{{ self.outputs.1 }}` (0-based)
 - **Mixed format**: Can combine named and anonymous inputs/outputs in the same task
 
 **Why Use Self-References?**
@@ -972,6 +972,129 @@ tasks:
     cmd: build-tool --config {{ self.inputs.config }} --output {{ self.outputs.binary }}
 ```
 
+**Positional Index References:**
+
+In addition to named references, you can access inputs and outputs by their positional index using `{{ self.inputs.0 }}`, `{{ self.inputs.1 }}`, etc. This provides an alternative way to reference items, especially useful for:
+
+- **Anonymous inputs/outputs**: Reference items that don't have names
+- **Simple sequential access**: When order is more important than naming
+- **Mixed with named access**: Use both styles in the same task
+
+**Syntax:**
+
+```yaml
+tasks:
+  process:
+    inputs: ["file1.txt", "file2.txt", "file3.txt"]
+    outputs: ["output1.txt", "output2.txt"]
+    cmd: |
+      cat {{ self.inputs.0 }} {{ self.inputs.1 }} > {{ self.outputs.0 }}
+      cat {{ self.inputs.2 }} > {{ self.outputs.1 }}
+```
+
+Indices follow YAML declaration order, starting from 0 (zero-based indexing):
+- First input/output = index 0
+- Second input/output = index 1
+- Third input/output = index 2, etc.
+
+**Works with Both Named and Anonymous:**
+
+```yaml
+tasks:
+  build:
+    inputs:
+      - config: "build.yaml"  # Index 0, also accessible as {{ self.inputs.config }}
+      - "src/**/*.c"          # Index 1, ONLY accessible as {{ self.inputs.1 }}
+      - headers: "include/*.h" # Index 2, also accessible as {{ self.inputs.headers }}
+    outputs:
+      - "dist/app.js"         # Index 0
+      - bundle: "dist/bundle.js" # Index 1, also accessible as {{ self.outputs.bundle }}
+    cmd: |
+      # Mix positional and named references
+      build-tool \
+        --config {{ self.inputs.0 }} \
+        --sources {{ self.inputs.1 }} \
+        --headers {{ self.inputs.headers }} \
+        --output {{ self.outputs.bundle }}
+```
+
+**Same Item, Multiple Ways:**
+
+Named items can be accessed by both name and index:
+
+```yaml
+tasks:
+  copy:
+    inputs:
+      - source: data.txt
+    cmd: |
+      # These are equivalent:
+      cat {{ self.inputs.source }} > copy1.txt
+      cat {{ self.inputs.0 }} > copy2.txt
+```
+
+**With Variables and Arguments:**
+
+Positional references work with variable-expanded paths:
+
+```yaml
+variables:
+  version: "1.0"
+
+tasks:
+  package:
+    args: [platform]
+    inputs:
+      - "dist/app-{{ var.version }}.js"
+      - "dist/lib-{{ arg.platform }}.so"
+    outputs: ["release-{{ var.version }}-{{ arg.platform }}.tar.gz"]
+    cmd: tar czf {{ self.outputs.0 }} {{ self.inputs.0 }} {{ self.inputs.1 }}
+```
+
+**Index Boundaries:**
+
+Indices are validated before execution:
+
+```yaml
+tasks:
+  build:
+    inputs: ["file1.txt", "file2.txt"]
+    cmd: cat {{ self.inputs.5 }}  # Error: index 5 out of bounds!
+```
+
+Error message:
+```
+Task 'build' references input index '5' but only has 2 inputs (indices 0-1)
+```
+
+**Empty Lists:**
+
+Referencing an index when no inputs/outputs exist:
+
+```yaml
+tasks:
+  generate:
+    cmd: echo "test" > {{ self.outputs.0 }}  # Error: no outputs defined!
+```
+
+Error message:
+```
+Task 'generate' references output index '0' but has no outputs defined
+```
+
+**When to Use Index References:**
+
+- **Anonymous items**: Only way to reference inputs/outputs without names
+- **Order-based processing**: When the sequence matters more than naming
+- **Simple tasks**: Quick access without defining names
+- **Compatibility**: Accessing items in legacy YAML that uses anonymous format
+
+**When to Use Named References:**
+
+- **Clarity**: Names make commands more readable (`{{ self.inputs.config }}` vs `{{ self.inputs.2 }}`)
+- **Maintainability**: Adding/removing items doesn't break indices
+- **Complex tasks**: Many inputs/outputs are easier to manage with names
+
 **Error Messages:**
 
 If you reference a non-existent input or output:
@@ -1011,18 +1134,21 @@ Hint: Define named inputs like: inputs: [{ src: 'file.txt' }]
 
 **Key Behaviors:**
 
+- **Two access methods**: Reference by name (`{{ self.inputs.name }}`) or by index (`{{ self.inputs.0 }}`)
 - **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
+- **Fail-fast validation**: Errors are caught before execution begins (missing names, out-of-bounds indices)
+- **Clear error messages**: Lists available names/indices if reference doesn't exist
 - **Backward compatible**: Existing anonymous inputs/outputs work unchanged
 - **State tracking**: Works correctly with incremental execution and freshness checks
+- **Index order**: Positional indices follow YAML declaration order (0-based)
 
 **Limitations:**
 
-- **Anonymous not referenceable**: Only named inputs/outputs can be referenced
+- **Anonymous not referenceable by name**: Anonymous inputs/outputs cannot be referenced by name (use positional index instead: `{{ self.inputs.0 }}`)
 - **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)
+- **No negative indices**: Python-style negative indexing (`{{ self.inputs.-1 }}`) is not supported
 
 **Use Cases:**
 

tasktree-0.0.22.dist-info/RECORD

@@ -0,0 +1,14 @@
+tasktree/__init__.py,sha256=ZfI6vy-TxinN7eK0_XjfHUFq83pFV1XiHFrai_SHNqw,1251
+tasktree/cli.py,sha256=588ngMB27T6FqUp5LIJ_x_UNoPRlMv39b1_U0a88tfE,23577
+tasktree/docker.py,sha256=DAvdr6kZqkhx8J9fhsz26Z41hFPreANC60vdunvPX00,15050
+tasktree/executor.py,sha256=UF2H-qCgkJ5E2QoYt3To3a-ypwTIYJT9oyWRcBw2CzQ,46800
+tasktree/graph.py,sha256=Ya4ATQidj0rlHxvvbWF0Xx2J18MTpz2XPAHTcJXFcBg,23637
+tasktree/hasher.py,sha256=fvs7vNBrHdAA6pX-ZLhNnWLtd5qdxjAVFJC8SDF-DhQ,6730
+tasktree/parser.py,sha256=OUuME_ZqITAMQEL90w-yJFLKoEquF_IIa-By8MifMvI,101074
+tasktree/state.py,sha256=R4ZXgfs_rwrOH9nEb4mOjuHa7gAVqi7QPVCi0CouNQA,3961
+tasktree/substitution.py,sha256=hwox1m9r8p5b0Fcln12C63GexJHc5ZMUoqOrpqQLuPk,18663
+tasktree/types.py,sha256=nCiPrxg3r3ZX4CoZ6L5FrkJO9mgz_lFsZ-98X8tYgns,5015
+tasktree-0.0.22.dist-info/METADATA,sha256=fuvZWDbtlwfbQNOP_TMCDRSDGKdZYUTeROo3eqVcJ6o,54519
+tasktree-0.0.22.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tasktree-0.0.22.dist-info/entry_points.txt,sha256=lQINlvRYnimvteBbnhH84A9clTg8NnpEjCWqWkqg8KE,40
+tasktree-0.0.22.dist-info/RECORD,,

tasktree-0.0.20.dist-info/RECORD

@@ -1,14 +0,0 @@
-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,,