timedbatch 0.2.0__tar.gz

timedbatch-0.2.0/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

timedbatch-0.2.0/.github/FUNDING.yml

@@ -0,0 +1 @@
+buy_me_a_coffee: jlianesglrs

timedbatch-0.2.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/

timedbatch-0.2.0/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.0]
+
+### Added
+
+- `TimedBatcher`: a thread-safe push batcher. A background thread delivers batches on
+  size, on age (also while idle), on `flush()` and on `close()`, one at a time and in
+  order. `on_error` or `FlushError` hands every failed batch back; `max_pending` adds
+  back-pressure (`BatcherFull` after `timeout`); a forgotten batcher is closed at
+  interpreter exit; `background=False` runs without a thread for deterministic tests.
+- `AsyncTimedBatcher`: the same for one asyncio event loop, with an async flush function.
+- `abatched_by_time`: batch an async iterable, yielding partial batches on time while the
+  source is idle without losing the read in flight.
+- `FlushError`, `BatcherClosed` and `BatcherFull`.
+
+### Changed
+
+- `batched_by_time` checks its limits when called instead of on the first step, rejects
+  `bool`, floats and other non-integer counts and a NaN window, and accepts `math.inf`
+  for count-only batching. Integer types such as NumPy's (anything with `__index__`)
+  and `Decimal` windows keep working.
+- When the source raises, `batched_by_time` yields the items already read before the
+  exception.
+
+## [0.1.0]
+
+- First release.
+- `batched_by_time`: batch an iterable by a max count and a max time window,
+  flushing when either limit is reached and at the end, with an injectable clock.

timedbatch-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,24 @@
+# Contributing
+
+Thanks for taking the time. This project keeps a small, predictable shape.
+
+## Setup
+
+```
+pip install -r requirements-dev.txt
+```
+
+## Before you open a pull request
+
+- Keep public API in `src/timedbatch/__init__.py`; internals live in `_`-prefixed modules.
+- Add a test for the behaviour you change. Tests inject time, disk and network where
+  they can. Three files use the real clock or real processes on purpose:
+  `test_batcher_thread.py` and the asyncio tests (idle flushes need real waiting, with
+  wide margins), `test_stress.py` (many threads and tasks), and `test_exit.py` (child
+  interpreters prove the exit flush).
+- `TIMEDBATCH_E2E=1 pytest tests/test_e2e_wheel.py` builds the wheel, installs it in a
+  fresh virtual environment and drives the installed package.
+- Run `scripts/check.ps1` (format, lint, types, tests) and make sure it passes.
+- One logical change per commit, imperative subject line.
+
+Open an issue first if the change is large or shifts the public API.

timedbatch-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Javier Lianes
+
+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.

timedbatch-0.2.0/PKG-INFO

@@ -0,0 +1,247 @@
+Metadata-Version: 2.5
+Name: timedbatch
+Version: 0.2.0
+Summary: Batch items by a max count and a max age, for iterables, threads and asyncio, without losing items
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Repository, https://github.com/JaviLianes8/timedbatch
+Project-URL: Issues, https://github.com/JaviLianes8/timedbatch/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/timedbatch/blob/main/CHANGELOG.md
+Project-URL: LinkedIn, https://www.linkedin.com/in/jlianes/
+Project-URL: Funding, https://buymeacoffee.com/jlianesglrs
+Author-email: Javier Lianes <javier@lianes8studio.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: asyncio,back-pressure,batch,batching,buffer,chunk,flush,iterator,streaming,time-window
+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 :: Only
+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: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# timedbatch
+
+Batch items by a max count and a max age, flushing when either limit is hit. Typed, no
+dependencies, for plain iterables, for threads and for asyncio.
+
+## Install
+
+```
+pip install timedbatch
+```
+
+## Which one to use
+
+| You have | Use | Flushes while idle |
+|---|---|---|
+| An iterable you loop over | `batched_by_time` | No: the age is checked when an item arrives |
+| An async iterable | `abatched_by_time` | Yes |
+| Many places calling `add(item)` from threads | `TimedBatcher` | Yes, from a background thread |
+| Many coroutines calling `await add(item)` | `AsyncTimedBatcher` | Yes, from a background task |
+
+A batch is delivered as soon as it holds `max_items` items or its oldest item is
+`max_seconds` old, whichever comes first. `max_seconds` may be `math.inf` to batch by
+count only.
+
+## Iterables
+
+```python
+from timedbatch import batched_by_time
+
+now = 0.0
+
+
+def clock() -> float:  # inject a clock and tests never sleep
+    return now
+
+
+def events():
+    global now
+    for moment, name in [(0.0, "a"), (0.5, "b"), (0.6, "c"), (9.0, "d"), (9.1, "e")]:
+        now = moment
+        yield name
+
+
+for batch in batched_by_time(events(), max_items=2, max_seconds=5.0, clock=clock):
+    print(batch)  # ['a', 'b']
+    # ['c', 'd']
+    # ['e']
+```
+
+`['c', 'd']` closes on age: `d` arrives 8.4 seconds after `c`. If the source raises, the
+items already read are yielded first and the exception follows.
+
+## Threads: `TimedBatcher`
+
+```python
+from timedbatch import TimedBatcher
+
+
+def write_rows(batch: list[int]) -> None:
+    print("insert", batch)
+
+
+with TimedBatcher(write_rows, max_items=2, max_seconds=1.0) as batcher:
+    for row in range(5):
+        batcher.add(row)  # safe from any number of threads
+# insert [0, 1]
+# insert [2, 3]
+# insert [4]
+```
+
+What it promises:
+
+- **Size and age.** A full batch goes out at once; a partial one goes out `max_seconds`
+  after its oldest item, even if nothing else is added.
+- **Order and no overlap.** One background thread calls your function, one batch at a
+  time, in the order the items were accepted. A batch never exceeds `max_items`.
+- **Nothing lost, nothing twice.** Every accepted item is delivered once or handed back
+  once. When `add` raises, the item was not accepted (one exception: with
+  `background=False`, an interrupt raised inside your function passes through `add`,
+  and its batch comes back in the next `FlushError`).
+- **Failures.** Give `on_error(exc, batch)` to decide what to do with a failed batch.
+  Without it, failed batches are kept and raised as a `FlushError` (with `.batches` and
+  `.errors`) by the next `add`, `poll`, `flush` or `close`.
+- **Back-pressure.** `max_pending` caps items accepted but not yet delivered. `add` waits
+  for room, or raises `BatcherFull` (a `TimeoutError`) after `timeout` seconds.
+- **Shutdown.** `close()` (or leaving the `with` block) delivers the rest and stops the
+  thread; later calls to `add` raise `BatcherClosed`. A batcher you forget to close, or
+  whose `close(timeout=...)` timed out, is closed when the interpreter exits normally,
+  through `sys.exit` or an uncaught exception (`flush_at_exit=True`). That exit flush
+  waits for your function, so give it its own timeouts. Nothing can flush after
+  `os._exit`, a kill signal, or in a child created by `os.fork` (it has no thread).
+- **No deadlocks from inside.** Calling `flush`, `poll` or `close` from the flush
+  function raises `RuntimeError`, and an `add` there that would wait raises `BatcherFull`.
+
+Failures come back with their items:
+
+```python
+from timedbatch import FlushError, TimedBatcher
+
+
+def flaky(batch: list[str]) -> None:
+    raise ConnectionError("database is down")
+
+
+batcher = TimedBatcher(flaky, max_items=10, max_seconds=60.0)
+batcher.add("order-1")
+batcher.add("order-2")
+try:
+    batcher.close()
+except FlushError as error:
+    print(error.batches)  # [['order-1', 'order-2']]
+    print(error)  # 1 batch (2 items) failed to flush: ConnectionError('database is down')
+```
+
+### Deterministic tests
+
+`background=False` removes the thread: due batches are delivered by the caller inside
+`add` and `poll()`, so an injected clock drives every age decision (and the `timeout`
+of `flush` and `close` has nothing to wait for).
+
+```python
+from timedbatch import TimedBatcher
+
+now = 0.0
+sent: list[list[str]] = []
+batcher = TimedBatcher(
+    sent.append, max_items=100, max_seconds=5.0, clock=lambda: now, background=False
+)
+batcher.add("x")
+now = 4.9
+batcher.poll()
+print(sent)  # []
+now = 5.0
+batcher.poll()
+print(sent)  # [['x']]
+```
+
+## asyncio
+
+`abatched_by_time` yields a partial batch on time even while the source waits. It keeps
+the pending read across those flushes (it uses `asyncio.wait`, which does not cancel on
+timeout), so no item is lost. Each read runs in its own task, so context variables the
+source sets do not carry from one item to the next. Closing it early drops the partial
+batch and the read in flight.
+
+```python
+import asyncio
+from timedbatch import abatched_by_time
+
+
+async def ticks():
+    yield 1
+    yield 2
+    await asyncio.sleep(0.3)  # the source goes quiet
+    yield 3
+
+
+async def main() -> None:
+    async for batch in abatched_by_time(ticks(), max_items=10, max_seconds=0.1):
+        print(batch)  # [1, 2]
+        # [3]
+
+
+asyncio.run(main())
+```
+
+`AsyncTimedBatcher` is `TimedBatcher` for one event loop, with an async flush function
+(`on_error` may be sync or async). Close it with `async with` or `await aclose()`:
+coroutines cannot run at interpreter exit. If its flush task is cancelled, for example
+because the loop ended first, the batcher closes and the next call hands back what it
+held. `TimedBatcher` refuses an `async def` flush function instead of dropping batches.
+
+```python
+import asyncio
+from timedbatch import AsyncTimedBatcher
+
+
+async def send(batch: list[str]) -> None:
+    print("send", batch)
+
+
+async def main() -> None:
+    async with AsyncTimedBatcher(send, max_items=3, max_seconds=1.0, max_pending=100) as out:
+        for word in ["a", "b", "c", "d"]:
+            await out.add(word)  # waits when 100 items are already pending
+
+
+asyncio.run(main())
+# send ['a', 'b', 'c']
+# send ['d']
+```
+
+## Why
+
+Count-based batching is everywhere (`itertools.batched`, `more-itertools` `chunked`),
+but none of it closes a batch on elapsed time. Code that ships logs, events or metrics
+almost always wants both bounds: cap the size so a batch never grows without limit, and
+cap the latency so a slow stream still drains on schedule. The hard part is the rest:
+flushing an idle buffer, not losing items when the sink fails or the program exits,
+slowing producers down when the sink falls behind. `timedbatch` does that once, with tests
+that run hundreds of random timelines against a reference model and hammer the batchers
+from many threads and tasks.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

timedbatch-0.2.0/README.md

@@ -0,0 +1,212 @@
+# timedbatch
+
+Batch items by a max count and a max age, flushing when either limit is hit. Typed, no
+dependencies, for plain iterables, for threads and for asyncio.
+
+## Install
+
+```
+pip install timedbatch
+```
+
+## Which one to use
+
+| You have | Use | Flushes while idle |
+|---|---|---|
+| An iterable you loop over | `batched_by_time` | No: the age is checked when an item arrives |
+| An async iterable | `abatched_by_time` | Yes |
+| Many places calling `add(item)` from threads | `TimedBatcher` | Yes, from a background thread |
+| Many coroutines calling `await add(item)` | `AsyncTimedBatcher` | Yes, from a background task |
+
+A batch is delivered as soon as it holds `max_items` items or its oldest item is
+`max_seconds` old, whichever comes first. `max_seconds` may be `math.inf` to batch by
+count only.
+
+## Iterables
+
+```python
+from timedbatch import batched_by_time
+
+now = 0.0
+
+
+def clock() -> float:  # inject a clock and tests never sleep
+    return now
+
+
+def events():
+    global now
+    for moment, name in [(0.0, "a"), (0.5, "b"), (0.6, "c"), (9.0, "d"), (9.1, "e")]:
+        now = moment
+        yield name
+
+
+for batch in batched_by_time(events(), max_items=2, max_seconds=5.0, clock=clock):
+    print(batch)  # ['a', 'b']
+    # ['c', 'd']
+    # ['e']
+```
+
+`['c', 'd']` closes on age: `d` arrives 8.4 seconds after `c`. If the source raises, the
+items already read are yielded first and the exception follows.
+
+## Threads: `TimedBatcher`
+
+```python
+from timedbatch import TimedBatcher
+
+
+def write_rows(batch: list[int]) -> None:
+    print("insert", batch)
+
+
+with TimedBatcher(write_rows, max_items=2, max_seconds=1.0) as batcher:
+    for row in range(5):
+        batcher.add(row)  # safe from any number of threads
+# insert [0, 1]
+# insert [2, 3]
+# insert [4]
+```
+
+What it promises:
+
+- **Size and age.** A full batch goes out at once; a partial one goes out `max_seconds`
+  after its oldest item, even if nothing else is added.
+- **Order and no overlap.** One background thread calls your function, one batch at a
+  time, in the order the items were accepted. A batch never exceeds `max_items`.
+- **Nothing lost, nothing twice.** Every accepted item is delivered once or handed back
+  once. When `add` raises, the item was not accepted (one exception: with
+  `background=False`, an interrupt raised inside your function passes through `add`,
+  and its batch comes back in the next `FlushError`).
+- **Failures.** Give `on_error(exc, batch)` to decide what to do with a failed batch.
+  Without it, failed batches are kept and raised as a `FlushError` (with `.batches` and
+  `.errors`) by the next `add`, `poll`, `flush` or `close`.
+- **Back-pressure.** `max_pending` caps items accepted but not yet delivered. `add` waits
+  for room, or raises `BatcherFull` (a `TimeoutError`) after `timeout` seconds.
+- **Shutdown.** `close()` (or leaving the `with` block) delivers the rest and stops the
+  thread; later calls to `add` raise `BatcherClosed`. A batcher you forget to close, or
+  whose `close(timeout=...)` timed out, is closed when the interpreter exits normally,
+  through `sys.exit` or an uncaught exception (`flush_at_exit=True`). That exit flush
+  waits for your function, so give it its own timeouts. Nothing can flush after
+  `os._exit`, a kill signal, or in a child created by `os.fork` (it has no thread).
+- **No deadlocks from inside.** Calling `flush`, `poll` or `close` from the flush
+  function raises `RuntimeError`, and an `add` there that would wait raises `BatcherFull`.
+
+Failures come back with their items:
+
+```python
+from timedbatch import FlushError, TimedBatcher
+
+
+def flaky(batch: list[str]) -> None:
+    raise ConnectionError("database is down")
+
+
+batcher = TimedBatcher(flaky, max_items=10, max_seconds=60.0)
+batcher.add("order-1")
+batcher.add("order-2")
+try:
+    batcher.close()
+except FlushError as error:
+    print(error.batches)  # [['order-1', 'order-2']]
+    print(error)  # 1 batch (2 items) failed to flush: ConnectionError('database is down')
+```
+
+### Deterministic tests
+
+`background=False` removes the thread: due batches are delivered by the caller inside
+`add` and `poll()`, so an injected clock drives every age decision (and the `timeout`
+of `flush` and `close` has nothing to wait for).
+
+```python
+from timedbatch import TimedBatcher
+
+now = 0.0
+sent: list[list[str]] = []
+batcher = TimedBatcher(
+    sent.append, max_items=100, max_seconds=5.0, clock=lambda: now, background=False
+)
+batcher.add("x")
+now = 4.9
+batcher.poll()
+print(sent)  # []
+now = 5.0
+batcher.poll()
+print(sent)  # [['x']]
+```
+
+## asyncio
+
+`abatched_by_time` yields a partial batch on time even while the source waits. It keeps
+the pending read across those flushes (it uses `asyncio.wait`, which does not cancel on
+timeout), so no item is lost. Each read runs in its own task, so context variables the
+source sets do not carry from one item to the next. Closing it early drops the partial
+batch and the read in flight.
+
+```python
+import asyncio
+from timedbatch import abatched_by_time
+
+
+async def ticks():
+    yield 1
+    yield 2
+    await asyncio.sleep(0.3)  # the source goes quiet
+    yield 3
+
+
+async def main() -> None:
+    async for batch in abatched_by_time(ticks(), max_items=10, max_seconds=0.1):
+        print(batch)  # [1, 2]
+        # [3]
+
+
+asyncio.run(main())
+```
+
+`AsyncTimedBatcher` is `TimedBatcher` for one event loop, with an async flush function
+(`on_error` may be sync or async). Close it with `async with` or `await aclose()`:
+coroutines cannot run at interpreter exit. If its flush task is cancelled, for example
+because the loop ended first, the batcher closes and the next call hands back what it
+held. `TimedBatcher` refuses an `async def` flush function instead of dropping batches.
+
+```python
+import asyncio
+from timedbatch import AsyncTimedBatcher
+
+
+async def send(batch: list[str]) -> None:
+    print("send", batch)
+
+
+async def main() -> None:
+    async with AsyncTimedBatcher(send, max_items=3, max_seconds=1.0, max_pending=100) as out:
+        for word in ["a", "b", "c", "d"]:
+            await out.add(word)  # waits when 100 items are already pending
+
+
+asyncio.run(main())
+# send ['a', 'b', 'c']
+# send ['d']
+```
+
+## Why
+
+Count-based batching is everywhere (`itertools.batched`, `more-itertools` `chunked`),
+but none of it closes a batch on elapsed time. Code that ships logs, events or metrics
+almost always wants both bounds: cap the size so a batch never grows without limit, and
+cap the latency so a slow stream still drains on schedule. The hard part is the rest:
+flushing an idle buffer, not losing items when the sink fails or the program exits,
+slowing producers down when the sink falls behind. `timedbatch` does that once, with tests
+that run hundreds of random timelines against a reference model and hammer the batchers
+from many threads and tasks.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

timedbatch-0.2.0/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "timedbatch"
+version = "0.2.0"
+description = "Batch items by a max count and a max age, for iterables, threads and asyncio, without losing items"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Javier Lianes", email = "javier@lianes8studio.com" }]
+keywords = [
+    "batch", "batching", "chunk", "iterator", "time-window", "streaming", "flush",
+    "buffer", "asyncio", "back-pressure",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Framework :: AsyncIO",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "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",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["ruff", "mypy", "pytest", "build", "twine"]
+
+[project.urls]
+Homepage = "https://lianes8studio.com"
+Repository = "https://github.com/JaviLianes8/timedbatch"
+Issues = "https://github.com/JaviLianes8/timedbatch/issues"
+Changelog = "https://github.com/JaviLianes8/timedbatch/blob/main/CHANGELOG.md"
+LinkedIn = "https://www.linkedin.com/in/jlianes/"
+Funding = "https://buymeacoffee.com/jlianesglrs"
+
+[tool.hatch.build.targets.sdist]
+exclude = ["IMPROVEMENTS-round.md"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/timedbatch"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "-q"

timedbatch-0.2.0/requirements-dev.txt

@@ -0,0 +1,3 @@
+# Development dependencies: the package in editable mode plus its dev extras
+# (ruff, mypy, pytest, build, twine). Install with:  pip install -r requirements-dev.txt
+-e .[dev]

timedbatch-0.2.0/scripts/check.ps1

@@ -0,0 +1,7 @@
+# Local quality gate. Run before every commit. No CI runs in the cloud.
+$ErrorActionPreference = "Stop"
+
+ruff format --check .
+ruff check .
+mypy --strict src tests
+pytest

timedbatch-0.2.0/scripts/release.ps1

@@ -0,0 +1,28 @@
+# Build and upload to PyPI. Run scripts/check.ps1 first.
+# The name must not already exist on PyPI; the token is read from a secret store, never git.
+$ErrorActionPreference = "Stop"
+
+# Works on both Windows PowerShell 5.1 and pwsh 7 (generic catch, no PS7-only types).
+$taken = $true
+try {
+    Invoke-WebRequest -UseBasicParsing "https://pypi.org/pypi/timedbatch/json" | Out-Null
+} catch {
+    if ($_.Exception.Response.StatusCode.value__ -eq 404) { $taken = $false } else { throw }
+}
+if ($taken) { throw "The name 'timedbatch' already exists on PyPI. Choose another before publishing." }
+
+$token = $env:PYPI_TOKEN
+if (-not $token -and (Test-Path "C:\secrets\pypi-token.txt")) {
+    $token = (Get-Content "C:\secrets\pypi-token.txt" -Raw).Trim()
+}
+if (-not $token) {
+    throw "No PyPI token. Set `$env:PYPI_TOKEN or save it to C:\secrets\pypi-token.txt (never commit it)."
+}
+
+Remove-Item -Recurse -Force dist -ErrorAction SilentlyContinue
+python -m build
+python -m twine check dist/*
+
+$env:TWINE_USERNAME = "__token__"
+$env:TWINE_PASSWORD = $token
+try { python -m twine upload dist/* } finally { Remove-Item Env:\TWINE_PASSWORD -ErrorAction SilentlyContinue }

timedbatch-0.2.0/src/timedbatch/__init__.py

@@ -0,0 +1,21 @@
+"""Batch items by a max count and a max age, flushing when either limit is hit."""
+
+from __future__ import annotations
+
+from ._abatcher import AsyncTimedBatcher
+from ._abatching import abatched_by_time
+from ._batcher import TimedBatcher
+from ._batching import batched_by_time
+from ._errors import BatcherClosed, BatcherFull, FlushError
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "AsyncTimedBatcher",
+    "BatcherClosed",
+    "BatcherFull",
+    "FlushError",
+    "TimedBatcher",
+    "abatched_by_time",
+    "batched_by_time",
+]