invoke-tasklib 0.0.1__tar.gz

invoke_tasklib-0.0.1/.gitignore

@@ -0,0 +1,218 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer,
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

invoke_tasklib-0.0.1/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.

invoke_tasklib-0.0.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,135 @@
+# 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/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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/pyproject.toml

@@ -0,0 +1,80 @@
+[build-system]
+requires = ["hatchling >= 1.32"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+sources = ["src"]
+
+[tool.hatch.build.targets.sdist]
+only-include = ["src"]
+
+[project]
+name = "invoke-tasklib"
+version = "0.0.1"
+description = "Reusable Invoke tasks shared across Python projects."
+readme = "README.md"
+authors = [
+    { name = "Thibaut Durand", email = "durand.tibo+gh@gmail.com" },
+]
+keywords = ["invoke", "tasks", "automation", "devtools"]
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: BSD License",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Build Tools",
+]
+
+requires-python = ">=3.10"
+dependencies = ["invoke>=3.0"]
+
+
+
+[dependency-groups]
+dev = [
+    "coverage[toml]>=7.15,<8.0",
+    "docformatter[tomli]>=1.7.8,<2.0",
+    "feu[all]>=0.8.1,<1.0",
+    "invoke>=3.0,<4.0",
+    "pre-commit>=4.6,<5.0",
+    "pygments>=2.20,<3.0",
+    "pyright>=1.1.411,<2.0",
+    "pytest>=9.1,<10.0",
+    "pytest-cov>=7.1,<8.0",
+    "pytest-timeout>=2.4,<3.0",
+    "ruff>=0.16,<1.0",
+    "xdoctest>=1.3,<2.0",
+]
+docs = [
+    "mike >=2.2,<3.0",
+    "mkdocs-material >=9.7,<10.0",
+    "mkdocstrings[python]>=1.0,<2.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/durandtibo/invoke-tasklib"
+Repository = "https://github.com/durandtibo/invoke-tasklib"
+Documentation = "https://durandtibo.github.io/invoke-tasklib/"
+Changelog = "https://github.com/durandtibo/invoke-tasklib/releases"
+Issues = "https://github.com/durandtibo/invoke-tasklib/issues"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.pyright]
+include = ["src"]
+venvPath = "."
+venv = ".venv"