invoke-tasklib 0.0.1__py3-none-any.whl

invoke_tasklib/__init__.py

@@ -0,0 +1,37 @@
+r"""Reusable Invoke tasks shared across Python projects.
+
+Typical usage in a consuming project's ``tasks.py``::
+
+    from invoke_tasklib import ns
+
+and an ``invoke.yaml`` at the project root::
+
+    tasklib:
+      package:
+        name: my_package
+
+To compose a custom subset of tasks instead of using the default
+``ns``, import individual task modules::
+
+    from invoke import Collection
+    from invoke_tasklib import lint, test
+
+    ns = Collection(lint, test)
+"""
+
+from __future__ import annotations
+
+from invoke.collection import Collection
+
+from invoke_tasklib import doc, env, format, lint, release, test, types
+
+__all__ = ["doc", "env", "format", "lint", "ns", "release", "test", "types"]
+
+ns: Collection = Collection()
+ns.add_collection(Collection.from_module(format), name="format")
+ns.add_collection(Collection.from_module(lint), name="lint")
+ns.add_collection(Collection.from_module(types), name="types")
+ns.add_collection(Collection.from_module(test), name="test")
+ns.add_collection(Collection.from_module(env), name="env")
+ns.add_collection(Collection.from_module(release), name="release")
+ns.add_collection(Collection.from_module(doc), name="doc")

invoke_tasklib/config.py

@@ -0,0 +1,109 @@
+r"""Config resolution for invoke-tasklib tasks.
+
+Consuming projects set project-specific values under a ``tasklib`` key in
+their ``invoke.yaml``, e.g.::
+
+    tasklib:
+      package:
+        name: coola
+      paths:
+        docs_config: docs/mkdocs.yml
+
+Only ``package.name`` is required; everything else has a default derived
+from it.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    from invoke.context import Context
+
+
+class PackageConfig(TypedDict):
+    r"""Resolved ``package`` config section."""
+
+    name: str
+    python_version: str
+
+
+class PathsConfig(TypedDict):
+    r"""Resolved ``paths`` config section."""
+
+    src: str
+    tests: str
+    unit_tests: str
+    integration_tests: str
+    functional_tests: str
+    benchmarks: str
+    docs_config: str
+
+
+class TasklibConfig(TypedDict):
+    r"""Resolved tasklib config."""
+
+    package: PackageConfig
+    paths: PathsConfig
+
+
+DEFAULT_PACKAGE: dict[str, str | None] = {
+    "name": None,
+    "python_version": "3.14",
+}
+
+DEFAULT_PATHS: dict[str, str | None] = {
+    "src": None,
+    "tests": "tests",
+    "unit_tests": None,
+    "integration_tests": None,
+    "functional_tests": None,
+    "benchmarks": None,
+    "docs_config": "docs/mkdocs.yml",
+}
+
+
+def get_config(c: Context) -> TasklibConfig:
+    r"""Return the effective tasklib config, merging user overrides from
+    ``invoke.yaml`` (under the ``tasklib`` key) on top of the defaults.
+
+    Args:
+        c: The invoke context.
+
+    Returns:
+        A dict with resolved ``package`` and ``paths`` sections.
+
+    Raises:
+        ValueError: If ``tasklib.package.name`` is not set.
+    """
+    user = dict(c.config.get("tasklib", {}))
+    package = {**DEFAULT_PACKAGE, **user.get("package", {})}
+    paths = {**DEFAULT_PATHS, **user.get("paths", {})}
+
+    if not package["name"]:
+        msg = "'tasklib.package.name' must be set in invoke.yaml"
+        raise ValueError(msg)
+
+    if not paths["src"]:
+        paths["src"] = f"src/{package['name']}"
+    if not paths["unit_tests"]:
+        paths["unit_tests"] = f"{paths['tests']}/unit"
+    if not paths["integration_tests"]:
+        paths["integration_tests"] = f"{paths['tests']}/integration"
+    if not paths["functional_tests"]:
+        paths["functional_tests"] = f"{paths['tests']}/functional"
+    if not paths["benchmarks"]:
+        paths["benchmarks"] = f"{paths['tests']}/benchmarks"
+
+    return {
+        "package": PackageConfig(name=package["name"], python_version=package["python_version"]),
+        "paths": PathsConfig(
+            src=paths["src"],
+            tests=paths["tests"],
+            unit_tests=paths["unit_tests"],
+            integration_tests=paths["integration_tests"],
+            functional_tests=paths["functional_tests"],
+            benchmarks=paths["benchmarks"],
+            docs_config=paths["docs_config"],
+        ),
+    }

invoke_tasklib/doc.py

@@ -0,0 +1,59 @@
+r"""Documentation publishing tasks (versioned docs via mike)."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from invoke.tasks import task
+
+from invoke_tasklib.config import get_config
+
+if TYPE_CHECKING:
+    from invoke.context import Context
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+@task
+def publish_dev(c: Context) -> None:
+    r"""Publish development (e.g. unstable) docs."""
+    cfg = get_config(c)
+    docs_config = cfg["paths"]["docs_config"]
+    logger.info("📚 Publishing development documentation...")
+    logger.info("🗑️  Deleting previous 'main' version if it exists...")
+    c.run(f"mike delete --config-file {docs_config} main", pty=True, warn=True)
+    logger.info("🚀 Deploying 'main' and 'dev' aliases...")
+    c.run(f"mike deploy --config-file {docs_config} --push --update-aliases main dev", pty=True)
+    logger.info("✅ Development documentation published")
+
+
+@task
+def publish_latest(c: Context) -> None:
+    r"""Publish latest (e.g. stable) docs.
+
+    Requires the ``feu`` and ``packaging`` packages to determine the
+    latest version tag.
+    """
+    from feu.local_git import get_last_version_tag_name
+    from packaging.version import Version
+
+    cfg = get_config(c)
+    docs_config = cfg["paths"]["docs_config"]
+    logger.info("📚 Publishing latest documentation...")
+
+    try:
+        version = Version(get_last_version_tag_name())
+        tag = f"{version.major}.{version.minor}"
+        logger.info(f"📌 Using version tag: {tag}")
+    except RuntimeError:
+        tag = "0.0"
+        logger.warning("⚠️  No version tag found, using default: 0.0")
+
+    logger.info(f"🗑️  Deleting previous '{tag}' version if it exists...")
+    c.run(f"mike delete --config-file {docs_config} {tag}", pty=True, warn=True)
+    logger.info(f"🚀 Deploying '{tag}' and 'latest' aliases...")
+    c.run(f"mike deploy --config-file {docs_config} --push --update-aliases {tag} latest", pty=True)
+    logger.info("🎯 Setting 'latest' as default...")
+    c.run(f"mike set-default --config-file {docs_config} --push --allow-empty latest", pty=True)
+    logger.info("✅ Latest documentation published")

invoke_tasklib/env.py

@@ -0,0 +1,95 @@
+r"""Environment and dependency management tasks."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from invoke.tasks import task
+
+from invoke_tasklib.config import get_config
+
+if TYPE_CHECKING:
+    from invoke.context import Context
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+@task
+def create_venv(c: Context) -> None:
+    r"""Create a virtual environment and install invoke.
+
+    Note:
+        The virtual environment will be created in the .venv directory and any
+        existing environment will be cleared.
+    """
+    cfg = get_config(c)
+    python_version = cfg["package"]["python_version"]
+    logger.info(f"🐍 Creating virtual environment with Python {python_version}...")
+    c.run(f"uv venv --python {python_version} --clear", pty=True)
+    logger.info("📦 Installing invoke...")
+    c.run("uv tool install invoke", pty=True)
+    logger.info("✅ Virtual environment created successfully")
+
+
+@task
+def install(
+    c: Context, optional_deps: bool = True, dev_deps: bool = True, docs_deps: bool = False
+) -> None:
+    r"""Install project dependencies and the package in editable mode.
+
+    Args:
+        c: The invoke context.
+        optional_deps: If True, install all optional dependencies defined in
+            the project extras. Default is True.
+        dev_deps: If True, install development dependencies. Default is True.
+        docs_deps: If True, install documentation generation dependencies.
+            Default is False.
+    """
+    logger.info("📦 Installing project dependencies...")
+    cmd = ["uv sync --frozen"]
+    if optional_deps:
+        cmd.append("--all-extras")
+    if dev_deps:
+        cmd.append("--group dev")
+    if docs_deps:
+        cmd.append("--group docs")
+    c.run(" ".join(cmd), pty=True)
+    logger.info("🔧 Installing package in editable mode...")
+    c.run("uv pip install -e .", pty=True)
+    logger.info("✅ Installation complete")
+
+
+@task
+def update(c: Context) -> None:
+    r"""Update dependencies and pre-commit hooks to their latest versions.
+
+    Warning:
+        This may introduce breaking changes. Review the changes and run tests
+        after updating.
+    """
+    logger.info("🔄 Updating dependencies...")
+    c.run("uv sync --upgrade", pty=True)
+    logger.info("🛠️  Upgrading uv tools...")
+    c.run("uv tool upgrade --all", pty=True)
+    logger.info("🪝 Updating pre-commit hooks...")
+    c.run("pre-commit autoupdate", pty=True)
+    logger.info("📦 Reinstalling with docs dependencies...")
+    install(c, docs_deps=True)
+    logger.info("✅ Update complete")
+
+
+@task
+def show_installed_packages(c: Context) -> None:
+    r"""Show the installed packages."""
+    logger.info("📦 Listing installed packages...")
+    c.run("uv pip list", pty=True)
+
+
+@task
+def show_python_config(c: Context) -> None:
+    r"""Show the python configuration."""
+    logger.info("🐍 Python configuration:")
+    c.run("uv python list --only-installed", pty=True)
+    c.run("uv python find", pty=True)
+    c.run("which python", pty=True)

invoke_tasklib/format.py

@@ -0,0 +1,89 @@
+r"""Code and docstring formatting tasks.
+
+Naming convention: ``check_<target>`` tasks are read-only (they fail
+without modifying files); ``fix_<target>`` tasks modify files in place.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from invoke.tasks import task
+
+from invoke_tasklib.config import get_config
+
+if TYPE_CHECKING:
+    from invoke.context import Context
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+_FIND_SH = "find . -name '*.sh' -type f -not -path './.git/*'"
+
+
+@task
+def check_python(c: Context) -> None:
+    r"""Check code format with ruff without modifying files."""
+    logger.info("🎨 Checking code format with ruff...")
+    c.run("ruff format --check .", pty=True)
+    logger.info("✅ Code format check passed")
+
+
+@task
+def check_docstrings(c: Context) -> None:
+    r"""Check docstring formatting with docformatter without modifying
+    files."""
+    cfg = get_config(c)
+    src = cfg["paths"]["src"]
+    logger.info("📖 Checking docstring formatting...")
+    c.run(f"docformatter --config ./pyproject.toml --check {src}", pty=True)
+    logger.info("✅ Docstring format check passed")
+
+
+@task
+def fix_python(c: Context) -> None:
+    r"""Format code in place with ruff.
+
+    Note:
+        This modifies files in place. Ensure your work is committed before
+        running this task.
+    """
+    logger.info("🎨 Formatting code with ruff...")
+    c.run("ruff format .", pty=True)
+    logger.info("✅ Code formatting complete")
+
+
+@task
+def fix_docstrings(c: Context) -> None:
+    r"""Format docstrings in source code with docformatter.
+
+    Note:
+        This modifies files in place. Ensure your work is committed before
+        running this task.
+    """
+    cfg = get_config(c)
+    src = cfg["paths"]["src"]
+    logger.info("📖 Formatting docstrings...")
+    c.run(f"docformatter --config ./pyproject.toml --in-place {src}", pty=True)
+    logger.info("✅ Docstring formatting complete")
+
+
+@task
+def check_shell(c: Context) -> None:
+    r"""Check shell scripts with shellcheck."""
+    logger.info("🐚 Running shellcheck on shell scripts...")
+    c.run(f"{_FIND_SH} -print0 | xargs -0 -r shellcheck --", pty=True)
+    logger.info("✅ Shellcheck passed")
+
+
+@task
+def fix_shell(c: Context) -> None:
+    r"""Format shell scripts in place with shfmt.
+
+    Note:
+        This modifies files in place. Ensure your work is committed before
+        running this task.
+    """
+    logger.info("🔧 Running shfmt to format shell scripts...")
+    c.run(f"{_FIND_SH} -print0 | xargs -0 -r shfmt -l -w --", pty=True)
+    logger.info("✅ Shell formatting complete")

invoke_tasklib/lint.py

@@ -0,0 +1,21 @@
+r"""Lint tasks."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from invoke.tasks import task
+
+if TYPE_CHECKING:
+    from invoke.context import Context
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+@task
+def check_lint(c: Context) -> None:
+    r"""Check code linting with ruff."""
+    logger.info("🔍 Checking code linting with ruff...")
+    c.run("ruff check --output-format=github .", pty=True)
+    logger.info("✅ Linting check passed")

invoke_tasklib/release.py

@@ -0,0 +1,47 @@
+r"""Build and publish tasks (PyPI package)."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from invoke.tasks import task
+
+from invoke_tasklib.config import get_config
+
+if TYPE_CHECKING:
+    from invoke.context import Context
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+@task
+def build(c: Context, check: bool = False) -> None:
+    r"""Build the package and verify it can be installed.
+
+    Args:
+        c: The invoke context.
+        check: If True, also check the package's PyPI metadata with
+            twine. Default is False.
+    """
+    cfg = get_config(c)
+    name = cfg["package"]["name"]
+    logger.info("📦 Building package...")
+    c.run("uv build", pty=True)
+    logger.info("🔍 Verifying package installation...")
+    c.run(
+        f'uv run --with {name} --refresh-package {name} --no-project -- python -c "import {name}"',
+        pty=True,
+    )
+    if check:
+        logger.info("🔍 Checking package metadata with twine...")
+        c.run("uvx twine check dist/*", pty=True)
+
+
+@task
+def pypi(c: Context) -> None:
+    r"""Build and publish the package to PyPI."""
+    build(c)
+    logger.info("🚀 Publishing to PyPI...")
+    c.run("uv publish --token ${PYPI_TOKEN}", pty=True)
+    logger.info("✅ Package published successfully")

invoke_tasklib/test.py

@@ -0,0 +1,124 @@
+r"""Test and benchmark tasks."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from invoke.tasks import task
+
+from invoke_tasklib.config import get_config
+
+if TYPE_CHECKING:
+    from invoke.context import Context
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+@task
+def doctest(c: Context) -> None:
+    r"""Run doctests on source code."""
+    cfg = get_config(c)
+    src = cfg["paths"]["src"]
+    logger.info("📚 Running doctests on source code...")
+    c.run(f"python -m pytest --xdoctest {src}", pty=True)
+    logger.info("✅ Doctest validation complete")
+
+
+@task
+def all(c: Context, cov: bool = False) -> None:
+    r"""Run all tests (unit, integration, and functional).
+
+    Args:
+        c: The invoke context.
+        cov: If True, generate coverage reports in HTML, XML, and terminal
+            formats. Default is False.
+    """
+    cfg = get_config(c)
+    name = cfg["package"]["name"]
+    tests = cfg["paths"]["tests"]
+    logger.info("🧪 Running all tests...")
+    cmd = ["python -m pytest --xdoctest --timeout 10"]
+    if cov:
+        cmd.append(f"--cov-report html --cov-report xml --cov-report term --cov={name}")
+        logger.info("📊 Coverage reports will be generated")
+    cmd.append(tests)
+    c.run(" ".join(cmd), pty=True)
+    logger.info("✅ All tests complete")
+
+
+@task
+def unit(c: Context, cov: bool = False) -> None:
+    r"""Run unit tests.
+
+    Args:
+        c: The invoke context.
+        cov: If True, generate coverage reports. Default is False.
+    """
+    cfg = get_config(c)
+    name = cfg["package"]["name"]
+    unit_tests = cfg["paths"]["unit_tests"]
+    logger.info("🧪 Running unit tests...")
+    cmd = ["python -m pytest --xdoctest --timeout 10"]
+    if cov:
+        cmd.append(f"--cov-report html --cov-report xml --cov-report term --cov={name}")
+        logger.info("📊 Coverage reports will be generated")
+    cmd.append(unit_tests)
+    c.run(" ".join(cmd), pty=True)
+    logger.info("✅ Unit tests complete")
+
+
+@task
+def integration(c: Context, cov: bool = False) -> None:
+    r"""Run integration tests.
+
+    Args:
+        c: The invoke context.
+        cov: If True, generate coverage reports (appended). Default is False.
+    """
+    cfg = get_config(c)
+    name = cfg["package"]["name"]
+    integration_tests = cfg["paths"]["integration_tests"]
+    logger.info("🧪 Running integration tests...")
+    cmd = ["python -m pytest --xdoctest --timeout 60"]
+    if cov:
+        cmd.append(
+            f"--cov-report html --cov-report xml --cov-report term --cov-append --cov={name}"
+        )
+        logger.info("📊 Coverage reports will be generated (appending)")
+    cmd.append(integration_tests)
+    c.run(" ".join(cmd), pty=True)
+    logger.info("✅ Integration tests complete")
+
+
+@task
+def functional(c: Context, cov: bool = False) -> None:
+    r"""Run functional tests.
+
+    Args:
+        c: The invoke context.
+        cov: If True, generate coverage reports (appended). Default is False.
+    """
+    cfg = get_config(c)
+    name = cfg["package"]["name"]
+    functional_tests = cfg["paths"]["functional_tests"]
+    logger.info("🧪 Running functional tests...")
+    cmd = ["python -m pytest --xdoctest --timeout 60"]
+    if cov:
+        cmd.append(
+            f"--cov-report html --cov-report xml --cov-report term --cov-append --cov={name}"
+        )
+        logger.info("📊 Coverage reports will be generated (appending)")
+    cmd.append(functional_tests)
+    c.run(" ".join(cmd), pty=True)
+    logger.info("✅ Functional tests complete")
+
+
+@task
+def benchmark(c: Context) -> None:
+    r"""Run performance benchmarks."""
+    cfg = get_config(c)
+    benchmarks = cfg["paths"]["benchmarks"]
+    logger.info("⏱️  Running benchmarks...")
+    c.run(f"python -m pytest {benchmarks}/ --benchmark-only", pty=True)
+    logger.info("✅ Benchmarks complete")

invoke_tasklib/types.py

@@ -0,0 +1,25 @@
+r"""Type-checking tasks."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from invoke.tasks import task
+
+from invoke_tasklib.config import get_config
+
+if TYPE_CHECKING:
+    from invoke.context import Context
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+@task
+def check(c: Context) -> None:
+    r"""Check type hints with pyright."""
+    cfg = get_config(c)
+    name = cfg["package"]["name"]
+    logger.info("🔬 Checking type hints with pyright...")
+    c.run(f"pyright --verifytypes {name} --ignoreexternal", pty=True)
+    logger.info("✅ Type check passed")

invoke_tasklib-0.0.1.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.5
+Name: invoke-tasklib
+Version: 0.0.1
+Summary: Reusable Invoke tasks shared across Python projects.
+Project-URL: Homepage, https://github.com/durandtibo/invoke-tasklib
+Project-URL: Repository, https://github.com/durandtibo/invoke-tasklib
+Project-URL: Documentation, https://durandtibo.github.io/invoke-tasklib/
+Project-URL: Changelog, https://github.com/durandtibo/invoke-tasklib/releases
+Project-URL: Issues, https://github.com/durandtibo/invoke-tasklib/issues
+Author-email: Thibaut Durand <durand.tibo+gh@gmail.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: automation,devtools,invoke,tasks
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.10
+Requires-Dist: invoke>=3.0
+Description-Content-Type: text/markdown
+
+# invoke-tasklib
+
+Reusable [Invoke](https://www.pyinvoke.org/) tasks shared across Python
+projects.
+
+## Installation
+
+Add `invoke-tasklib` as a dev dependency.
+
+## Usage
+
+In your project's `tasks.py`:
+
+```python
+from invoke_tasklib import ns
+```
+
+Set the required config in `invoke.yaml` at the project root:
+
+```yaml
+tasklib:
+  package:
+    name: my_package
+```
+
+Then list the available tasks:
+
+```shell
+invoke --list
+```
+
+## Tasks
+
+Tasks are organized into namespaces: `format.*`, `lint.*`, `types.*`,
+`test.*`, `env.*`, `release.*`, `doc.*`.
+
+### `format.*` and `lint.*`
+
+Tasks that check or verify something (never modify files, exit non-zero on
+violations) are named `check_<target>`. Tasks that modify files in place are
+named `fix_<target>`. Both share the same `<target>` (e.g. `python`, `shell`,
+`docstrings`) so the read-only/mutating counterpart of a task is easy to find:
+
+| Task                      | Behavior                                                  |
+| ------------------------- | --------------------------------------------------------- |
+| `format.check-python`     | Checks Python formatting with ruff (read-only)            |
+| `format.check-docstrings` | Checks docstring formatting with docformatter (read-only) |
+| `format.check-shell`      | Checks shell scripts with shellcheck (read-only)          |
+| `format.fix-python`       | Formats Python code with ruff (in place)                  |
+| `format.fix-docstrings`   | Formats docstrings with docformatter (in place)           |
+| `format.fix-shell`        | Formats shell scripts with shfmt (in place)               |
+| `lint.check-lint`         | Checks linting with ruff (read-only)                      |
+
+When adding a new task to these namespaces, follow this convention: pick
+`check_` or `fix_` based on whether the task mutates files, and use a
+`<target>` name that matches its read-only/mutating counterpart if one
+exists.
+
+### `types.*`
+
+| Task          | Behavior                                   |
+| ------------- | ------------------------------------------ |
+| `types.check` | Checks type hints with pyright (read-only) |
+
+### `test.*`
+
+| Task               | Behavior                                           |
+| ------------------ | -------------------------------------------------- |
+| `test.doctest`     | Runs doctests on source code                       |
+| `test.unit`        | Runs unit tests                                    |
+| `test.integration` | Runs integration tests                             |
+| `test.functional`  | Runs functional tests                              |
+| `test.all`         | Runs all tests (unit, integration, and functional) |
+| `test.benchmark`   | Runs performance benchmarks                        |
+
+### `env.*`
+
+| Task                          | Behavior                                                 |
+| ----------------------------- | -------------------------------------------------------- |
+| `env.create-venv`             | Creates a virtual environment and installs invoke        |
+| `env.install`                 | Installs project dependencies and the package (editable) |
+| `env.update`                  | Updates dependencies and pre-commit hooks                |
+| `env.show-installed-packages` | Shows the installed packages                             |
+| `env.show-python-config`      | Shows the Python configuration                           |
+
+### `release.*`
+
+| Task            | Behavior                                                                                    |
+| --------------- | ------------------------------------------------------------------------------------------- |
+| `release.build` | Builds the package and verifies installation (`--check` also validates metadata with twine) |
+| `release.pypi`  | Builds and publishes the package to PyPI                                                    |
+
+### `doc.*`
+
+| Task                 | Behavior                              |
+| -------------------- | ------------------------------------- |
+| `doc.publish-dev`    | Publishes development (unstable) docs |
+| `doc.publish-latest` | Publishes latest (stable) docs        |
+
+## Config
+
+Only `tasklib.package.name` is required. Everything else has a default
+derived from it. Full schema:
+
+```yaml
+tasklib:
+  package:
+    name: my_package # required
+    python_version: "3.14" # used by env.create-venv
+  paths:
+    src: src/my_package # default: src/<package.name>
+    tests: tests
+    unit_tests: tests/unit # default: <tests>/unit
+    integration_tests: tests/integration # default: <tests>/integration
+    functional_tests: tests/functional # default: <tests>/functional
+    benchmarks: tests/benchmarks # default: <tests>/benchmarks
+    docs_config: docs/mkdocs.yml
+```
+
+## Composing a custom subset of tasks
+
+If a project needs a different set of tasks, or a one-off task alongside the
+shared ones, import individual task modules instead of the pre-built `ns`:
+
+```python
+from invoke import Collection
+from invoke_tasklib import lint, test
+
+from . import my_custom_task
+
+ns = Collection(lint, test, my_custom_task)
+```
+
+Prefer adding a config knob to a shared task over forking it; reserve custom
+composition for things that are genuinely one-off to a single project.

invoke_tasklib-0.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+invoke_tasklib/__init__.py,sha256=Hd-mmmIvfnAx43Zu9aQSIwdIrsK8OJ2v6W1Glk2kQoo,1163
+invoke_tasklib/config.py,sha256=L-lGrvaSzBnordp_4DFC1lYRxkfqCHt5m8lt0ddU-lU,2884
+invoke_tasklib/doc.py,sha256=ddEaXbaoZsaL-zspDESjPbME-s-8pHNtOTQ_CPz7MOg,2190
+invoke_tasklib/env.py,sha256=ZFy3VjpIGDTmVwVSfirHgtlys2csBTnPKO3odddGDpw,3057
+invoke_tasklib/format.py,sha256=NvLJQxPPsQ9GhrOmxkM5nvyE57pgLCfHns44LUQQzFI,2638
+invoke_tasklib/lint.py,sha256=ojAPP6G16C2sLEk3JIrjeaIqIelEegyDrNgwv_lOe6c,494
+invoke_tasklib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+invoke_tasklib/release.py,sha256=_J2lrVlbFZksfVd5lsDOjhb3odL_xXRtTkui6z-9FKg,1310
+invoke_tasklib/test.py,sha256=HdcDyqGB91eQAEGGBiqKZXmg9VrqvPo-MbbDgah5YjQ,3875
+invoke_tasklib/types.py,sha256=k01Yx781neHaftciTTLE1M-fWeNf0G29QLSvqTf4P9o,612
+invoke_tasklib-0.0.1.dist-info/METADATA,sha256=m6MDkqqTjHA1CI2SPw6tDt0UKqw9prFGNcU-qcLwvNw,6521
+invoke_tasklib-0.0.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+invoke_tasklib-0.0.1.dist-info/licenses/LICENSE,sha256=ZvV2ToDI3ZjTHHMRFQpG9WG1zV-OwBJCJRe_FZM6lBw,1501
+invoke_tasklib-0.0.1.dist-info/RECORD,,

invoke_tasklib-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

invoke_tasklib-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Thibaut Durand
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.