tasklane 0.1.0__tar.gz

tasklane-0.1.0/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,31 @@
+---
+name: Bug report
+about: Report something that isn't working as documented
+title: ""
+labels: bug
+assignees: ""
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**Minimal reproducible example**
+
+```python
+import asyncio
+import tasklane
+
+# ... the smallest snippet that reproduces the problem
+```
+
+**Expected behavior**
+What you expected to happen.
+
+**Actual behavior**
+What actually happened, including the full traceback if there is one.
+
+**Environment**
+
+- tasklane version:
+- Python version:
+- OS:

tasklane-0.1.0/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,19 @@
+---
+name: Feature request
+about: Suggest an idea for tasklane
+title: ""
+labels: enhancement
+assignees: ""
+---
+
+**What problem are you trying to solve?**
+A clear description of the use case or pain point.
+
+**Proposed solution**
+What you'd like to see. A sketch of the API you have in mind helps a lot.
+
+**Alternatives considered**
+Any workarounds you're using today, or other approaches you weighed.
+
+**Additional context**
+Anything else relevant — links, prior art in other libraries, etc.

tasklane-0.1.0/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,15 @@
+## Summary
+
+<!-- What does this PR change, and why? -->
+
+## Checklist
+
+- [ ] Tests added or updated (and `uv run pytest` passes)
+- [ ] `uv run ruff check .` and `uv run ruff format --check .` pass
+- [ ] `uv run mypy` passes
+- [ ] Docstrings / README updated if behavior changed
+- [ ] Added a `CHANGELOG.md` entry under `Unreleased`
+
+## Notes for reviewers
+
+<!-- Anything that needs special attention, trade-offs, follow-ups, etc. -->

tasklane-0.1.0/.github/dependabot.yml

@@ -0,0 +1,21 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    groups:
+      actions:
+        patterns: ["*"]
+    commit-message:
+      prefix: "ci"
+
+  - package-ecosystem: "uv"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    groups:
+      dev-dependencies:
+        patterns: ["*"]
+    commit-message:
+      prefix: "deps"

tasklane-0.1.0/.github/workflows/ai-review.yml

@@ -0,0 +1,59 @@
+name: AI review
+
+# Advisory Codex review on pull requests. Runs only when the OPENAI_API_KEY
+# secret is configured, which means it never runs for fork PRs (secrets are not
+# exposed to forks). The review is posted as a single sticky comment and never
+# blocks a merge. Override the model with the OPENAI_MODEL repository variable.
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+concurrency:
+  group: ai-review-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  codex-review:
+    name: Codex review
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: Check for API key
+        id: guard
+        env:
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+        run: |
+          if [ -n "$OPENAI_API_KEY" ]; then
+            echo "enabled=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "enabled=false" >> "$GITHUB_OUTPUT"
+            echo "OPENAI_API_KEY not set; skipping AI review (this is fine)."
+          fi
+      - name: Set up Python
+        if: steps.guard.outputs.enabled == 'true'
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - name: Collect PR diff
+        if: steps.guard.outputs.enabled == 'true'
+        env:
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: git diff "$BASE_SHA...$HEAD_SHA" > pr.diff
+      - name: Run Codex review
+        if: steps.guard.outputs.enabled == 'true'
+        env:
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          OPENAI_MODEL: ${{ vars.OPENAI_MODEL }}
+          GITHUB_TOKEN: ${{ github.token }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          DIFF_FILE: pr.diff
+        run: python3 scripts/ai_review.py

tasklane-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,54 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    name: lint & type-check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+      - name: Sync dependencies
+        run: uv sync --locked
+      - name: Ruff (lint)
+        run: uv run ruff check --output-format=github .
+      - name: Ruff (format)
+        run: uv run ruff format --check .
+      - name: Mypy
+        run: uv run mypy
+
+  test:
+    name: test (py${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v6
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+      - name: Sync dependencies
+        run: uv sync --locked
+      - name: Run tests with coverage
+        run: |
+          uv run coverage run -m pytest
+          uv run coverage report

tasklane-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,48 @@
+name: Release
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build distributions
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+      - name: Build sdist and wheel
+        run: uv build
+      - name: Check distribution metadata
+        run: uvx twine check dist/*
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    name: Publish to PyPI
+    needs: build
+    runs-on: ubuntu-latest
+    # Trusted Publishing: configure this environment on PyPI, no API token needed.
+    environment:
+      name: pypi
+      url: https://pypi.org/p/tasklane
+    permissions:
+      id-token: write
+    steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@v8
+        with:
+          name: dist
+          path: dist/
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@release/v1

tasklane-0.1.0/.gitignore

@@ -0,0 +1,27 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+*.so
+
+# Virtual environments
+.venv/
+venv/
+
+# Tooling caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+
+# Editors / OS
+.idea/
+.vscode/
+.claude/
+.DS_Store

tasklane-0.1.0/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+All notable changes to this project are documented here. The format is based on
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-06-02
+
+### Added
+
+- `amap()` — concurrent map with a bounded concurrency limit, returning results
+  in input order. Supports sync and async iterables in constant memory.
+- `stream()` — async iterator yielding results in completion order.
+- `gather()` — a concurrency-limited drop-in for `asyncio.gather`, closing any
+  un-awaited coroutines on fail-fast.
+- `Lane` — an immutable, reusable bundle of settings.
+- Retries with `Backoff` strategies (`exponential`, `linear`, `constant`) and a
+  flexible `retry_on` (type, tuple, or predicate).
+- Per-task `timeout` and per-second `rate_limit`.
+- `Progress` snapshots via an `on_progress` callback.
+- `return_exceptions` to collect failures instead of raising.
+- Fully typed, `py.typed`, zero runtime dependencies, Python 3.10–3.14.
+
+### Fixed
+
+- `timeout` always surfaces the builtin `TimeoutError`. On Python 3.10,
+  `asyncio.wait_for` raises the distinct `asyncio.TimeoutError` (the two types
+  were unified in 3.11), so `except TimeoutError` and `retry_on=TimeoutError`
+  now behave consistently across Python 3.10–3.14.
+
+[Unreleased]: https://github.com/jpwm2/tasklane/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/jpwm2/tasklane/releases/tag/v0.1.0

tasklane-0.1.0/CODE_OF_CONDUCT.md

@@ -0,0 +1,57 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment include:
+
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes
+- Focusing on what is best for the overall community
+
+Examples of unacceptable behavior include:
+
+- The use of sexualized language or imagery, and sexual attention or advances
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information without explicit permission
+- Other conduct which could reasonably be considered inappropriate
+
+## Enforcement Responsibilities
+
+Community maintainers are responsible for clarifying and enforcing our standards
+and will take appropriate and fair corrective action in response to any behavior
+they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the maintainers privately via
+[GitHub Security Advisories](https://github.com/jpwm2/tasklane/security/advisories/new).
+All complaints will be reviewed and investigated promptly and fairly.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+https://www.contributor-covenant.org/version/2/1/code_of_conduct.html.
+
+[homepage]: https://www.contributor-covenant.org

tasklane-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,62 @@
+# Contributing to tasklane
+
+Thanks for your interest in improving `tasklane`! This project aims to be small,
+correct, and a pleasure to depend on, so contributions of all sizes are welcome —
+bug reports, docs, tests, and features alike.
+
+## Development setup
+
+`tasklane` uses [uv](https://docs.astral.sh/uv/) for environment management.
+
+```bash
+git clone https://github.com/jpwm2/tasklane
+cd tasklane
+uv sync
+```
+
+## The checks that CI runs
+
+Please make sure these pass locally before opening a pull request:
+
+```bash
+uv run pytest                 # test suite
+uv run ruff check .           # lint
+uv run ruff format --check .  # formatting
+uv run mypy                   # static types (strict)
+```
+
+To auto-fix formatting and lint:
+
+```bash
+uv run ruff format .
+uv run ruff check --fix .
+```
+
+## Automated review
+
+Pull requests opened from this repository receive an **advisory** Codex review
+that posts a single sticky comment (it only runs when a maintainer has configured
+the `OPENAI_API_KEY` secret, so it never runs on fork PRs). It is a helper, not a
+gate — a green CI run is what's required to merge.
+
+## Guidelines
+
+- **Keep the runtime dependency-free.** A core promise of `tasklane` is zero
+  third-party runtime dependencies. Dev/test dependencies are fine.
+- **Stay typed.** The codebase passes `mypy --strict`. New public API needs full
+  type annotations.
+- **Add tests.** Bug fixes should come with a regression test; features with
+  tests covering the happy path and the obvious edge cases.
+- **Update the docs.** If you change behavior, update the README and docstrings.
+- **Add a changelog entry** under the `Unreleased` heading in
+  [CHANGELOG.md](CHANGELOG.md).
+
+## Reporting bugs and requesting features
+
+Open an issue using one of the templates. For bugs, a minimal reproducible
+example and your Python version go a long way.
+
+## Code of Conduct
+
+This project follows the [Contributor Covenant](CODE_OF_CONDUCT.md). By
+participating, you are expected to uphold it.

tasklane-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tasklane contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tasklane-0.1.0/PKG-INFO

@@ -0,0 +1,226 @@
+Metadata-Version: 2.4
+Name: tasklane
+Version: 0.1.0
+Summary: Bounded-concurrency async for Python: run, map, and stream awaitables with limits, retries, rate limiting, and progress — in one typed call.
+Project-URL: Homepage, https://github.com/jpwm2/tasklane
+Project-URL: Repository, https://github.com/jpwm2/tasklane
+Project-URL: Issues, https://github.com/jpwm2/tasklane/issues
+Project-URL: Changelog, https://github.com/jpwm2/tasklane/blob/main/CHANGELOG.md
+Author: jpwm2
+License-Expression: MIT
+License-File: LICENSE
+Keywords: async,asyncio,concurrency,gather,parallel,rate-limit,retry,semaphore,task-pool,throttle
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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 :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# tasklane
+
+**Bounded-concurrency async for Python — run, map, and stream awaitables with a
+concurrency limit, retries, backoff, rate limiting, and progress, in one typed call.**
+
+[![CI](https://github.com/jpwm2/tasklane/actions/workflows/ci.yml/badge.svg)](https://github.com/jpwm2/tasklane/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/tasklane.svg)](https://pypi.org/project/tasklane/)
+[![Python](https://img.shields.io/pypi/pyversions/tasklane.svg)](https://pypi.org/project/tasklane/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Types: typed](https://img.shields.io/badge/types-100%25-blue.svg)](src/tasklane/py.typed)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+Every Python project that fans out async work eventually rewrites the same block:
+an `asyncio.Semaphore` to cap concurrency, a `try/except` retry loop, a counter
+for progress, maybe a sleep to stay under a rate limit. `tasklane` is that block,
+done once — correct, fully typed, and **zero runtime dependencies**.
+
+```python
+import asyncio
+import httpx
+import tasklane
+
+async def fetch(url: str) -> int:
+    async with httpx.AsyncClient() as client:
+        return len((await client.get(url)).text)
+
+async def main() -> None:
+    urls = [f"https://example.com/{i}" for i in range(1000)]
+
+    sizes = await tasklane.amap(
+        fetch, urls,
+        limit=20,          # at most 20 requests in flight
+        retries=3,         # retry failures up to 3x with exponential backoff
+        rate_limit=50,     # start at most 50 requests per second
+        timeout=10,        # per-attempt timeout (seconds)
+    )
+    print(sum(sizes))
+
+asyncio.run(main())
+```
+
+## Install
+
+```bash
+pip install tasklane
+# or
+uv add tasklane
+```
+
+Requires Python 3.10+. No third-party dependencies.
+
+## Why not just `asyncio.gather`?
+
+`asyncio.gather` starts **everything at once**. Fan out 10,000 requests and you
+open 10,000 sockets, trip rate limits, and OOM. The usual fixes are scattered
+across the stdlib and third-party libs; `tasklane` brings them together:
+
+|                              | `asyncio.gather` | `Semaphore` + `gather` | `aiometer` | **tasklane** |
+| ---------------------------- | :--------------: | :--------------------: | :--------: | :----------: |
+| Concurrency limit            |        ✗         |        manual          |     ✓      |      ✓       |
+| Results in input order       |        ✓         |          ✓             |     ✓      |      ✓       |
+| Stream results as completed  |   `as_completed` |        manual          |     ✓      |      ✓       |
+| Retries + backoff            |        ✗         |          ✗             |     ✗      |      ✓       |
+| Rate limiting (per second)   |        ✗         |          ✗             |     ✓      |      ✓       |
+| Progress callbacks           |        ✗         |          ✗             |     ✗      |      ✓       |
+| Per-task timeout             |        ✗         |        manual          |     ✗      |      ✓       |
+| Backpressure on huge inputs  |        ✗         |        manual          |     ✓      |      ✓       |
+| Runtime dependencies         |      stdlib      |        stdlib          |  `anyio`   |  **none**    |
+
+## Features
+
+### `amap` — concurrent map, results in order
+
+```python
+results = await tasklane.amap(fetch, urls, limit=10)
+# results[i] corresponds to urls[i]
+```
+
+Accepts both sync and **async** iterables, and works in constant memory thanks to
+a bounded internal queue — you can map over a million-item generator without
+materializing a million tasks.
+
+### `stream` — react to results as they finish
+
+```python
+async for size in tasklane.stream(fetch, urls, limit=10):
+    print(size)  # arrives in completion order, fastest first
+```
+
+### `gather` — a drop-in `asyncio.gather` with a limit
+
+```python
+results = await tasklane.gather(*(fetch(u) for u in urls), limit=10)
+```
+
+On fail-fast, the remaining coroutines are cancelled **and closed**, so you never
+see a `coroutine was never awaited` warning.
+
+### Retries with backoff
+
+```python
+from tasklane import Backoff
+
+await tasklane.amap(
+    fetch, urls,
+    retries=5,
+    backoff=Backoff.exponential(0.2, factor=2, max_delay=30),  # 0.2, 0.4, 0.8, ... + jitter
+    retry_on=(TimeoutError, ConnectionError),                  # type, tuple, or predicate
+)
+```
+
+`Backoff.exponential()` (the default when `retries > 0`), `Backoff.linear()`, and
+`Backoff.constant()` cover the common cases. `retry_on` accepts an exception type,
+a tuple of types, or a `Callable[[BaseException], bool]` predicate.
+
+### Rate limiting
+
+```python
+# Never start more than 100 tasks per second, regardless of the concurrency limit.
+await tasklane.amap(call_api, items, limit=50, rate_limit=100)
+```
+
+### Progress
+
+```python
+from tasklane import Progress
+
+def show(p: Progress) -> None:
+    print(f"{p.completed}/{p.total}  ({p.failed} failed)  {p.rate:.0f}/s")
+
+await tasklane.amap(fetch, urls, limit=10, on_progress=show)
+```
+
+`Progress` carries `completed`, `total`, `succeeded`, `failed`, `in_flight`, and
+`elapsed`, plus `remaining`, `fraction`, and `rate` helpers. Plug it into `tqdm`,
+a logger, or a web UI — no progress-bar dependency is imposed on you.
+
+### Collect errors instead of raising
+
+```python
+results = await tasklane.amap(fetch, urls, return_exceptions=True)
+ok = [r for r in results if not isinstance(r, Exception)]
+```
+
+### `Lane` — configure once, reuse everywhere
+
+```python
+from tasklane import Lane
+
+# One policy for a specific downstream API.
+github = Lane(limit=8, retries=3, rate_limit=20, timeout=10)
+
+repos = await github.map(fetch_repo, repo_names)
+async for issue in github.stream(fetch_issue, issue_ids):
+    ...
+
+# Lanes are immutable; derive a variant with .replace()
+bulk = github.replace(limit=32)
+```
+
+## How it works
+
+`tasklane` runs a fixed pool of `limit` worker coroutines that pull items off a
+bounded `asyncio.Queue`. The bounded queue is what gives you backpressure and
+constant memory; the worker pool is what enforces the concurrency limit exactly.
+Retries, per-attempt timeouts, and rate limiting are applied inside each worker,
+and completions are streamed back to the caller — collected into order for
+`amap`, or yielded as-they-finish for `stream`. On any early exit (fail-fast,
+`break`, or external cancellation) every in-flight task is cancelled and awaited,
+so nothing leaks.
+
+## API reference
+
+| Symbol | Description |
+| ------ | ----------- |
+| `amap(func, items, *, limit, retries, backoff, retry_on, timeout, return_exceptions, rate_limit, on_progress)` | Concurrent map; returns a list in input order. |
+| `stream(func, items, *, ...)` | Async iterator yielding results in completion order. |
+| `gather(*coros, limit, timeout, rate_limit, return_exceptions, on_progress)` | Concurrency-limited `asyncio.gather`. |
+| `Lane(...)` | Reusable, immutable bundle of settings with `.map`, `.stream`, `.gather`, `.replace`. |
+| `Backoff` | Retry delay strategy: `.exponential`, `.linear`, `.constant`. |
+| `Progress` | Immutable progress snapshot passed to `on_progress`. |
+
+Full signatures and docstrings ship with the package and are surfaced by your
+editor (the library is fully typed and marked with `py.typed`).
+
+## Contributing
+
+Contributions are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md). In short:
+
+```bash
+uv sync
+uv run pytest          # tests
+uv run ruff check .    # lint
+uv run mypy            # types
+```
+
+## License
+
+[MIT](LICENSE) © tasklane contributors