sightingdb-client 0.0.1__tar.gz

sightingdb_client-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (C) 2020-2026 Sebastien Tricaud
+
+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.

sightingdb_client-0.0.1/MANIFEST.in

@@ -0,0 +1,7 @@
+# The sdist carries what is needed to check the package out and test it, so a
+# distribution rebuilt from PyPI can be verified without cloning the repository.
+include LICENSE
+include README.md
+recursive-include tests *.py
+recursive-include samples *.py
+global-exclude __pycache__/* *.py[cod]

sightingdb_client-0.0.1/PKG-INFO

@@ -0,0 +1,249 @@
+Metadata-Version: 2.4
+Name: sightingdb-client
+Version: 0.0.1
+Summary: The Python Client Library for SightingDB
+Author-email: Sebastien Tricaud <sebastien@honeynet.org>
+Maintainer-email: Sebastien Tricaud <sebastien@honeynet.org>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/stricaud/sightingdb-client
+Project-URL: Source, https://github.com/stricaud/sightingdb-client
+Project-URL: Server, https://github.com/stricaud/sightingdb
+Keywords: sightingdb,sightings,threat-intelligence,security
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+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: Topic :: Security
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24
+Requires-Dist: tomli>=1.1.0; python_version < "3.11"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Dynamic: license-file
+
+# SightingDB Python Client
+
+[SightingDB](https://github.com/stricaud/sightingdb) counts things: how many
+times a value was seen, when it was first seen, when it was last seen, and how
+many namespaces hold it. This library is its REST API as Python objects, for
+both synchronous and asyncio code.
+
+```
+pip install sightingdb-client
+```
+
+The distribution is `sightingdb-client`; the module it installs is
+`sightingdb`, so `import sightingdb` is what you write. Requires Python 3.10+
+and talks to SightingDB 0.5 or later.
+
+## Writing
+
+```python
+import sightingdb
+
+with sightingdb.SightingDB("https://localhost:9999", apikey="changeme") as db:
+    db.write("feeds/misp/ips", "127.0.0.1")          # returns the new count
+    db.write("feeds/misp/ips", "127.0.0.1", ttl=86400)   # expires a day after last seen
+    db.write("feeds/misp/ips", "10.0.0.1", timestamp=1587364370)  # seen in the past
+```
+
+Make the client once and keep it: it holds a connection pool, and a client per
+call re-runs the TLS handshake every time. `timestamp` takes Unix seconds or a
+`datetime`; `ttl` takes seconds or a `timedelta`.
+
+Many values go in one request:
+
+```python
+result = db.write_many([
+    ("feeds/misp/ips", "8.8.8.8"),
+    sightingdb.Sighting("feeds/misp/ips", "1.1.1.1", ttl=86400),
+    {"namespace": "feeds/misp/domains", "value": "example.com"},
+])
+print(result.written)
+```
+
+Anything the server refuses raises `BulkWriteError`, naming the items that did
+not land — pass `strict=False` to get them in `result.errors` instead.
+
+For a feed you are streaming rather than holding in memory, batch it:
+
+```python
+with db.batch(chunk_size=1000) as batch:      # one request per 1000 sightings
+    for value in feed:
+        batch.add("feeds/misp/ips", value)
+print(batch.result.written)
+```
+
+## Reading
+
+```python
+attribute = db.read("feeds/misp/ips", "127.0.0.1")
+attribute.count          # 2
+attribute.consensus      # how many namespaces hold this value
+attribute.first_seen     # 1566624658
+attribute.first_seen_at  # datetime(2019, 8, 24, 5, 30, 58, tzinfo=timezone.utc)
+attribute.expires_at     # None when the value has no TTL
+```
+
+`read` raises `NotFoundError` for a value that was never seen. When you are
+enriching a list, ask for them together instead — there a miss is an answer,
+not an error:
+
+```python
+for result in db.read_many([("feeds/misp/ips", v) for v in indicators]):
+    if result.found:
+        print(result.value, result.count, result.consensus)
+    else:
+        print(result.value, result.error)   # "Value not found" / "Path not found"
+```
+
+Reading is itself recorded, as a "shadow sighting" under `_shadow/`, so that you
+can see how often a value was searched for. Pass `shadow=False` (or
+`Sighting(..., noshadow=True)` in a bulk read) to look without leaving a trace.
+
+Other reads:
+
+```python
+db.read("feeds/misp/ips", "127.0.0.1", stats=True).stats_by_hour  # hourly histogram
+db.list_values("feeds/misp/ips")     # every value in a namespace
+db.exists("feeds/misp/ips", "8.8.8.8")
+db.delete("feeds/misp/ips")          # the whole namespace, with care
+db.info()                            # what the server says it is
+```
+
+Namespaces are normalized for you: `feeds/ips`, `/feeds/ips` and `/feeds/ips/`
+are the same namespace here. To the server they are not — a trailing slash is a
+different namespace with its own counts.
+
+## asyncio
+
+`AsyncSightingDB` is the same API, awaited:
+
+```python
+import asyncio, sightingdb
+
+async def main():
+    async with sightingdb.AsyncSightingDB(apikey="changeme") as db:
+        async with db.batch(chunk_size=1000) as batch:
+            for value in feed:
+                await batch.add("feeds/misp/ips", value)
+
+        results = await db.read_many([("feeds/misp/ips", v) for v in indicators])
+        counts = await asyncio.gather(*(db.write("feeds/live", v) for v in values))
+
+asyncio.run(main())
+```
+
+## Configuration
+
+Settings are resolved per field, most specific first:
+
+1. what you pass to the client,
+2. the environment: `SIGHTINGDB_URL` (or `SIGHTINGDB_HOST`, `SIGHTINGDB_PORT`,
+   `SIGHTINGDB_SSL`), `SIGHTINGDB_APIKEY`, `SIGHTINGDB_VERIFY`,
+   `SIGHTINGDB_TIMEOUT`, `SIGHTINGDB_MAX_RETRIES`,
+3. a TOML file — `$SIGHTINGDB_CONFIG`, else `~/.sightingdb/client.toml`.
+
+```toml
+# ~/.sightingdb/client.toml
+[client]
+url = "https://sightingdb.example.com:9999"
+apikey = "changeme"
+verify = "/etc/ssl/sightingdb-ca.pem"
+timeout = 10.0
+max_retries = 2
+```
+
+So a config file can hold the URL while the key comes from the environment,
+without either repeating the other. `use_env=False` and `use_file=False` cut a
+client off from both, which is what you want in tests.
+
+### TLS
+
+`verify` defaults to `True`. SightingDB generates a self-signed certificate on
+first run, which nothing will verify, so either point `verify` at that
+certificate — `verify="/Users/you/.sightingdb/ssl/cert.pem"` — or, knowing what
+it costs, pass `verify=False`.
+
+## Errors
+
+Everything raised derives from `SightingDBError`.
+
+| Exception | When |
+|---|---|
+| `ConfigurationError` | The settings do not make sense. |
+| `TransportError`, `TimeoutError` | No answer arrived: DNS, TCP, TLS, timeout. |
+| `ProtocolError` | The answer was not what the API promises — usually a wrong URL, or a server too old for an endpoint. |
+| `BadRequestError` (400) | The server could not make sense of the request. |
+| `AuthenticationError` (401) | No API key was sent. |
+| `PermissionDeniedError` (403) | The key is unknown, or not granted this namespace. |
+| `NotFoundError` (404) | No such namespace, or no such value. Carries `.namespace` and `.value`. |
+| `ServerError` (5xx) | The server failed to handle the request. |
+| `BulkWriteError` | A bulk write landed only in part. Carries the full `.result`. |
+
+Requests that fail in a way a retry could fix are retried with backoff. Writes
+are only retried when the connection was never established: SightingDB counts,
+and a retried write that did land would count twice.
+
+## Development
+
+```
+pip install -e '.[dev]'
+pytest                     # unit tests, no server needed
+
+SIGHTINGDB_TEST_URL=https://localhost:9999 \
+SIGHTINGDB_TEST_APIKEY=changeme \
+SIGHTINGDB_TEST_VERIFY=false \
+pytest -m live             # against a real server
+```
+
+`samples/everything.py` walks through the whole API, and
+`samples/async_feed.py` shows the asyncio client ingesting and enriching a feed.
+
+CI runs the unit tests on 3.10 through 3.14, builds the distribution, and runs
+the live tests against a real SightingDB downloaded from the server's own
+releases — because every bug this client has had was a disagreement with the
+server that mocks could not have caught.
+
+### Releasing
+
+Tag it:
+
+```
+git tag python-v1.0.1 && git push origin python-v1.0.1
+```
+
+`.github/workflows/release.yml` does the rest: if `__version__.py` disagrees
+with the tag it bumps, commits and moves the tag onto that commit, then tests,
+builds, publishes to PyPI over Trusted Publishing, and cuts a GitHub Release
+with the sdist and wheel attached. `python-v1.0.1` and `v1.0.1` are both
+accepted, and `1.0.1rc1` publishes as a prerelease.
+
+## Upgrading from 0.0.x
+
+The 0.0.x API is gone. It predates several versions of the server, reported
+failures as successes, and its `auth` object called endpoints that no longer
+exist — API keys now live in the server's `acl.toml`.
+
+| 0.0.x | 1.0 |
+|---|---|
+| `sightingdb.connection(host=..., apikey=...)` | `sightingdb.SightingDB(url, apikey=...)` |
+| `writer.add(...)` then `writer.commit()` | `db.write_many([...])` or `with db.batch() as b: b.add(...)` |
+| `writer.write_one(ns, v)` | `db.write(ns, v)` |
+| `reader.add(...)` then `reader.fetch()` | `db.read_many([...])` |
+| `reader.read_one(ns, v)` | `db.read(ns, v)` |
+| `reader.read_one_with_stats(ns, v)` | `db.read(ns, v, stats=True)` |
+| `delete(con).delete(ns)` | `db.delete(ns)` |
+| `con.disable_ssl_warnings()` | nothing to disable; `httpx` does not warn |
+| `sightingdb.auth(con)` | removed — keys are configured server-side |

sightingdb_client-0.0.1/README.md

@@ -0,0 +1,215 @@
+# SightingDB Python Client
+
+[SightingDB](https://github.com/stricaud/sightingdb) counts things: how many
+times a value was seen, when it was first seen, when it was last seen, and how
+many namespaces hold it. This library is its REST API as Python objects, for
+both synchronous and asyncio code.
+
+```
+pip install sightingdb-client
+```
+
+The distribution is `sightingdb-client`; the module it installs is
+`sightingdb`, so `import sightingdb` is what you write. Requires Python 3.10+
+and talks to SightingDB 0.5 or later.
+
+## Writing
+
+```python
+import sightingdb
+
+with sightingdb.SightingDB("https://localhost:9999", apikey="changeme") as db:
+    db.write("feeds/misp/ips", "127.0.0.1")          # returns the new count
+    db.write("feeds/misp/ips", "127.0.0.1", ttl=86400)   # expires a day after last seen
+    db.write("feeds/misp/ips", "10.0.0.1", timestamp=1587364370)  # seen in the past
+```
+
+Make the client once and keep it: it holds a connection pool, and a client per
+call re-runs the TLS handshake every time. `timestamp` takes Unix seconds or a
+`datetime`; `ttl` takes seconds or a `timedelta`.
+
+Many values go in one request:
+
+```python
+result = db.write_many([
+    ("feeds/misp/ips", "8.8.8.8"),
+    sightingdb.Sighting("feeds/misp/ips", "1.1.1.1", ttl=86400),
+    {"namespace": "feeds/misp/domains", "value": "example.com"},
+])
+print(result.written)
+```
+
+Anything the server refuses raises `BulkWriteError`, naming the items that did
+not land — pass `strict=False` to get them in `result.errors` instead.
+
+For a feed you are streaming rather than holding in memory, batch it:
+
+```python
+with db.batch(chunk_size=1000) as batch:      # one request per 1000 sightings
+    for value in feed:
+        batch.add("feeds/misp/ips", value)
+print(batch.result.written)
+```
+
+## Reading
+
+```python
+attribute = db.read("feeds/misp/ips", "127.0.0.1")
+attribute.count          # 2
+attribute.consensus      # how many namespaces hold this value
+attribute.first_seen     # 1566624658
+attribute.first_seen_at  # datetime(2019, 8, 24, 5, 30, 58, tzinfo=timezone.utc)
+attribute.expires_at     # None when the value has no TTL
+```
+
+`read` raises `NotFoundError` for a value that was never seen. When you are
+enriching a list, ask for them together instead — there a miss is an answer,
+not an error:
+
+```python
+for result in db.read_many([("feeds/misp/ips", v) for v in indicators]):
+    if result.found:
+        print(result.value, result.count, result.consensus)
+    else:
+        print(result.value, result.error)   # "Value not found" / "Path not found"
+```
+
+Reading is itself recorded, as a "shadow sighting" under `_shadow/`, so that you
+can see how often a value was searched for. Pass `shadow=False` (or
+`Sighting(..., noshadow=True)` in a bulk read) to look without leaving a trace.
+
+Other reads:
+
+```python
+db.read("feeds/misp/ips", "127.0.0.1", stats=True).stats_by_hour  # hourly histogram
+db.list_values("feeds/misp/ips")     # every value in a namespace
+db.exists("feeds/misp/ips", "8.8.8.8")
+db.delete("feeds/misp/ips")          # the whole namespace, with care
+db.info()                            # what the server says it is
+```
+
+Namespaces are normalized for you: `feeds/ips`, `/feeds/ips` and `/feeds/ips/`
+are the same namespace here. To the server they are not — a trailing slash is a
+different namespace with its own counts.
+
+## asyncio
+
+`AsyncSightingDB` is the same API, awaited:
+
+```python
+import asyncio, sightingdb
+
+async def main():
+    async with sightingdb.AsyncSightingDB(apikey="changeme") as db:
+        async with db.batch(chunk_size=1000) as batch:
+            for value in feed:
+                await batch.add("feeds/misp/ips", value)
+
+        results = await db.read_many([("feeds/misp/ips", v) for v in indicators])
+        counts = await asyncio.gather(*(db.write("feeds/live", v) for v in values))
+
+asyncio.run(main())
+```
+
+## Configuration
+
+Settings are resolved per field, most specific first:
+
+1. what you pass to the client,
+2. the environment: `SIGHTINGDB_URL` (or `SIGHTINGDB_HOST`, `SIGHTINGDB_PORT`,
+   `SIGHTINGDB_SSL`), `SIGHTINGDB_APIKEY`, `SIGHTINGDB_VERIFY`,
+   `SIGHTINGDB_TIMEOUT`, `SIGHTINGDB_MAX_RETRIES`,
+3. a TOML file — `$SIGHTINGDB_CONFIG`, else `~/.sightingdb/client.toml`.
+
+```toml
+# ~/.sightingdb/client.toml
+[client]
+url = "https://sightingdb.example.com:9999"
+apikey = "changeme"
+verify = "/etc/ssl/sightingdb-ca.pem"
+timeout = 10.0
+max_retries = 2
+```
+
+So a config file can hold the URL while the key comes from the environment,
+without either repeating the other. `use_env=False` and `use_file=False` cut a
+client off from both, which is what you want in tests.
+
+### TLS
+
+`verify` defaults to `True`. SightingDB generates a self-signed certificate on
+first run, which nothing will verify, so either point `verify` at that
+certificate — `verify="/Users/you/.sightingdb/ssl/cert.pem"` — or, knowing what
+it costs, pass `verify=False`.
+
+## Errors
+
+Everything raised derives from `SightingDBError`.
+
+| Exception | When |
+|---|---|
+| `ConfigurationError` | The settings do not make sense. |
+| `TransportError`, `TimeoutError` | No answer arrived: DNS, TCP, TLS, timeout. |
+| `ProtocolError` | The answer was not what the API promises — usually a wrong URL, or a server too old for an endpoint. |
+| `BadRequestError` (400) | The server could not make sense of the request. |
+| `AuthenticationError` (401) | No API key was sent. |
+| `PermissionDeniedError` (403) | The key is unknown, or not granted this namespace. |
+| `NotFoundError` (404) | No such namespace, or no such value. Carries `.namespace` and `.value`. |
+| `ServerError` (5xx) | The server failed to handle the request. |
+| `BulkWriteError` | A bulk write landed only in part. Carries the full `.result`. |
+
+Requests that fail in a way a retry could fix are retried with backoff. Writes
+are only retried when the connection was never established: SightingDB counts,
+and a retried write that did land would count twice.
+
+## Development
+
+```
+pip install -e '.[dev]'
+pytest                     # unit tests, no server needed
+
+SIGHTINGDB_TEST_URL=https://localhost:9999 \
+SIGHTINGDB_TEST_APIKEY=changeme \
+SIGHTINGDB_TEST_VERIFY=false \
+pytest -m live             # against a real server
+```
+
+`samples/everything.py` walks through the whole API, and
+`samples/async_feed.py` shows the asyncio client ingesting and enriching a feed.
+
+CI runs the unit tests on 3.10 through 3.14, builds the distribution, and runs
+the live tests against a real SightingDB downloaded from the server's own
+releases — because every bug this client has had was a disagreement with the
+server that mocks could not have caught.
+
+### Releasing
+
+Tag it:
+
+```
+git tag python-v1.0.1 && git push origin python-v1.0.1
+```
+
+`.github/workflows/release.yml` does the rest: if `__version__.py` disagrees
+with the tag it bumps, commits and moves the tag onto that commit, then tests,
+builds, publishes to PyPI over Trusted Publishing, and cuts a GitHub Release
+with the sdist and wheel attached. `python-v1.0.1` and `v1.0.1` are both
+accepted, and `1.0.1rc1` publishes as a prerelease.
+
+## Upgrading from 0.0.x
+
+The 0.0.x API is gone. It predates several versions of the server, reported
+failures as successes, and its `auth` object called endpoints that no longer
+exist — API keys now live in the server's `acl.toml`.
+
+| 0.0.x | 1.0 |
+|---|---|
+| `sightingdb.connection(host=..., apikey=...)` | `sightingdb.SightingDB(url, apikey=...)` |
+| `writer.add(...)` then `writer.commit()` | `db.write_many([...])` or `with db.batch() as b: b.add(...)` |
+| `writer.write_one(ns, v)` | `db.write(ns, v)` |
+| `reader.add(...)` then `reader.fetch()` | `db.read_many([...])` |
+| `reader.read_one(ns, v)` | `db.read(ns, v)` |
+| `reader.read_one_with_stats(ns, v)` | `db.read(ns, v, stats=True)` |
+| `delete(con).delete(ns)` | `db.delete(ns)` |
+| `con.disable_ssl_warnings()` | nothing to disable; `httpx` does not warn |
+| `sightingdb.auth(con)` | removed — keys are configured server-side |

sightingdb_client-0.0.1/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+# 77 is where the SPDX `license = "MIT"` expression and `license-files` became
+# valid metadata, replacing the deprecated License:: classifiers.
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sightingdb-client"
+dynamic = ["version"]
+description = "The Python Client Library for SightingDB"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Sebastien Tricaud", email = "sebastien@honeynet.org" }]
+maintainers = [{ name = "Sebastien Tricaud", email = "sebastien@honeynet.org" }]
+keywords = ["sightingdb", "sightings", "threat-intelligence", "security"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "Operating System :: OS Independent",
+    "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",
+    "Topic :: Security",
+    "Typing :: Typed",
+]
+dependencies = [
+    "httpx>=0.24",
+    "tomli>=1.1.0; python_version < '3.11'",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7",
+    "pytest-asyncio>=0.23",
+]
+
+[project.urls]
+Homepage = "https://github.com/stricaud/sightingdb-client"
+Source = "https://github.com/stricaud/sightingdb-client"
+Server = "https://github.com/stricaud/sightingdb"
+
+[tool.setuptools]
+packages = ["sightingdb"]
+
+[tool.setuptools.dynamic]
+version = { attr = "sightingdb.__version__.__version__" }
+
+[tool.setuptools.package-data]
+sightingdb = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+markers = [
+    "live: talks to a real SightingDB server; needs SIGHTINGDB_TEST_URL",
+]

sightingdb_client-0.0.1/samples/async_feed.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Ingesting a feed and enriching it, with the asyncio client.
+
+    SIGHTINGDB_APIKEY=changeme ./samples/async_feed.py
+
+The point of the async client is here: one connection pool, many requests in
+flight, and lookups that would otherwise be a serial round trip each.
+"""
+
+import asyncio
+import os
+import sys
+
+import sightingdb
+
+NAMESPACE = "_tests/samples/feed"
+
+FEED = [f"198.51.100.{n}" for n in range(50)]
+TO_ENRICH = ["198.51.100.7", "198.51.100.42", "203.0.113.1"]
+
+
+async def main() -> int:
+    async with sightingdb.AsyncSightingDB(
+        os.environ.get("SIGHTINGDB_URL", "https://localhost:9999"),
+        apikey=os.environ.get("SIGHTINGDB_APIKEY", "changeme"),
+        verify=False,
+    ) as db:
+        # Ingest: one request per thousand sightings, not one per sighting.
+        async with db.batch(chunk_size=1000) as batch:
+            for value in FEED:
+                await batch.add(NAMESPACE, value, ttl=86400)
+        print(f"ingested {batch.result.written} sightings")
+
+        # Enrich: one bulk read answers all of them, misses included.
+        results = await db.read_many(
+            [sightingdb.Sighting(NAMESPACE, v, noshadow=True) for v in TO_ENRICH]
+        )
+        for value, result in zip(TO_ENRICH, results):
+            if result.found:
+                print(f"  {value}: seen {result.count}x, consensus {result.consensus}")
+            else:
+                print(f"  {value}: {result.error}")
+
+        # When the calls are genuinely independent, run them at once.
+        counts = await asyncio.gather(
+            *(db.write(NAMESPACE, value) for value in TO_ENRICH[:2])
+        )
+        print(f"concurrent writes now count {counts}")
+
+        await db.delete(NAMESPACE, missing_ok=True)
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(asyncio.run(main()))
+    except sightingdb.SightingDBError as exc:
+        sys.exit(f"SightingDB: {exc}")