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

tasktree/types.py

@@ -10,7 +10,10 @@ import click
 
 
 class HostnameType(click.ParamType):
-    """Validates hostname format (not DNS resolution)."""
+    """
+    Validates hostname format (not DNS resolution).
+    @athena: 84a721c40458
+    """
 
     name = "hostname"
 
@@ -20,6 +23,9 @@ class HostnameType(click.ParamType):
     )
 
     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,7 +33,10 @@ class HostnameType(click.ParamType):
 
 
 class EmailType(click.ParamType):
-    """Validates email format (not deliverability)."""
+    """
+    Validates email format (not deliverability).
+    @athena: 95cfacc3f4cd
+    """
 
     name = "email"
 
@@ -37,6 +46,9 @@ class EmailType(click.ParamType):
     )
 
     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 +56,17 @@ 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:
+        """
+        @athena: d57618e5ad89
+        """
         try:
             ip_address(value)
             return str(value)
@@ -57,11 +75,17 @@ 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:
+        """
+        @athena: 7ed2d17d1f1a
+        """
         try:
             IPv4Address(value)
             return str(value)
@@ -70,11 +94,17 @@ 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:
+        """
+        @athena: 4b101e4d54cf
+        """
         try:
             IPv6Address(value)
             return str(value)
@@ -83,11 +113,17 @@ 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:
+        """
+        @athena: 13fa66adfe94
+        """
         if isinstance(value, str):
             try:
                 datetime.fromisoformat(value)
@@ -114,18 +150,20 @@ 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.
+    """
+    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.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.20
+Version: 0.0.21
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0
@@ -835,7 +835,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 +862,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 +974,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 +1136,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.21.dist-info/RECORD

@@ -0,0 +1,14 @@
+tasktree/__init__.py,sha256=ZfI6vy-TxinN7eK0_XjfHUFq83pFV1XiHFrai_SHNqw,1251
+tasktree/cli.py,sha256=pyXMUENz1ldl8z9SPXBZ1zhOHzmvIRUGu2y5VwRUdgo,22960
+tasktree/docker.py,sha256=EeIUqptvDqSXbjWKXwWGhA4hWvsBjOk0Z-3cS3cqEOM,14857
+tasktree/executor.py,sha256=x0K-TIVRmiKuUlur1UTOpB2xOJOE_Cv3-3MlE7xUNEk,47271
+tasktree/graph.py,sha256=BjpLaa7EE2vmOcUlqhvp1KK7yT5VbXHQCbxljOhF84k,23603
+tasktree/hasher.py,sha256=UM-2dqRE-rspQUbhA-noGHc80-Hu-QaxCTPRb_UzPto,6661
+tasktree/parser.py,sha256=sXgotDdDQiNSmo7FaESFQ4j1OytaheyplJSdFrFXTYk,99286
+tasktree/state.py,sha256=0fxKbMNYbo-dCpCTTnKTmJhGRy72G5kLnh99FScMLGU,3985
+tasktree/substitution.py,sha256=2ubFn6jIX5qmtzyWSCxTut-_Cn0zew8KnwxMqDIPq1o,18545
+tasktree/types.py,sha256=2uHdUncfyfw4jNWbQTBUirew-frmTjuk1ZYNd15cyQQ,4908
+tasktree-0.0.21.dist-info/METADATA,sha256=nyjDhb1hdQMEiLx0t_qqonqPoyFZVMCrIg7xFIKxMs8,54353
+tasktree-0.0.21.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tasktree-0.0.21.dist-info/entry_points.txt,sha256=lQINlvRYnimvteBbnhH84A9clTg8NnpEjCWqWkqg8KE,40
+tasktree-0.0.21.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,,