bug(reporting): capability_block() is empty until the service is running, so reporting_delivery comes and goes with the lifecycle #1298

import asyncio
import logging
import warnings

warnings.simplefilter("ignore")
logging.disable(logging.CRITICAL)

from adcp.decisioning import DecisioningCapabilities, DecisioningPlatform, SingletonAccounts
from adcp.decisioning.serve import create_adcp_server_from_platform
from adcp.reporting import ReliableReportingService
from adcp.reporting.fixtures import redacted_capabilities
from adcp.reporting.testing import ScriptedReportingAdapter
from adcp.server.base import ToolContext
from adcp.types import GetAdcpCapabilitiesRequest

source = redacted_capabilities()
contract = source.offerings[0].contract
OFFERING = {  # the public buyer contract, declared before any account configures reporting
    "offering_id": "daily-snapshot",
    "feed_purpose": "analytics",
    "report_definition_id": contract.report_definition_id,
    "report_definition_uri": contract.report_definition_uri,
    "report_definition_sha256": contract.report_definition_sha256,
    "reporting_profile": {
        "id": contract.reporting_profile, "version": contract.schema_version,
        "schema_uri": contract.schema_uri, "schema_sha256": contract.schema_sha256,
        "schema_dialect": "https://json-schema.org/draft/2020-12/schema",
        "schema_ref_policy": "local_fragment_only",
        "grain": "one row per media buy per period", "primary_keys": ["media_buy_id"],
    },
    "schedule": {"period_duration": "P1D", "delivery_sla": "PT1H", "alignment": "utc"},
    "supported_finality": ["snapshot"],
    "reconciliation_mode": "delivery_only",
}


class Seller(DecisioningPlatform):
    capabilities = DecisioningCapabilities(specialisms=["sales-non-guaranteed"], supported_billing=["operator"])
    accounts = SingletonAccounts(account_id="acct")

    def get_products(self, req, ctx): return {"products": []}
    def create_media_buy(self, req, ctx): raise NotImplementedError
    def update_media_buy(self, media_buy_id, patch, ctx): raise NotImplementedError
    def sync_creatives(self, req, ctx): raise NotImplementedError
    def get_media_buy_delivery(self, req, ctx): raise NotImplementedError


service = ReliableReportingService.memory(account_context=lambda c: None)
service.sources.register("src", ScriptedReportingAdapter(source), capability_offerings=[OFFERING])
print("at build time:", service.capability_block())
handler, _, _ = create_adcp_server_from_platform(service.install(Seller()))
print("tools advertised:", sorted(service.reporting_tools))


async def caps():
    resp = await handler.get_adcp_capabilities(GetAdcpCapabilitiesRequest(), ToolContext())
    resp = resp if isinstance(resp, dict) else resp.model_dump(mode="json", exclude_none=True)
    return "reporting_delivery" in (resp.get("media_buy") or {}), resp.get("experimental_features")


async def main():
    print("before start: reporting_delivery=%s experimental=%s" % await caps())
    await service.start()
    print("after start:  reporting_delivery=%s experimental=%s" % await caps())
    await service.close()
    print("after close:  reporting_delivery=%s experimental=%s" % await caps())

asyncio.run(main())