Module adcp.reporting.production.memory

Reference production transactions for shared state-machine conformance.

Classes

class InMemoryReportingProductionOutbox (store: InMemoryReportingProductionStore)
Expand source code
class InMemoryReportingProductionOutbox(InMemoryReportingOutbox):
    """The ordinary SDK expansion/delivery state machine, in a separate collection."""

    _store: InMemoryReportingProductionStore

    def __init__(self, store: InMemoryReportingProductionStore) -> None:
        if store._production_outbox is None:
            raise ReportingNotificationError("notifications_disabled")
        self._store = store

    @property
    def _state(self) -> NotificationState:
        assert self._store._production_outbox is not None
        return self._store._production_outbox

The ordinary SDK expansion/delivery state machine, in a separate collection.

Ancestors

Inherited members

class InMemoryReportingProductionStore (**kwargs: Any)
Expand source code
class InMemoryReportingProductionStore(InMemoryReportingProjectionStore):
    """Matches production atomicity and epochs, without claiming durable storage."""

    _materializer_writer_epoch = 2
    production_support: weakref.ReferenceType[ReportingProductionSupport] | None = None

    def __init__(self, **kwargs: Any) -> None:
        super().__init__(**kwargs)
        self._production_accounts: dict[str, _Admission] = {}
        self._production_delivery_windows: dict[
            tuple[str, str], tuple[str, str, datetime, datetime]
        ] = {}
        self._production_generations: dict[ReportingConfigurationGenerationKey, str] = {}
        self._production_source_bindings: dict[
            ReportingConfigurationGenerationKey, ReportingProductionSourceBinding
        ] = {}
        self._production_destination_bindings: dict[
            tuple[ReportingConfigurationGenerationKey, str], bytes
        ] = {}
        self._production_outbox = (
            NotificationState() if self._notification_state is not None else None
        )
        self._production_status_heads: dict[ReportingDeliveryPrincipal, int] = {}
        self._production_boundaries: list[ReportingMaterializerBoundary] = []
        self._production_closed: dict[ReportingConfigurationGenerationKey, datetime] = {}
        self._production_source_turns: dict[ReportingConfigurationGenerationKey, int] = {}
        self._production_source_work: dict[str, _SourceWork] = {}

    def _owner(self) -> ReportingProductionSupport:
        from adcp.reporting.production.service import production_owner

        return production_owner(self)

    # -- the production store contract (adcp.reporting.production.store) ------

    @property
    def durable(self) -> bool:
        return False

    @property
    def storage_identity(self) -> object:
        return self

    @property
    def storage_open(self) -> bool:
        return True

    def is_sdk_production_store(self) -> bool:
        return type(self) is InMemoryReportingProductionStore

    def status_projection(
        self,
        *,
        consumer_status_enabled: bool,
        escalation: ReportingDeliveryEscalation | None,
        revision_ownership: bool,
    ) -> InMemoryReportingStatusProjection:
        return InMemoryReportingStatusProjection(
            self,
            consumer_status_enabled=consumer_status_enabled,
            escalation=escalation,
            revision_ownership=revision_ownership,
        )

    def is_sdk_status_projection(self, projection: object) -> bool:
        return type(projection) is InMemoryReportingStatusProjection

    def projection_linked(self, projection: ReportingProductionProjection) -> bool:
        return (
            type(projection.outbox) is InMemoryReportingProjectionOutbox
            and projection.outbox._store is self
        )

    def production_outboxes(
        self, projection: ReportingProductionProjection
    ) -> tuple[Any, Any, Any]:
        if type(self) is not InMemoryReportingProductionStore:
            raise ReportingNotificationError("notification_chain_unready")
        return (
            InMemoryReportingOutbox(self),
            projection.outbox,
            InMemoryReportingProductionOutbox(self),
        )

    def notification_workers_linked(self, workers: Sequence[Any]) -> bool:
        expected = (
            InMemoryReportingOutbox,
            InMemoryReportingProjectionOutbox,
            InMemoryReportingProductionOutbox,
        )
        return (
            all(getattr(w.outbox, "_store", None) is self for w in workers)
            and tuple(type(w.outbox) for w in workers) == expected
        )

    async def validate_production_schema(
        self, *, notifications: bool, service_context: bool
    ) -> None:
        """Memory has no catalog; it never advertises durability either."""

    async def read_delivery_window(
        self, key: tuple[str, str], *, now: datetime
    ) -> tuple[SavedDeliveryWindow | None, datetime]:
        async with self._lock:
            return self._production_delivery_windows.get(key), now

    async def reserve_delivery_attempt(
        self,
        activity: ReportingActivityStore,
        lease: DeliveryLease,
        *,
        request: ActivityRequest,
        now: datetime,
        queue: str,
        expected: tuple[str, str],
        horizon_seconds: int,
    ) -> tuple[WebhookAttempt | None, datetime | None, bool]:
        from adcp.reporting.production.delivery_window import inspect_window

        binding = lease.delivery.binding
        key = (binding.account_id, binding.idempotency_key)
        if not isinstance(activity, InMemoryReportingOutbox) or activity._store is not self:
            raise ReportingNotificationError("notification_retry_unready")
        async with self._mutation():
            saved = self._production_delivery_windows.get(key)
            deadline, expired = inspect_window(saved, expected, now)
            if expired:
                return None, deadline, True
            attempt = activity._reserve_attempt_locked(lease, request=request, now=now)
            if attempt is None:
                return None, deadline, False
            retained = self._production_delivery_windows.setdefault(
                key,
                (
                    *expected,
                    attempt.fired_at,
                    attempt.fired_at + timedelta(seconds=horizon_seconds),
                ),
            )
            return attempt, retained[3], False

    def maintenance_operations(self) -> tuple[MaintenanceOperation, ...]:
        return ()

    async def admit_production_configuration(
        self,
        configuration: ReportingConfiguration,
        binding: ReportingDestinationBinding,
        *,
        offering_id: str,
        service_context: ReportingProductionSourceContext | None = None,
    ) -> None:
        offering = self._owner()._configuration_offering(
            configuration, binding, offering_id=offering_id
        )
        async with self._mutation():
            await self.put_configuration(configuration)
            await self.put_destination_binding(binding)
            self._enroll(
                configuration, offering._producer_key, binding, service_context=service_context
            )

    def _enroll(
        self,
        configuration: ReportingConfiguration,
        producer_key: str,
        destination: ReportingDestinationBinding,
        *,
        service_context: ReportingProductionSourceContext | None = None,
    ) -> None:
        previous_context = self._production_source_bindings.get(configuration.generation_key)
        binding = self._owner()._source_binding(
            configuration,
            producer_key,
            service_context=service_context,
            document=previous_context.document() if previous_context is not None else None,
        )
        previous = self._production_generations.setdefault(
            configuration.generation_key, producer_key
        )
        previous_binding = self._production_source_bindings.setdefault(
            configuration.generation_key, binding
        )
        if previous != producer_key or previous_binding != binding:
            raise ReportingNotificationError("reporting_production_source_conflict")
        owner = self._owner()
        offering = owner._configuration_offering(
            configuration, destination, producer_key=producer_key
        )
        document = canonical_json_utf8_v1(owner._destination_binding(destination, offering).wire())
        original = self._production_destination_bindings.setdefault(
            (configuration.generation_key, destination.consumer_id), document
        )
        if original != document:
            raise ReportingNotificationError("reporting_production_destination_conflict")

    def _destination_document(self, binding: ReportingDestinationBinding) -> dict[str, Any] | None:
        raw = self._production_destination_bindings.get(
            (binding.generation_key, binding.consumer_id)
        )
        return dict(json.loads(raw)) if raw is not None else None

    def _configuration_lease_eligible(self, configuration: ReportingConfiguration) -> bool:
        if configuration.quarantined:
            return False
        try:
            self._check_source_generation(configuration)
        except Exception:
            return False
        return True

    def _check_source_generation(self, configuration: ReportingConfiguration) -> None:
        producer_key = self._production_generations.get(configuration.generation_key)
        binding = self._production_source_bindings.get(configuration.generation_key)
        if (
            configuration.account_id not in self._production_accounts
            or producer_key not in self._owner()._producer_keys()
            or binding is None
            or self._configurations.get(configuration.generation_key) != configuration
        ):
            raise LedgerConflictError("HISTORY_UNAVAILABLE", "producer generation is unavailable")
        self._owner()._check_source_binding(configuration, producer_key, binding.document())

    def _wake_obligation(self, account_id: str, obligation_id: str) -> None:
        super()._wake_obligation(account_id, obligation_id)
        obligation = self._obligations.get(obligation_id)
        if (
            obligation is not None
            and obligation.account_id == account_id
            and obligation.generation_key in self._production_generations
        ):
            previous = self._production_source_work.get(obligation_id)
            self._production_source_work[obligation_id] = _SourceWork(
                obligation, previous.turn if previous else 0
            )

    async def producer_closed_through(
        self, configuration: ReportingConfiguration
    ) -> datetime | None:
        async with self._lock:
            self._check_source_generation(configuration)
            return self._production_closed.get(configuration.generation_key)

    async def producer_constituents(
        self, configuration: ReportingConfiguration, obligation: ReportingObligationRecord
    ) -> tuple[ReportingConstituent, ...]:
        async with self._lock:
            self._check_source_generation(configuration)
            if obligation.generation_key != configuration.generation_key or set(
                obligation.media_buy_ids
            ) != set(configuration.media_buy_ids):
                raise LedgerConflictError("HISTORY_UNAVAILABLE", "source denominator differs")
            return self._production_source_bindings[configuration.generation_key].constituents()

    async def commit_producer_period(
        self,
        configuration: ReportingConfiguration,
        obligation: ReportingObligationRecord,
        *,
        previous_end: datetime | None,
    ) -> ReportingObligationRecord:
        check_next_period(configuration, obligation, previous_end)
        async with self._mutation():
            self._check_source_generation(configuration)
            current = self._production_closed.get(configuration.generation_key)
            if current != previous_end and (current is None or current < obligation.period.end):
                raise LedgerConflictError("HISTORY_UNAVAILABLE", "producer progress changed")
            stored = await self.commit_obligation(obligation)
            self._production_source_work.setdefault(
                stored.reporting_obligation_id, _SourceWork(stored)
            )
            self._production_closed[configuration.generation_key] = max(
                obligation.period.end, current or obligation.period.end
            )
            return stored

    async def next_producer_obligations(
        self, configuration: ReportingConfiguration, *, now: datetime, limit: int
    ) -> tuple[str, ...]:
        if type(limit) is not int or not 1 <= limit <= 64:
            raise ValueError("production acquisition limit must be in 1..64")
        async with self._lock:
            self._check_source_generation(configuration)
            candidates = sorted(
                (work.turn, work.obligation.reporting_obligation_id)
                for work in self._production_source_work.values()
                if work.obligation.generation_key == configuration.generation_key
                and work.obligation.period.end <= now
                and work.state == "pending"
            )[:limit]
            turn = self._production_source_turns.get(configuration.generation_key, 0)
            for offset, (_, identifier) in enumerate(candidates, 1):
                work = self._production_source_work[identifier]
                self._production_source_work[identifier] = _SourceWork(
                    work.obligation, turn + offset
                )
            self._production_source_turns[configuration.generation_key] = turn + len(candidates)
            return tuple(identifier for _, identifier in candidates)

    async def finish_producer_acquisition(
        self, configuration: ReportingConfiguration, *, reporting_obligation_id: str
    ) -> None:
        async with self._lock:
            self._check_source_generation(configuration)
            work = self._production_source_work[reporting_obligation_id]
            if work.obligation.generation_key != configuration.generation_key:
                raise LedgerConflictError("HISTORY_UNAVAILABLE", "producer generation differs")
            revisions = await self.list_revisions(
                account_id=configuration.account_id,
                reporting_obligation_id=reporting_obligation_id,
            )
            self._production_source_work[reporting_obligation_id] = _SourceWork(
                work.obligation, work.turn, acquisition_state(work.obligation, revisions)
            )

    async def activate_production(self, *, account_id: str) -> bool:
        owner = self._owner()
        async with self._mutation():
            projection = self._projection_accounts.get(account_id)
            if (
                projection is None
                or not projection.ready
                or projection.policy != owner.projection.policy
            ):
                raise ReportingNotificationError("status_projection_activation_required")
            policy = owner._admission_policy()
            current = self._production_accounts.get(account_id)
            if current is not None:
                if current.policy != policy:
                    raise ReportingNotificationError("reporting_production_policy_conflict")
                return False
            self._production_accounts[account_id] = _Admission(self._clock(), policy)
            for _, _, record in self._retained_delivery_records():
                if (
                    isinstance(record, ReportingDestinationBinding)
                    and record.principal.account_id == account_id
                ):
                    configuration = self._configurations[record.generation_key]
                    try:
                        offering = owner._configuration_offering(configuration, record)
                    # Unsupported or unavailable bindings remain unadmitted.
                    except Exception:  # nosec B112
                        continue
                    self._enroll(configuration, offering._producer_key, record)
            return True

    def _check_admission(self, lease: ReportingMaterializerLease) -> None:
        if lease.admission_epoch != 2:
            return
        admission = self._production_accounts.get(lease.scope.principal.account_id)
        if admission is None or lease.attempt.created_at < admission.activated_at:
            raise failure("BINDING_MISMATCH")
        self._owner()._check_context(
            self._context(lease.scope),
            lease.request.verification_key,
            admission.policy,
            self._production_generations.get(lease.scope.generation_key),
            (
                self._production_source_bindings[lease.scope.generation_key].document()
                if lease.scope.generation_key in self._production_source_bindings
                else None
            ),
            self._destination_document(self._context(lease.scope).binding),
        )

    def _new_admission_epoch(
        self, context: MaterializerContext, key: ReportingVerificationKey
    ) -> int:
        admission = self._production_accounts.get(context.scope.principal.account_id)
        if admission is None:
            raise ReportingNotificationError("reporting_production_activation_required")
        self._owner()._check_context(
            context,
            key,
            admission.policy,
            self._production_generations.get(context.configuration.generation_key),
            (
                self._production_source_bindings[context.configuration.generation_key].document()
                if context.configuration.generation_key in self._production_source_bindings
                else None
            ),
            self._destination_document(context.binding),
        )
        return 2

    def _materializer_candidate_enabled(self, account_id: str) -> bool:
        return account_id in self._production_accounts

    def _held(self, lease: ReportingMaterializerLease) -> _Work | None:
        work = super()._held(lease)
        if work is not None:
            self._check_admission(lease)
        return work

    def _materializer_capture_collections(
        self, outcome: ReportingMaterializationRecord
    ) -> tuple[dict[ReportingDeliveryPrincipal, int], list[ReportingMaterializerBoundary]]:
        work = self._materializer_work.get(
            (
                outcome.scope.principal.account_id,
                outcome.scope.consumer_id,
                outcome.reporting_materialization_id,
            )
        )
        if work is not None and work.admission_epoch == 2:
            return self._production_status_heads, self._production_boundaries
        return super()._materializer_capture_collections(outcome)

    def _enqueue_materializer(
        self, event: ReportingDomainEvent, lease: ReportingMaterializerLease
    ) -> None:
        if lease.admission_epoch == 0:
            return super()._enqueue_materializer(event, lease)
        self._check_admission(lease)
        if self._production_outbox is None:
            raise failure("BINDING_MISMATCH")
        self._production_outbox.enqueue(event)
        if (
            self._production_outbox.events.get(
                (event.account_id, event.consumer_namespace, event.notification_id)
            )
            != event
        ):
            raise failure("BINDING_MISMATCH")

    async def read_production_boundaries(
        self, *, caller: ReportingDeliveryPrincipal, after: int = 0, limit: int = 100
    ) -> tuple[ReportingMaterializerBoundary, ...]:
        if type(after) is not int or after < 0 or type(limit) is not int or not 1 <= limit <= 100:
            raise ValueError("production boundary reads require bounded positions")
        async with self._lock:
            return tuple(
                b for b in self._production_boundaries if b.caller == caller and b.sequence > after
            )[:limit]

Matches production atomicity and epochs, without claiming durable storage.

Ancestors

Class variables

var production_support : weakref.ReferenceType[ReportingProductionSupport] | None

Instance variables

prop durable : bool
Expand source code
@property
def durable(self) -> bool:
    return False
prop storage_identity : object
Expand source code
@property
def storage_identity(self) -> object:
    return self
prop storage_open : bool
Expand source code
@property
def storage_open(self) -> bool:
    return True

Methods

async def activate_production(self, *, account_id: str) ‑> bool
Expand source code
async def activate_production(self, *, account_id: str) -> bool:
    owner = self._owner()
    async with self._mutation():
        projection = self._projection_accounts.get(account_id)
        if (
            projection is None
            or not projection.ready
            or projection.policy != owner.projection.policy
        ):
            raise ReportingNotificationError("status_projection_activation_required")
        policy = owner._admission_policy()
        current = self._production_accounts.get(account_id)
        if current is not None:
            if current.policy != policy:
                raise ReportingNotificationError("reporting_production_policy_conflict")
            return False
        self._production_accounts[account_id] = _Admission(self._clock(), policy)
        for _, _, record in self._retained_delivery_records():
            if (
                isinstance(record, ReportingDestinationBinding)
                and record.principal.account_id == account_id
            ):
                configuration = self._configurations[record.generation_key]
                try:
                    offering = owner._configuration_offering(configuration, record)
                # Unsupported or unavailable bindings remain unadmitted.
                except Exception:  # nosec B112
                    continue
                self._enroll(configuration, offering._producer_key, record)
        return True
async def admit_production_configuration(self,
configuration: ReportingConfiguration,
binding: ReportingDestinationBinding,
*,
offering_id: str,
service_context: ReportingProductionSourceContext | None = None) ‑> None
Expand source code
async def admit_production_configuration(
    self,
    configuration: ReportingConfiguration,
    binding: ReportingDestinationBinding,
    *,
    offering_id: str,
    service_context: ReportingProductionSourceContext | None = None,
) -> None:
    offering = self._owner()._configuration_offering(
        configuration, binding, offering_id=offering_id
    )
    async with self._mutation():
        await self.put_configuration(configuration)
        await self.put_destination_binding(binding)
        self._enroll(
            configuration, offering._producer_key, binding, service_context=service_context
        )
async def commit_producer_period(self,
configuration: ReportingConfiguration,
obligation: ReportingObligationRecord,
*,
previous_end: datetime | None) ‑> ReportingObligationRecord
Expand source code
async def commit_producer_period(
    self,
    configuration: ReportingConfiguration,
    obligation: ReportingObligationRecord,
    *,
    previous_end: datetime | None,
) -> ReportingObligationRecord:
    check_next_period(configuration, obligation, previous_end)
    async with self._mutation():
        self._check_source_generation(configuration)
        current = self._production_closed.get(configuration.generation_key)
        if current != previous_end and (current is None or current < obligation.period.end):
            raise LedgerConflictError("HISTORY_UNAVAILABLE", "producer progress changed")
        stored = await self.commit_obligation(obligation)
        self._production_source_work.setdefault(
            stored.reporting_obligation_id, _SourceWork(stored)
        )
        self._production_closed[configuration.generation_key] = max(
            obligation.period.end, current or obligation.period.end
        )
        return stored
async def finish_producer_acquisition(self, configuration: ReportingConfiguration, *, reporting_obligation_id: str) ‑> None
Expand source code
async def finish_producer_acquisition(
    self, configuration: ReportingConfiguration, *, reporting_obligation_id: str
) -> None:
    async with self._lock:
        self._check_source_generation(configuration)
        work = self._production_source_work[reporting_obligation_id]
        if work.obligation.generation_key != configuration.generation_key:
            raise LedgerConflictError("HISTORY_UNAVAILABLE", "producer generation differs")
        revisions = await self.list_revisions(
            account_id=configuration.account_id,
            reporting_obligation_id=reporting_obligation_id,
        )
        self._production_source_work[reporting_obligation_id] = _SourceWork(
            work.obligation, work.turn, acquisition_state(work.obligation, revisions)
        )
def is_sdk_production_store(self) ‑> bool
Expand source code
def is_sdk_production_store(self) -> bool:
    return type(self) is InMemoryReportingProductionStore
def is_sdk_status_projection(self, projection: object) ‑> bool
Expand source code
def is_sdk_status_projection(self, projection: object) -> bool:
    return type(projection) is InMemoryReportingStatusProjection
def maintenance_operations(self) ‑> tuple[tuple[str, Callable[[], Awaitable[typing.Any]]], ...]
Expand source code
def maintenance_operations(self) -> tuple[MaintenanceOperation, ...]:
    return ()
async def next_producer_obligations(self, configuration: ReportingConfiguration, *, now: datetime, limit: int) ‑> tuple[str, ...]
Expand source code
async def next_producer_obligations(
    self, configuration: ReportingConfiguration, *, now: datetime, limit: int
) -> tuple[str, ...]:
    if type(limit) is not int or not 1 <= limit <= 64:
        raise ValueError("production acquisition limit must be in 1..64")
    async with self._lock:
        self._check_source_generation(configuration)
        candidates = sorted(
            (work.turn, work.obligation.reporting_obligation_id)
            for work in self._production_source_work.values()
            if work.obligation.generation_key == configuration.generation_key
            and work.obligation.period.end <= now
            and work.state == "pending"
        )[:limit]
        turn = self._production_source_turns.get(configuration.generation_key, 0)
        for offset, (_, identifier) in enumerate(candidates, 1):
            work = self._production_source_work[identifier]
            self._production_source_work[identifier] = _SourceWork(
                work.obligation, turn + offset
            )
        self._production_source_turns[configuration.generation_key] = turn + len(candidates)
        return tuple(identifier for _, identifier in candidates)
def notification_workers_linked(self, workers: Sequence[Any]) ‑> bool
Expand source code
def notification_workers_linked(self, workers: Sequence[Any]) -> bool:
    expected = (
        InMemoryReportingOutbox,
        InMemoryReportingProjectionOutbox,
        InMemoryReportingProductionOutbox,
    )
    return (
        all(getattr(w.outbox, "_store", None) is self for w in workers)
        and tuple(type(w.outbox) for w in workers) == expected
    )
async def producer_closed_through(self, configuration: ReportingConfiguration) ‑> datetime.datetime | None
Expand source code
async def producer_closed_through(
    self, configuration: ReportingConfiguration
) -> datetime | None:
    async with self._lock:
        self._check_source_generation(configuration)
        return self._production_closed.get(configuration.generation_key)
async def producer_constituents(self,
configuration: ReportingConfiguration,
obligation: ReportingObligationRecord) ‑> tuple[ProductConstituentV1 | PackageItemConstituentV1 | MediaBuyConstituentV1, ...]
Expand source code
async def producer_constituents(
    self, configuration: ReportingConfiguration, obligation: ReportingObligationRecord
) -> tuple[ReportingConstituent, ...]:
    async with self._lock:
        self._check_source_generation(configuration)
        if obligation.generation_key != configuration.generation_key or set(
            obligation.media_buy_ids
        ) != set(configuration.media_buy_ids):
            raise LedgerConflictError("HISTORY_UNAVAILABLE", "source denominator differs")
        return self._production_source_bindings[configuration.generation_key].constituents()
def production_outboxes(self, projection: ReportingProductionProjection) ‑> tuple[typing.Any, typing.Any, typing.Any]
Expand source code
def production_outboxes(
    self, projection: ReportingProductionProjection
) -> tuple[Any, Any, Any]:
    if type(self) is not InMemoryReportingProductionStore:
        raise ReportingNotificationError("notification_chain_unready")
    return (
        InMemoryReportingOutbox(self),
        projection.outbox,
        InMemoryReportingProductionOutbox(self),
    )
def projection_linked(self, projection: ReportingProductionProjection) ‑> bool
Expand source code
def projection_linked(self, projection: ReportingProductionProjection) -> bool:
    return (
        type(projection.outbox) is InMemoryReportingProjectionOutbox
        and projection.outbox._store is self
    )
async def read_delivery_window(self, key: tuple[str, str], *, now: datetime) ‑> tuple[tuple[str, str, datetime.datetime, datetime.datetime] | None, datetime.datetime]
Expand source code
async def read_delivery_window(
    self, key: tuple[str, str], *, now: datetime
) -> tuple[SavedDeliveryWindow | None, datetime]:
    async with self._lock:
        return self._production_delivery_windows.get(key), now
async def read_production_boundaries(self, *, caller: ReportingDeliveryPrincipal, after: int = 0, limit: int = 100) ‑> tuple[ReportingMaterializerBoundary, ...]
Expand source code
async def read_production_boundaries(
    self, *, caller: ReportingDeliveryPrincipal, after: int = 0, limit: int = 100
) -> tuple[ReportingMaterializerBoundary, ...]:
    if type(after) is not int or after < 0 or type(limit) is not int or not 1 <= limit <= 100:
        raise ValueError("production boundary reads require bounded positions")
    async with self._lock:
        return tuple(
            b for b in self._production_boundaries if b.caller == caller and b.sequence > after
        )[:limit]
async def reserve_delivery_attempt(self,
activity: ReportingActivityStore,
lease: DeliveryLease,
*,
request: ActivityRequest,
now: datetime,
queue: str,
expected: tuple[str, str],
horizon_seconds: int) ‑> tuple[WebhookAttempt | None, datetime.datetime | None, bool]
Expand source code
async def reserve_delivery_attempt(
    self,
    activity: ReportingActivityStore,
    lease: DeliveryLease,
    *,
    request: ActivityRequest,
    now: datetime,
    queue: str,
    expected: tuple[str, str],
    horizon_seconds: int,
) -> tuple[WebhookAttempt | None, datetime | None, bool]:
    from adcp.reporting.production.delivery_window import inspect_window

    binding = lease.delivery.binding
    key = (binding.account_id, binding.idempotency_key)
    if not isinstance(activity, InMemoryReportingOutbox) or activity._store is not self:
        raise ReportingNotificationError("notification_retry_unready")
    async with self._mutation():
        saved = self._production_delivery_windows.get(key)
        deadline, expired = inspect_window(saved, expected, now)
        if expired:
            return None, deadline, True
        attempt = activity._reserve_attempt_locked(lease, request=request, now=now)
        if attempt is None:
            return None, deadline, False
        retained = self._production_delivery_windows.setdefault(
            key,
            (
                *expected,
                attempt.fired_at,
                attempt.fired_at + timedelta(seconds=horizon_seconds),
            ),
        )
        return attempt, retained[3], False
def status_projection(self,
*,
consumer_status_enabled: bool,
escalation: ReportingDeliveryEscalation | None,
revision_ownership: bool) ‑> InMemoryReportingStatusProjection
Expand source code
def status_projection(
    self,
    *,
    consumer_status_enabled: bool,
    escalation: ReportingDeliveryEscalation | None,
    revision_ownership: bool,
) -> InMemoryReportingStatusProjection:
    return InMemoryReportingStatusProjection(
        self,
        consumer_status_enabled=consumer_status_enabled,
        escalation=escalation,
        revision_ownership=revision_ownership,
    )
async def validate_production_schema(self, *, notifications: bool, service_context: bool) ‑> None
Expand source code
async def validate_production_schema(
    self, *, notifications: bool, service_context: bool
) -> None:
    """Memory has no catalog; it never advertises durability either."""

Memory has no catalog; it never advertises durability either.

Inherited members