hotdata-runtime 0.1.1__tar.gz → 0.2.1__tar.gz

hotdata_runtime-0.2.1/.github/workflows/check-release.yml

@@ -0,0 +1,26 @@
+name: Check release metadata
+
+on:
+  pull_request:
+    paths:
+      - 'pyproject.toml'
+      - 'CHANGELOG.md'
+
+permissions:
+  contents: read
+
+jobs:
+  check:
+    name: Verify changelog matches version bump
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
+        with:
+          python-version: '3.12'
+
+      - name: Check release metadata
+        run: python scripts/check-release.py

hotdata_runtime-0.2.1/.github/workflows/ci.yml

@@ -0,0 +1,33 @@
+name: CI
+
+on:
+  push:
+    branches: ["main", "master"]
+  pull_request:
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Test (Python 3.12)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+
+      - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v6
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Install dependencies
+        run: uv sync --locked
+
+      - name: Test
+        run: uv run pytest -v

{hotdata_runtime-0.1.1 → hotdata_runtime-0.2.1}/.github/workflows/publish.yml

@@ -28,7 +28,6 @@ jobs:
 
       - name: Verify tag matches pyproject version
         run: |
-          # Release tags must start with `v` followed by a PEP 440 version (e.g. v1.2.3, v1.2.3a1).
           if [[ ! "$GITHUB_REF_NAME" =~ ^v[0-9] ]]; then
             echo "Release tag '$GITHUB_REF_NAME' must start with 'v' followed by a digit (e.g. v1.0.0)" >&2
             exit 1

hotdata_runtime-0.2.1/.github/workflows/release.yml

@@ -0,0 +1,54 @@
+name: GitHub Release
+
+on:
+  push:
+    tags:
+      - 'v[0-9]*'
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    name: Create GitHub Release
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
+        with:
+          python-version: '3.12'
+
+      - name: Read package metadata
+        id: meta
+        run: |
+          pkg_name=$(python -c "import tomllib,pathlib; print(tomllib.loads(pathlib.Path('pyproject.toml').read_text())['project']['name'])")
+          pkg_version="${GITHUB_REF_NAME#v}"
+          echo "name=${pkg_name}" >> "$GITHUB_OUTPUT"
+          echo "version=${pkg_version}" >> "$GITHUB_OUTPUT"
+
+      - name: Extract changelog notes
+        id: notes
+        run: |
+          set -euo pipefail
+          version="${GITHUB_REF_NAME#v}"
+          if [[ -f CHANGELOG.md ]]; then
+            body="$(python scripts/extract-changelog.py "$version")"
+          else
+            body="Release ${version}."
+          fi
+          delimiter="EOF_${RANDOM}_${RANDOM}"
+          {
+            echo "body<<${delimiter}"
+            echo "$body"
+            echo "${delimiter}"
+          } >> "$GITHUB_OUTPUT"
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@da05d552573ad5aba039eaac05058a918a7bf631 # v2.2.2
+        with:
+          tag_name: ${{ github.ref_name }}
+          name: ${{ steps.meta.outputs.name }} ${{ steps.meta.outputs.version }}
+          body: ${{ steps.notes.outputs.body }}
+          generate_release_notes: false
+          make_latest: true

hotdata_runtime-0.2.1/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+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.2.1] - 2026-05-24
+
+### Added
+
+- `execute_sql` accepts an optional `database` keyword argument. When provided, the database name is resolved to an ID and sent as the `X-Database-Id` header so SQL can reference managed database tables as `"default"."<schema>"."<table>"`. Behaviour is unchanged when `database` is omitted.
+
+## [0.2.0] - 2026-05-24
+
+### Changed
+
+- Switch managed database operations from the connections API to the dedicated `/databases` API (`hotdata>=0.2.3` required).
+- `create_managed_database` first parameter renamed from `name` to `description` (keyword-only).
+- `ManagedDatabase` dataclass: replace `name`/`source_type` fields with `description`/`default_connection_id`.
+- `resolve_managed_database` tries direct ID lookup first, then falls back to a description scan.
+- `list_managed_databases` now fetches all databases regardless of source type.
+- `list_managed_tables`, `load_managed_table`, and `delete_managed_table` use `default_connection_id` instead of database `id` for connection-scoped operations.
+
+### Added
+
+- `create_managed_database` accepts an optional `expires_at` parameter.
+
+### Removed
+
+- `MANAGED_SOURCE_TYPE`, `build_managed_config`, and `create_connection_request` removed from the public API.
+
+## [0.1.1] - 2026-05-19
+
+### Added
+
+- Managed database helpers on `HotdataClient`.
+
+## [0.1.0] - 2026-05-06
+
+### Added
+
+- Initial release.

{hotdata_runtime-0.1.1 → hotdata_runtime-0.2.1}/CONTRACT.md

@@ -33,10 +33,7 @@ The supported import surface is:
 - `ManagedDatabase`
 - `ManagedTable`
 - `LoadManagedTableResult`
-- `MANAGED_SOURCE_TYPE`
 - `DEFAULT_SCHEMA`
-- `build_managed_config`
-- `create_connection_request`
 - `is_parquet_path`
 
 Adapters should import from `hotdata_runtime` and treat this surface as the stable API.
@@ -58,10 +55,10 @@ Adapters should import from `hotdata_runtime` and treat this surface as the stab
 - `columns_for_qualified(qualified, connection_id=...)` resolves table columns, and
   adapters should pass `connection_id` when known.
 - `uploads()` returns the uploads API wrapper for parquet staging.
-- `list_managed_databases()` returns managed-catalog connections (`source_type: managed`).
-- `resolve_managed_database(name_or_id)` resolves a managed database by name or id.
-- `create_managed_database(name, schema=..., tables=...)` creates a managed database and optionally declares tables up front.
-- `delete_managed_database(name_or_id)` deletes a managed database connection.
+- `list_managed_databases()` returns all databases via the `/databases` API.
+- `resolve_managed_database(name_or_id)` resolves a database by id (direct lookup) or description (list scan).
+- `create_managed_database(description=..., schema=..., tables=..., expires_at=...)` creates a database via the `/databases` API and optionally declares tables up front.
+- `delete_managed_database(name_or_id)` deletes a database via the `/databases` API.
 - `list_managed_tables(database, schema=...)` lists tables in a managed database.
 - `upload_parquet(path)` uploads a local parquet file and returns an upload id.
 - `load_managed_table(database, table, schema=..., upload_id=..., file=...)` publishes parquet data into a declared managed table.

{hotdata_runtime-0.1.1 → hotdata_runtime-0.2.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: hotdata-runtime
-Version: 0.1.1
+Version: 0.2.1
 Summary: Workspace/session runtime primitives for Hotdata integrations
 License: MIT
 Requires-Python: >=3.10
-Requires-Dist: hotdata>=0.2.0
+Requires-Dist: hotdata>=0.2.3
 Requires-Dist: pandas>=2.0
 Description-Content-Type: text/markdown
 

hotdata_runtime-0.2.1/RELEASING.md

@@ -0,0 +1,43 @@
+# Releasing
+
+Every release uses `./scripts/release.sh`. Do not bump versions, tag, or create GitHub Releases manually.
+
+## One-time setup
+
+- Install [GitHub CLI](https://cli.github.com/) (`gh`) and authenticate.
+- Ensure PyPI [trusted publishing](https://docs.pypi.org/trusted-publishers/) is configured for this repo (`publish.yml` uses the `pypi` GitHub environment).
+
+## Release steps
+
+1. Add user-facing notes under `## [Unreleased]` in `CHANGELOG.md`.
+2. Prepare the release PR:
+
+   ```bash
+   ./scripts/release.sh prepare patch   # or minor | major | 1.2.3
+   ```
+
+3. Merge the PR after CI passes (including the changelog check).
+4. Publish from a clean default branch checkout:
+
+   ```bash
+   git checkout main   # or master for hotdata-marimo
+   git pull
+   ./scripts/release.sh publish
+   ```
+
+## What happens automatically
+
+Pushing a `vX.Y.Z` tag triggers two workflows:
+
+| Workflow | Purpose |
+|----------|---------|
+| `publish.yml` | Build wheel/sdist and publish to PyPI |
+| `release.yml` | Create the GitHub Release with notes from `CHANGELOG.md` |
+
+## Enforcement
+
+- **PR check** (`check-release.yml`): if `pyproject.toml` version changes, `CHANGELOG.md` must contain a matching `## [X.Y.Z]` section.
+- **Tag check** (`publish.yml`): the tag (without `v`) must match `[project].version` in `pyproject.toml`.
+- **Publish guard** (`release.sh publish`): refuses to tag if the changelog section is missing.
+
+Together, these make it hard to ship a version without changelog notes or a GitHub Release.

{hotdata_runtime-0.1.1 → hotdata_runtime-0.2.1}/hotdata_runtime/__init__.py

@@ -13,9 +13,6 @@ from hotdata_runtime.databases import (
     LoadManagedTableResult,
     ManagedDatabase,
     ManagedTable,
-    MANAGED_SOURCE_TYPE,
-    build_managed_config,
-    create_connection_request,
     is_parquet_path,
 )
 from hotdata_runtime.env import (
@@ -42,12 +39,9 @@ __all__ = [
     "DEFAULT_SCHEMA",
     "HotdataClient",
     "LoadManagedTableResult",
-    "MANAGED_SOURCE_TYPE",
     "ManagedDatabase",
     "ManagedTable",
     "QueryResult",
-    "build_managed_config",
-    "create_connection_request",
     "is_parquet_path",
     "workspace_health_lines",
     "default_api_key",

{hotdata_runtime-0.1.1 → hotdata_runtime-0.2.1}/hotdata_runtime/client.py

@@ -9,6 +9,7 @@ from urllib3.exceptions import ProtocolError
 
 from hotdata import ApiClient, Configuration
 from hotdata.api.connections_api import ConnectionsApi
+from hotdata.api.databases_api import DatabasesApi
 from hotdata.api.information_schema_api import InformationSchemaApi
 from hotdata.api.query_api import QueryApi
 from hotdata.api.query_runs_api import QueryRunsApi
@@ -16,9 +17,12 @@ from hotdata.api.results_api import ResultsApi
 from hotdata.api.uploads_api import UploadsApi
 from hotdata.exceptions import ApiException
 from hotdata.models.async_query_response import AsyncQueryResponse
+from hotdata.models.create_database_request import CreateDatabaseRequest
+from hotdata.models.database_default_schema_decl import DatabaseDefaultSchemaDecl
+from hotdata.models.database_default_table_decl import DatabaseDefaultTableDecl
+from hotdata.models.load_managed_table_request import LoadManagedTableRequest
 from hotdata.models.query_request import QueryRequest
 from hotdata.models.query_response import QueryResponse
-from hotdata.models.load_managed_table_request import LoadManagedTableRequest
 from hotdata.models.table_info import TableInfo
 
 from hotdata_runtime.env import (
@@ -33,11 +37,9 @@ from hotdata_runtime.databases import (
     LoadManagedTableResult,
     ManagedDatabase,
     ManagedTable,
-    MANAGED_SOURCE_TYPE,
     api_error_message,
-    create_connection_request,
     is_parquet_path,
-    managed_database_from_connection,
+    managed_database_from_detail,
 )
 from hotdata_runtime.http import default_http_retries
 from hotdata_runtime.result import QueryResult
@@ -130,6 +132,9 @@ class HotdataClient:
     def connections(self) -> ConnectionsApi:
         return ConnectionsApi(self._api)
 
+    def _databases_api(self) -> DatabasesApi:
+        return DatabasesApi(self._api)
+
     def _information_schema(self) -> InformationSchemaApi:
         return InformationSchemaApi(self._api)
 
@@ -152,47 +157,71 @@ class HotdataClient:
         return UploadsApi(self._api)
 
     def list_managed_databases(self) -> list[ManagedDatabase]:
-        listing = self.connections().list_connections()
-        return [
-            managed_database_from_connection(c)
-            for c in listing.connections
-            if c.source_type == MANAGED_SOURCE_TYPE
-        ]
+        listing = self._databases_api().list_databases()
+        result: list[ManagedDatabase] = []
+        for summary in listing.databases:
+            try:
+                detail = self._databases_api().get_database(summary.id)
+                result.append(managed_database_from_detail(detail))
+            except ApiException:
+                pass
+        return result
 
     def resolve_managed_database(self, name_or_id: str) -> ManagedDatabase:
-        listing = self.connections().list_connections()
-        match = None
-        for c in listing.connections:
-            if c.id == name_or_id or c.name == name_or_id:
-                match = c
+        # Try direct ID lookup first
+        try:
+            detail = self._databases_api().get_database(name_or_id)
+            return managed_database_from_detail(detail)
+        except ApiException as e:
+            if e.status != 404:
+                raise RuntimeError(api_error_message(e)) from e
+
+        # Fall back to description-based lookup
+        listing = self._databases_api().list_databases()
+        match_id: str | None = None
+        for db in listing.databases:
+            if db.description == name_or_id:
+                match_id = db.id
                 break
-        if match is None:
+        if match_id is None:
             raise KeyError(f"No database named or with id {name_or_id!r}")
-        if match.source_type != MANAGED_SOURCE_TYPE:
-            raise ValueError(
-                f"{match.name!r} is not a managed database "
-                f"(source_type: {match.source_type})"
-            )
-        return managed_database_from_connection(match)
+        try:
+            detail = self._databases_api().get_database(match_id)
+        except ApiException as e:
+            raise RuntimeError(api_error_message(e)) from e
+        return managed_database_from_detail(detail)
 
     def create_managed_database(
         self,
-        name: str,
+        description: str | None = None,
         *,
         schema: str = DEFAULT_SCHEMA,
         tables: list[str] | None = None,
+        expires_at: str | None = None,
     ) -> ManagedDatabase:
-        request = create_connection_request(name, schema=schema, tables=tables)
+        schemas = None
+        if tables:
+            schemas = [
+                DatabaseDefaultSchemaDecl(
+                    name=schema,
+                    tables=[DatabaseDefaultTableDecl(name=t) for t in tables],
+                )
+            ]
+        request = CreateDatabaseRequest(
+            description=description,
+            schemas=schemas,
+            expires_at=expires_at,
+        )
         try:
-            created = self.connections().create_connection(request)
+            created = self._databases_api().create_database(request)
         except ApiException as e:
             raise RuntimeError(api_error_message(e)) from e
-        return managed_database_from_connection(created)
+        return managed_database_from_detail(created)
 
     def delete_managed_database(self, name_or_id: str) -> None:
         db = self.resolve_managed_database(name_or_id)
         try:
-            self.connections().delete_connection(db.id)
+            self._databases_api().delete_database(db.id)
         except ApiException as e:
             raise RuntimeError(api_error_message(e)) from e
 
@@ -204,12 +233,12 @@ class HotdataClient:
     ) -> list[ManagedTable]:
         db = self.resolve_managed_database(database)
         rows: list[ManagedTable] = []
-        for t in self.iter_tables(connection_id=db.id):
+        for t in self.iter_tables(connection_id=db.default_connection_id):
             if schema is not None and t.var_schema != schema:
                 continue
             rows.append(
                 ManagedTable(
-                    full_name=f"{db.name}.{t.var_schema}.{t.table}",
+                    full_name=f"{db.id}.{t.var_schema}.{t.table}",
                     schema=t.var_schema,
                     table=t.table,
                     synced=t.synced,
@@ -258,7 +287,7 @@ class HotdataClient:
         )
         try:
             loaded = self.connections().load_managed_table(
-                db.id,
+                db.default_connection_id,
                 schema,
                 table,
                 request,
@@ -270,7 +299,7 @@ class HotdataClient:
             schema_name=loaded.schema_name,
             table_name=loaded.table_name,
             row_count=loaded.row_count,
-            full_name=f"{db.name}.{loaded.schema_name}.{loaded.table_name}",
+            full_name=f"{db.id}.{loaded.schema_name}.{loaded.table_name}",
         )
 
     def delete_managed_table(
@@ -282,7 +311,7 @@ class HotdataClient:
     ) -> None:
         db = self.resolve_managed_database(database)
         try:
-            self.connections().delete_managed_table(db.id, schema, table)
+            self.connections().delete_managed_table(db.default_connection_id, schema, table)
         except ApiException as e:
             raise RuntimeError(api_error_message(e)) from e
 
@@ -446,11 +475,20 @@ class HotdataClient:
             f"(last status: {getattr(last, 'status', None)})"
         )
 
-    def execute_sql(self, sql: str) -> QueryResult:
+    def execute_sql(self, sql: str, *, database: str | None = None) -> QueryResult:
+        """Execute SQL and return a :class:`QueryResult`.
+
+        Pass ``database`` to scope the query to a managed database.  The name
+        is resolved to a database ID once before the retry loop, and the
+        ``X-Database-Id`` header is sent with every attempt.  Inside a managed
+        database the built-in catalog is always ``"default"``, so table
+        references should use ``"default"."<schema>"."<table>"``.
+        """
+        database_id = self.resolve_managed_database(database).id if database else None
         last_err: BaseException | None = None
         for attempt in range(3):
             try:
-                return self._execute_sql_once(sql)
+                return self._execute_sql_once(sql, database_id=database_id)
             except (ProtocolError, ConnectionResetError, Urllib3HTTPError) as e:
                 last_err = e
                 if attempt == 2:
@@ -458,10 +496,13 @@ class HotdataClient:
                 time.sleep(0.2 * (2**attempt))
         raise last_err  # pragma: no cover
 
-    def _execute_sql_once(self, sql: str) -> QueryResult:
+    def _execute_sql_once(self, sql: str, *, database_id: str | None = None) -> QueryResult:
         q = self._query_api()
         try:
-            raw = q.query(QueryRequest(sql=sql))
+            if database_id:
+                raw = q.query(QueryRequest(sql=sql), x_database_id=database_id)
+            else:
+                raw = q.query(QueryRequest(sql=sql))
         except ApiException as e:
             raise RuntimeError(e.reason or str(e)) from e
 

{hotdata_runtime-0.1.1 → hotdata_runtime-0.2.1}/hotdata_runtime/databases.py

@@ -7,17 +7,15 @@ from pathlib import Path
 from typing import Any
 
 from hotdata.exceptions import ApiException
-from hotdata.models.create_connection_request import CreateConnectionRequest
 
-MANAGED_SOURCE_TYPE = "managed"
 DEFAULT_SCHEMA = "public"
 
 
 @dataclass(frozen=True)
 class ManagedDatabase:
     id: str
-    name: str
-    source_type: str
+    description: str | None
+    default_connection_id: str
 
     def to_dict(self) -> dict[str, Any]:
         return asdict(self)
@@ -51,39 +49,11 @@ def is_parquet_path(path: str) -> bool:
     return Path(path).suffix.lower() == ".parquet"
 
 
-def build_managed_config(schema: str, tables: list[str]) -> dict[str, Any]:
-    if not tables:
-        return {}
-    return {
-        "schemas": [
-            {
-                "name": schema,
-                "tables": [{"name": table} for table in tables],
-            }
-        ]
-    }
-
-
-def create_connection_request(
-    name: str,
-    *,
-    schema: str = DEFAULT_SCHEMA,
-    tables: list[str] | None = None,
-) -> CreateConnectionRequest:
-    table_list = tables or []
-    return CreateConnectionRequest(
-        name=name,
-        source_type=MANAGED_SOURCE_TYPE,
-        config=build_managed_config(schema, table_list),
-        skip_discovery=True,
-    )
-
-
-def managed_database_from_connection(conn: Any) -> ManagedDatabase:
+def managed_database_from_detail(detail: Any) -> ManagedDatabase:
     return ManagedDatabase(
-        id=str(conn.id),
-        name=str(conn.name),
-        source_type=str(conn.source_type),
+        id=str(detail.id),
+        description=detail.description,
+        default_connection_id=str(detail.default_connection_id),
     )
 
 

{hotdata_runtime-0.1.1 → hotdata_runtime-0.2.1}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hotdata-runtime"
-version = "0.1.1"
+version = "0.2.1"
 description = "Workspace/session runtime primitives for Hotdata integrations"
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }
 dependencies = [
-  "hotdata>=0.2.0",
+  "hotdata>=0.2.3",
   "pandas>=2.0",
 ]
 

hotdata_runtime-0.2.1/scripts/check-release.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""Fail CI when pyproject.toml version changes without a matching CHANGELOG entry."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+
+def git_show(path: str, ref: str) -> str:
+    try:
+        return subprocess.check_output(["git", "show", f"{ref}:{path}"], text=True)
+    except subprocess.CalledProcessError:
+        return ""
+
+
+def read_version(text: str) -> str:
+    match = re.search(r'(?m)^version = "([^"]+)"', text)
+    if not match:
+        raise SystemExit("could not read version from pyproject.toml")
+    return match.group(1)
+
+
+def has_changelog_section(version: str) -> bool:
+    changelog = Path("CHANGELOG.md")
+    if not changelog.exists():
+        return False
+    return bool(re.search(rf"^## \[{re.escape(version)}\]", changelog.read_text(), re.M))
+
+
+def main() -> None:
+    base = "origin/main"
+    for candidate in ("origin/main", "origin/master"):
+        if subprocess.call(["git", "rev-parse", "--verify", candidate], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) == 0:
+            base = candidate
+            break
+
+    current = Path("pyproject.toml").read_text()
+    previous = git_show("pyproject.toml", base)
+    if not previous:
+        print("skip: no base pyproject.toml to compare")
+        return
+
+    old_version = read_version(previous)
+    new_version = read_version(current)
+    if old_version == new_version:
+        print(f"version unchanged ({new_version})")
+        return
+
+    if not has_changelog_section(new_version):
+        raise SystemExit(
+            f"pyproject.toml version bumped to {new_version} but CHANGELOG.md "
+            f"has no '## [{new_version}]' section"
+        )
+
+    print(f"release metadata ok for {new_version}")
+
+
+if __name__ == "__main__":
+    main()

hotdata_runtime-0.2.1/scripts/extract-changelog.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""Print the Keep a Changelog section for a release version."""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+
+def extract(changelog: str, version: str) -> str:
+    pattern = rf"^## \[{re.escape(version)}\].*$"
+    match = re.search(pattern, changelog, re.M)
+    if not match:
+        raise SystemExit(f"no changelog section for {version}")
+
+    start = match.start()
+    rest = changelog[match.end() :]
+    next_heading = re.search(r"^## \[", rest, re.M)
+    end = match.end() + (next_heading.start() if next_heading else len(rest))
+    section = changelog[start:end].strip()
+    title, _, body = section.partition("\n")
+    return body.strip() or f"Release {version}."
+
+
+def main() -> None:
+    if len(sys.argv) != 2:
+        raise SystemExit("usage: extract-changelog.py VERSION")
+
+    version = sys.argv[1]
+    changelog = Path("CHANGELOG.md").read_text()
+    print(extract(changelog, version))
+
+
+if __name__ == "__main__":
+    main()