adcp-reporting-storage 0.1.0b1__tar.gz

adcp_reporting_storage-0.1.0b1/LICENSE

@@ -0,0 +1,17 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+Copyright 2025 AdCP Community
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

adcp_reporting_storage-0.1.0b1/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: adcp-reporting-storage
+Version: 0.1.0b1
+Summary: PostgreSQL and object-storage implementations of the AdCP Reliable Reporting stores
+Author-email: AdCP Community <maintainers@adcontextprotocol.org>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/adcontextprotocol/adcp-client-python
+Project-URL: Documentation, https://github.com/adcontextprotocol/adcp-client-python/blob/main/packages/adcp-reporting-storage/README.md
+Project-URL: Repository, https://github.com/adcontextprotocol/adcp-client-python
+Project-URL: Issues, https://github.com/adcontextprotocol/adcp-client-python/issues
+Keywords: adcp,reporting,postgresql,advertising
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: adcp<10,>=9.0.0
+Requires-Dist: rfc8785>=0.1.4
+Provides-Extra: pg
+Requires-Dist: psycopg[binary]>=3.1.0; extra == "pg"
+Requires-Dist: psycopg-pool>=3.2.0; extra == "pg"
+Provides-Extra: gcs
+Requires-Dist: google-cloud-storage>=2.18; extra == "gcs"
+Provides-Extra: s3
+Requires-Dist: boto3>=1.35; extra == "s3"
+Provides-Extra: azure
+Requires-Dist: azure-storage-blob>=12.20; extra == "azure"
+Dynamic: license-file
+
+# adcp-reporting-storage
+
+PostgreSQL and object-storage implementations of the AdCP Reliable Reporting
+stores, maintained in the [adcp-client-python](https://github.com/adcontextprotocol/adcp-client-python)
+repository and versioned on its own line.
+
+[`adcp`](https://pypi.org/project/adcp/) defines the store protocols, the
+in-memory stores, the producer, the `get_reporting_status` handlers, the
+reconciliation logic and the row encoding. This distribution implements those
+protocols durably:
+
+| What | Where |
+| --- | --- |
+| Core ledger, reconciliation, materializer, receipt, feed, projection and production stores over PostgreSQL | `adcp_reporting_storage.ledger.pg`, `.ledger.delivery_pg`, `.materializer.pg`, `.receipts.pg`, `.feed.pg`, `.projection.pg`, `.production.pg` |
+| Notification, status and activity queues over PostgreSQL | `adcp_reporting_storage.outbox.pg`, `.outbox.status_pg`, `.outbox.status_activity_pg` |
+| Chunked revision row storage, with filesystem, Google Cloud Storage, Amazon S3 and Azure Blob providers | `adcp_reporting_storage.ledger.row_storage*` |
+| The host change feed, period retirement, row migration and retention | `adcp_reporting_storage.ledger.change_feed`, `.period_retirement`, `.row_migration`, `.row_retention` |
+| Durable inline source staging and seals, buyer submission intents | `adcp_reporting_storage.inline_storage`, `.submissions.pg` |
+| Caller-ownership migration helpers | `adcp_reporting_storage.migration` |
+| The adapter-first `ReliableReportingService` over a borrowed pool | `adcp_reporting_storage.service` |
+
+Every public name is also importable from the top-level package, lazily:
+
+```python
+from psycopg_pool import AsyncConnectionPool
+
+from adcp.reporting.ledger import ProducerOfferings, ReportingProducer
+from adcp_reporting_storage import PgReportingLedgerStore, ReportingRowStorageOptionsV1
+
+async with AsyncConnectionPool(dsn, min_size=2, max_size=10) as pool:
+    store = PgReportingLedgerStore(
+        pool=pool,
+        row_storage=ReportingRowStorageOptionsV1(deployment_namespace="prod-us"),
+    )
+    await store.create_schema()
+    producer = ReportingProducer(source=..., offerings=ProducerOfferings(...), store=store)
+    await producer.run_worker()
+```
+
+## Install
+
+```bash
+pip install "adcp-reporting-storage[pg]"            # PostgreSQL stores (psycopg)
+pip install "adcp-reporting-storage[pg,gcs]"        # + rows on Google Cloud Storage
+pip install "adcp-reporting-storage[pg,s3]"         # + rows on Amazon S3
+pip install "adcp-reporting-storage[pg,azure]"      # + rows on Azure Blob Storage
+```
+
+`adcp` is a dependency and is installed with it. The cloud providers take a
+client you build; the extras only pin the client libraries.
+
+## Compatibility
+
+This package implements the protocols of one `adcp` major and imports a few
+private helpers of `adcp.reporting` to do so (`adcp.reporting.ledger._record_rows`,
+`_delivery_state`, `status_snapshot`). Its dependency range is therefore one
+major (`adcp>=9.0.0,<10`), and a new `adcp` major means a new release here.
+`adcp` never imports this package; a test in the main repository enforces that.
+
+## Versioning
+
+0.x: breaking changes may land in a minor release, each with a migration note in
+[CHANGELOG.md](CHANGELOG.md). The package reaches 1.0 when the storage layout
+shared with the JavaScript SDK (`@adcp/reporting-storage`) is declared stable.
+
+## Documentation
+
+The guides live in the repository: [Reliable Reporting service](../../docs/reliable-reporting-service.md),
+[row storage](../../docs/reporting-row-storage.md), [ledger migrations](../../docs/reporting-ledger-migration.md),
+[caller-ownership migration](../../docs/reporting-caller-ownership-migration.md),
+and the [migration note for the 9.0 split](../../docs/reporting-storage-package-migration.md).

adcp_reporting_storage-0.1.0b1/README.md

@@ -0,0 +1,71 @@
+# adcp-reporting-storage
+
+PostgreSQL and object-storage implementations of the AdCP Reliable Reporting
+stores, maintained in the [adcp-client-python](https://github.com/adcontextprotocol/adcp-client-python)
+repository and versioned on its own line.
+
+[`adcp`](https://pypi.org/project/adcp/) defines the store protocols, the
+in-memory stores, the producer, the `get_reporting_status` handlers, the
+reconciliation logic and the row encoding. This distribution implements those
+protocols durably:
+
+| What | Where |
+| --- | --- |
+| Core ledger, reconciliation, materializer, receipt, feed, projection and production stores over PostgreSQL | `adcp_reporting_storage.ledger.pg`, `.ledger.delivery_pg`, `.materializer.pg`, `.receipts.pg`, `.feed.pg`, `.projection.pg`, `.production.pg` |
+| Notification, status and activity queues over PostgreSQL | `adcp_reporting_storage.outbox.pg`, `.outbox.status_pg`, `.outbox.status_activity_pg` |
+| Chunked revision row storage, with filesystem, Google Cloud Storage, Amazon S3 and Azure Blob providers | `adcp_reporting_storage.ledger.row_storage*` |
+| The host change feed, period retirement, row migration and retention | `adcp_reporting_storage.ledger.change_feed`, `.period_retirement`, `.row_migration`, `.row_retention` |
+| Durable inline source staging and seals, buyer submission intents | `adcp_reporting_storage.inline_storage`, `.submissions.pg` |
+| Caller-ownership migration helpers | `adcp_reporting_storage.migration` |
+| The adapter-first `ReliableReportingService` over a borrowed pool | `adcp_reporting_storage.service` |
+
+Every public name is also importable from the top-level package, lazily:
+
+```python
+from psycopg_pool import AsyncConnectionPool
+
+from adcp.reporting.ledger import ProducerOfferings, ReportingProducer
+from adcp_reporting_storage import PgReportingLedgerStore, ReportingRowStorageOptionsV1
+
+async with AsyncConnectionPool(dsn, min_size=2, max_size=10) as pool:
+    store = PgReportingLedgerStore(
+        pool=pool,
+        row_storage=ReportingRowStorageOptionsV1(deployment_namespace="prod-us"),
+    )
+    await store.create_schema()
+    producer = ReportingProducer(source=..., offerings=ProducerOfferings(...), store=store)
+    await producer.run_worker()
+```
+
+## Install
+
+```bash
+pip install "adcp-reporting-storage[pg]"            # PostgreSQL stores (psycopg)
+pip install "adcp-reporting-storage[pg,gcs]"        # + rows on Google Cloud Storage
+pip install "adcp-reporting-storage[pg,s3]"         # + rows on Amazon S3
+pip install "adcp-reporting-storage[pg,azure]"      # + rows on Azure Blob Storage
+```
+
+`adcp` is a dependency and is installed with it. The cloud providers take a
+client you build; the extras only pin the client libraries.
+
+## Compatibility
+
+This package implements the protocols of one `adcp` major and imports a few
+private helpers of `adcp.reporting` to do so (`adcp.reporting.ledger._record_rows`,
+`_delivery_state`, `status_snapshot`). Its dependency range is therefore one
+major (`adcp>=9.0.0,<10`), and a new `adcp` major means a new release here.
+`adcp` never imports this package; a test in the main repository enforces that.
+
+## Versioning
+
+0.x: breaking changes may land in a minor release, each with a migration note in
+[CHANGELOG.md](CHANGELOG.md). The package reaches 1.0 when the storage layout
+shared with the JavaScript SDK (`@adcp/reporting-storage`) is declared stable.
+
+## Documentation
+
+The guides live in the repository: [Reliable Reporting service](../../docs/reliable-reporting-service.md),
+[row storage](../../docs/reporting-row-storage.md), [ledger migrations](../../docs/reporting-ledger-migration.md),
+[caller-ownership migration](../../docs/reporting-caller-ownership-migration.md),
+and the [migration note for the 9.0 split](../../docs/reporting-storage-package-migration.md).

adcp_reporting_storage-0.1.0b1/pyproject.toml

@@ -0,0 +1,87 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "adcp-reporting-storage"
+version = "0.1.0b1"
+description = "PostgreSQL and object-storage implementations of the AdCP Reliable Reporting stores"
+authors = [
+    {name = "AdCP Community", email = "maintainers@adcontextprotocol.org"}
+]
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
+keywords = ["adcp", "reporting", "postgresql", "advertising"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+
+dependencies = [
+    # The store protocols, in-memory stores, producer, handlers, row encoding
+    # and record codecs this distribution implements against. The stores in
+    # this package subclass nothing in ``adcp`` but import its private
+    # ``adcp.reporting`` helpers, so the range is one major: a new ``adcp``
+    # major means a new release here.
+    "adcp>=9.0.0,<10",
+    # RFC 8785 canonical JSON for row bodies and object keys; the same pin as adcp.
+    "rfc8785>=0.1.4",
+]
+
+[project.optional-dependencies]
+pg = [
+    # Every store in this package is PostgreSQL-backed. psycopg3 ships both
+    # sync and async pool interfaces; the stores take an AsyncConnectionPool.
+    "psycopg[binary]>=3.1.0",
+    "psycopg-pool>=3.2.0",
+]
+gcs = [
+    # Row storage on Google Cloud Storage. The provider takes a client you build,
+    # with keyless credentials; it never imports the library itself.
+    "google-cloud-storage>=2.18",
+]
+s3 = [
+    # Row storage on Amazon S3 or an S3-compatible store (needs bucket versioning).
+    "boto3>=1.35",
+]
+azure = [
+    # Row storage on Azure Blob Storage (needs blob versioning on the account).
+    "azure-storage-blob>=12.20",
+]
+
+[project.urls]
+Homepage = "https://github.com/adcontextprotocol/adcp-client-python"
+Documentation = "https://github.com/adcontextprotocol/adcp-client-python/blob/main/packages/adcp-reporting-storage/README.md"
+Repository = "https://github.com/adcontextprotocol/adcp-client-python"
+Issues = "https://github.com/adcontextprotocol/adcp-client-python/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+adcp_reporting_storage = [
+    "py.typed",
+    "ledger/*.sql",
+    "ledger/*.json",
+    "outbox/*.json",
+    "materializer/*.json",
+    "receipts/*.json",
+    "feed/*.json",
+    "projection/*.json",
+    "production/*.json",
+    "production/*.sql",
+]
+
+# Inside this repository the dependency is the checkout, not PyPI. uv ignores
+# this when the package is installed from a built distribution.
+[tool.uv.sources]
+adcp = { workspace = true }

adcp_reporting_storage-0.1.0b1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

adcp_reporting_storage-0.1.0b1/src/adcp_reporting_storage/__init__.py

@@ -0,0 +1,353 @@
+"""PostgreSQL and object-storage implementations of the AdCP Reliable Reporting stores.
+
+``adcp`` defines the store protocols, the in-memory stores, the producer, the
+handlers and the row encoding. This distribution implements those protocols
+over PostgreSQL and, for revision rows, over a filesystem or an object store
+(Google Cloud Storage, Amazon S3, Azure Blob Storage). It is versioned on its
+own line so a storage fix never has to ship as a protocol-client release.
+
+What you assemble::
+
+    from psycopg_pool import AsyncConnectionPool
+    from adcp.reporting.ledger import ProducerOfferings, ReportingProducer
+    from adcp_reporting_storage import PgReportingLedgerStore
+
+    store = PgReportingLedgerStore(pool=pool)
+    await store.create_schema()
+    producer = ReportingProducer(source=..., offerings=..., store=store)
+
+or, for the adapter-first service::
+
+    from adcp_reporting_storage import postgres_reliable_reporting_service
+
+    reporting = postgres_reliable_reporting_service(pool=pool, account_context=...)
+
+Names are resolved lazily (:pep:`562`): importing this package loads no driver
+and no cloud SDK until the first store or provider is touched. The layout
+mirrors ``adcp.reporting`` (``adcp_reporting_storage.ledger.pg`` is where
+``PgReportingLedgerStore`` is defined), so a deep import is a supported
+address too.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    __version__: str
+    from adcp_reporting_storage.feed.pg import PgReportingFeedStore as PgReportingFeedStore
+    from adcp_reporting_storage.inline_storage import (
+        PgReportingSealStore as PgReportingSealStore,
+    )
+    from adcp_reporting_storage.inline_storage import (
+        PgReportingStagingStore as PgReportingStagingStore,
+    )
+    from adcp_reporting_storage.ledger.change_feed import (
+        ReportingChangeCursorExpiredError as ReportingChangeCursorExpiredError,
+    )
+    from adcp_reporting_storage.ledger.change_feed import (
+        ReportingChangeKindV1 as ReportingChangeKindV1,
+    )
+    from adcp_reporting_storage.ledger.change_feed import (
+        ReportingChangeRecordV1 as ReportingChangeRecordV1,
+    )
+    from adcp_reporting_storage.ledger.change_feed import (
+        ReportingChangesPageV1 as ReportingChangesPageV1,
+    )
+    from adcp_reporting_storage.ledger.delivery_pg import (
+        PgReportingReconciliationStore as PgReportingReconciliationStore,
+    )
+    from adcp_reporting_storage.ledger.period_retirement import (
+        ReportingPeriodRetirementV1 as ReportingPeriodRetirementV1,
+    )
+    from adcp_reporting_storage.ledger.pg import (
+        PgReportingLedgerStore as PgReportingLedgerStore,
+    )
+    from adcp_reporting_storage.ledger.row_migration import (
+        ReportingRowMigrationBatchV1 as ReportingRowMigrationBatchV1,
+    )
+    from adcp_reporting_storage.ledger.row_migration import (
+        ReportingRowQuarantineReason as ReportingRowQuarantineReason,
+    )
+    from adcp_reporting_storage.ledger.row_retention import (
+        ReportingRowIntentSweepV1 as ReportingRowIntentSweepV1,
+    )
+    from adcp_reporting_storage.ledger.row_retention import (
+        ReportingRowPruneV1 as ReportingRowPruneV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage import (
+        ReportingObjectRowBindingV1 as ReportingObjectRowBindingV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage import (
+        ReportingPostgresRowBindingV1 as ReportingPostgresRowBindingV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage import (
+        ReportingRowBindingSelectionInputV1 as ReportingRowBindingSelectionInputV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage import (
+        ReportingRowStorageOptionsV1 as ReportingRowStorageOptionsV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage import (
+        ReportingRowStorageV1 as ReportingRowStorageV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage_azure import (
+        create_azure_blob_reporting_row_object_provider_v1 as create_azure_blob_reporting_row_object_provider_v1,  # noqa: E501
+    )
+    from adcp_reporting_storage.ledger.row_storage_gcs import (
+        assert_gcs_reporting_row_bucket_policy_v1 as assert_gcs_reporting_row_bucket_policy_v1,
+    )
+    from adcp_reporting_storage.ledger.row_storage_gcs import (
+        create_gcs_reporting_row_object_provider_v1 as create_gcs_reporting_row_object_provider_v1,
+    )
+    from adcp_reporting_storage.ledger.row_storage_object import (
+        ReportingRowObjectContextV1 as ReportingRowObjectContextV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage_object import (
+        ReportingRowObjectDeleteInputV1 as ReportingRowObjectDeleteInputV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage_object import (
+        ReportingRowObjectGetInputV1 as ReportingRowObjectGetInputV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage_object import (
+        ReportingRowObjectProviderV1 as ReportingRowObjectProviderV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage_object import (
+        ReportingRowObjectPutInputV1 as ReportingRowObjectPutInputV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage_object import (
+        ReportingRowObjectPutResultV1 as ReportingRowObjectPutResultV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage_object import (
+        ReportingRowObjectStatInputV1 as ReportingRowObjectStatInputV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage_object import (
+        ReportingRowObjectStatResultV1 as ReportingRowObjectStatResultV1,
+    )
+    from adcp_reporting_storage.ledger.row_storage_object import (
+        create_filesystem_reporting_row_object_provider_v1 as create_filesystem_reporting_row_object_provider_v1,  # noqa: E501
+    )
+    from adcp_reporting_storage.ledger.row_storage_object import (
+        render_reporting_row_object_key_v1 as render_reporting_row_object_key_v1,
+    )
+    from adcp_reporting_storage.ledger.row_storage_object import (
+        reporting_period_date_v1 as reporting_period_date_v1,
+    )
+    from adcp_reporting_storage.ledger.row_storage_object import (
+        run_reporting_row_object_provider_conformance_v1 as run_reporting_row_object_provider_conformance_v1,  # noqa: E501
+    )
+    from adcp_reporting_storage.ledger.row_storage_s3 import (
+        create_s3_reporting_row_object_provider_v1 as create_s3_reporting_row_object_provider_v1,
+    )
+    from adcp_reporting_storage.materializer.pg import (
+        PgReportingMaterializerStore as PgReportingMaterializerStore,
+    )
+    from adcp_reporting_storage.migration import (
+        ReportingOwnershipBackfill as ReportingOwnershipBackfill,
+    )
+    from adcp_reporting_storage.migration import (
+        ReportingOwnershipMigrationError as ReportingOwnershipMigrationError,
+    )
+    from adcp_reporting_storage.migration import (
+        backfill_legacy_reporting as backfill_legacy_reporting,
+    )
+    from adcp_reporting_storage.migration import (
+        legacy_generation_digest as legacy_generation_digest,
+    )
+    from adcp_reporting_storage.migration import (
+        migrate_legacy_reporting as migrate_legacy_reporting,
+    )
+    from adcp_reporting_storage.migration import (
+        replace_empty_legacy_reporting as replace_empty_legacy_reporting,
+    )
+    from adcp_reporting_storage.migration import (
+        replace_empty_legacy_reporting_sync as replace_empty_legacy_reporting_sync,
+    )
+    from adcp_reporting_storage.migration import (
+        replace_empty_owned_reporting as replace_empty_owned_reporting,
+    )
+    from adcp_reporting_storage.migration import (
+        replace_empty_owned_reporting_sync as replace_empty_owned_reporting_sync,
+    )
+    from adcp_reporting_storage.migration import (
+        require_owned_schema_or_empty as require_owned_schema_or_empty,
+    )
+    from adcp_reporting_storage.outbox.pg import PgReportingOutbox as PgReportingOutbox
+    from adcp_reporting_storage.outbox.status_activity_pg import (
+        PgReportingActivityUnionStore as PgReportingActivityUnionStore,
+    )
+    from adcp_reporting_storage.outbox.status_pg import (
+        PgReportingStatusOutbox as PgReportingStatusOutbox,
+    )
+    from adcp_reporting_storage.outbox.status_pg import (
+        PgStatusNotificationStore as PgStatusNotificationStore,
+    )
+    from adcp_reporting_storage.production.pg import (
+        PgReportingProductionOutbox as PgReportingProductionOutbox,
+    )
+    from adcp_reporting_storage.production.pg import (
+        PgReportingProductionStore as PgReportingProductionStore,
+    )
+    from adcp_reporting_storage.projection.notifications import (
+        PgReportingProjectionOutbox as PgReportingProjectionOutbox,
+    )
+    from adcp_reporting_storage.projection.pg import (
+        PgReportingProjectionStore as PgReportingProjectionStore,
+    )
+    from adcp_reporting_storage.projection.pg import (
+        PgReportingStatusProjection as PgReportingStatusProjection,
+    )
+    from adcp_reporting_storage.receipts.pg import (
+        PgReportingReceiptStore as PgReportingReceiptStore,
+    )
+    from adcp_reporting_storage.service import (
+        postgres_reliable_reporting_service as postgres_reliable_reporting_service,
+    )
+    from adcp_reporting_storage.submissions.pg import (
+        PgReportingSubmissionIntentStore as PgReportingSubmissionIntentStore,
+    )
+
+#: Public name -> (module under this package, attribute). Resolved on first use.
+_LAZY_EXPORTS: dict[str, tuple[str, str]] = {
+    # Stores
+    "PgReportingLedgerStore": ("ledger.pg", "PgReportingLedgerStore"),
+    "PgReportingReconciliationStore": ("ledger.delivery_pg", "PgReportingReconciliationStore"),
+    "PgReportingMaterializerStore": ("materializer.pg", "PgReportingMaterializerStore"),
+    "PgReportingReceiptStore": ("receipts.pg", "PgReportingReceiptStore"),
+    "PgReportingFeedStore": ("feed.pg", "PgReportingFeedStore"),
+    "PgReportingProjectionStore": ("projection.pg", "PgReportingProjectionStore"),
+    "PgReportingStatusProjection": ("projection.pg", "PgReportingStatusProjection"),
+    "PgReportingProjectionOutbox": ("projection.notifications", "PgReportingProjectionOutbox"),
+    "PgReportingProductionStore": ("production.pg", "PgReportingProductionStore"),
+    "PgReportingProductionOutbox": ("production.pg", "PgReportingProductionOutbox"),
+    "PgReportingOutbox": ("outbox.pg", "PgReportingOutbox"),
+    "PgReportingStatusOutbox": ("outbox.status_pg", "PgReportingStatusOutbox"),
+    "PgStatusNotificationStore": ("outbox.status_pg", "PgStatusNotificationStore"),
+    "PgReportingActivityUnionStore": ("outbox.status_activity_pg", "PgReportingActivityUnionStore"),
+    "PgReportingSubmissionIntentStore": ("submissions.pg", "PgReportingSubmissionIntentStore"),
+    "PgReportingStagingStore": ("inline_storage", "PgReportingStagingStore"),
+    "PgReportingSealStore": ("inline_storage", "PgReportingSealStore"),
+    # The adapter-first service over PostgreSQL
+    "postgres_reliable_reporting_service": ("service", "postgres_reliable_reporting_service"),
+    # Caller-ownership migration
+    "ReportingOwnershipBackfill": ("migration", "ReportingOwnershipBackfill"),
+    "ReportingOwnershipMigrationError": ("migration", "ReportingOwnershipMigrationError"),
+    "backfill_legacy_reporting": ("migration", "backfill_legacy_reporting"),
+    "legacy_generation_digest": ("migration", "legacy_generation_digest"),
+    "migrate_legacy_reporting": ("migration", "migrate_legacy_reporting"),
+    "replace_empty_legacy_reporting": ("migration", "replace_empty_legacy_reporting"),
+    "replace_empty_legacy_reporting_sync": ("migration", "replace_empty_legacy_reporting_sync"),
+    "replace_empty_owned_reporting": ("migration", "replace_empty_owned_reporting"),
+    "replace_empty_owned_reporting_sync": ("migration", "replace_empty_owned_reporting_sync"),
+    "require_owned_schema_or_empty": ("migration", "require_owned_schema_or_empty"),
+    # Host change feed
+    "ReportingChangeCursorExpiredError": (
+        "ledger.change_feed",
+        "ReportingChangeCursorExpiredError",
+    ),
+    "ReportingChangeKindV1": ("ledger.change_feed", "ReportingChangeKindV1"),
+    "ReportingChangeRecordV1": ("ledger.change_feed", "ReportingChangeRecordV1"),
+    "ReportingChangesPageV1": ("ledger.change_feed", "ReportingChangesPageV1"),
+    # Row storage: options, bindings, maintenance results
+    "ReportingRowStorageV1": ("ledger.row_storage", "ReportingRowStorageV1"),
+    "ReportingRowStorageOptionsV1": ("ledger.row_storage", "ReportingRowStorageOptionsV1"),
+    "ReportingObjectRowBindingV1": ("ledger.row_storage", "ReportingObjectRowBindingV1"),
+    "ReportingPostgresRowBindingV1": ("ledger.row_storage", "ReportingPostgresRowBindingV1"),
+    "ReportingRowBindingSelectionInputV1": (
+        "ledger.row_storage",
+        "ReportingRowBindingSelectionInputV1",
+    ),
+    "ReportingRowIntentSweepV1": ("ledger.row_retention", "ReportingRowIntentSweepV1"),
+    "ReportingRowPruneV1": ("ledger.row_retention", "ReportingRowPruneV1"),
+    "ReportingPeriodRetirementV1": ("ledger.period_retirement", "ReportingPeriodRetirementV1"),
+    "ReportingRowMigrationBatchV1": ("ledger.row_migration", "ReportingRowMigrationBatchV1"),
+    "ReportingRowQuarantineReason": ("ledger.row_migration", "ReportingRowQuarantineReason"),
+    # Row object providers: the contract, the filesystem reference, the cloud factories
+    "ReportingRowObjectProviderV1": ("ledger.row_storage_object", "ReportingRowObjectProviderV1"),
+    "ReportingRowObjectContextV1": ("ledger.row_storage_object", "ReportingRowObjectContextV1"),
+    "ReportingRowObjectPutInputV1": ("ledger.row_storage_object", "ReportingRowObjectPutInputV1"),
+    "ReportingRowObjectPutResultV1": ("ledger.row_storage_object", "ReportingRowObjectPutResultV1"),
+    "ReportingRowObjectGetInputV1": ("ledger.row_storage_object", "ReportingRowObjectGetInputV1"),
+    "ReportingRowObjectDeleteInputV1": (
+        "ledger.row_storage_object",
+        "ReportingRowObjectDeleteInputV1",
+    ),
+    "ReportingRowObjectStatInputV1": ("ledger.row_storage_object", "ReportingRowObjectStatInputV1"),
+    "ReportingRowObjectStatResultV1": (
+        "ledger.row_storage_object",
+        "ReportingRowObjectStatResultV1",
+    ),
+    "render_reporting_row_object_key_v1": (
+        "ledger.row_storage_object",
+        "render_reporting_row_object_key_v1",
+    ),
+    "reporting_period_date_v1": ("ledger.row_storage_object", "reporting_period_date_v1"),
+    "create_filesystem_reporting_row_object_provider_v1": (
+        "ledger.row_storage_object",
+        "create_filesystem_reporting_row_object_provider_v1",
+    ),
+    "run_reporting_row_object_provider_conformance_v1": (
+        "ledger.row_storage_object",
+        "run_reporting_row_object_provider_conformance_v1",
+    ),
+    "create_gcs_reporting_row_object_provider_v1": (
+        "ledger.row_storage_gcs",
+        "create_gcs_reporting_row_object_provider_v1",
+    ),
+    "assert_gcs_reporting_row_bucket_policy_v1": (
+        "ledger.row_storage_gcs",
+        "assert_gcs_reporting_row_bucket_policy_v1",
+    ),
+    "create_s3_reporting_row_object_provider_v1": (
+        "ledger.row_storage_s3",
+        "create_s3_reporting_row_object_provider_v1",
+    ),
+    "create_azure_blob_reporting_row_object_provider_v1": (
+        "ledger.row_storage_azure",
+        "create_azure_blob_reporting_row_object_provider_v1",
+    ),
+}
+
+_LAZY_SUBMODULES = frozenset(
+    {
+        "feed",
+        "inline_storage",
+        "ledger",
+        "materializer",
+        "migration",
+        "outbox",
+        "production",
+        "projection",
+        "receipts",
+        "service",
+        "submissions",
+    }
+)
+
+__all__ = sorted(_LAZY_EXPORTS)
+
+
+def __getattr__(name: str) -> Any:
+    if name == "__version__":
+        # Read the installed distribution's PEP 440 version rather than a
+        # literal Release Please would rewrite in its own -beta.N spelling.
+        from importlib.metadata import PackageNotFoundError, version
+
+        try:
+            return version("adcp-reporting-storage")
+        except PackageNotFoundError:
+            return "0.0.0"
+    lazy_export = _LAZY_EXPORTS.get(name)
+    if lazy_export is not None:
+        import importlib
+
+        module_name, attribute = lazy_export
+        return getattr(importlib.import_module(f"{__name__}.{module_name}"), attribute)
+    if name in _LAZY_SUBMODULES:
+        import importlib
+
+        return importlib.import_module(f"{__name__}.{name}")
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(__all__) | _LAZY_SUBMODULES | {"__version__"})