invoke-toolkit 0.0.59

A set of extended APIs for PyInvoke for composable scripts, plugins and richer output

invoke-toolkit

A set of extensions for rich output, more options in collection/config discovery through entry-points.

This extends the Collection from Invoke so it can create automatically collections.

---

Table of Contents

• invoke-toolkit
  • Table of Contents
  • Features
  • Do I need this package
  • Installation
  • Development
  • License

Features

• Task discovery by namespace for extendable/composable CLIs
• Discovery to plain old tasks.py (or any other name)
• Local tasks discovery from local_tasks.py in the current directory
• Integration with stand alone binaries for specific tasks
• Task result caching with TTL support via diskcache (optional)
• Future Download binaries

Do I need this package

If you have...

• Used invoke for a while and...
• Have a large tasks.py that needs to be modularized
• Have a lot of copy/pasted code in multiple tasks.py across multiple repos.
• Have exceeded the approach of a repository cloned as ~/tasks/ with more .py files that you want to manage.
• Or you want to combine various tasks defined in multiple directories
• You want to create a zipped (shiv) redistribute script for container environments like Kubernetes based CI environments with only requiring the Python interpreter.

Installation

pip install invoke-toolkit

Quick Start

Using Local Tasks

Create a local_tasks.py file in your project directory with your tasks:

from invoke_toolkit import task

@task()
def my_task(ctx):
    """Do something useful"""
    print("Hello from local tasks!")

Then run it with:

intk local.my-task

Local tasks are automatically discovered and added to the local namespace, allowing you to keep project-specific tasks separate from your main task collection.

Using Task Caching

Cache expensive task results with the cache parameter:

from invoke_toolkit import task

# Simple caching (no expiration)
@task(cache=True)
def expensive_task(ctx, param: str) -> str:
    """Results are cached across invocations."""
    return do_expensive_computation(param)

# Caching with TTL (1 hour)
@task(cache={"ttl": 3600})
def cached_task(ctx, name: str) -> dict:
    """Results cached for 1 hour."""
    return fetch_data(name)

# Caching with ignored arguments
@task(cache={"ttl": 600, "ignore_args": ["verbose"]})
def cached_with_options(ctx, query: str, verbose: bool = False) -> list:
    """Cache key ignores verbose flag."""
    return search(query, verbose=verbose)

Cache features:

• Cache location is computed from git repository root + platformdirs
• Debug logging (-d flag) shows cache hits/misses
• Graceful degradation when diskcache is not installed

To enable caching, install with the cache extra:

pip install invoke-toolkit[cache]

Development

This project utilizes the pre-commit framework, make sure you run:

pre-commit install

With uvx:

uvx --with pre-commit-uv pre-commit install

License

invoke-toolkit is distributed under the terms of the MIT license.