Bursar storage API

This surface contains the optional PostgreSQL runtime, bounded maintenance and diagnostics, outbox recovery, and S3 and ClickHouse adapters.

Optional high-volume storage infrastructure.

Importing this module requires the postgres extra, mirroring the JavaScript SDK’s Node-only storage entry point. Using the native S3 adapter additionally requires the s3 extra.

class bursar.storage.BillingEventPayloadExport(*, tenant_id, event_id, provider, provider_environment, provider_event_id, event_type, status, received_at, completed_at, envelope, object_key=None, object_version=None, archived_at=None)

• Parameters:
  • tenant_id (str)
  • event_id (str)
  • provider (str)
  • provider_environment (str)
  • provider_event_id (str)
  • event_type (str)
  • status (str)
  • received_at (str)
  • completed_at (str | None)
  • envelope (dict *[*str , Any ] | None)
  • object_key (str | None)
  • object_version (str | None)
  • archived_at (str | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.BillingPayloadArchive(*args, **kwargs)

class bursar.storage.BillingPayloadArchiveResult(*, key, version_id)

• Parameters:
  • key (str)
  • version_id (str | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.BatchUsageEventSink(*args, **kwargs)

class bursar.storage.BursarMaintenance(operations)

Tenant-scoped maintenance that never schedules itself.

• Parameters: operations (MaintenanceOperations)

class bursar.storage.BursarOperatorMaintenance(query)

Explicit operator-only storage and partition maintenance entry points.

• Parameters: query (QueryFn)

class bursar.storage.BursarRuntime(options)

Composition root for Postgres and optional external projections.

• Parameters: options (BursarRuntimeOptions)

class bursar.storage.BursarRuntimeDiagnostics(*, checked_at, ready, financial_ready, projection_ready, degraded, state, postgres, catalog, outbox)

• Parameters:
  • checked_at (str)
  • ready (bool)
  • financial_ready (bool)
  • projection_ready (bool)
  • degraded (bool)
  • state (BursarRuntimeState)
  • postgres (DependencyCheck)
  • catalog (CatalogDependencyCheck)
  • outbox (OutboxDependencyCheck)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.BursarRuntimeHealth(*, ready, financial_ready, projection_ready, degraded, started, closed, catalog_loaded)

• Parameters:
  • ready (bool)
  • financial_ready (bool)
  • projection_ready (bool)
  • degraded (bool)
  • started (bool)
  • closed (bool)
  • catalog_loaded (bool)

model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.BursarRuntimeBursarOptions(*, credits_options=None, billing_options=None, commerce_options=None, emitter=None)

• Parameters:
  • credits_options (CreditsServiceOptions | None)
  • billing_options (BillingServiceOptions | None)
  • commerce_options (CommerceRuntimeOptions | None)
  • emitter (Annotated [CreditEventEmitter , SkipValidation ( ) ] | None)

model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.BursarRuntimeOptions(*, postgres, operator_postgres, tenant_id, provider_environment, tenant_slug=None, postgres_options=, s3=None, clickhouse=None, outbox=None, bursar=)

• Parameters:
  • postgres (str | Annotated *[*PostgresPool , SkipValidation ( ) ])
  • operator_postgres (str | Annotated *[*PostgresPool , SkipValidation ( ) ])
  • tenant_id (UUID)
  • provider_environment (Literal [ 'live' , 'test' , 'sandbox' ])
  • tenant_slug (str | None)
  • postgres_options (Annotated [PostgresConnectionOptions , SkipValidation ( ) ])
  • s3 (Annotated *[*BillingPayloadArchive , SkipValidation ( ) ] | S3BillingArchiveOptions | None)
  • clickhouse (Annotated *[*UsageAnalyticsSink , SkipValidation ( ) ] | ClickHouseUsageStoreOptions | None)
  • outbox (OutboxWorkerOptions | Literal *[*False ] | None)
  • bursar (BursarRuntimeBursarOptions)

model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.BursarRuntimeStartOptions(*, load_catalog=True, max_attempts=1, retry_delay_seconds=0.25, max_elapsed_seconds=30.0, should_retry=None)

• Parameters:
  • load_catalog (bool)
  • max_attempts (int)
  • retry_delay_seconds (float)
  • max_elapsed_seconds (float)
  • should_retry (Callable [ *[*BaseException ] , bool ] | None)

model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.BursarRuntimeState(*, ready, financial_ready, projection_ready, degraded, started, closed, catalog_loaded, worker)

• Parameters:
  • ready (bool)
  • financial_ready (bool)
  • projection_ready (bool)
  • degraded (bool)
  • started (bool)
  • closed (bool)
  • catalog_loaded (bool)
  • worker (WorkerState)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.CatalogDependencyCheck(*, status, latency_ms=None, error=None, reason=None, loaded, current_revision_id, current_revision=None)

• Parameters:
  • status (Literal [ 'ok' , 'error' , 'skipped' , 'unsupported' ])
  • latency_ms (float | None)
  • error (str | None)
  • reason (str | None)
  • loaded (bool)
  • current_revision_id (str | None)
  • current_revision (int | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.CheckDependenciesOptions(*, outbox_limit=100)

• Parameters: outbox_limit (int)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.ClickHouseClient(*args, **kwargs)

class bursar.storage.ClickHouseQueryResult(*args, **kwargs)

class bursar.storage.ClickHouseUsageStore(options)

Idempotent ClickHouse projection and usage analytics read port.

• Parameters: options (ClickHouseUsageStoreOptions)

initialize_schema()

Explicitly create Bursar’s standalone projection schema.

• Return type: None

write_usage_batch(entries)

Insert a batch in one request while retaining each outbox identity.

• Parameters: entries (Sequence *[*tuple *[*UsageChargeExport , str ] ])
• Return type: None

check_schema_compatibility()

Validate the existing schema without creating or modifying it.

• Return type: None

class bursar.storage.ClickHouseUsageStoreOptions(*, client, tenant_id, table='bursar_usage_events', create_table=False, retention_days=None)

• Parameters:
  • client (Annotated *[*ClickHouseClient , SkipValidation ( ) ])
  • tenant_id (UUID)
  • table (str)
  • create_table (bool)
  • retention_days (int | None)

model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.DependencyCheck(*, status, latency_ms=None, error=None, reason=None)

• Parameters:
  • status (Literal [ 'ok' , 'error' , 'skipped' , 'unsupported' ])
  • latency_ms (float | None)
  • error (str | None)
  • reason (str | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.MaintenanceRunOptions(*, limit=100, now=None)

• Parameters:
  • limit (int)
  • now (datetime | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.MaintenanceRunResult(*, status, count, has_more, tasks)

• Parameters:
  • status (Literal [ 'completed' , 'partial' , 'failed' ])
  • count (int)
  • has_more (bool)
  • tasks (dict *[*Literal [ 'expired_leases' , 'expired_credits' , 'due_plan_changes' , 'past_due_grace_periods' ] , ~bursar.storage.maintenance.MaintenanceTaskResult ])

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.MaintenanceOperations(*, expire_leases=None, expire_credits=None, apply_due_plan_changes=None, expire_past_due_grace_periods=None, past_due_grace_period_limit=100, past_due_grace_periods_unavailable_reason=None)

• Parameters:
  • expire_leases (Callable [ *[*int ] , int ] | None)
  • expire_credits (Callable [ *[*int ] , int ] | None)
  • apply_due_plan_changes (Callable [ *[*int ] , int ] | None)
  • expire_past_due_grace_periods (Callable [ *[*datetime ] , int ] | None)
  • past_due_grace_period_limit (int)
  • past_due_grace_periods_unavailable_reason (str | None)

model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.MaintenanceTaskResult(*, status, count, limit, has_more, reason=None, error=None)

• Parameters:
  • status (Literal [ 'completed' , 'skipped' , 'unsupported' , 'failed' ])
  • count (int)
  • limit (int)
  • has_more (bool)
  • reason (str | None)
  • error (str | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.OperatorMaintenanceRunOptions(*, mode='if_due', now=None)

• Parameters:
  • mode (Literal [ 'if_due' , 'force' ])
  • now (datetime | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.OutboxClaimRenewalStore(*args, **kwargs)

class bursar.storage.OutboxDeadLetter(*, event_id, tenant_id, topic, aggregate_type, aggregate_id, payload_version, attempt_count, last_error, created_at, updated_at)

• Parameters:
  • event_id (str)
  • tenant_id (str)
  • topic (str)
  • aggregate_type (str)
  • aggregate_id (str)
  • payload_version (int)
  • attempt_count (int)
  • last_error (str | None)
  • created_at (str)
  • updated_at (str)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.OutboxDeadLetterCursor(*, created_at, event_id)

• Parameters:
  • created_at (str)
  • event_id (str)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.OutboxDeadLetterListOptions(*, limit=100, cursor=None)

• Parameters:
  • limit (int)
  • cursor (OutboxDeadLetterCursor | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.OutboxDeadLetterPage(*, items, next_cursor)

• Parameters:
  • items (list *[*OutboxDeadLetter ])
  • next_cursor (OutboxDeadLetterCursor | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.OutboxDependencyCheck(*, status, latency_ms=None, error=None, reason=None, snapshot, limit)

• Parameters:
  • status (Literal [ 'ok' , 'error' , 'skipped' , 'unsupported' ])
  • latency_ms (float | None)
  • error (str | None)
  • reason (str | None)
  • snapshot (OutboxStatusSnapshot | None)
  • limit (int)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.OutboxEvent(*, event_id, tenant_id, topic, aggregate_type, aggregate_id, payload_version, payload, claim_token, attempt_count, created_at)

• Parameters:
  • event_id (str)
  • tenant_id (str)
  • topic (str)
  • aggregate_type (str)
  • aggregate_id (str)
  • payload_version (int)
  • payload (dict *[*str , Any ])
  • claim_token (str)
  • attempt_count (int)
  • created_at (str)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.OutboxEventOutcome(*, topic, attempt_count, status, summary, duration_ms, retry_delay_seconds, dead_lettered, claim_loss_phase)

• Parameters:
  • topic (str)
  • attempt_count (int)
  • status (Literal [ 'delivered' , 'delivery_failed' , 'claim_lost' ])
  • summary (str | None)
  • duration_ms (float)
  • retry_delay_seconds (int | None)
  • dead_lettered (bool)
  • claim_loss_phase (Literal [ 'heartbeat' , 'complete' , 'fail' ] | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.OutboxHandler(*args, **kwargs)

class bursar.storage.OutboxRecoveryStore(*args, **kwargs)

class bursar.storage.OutboxRunResult(*, claimed, delivered, failed, claim_lost)

• Parameters:
  • claimed (int)
  • delivered (int)
  • failed (int)
  • claim_lost (int)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.OutboxStats(*, pending_count, processing_count, delivered_count, dead_letter_count, oldest_pending_at)

• Parameters:
  • pending_count (int)
  • processing_count (int)
  • delivered_count (int)
  • dead_letter_count (int)
  • oldest_pending_at (str | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.OutboxStatusSnapshot(*, pending_count, processing_count, delivered_count, dead_letter_count, oldest_pending_at)

• Parameters:
  • pending_count (int)
  • processing_count (int)
  • delivered_count (int)
  • dead_letter_count (int)
  • oldest_pending_at (str | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.OutboxStore(*args, **kwargs)

class bursar.storage.OutboxWorker(store, handlers, options=None)

Generic leased-outbox dispatcher.

Handlers must be idempotent because a process can stop after the external write succeeds but before PostgreSQL records the acknowledgement.

• Parameters:
  • store (OutboxStore)
  • handlers (Sequence *[*OutboxHandler ])
  • options (OutboxWorkerOptions | None)

class bursar.storage.OutboxWorkerOptions(*, batch_size=100, concurrency=4, lease_seconds=60, poll_interval_ms=1000, retry_delay_seconds=30, max_retry_delay_seconds=3600, attempt_limit=10, on_error=None, on_event_outcome=None)

• Parameters:
  • batch_size (int)
  • concurrency (int)
  • lease_seconds (int)
  • poll_interval_ms (int)
  • retry_delay_seconds (int)
  • max_retry_delay_seconds (int)
  • attempt_limit (int)
  • on_error (Callable [ *[*BaseException ] , None ] | None)
  • on_event_outcome (Callable [ *[*OutboxEventOutcome ] , None ] | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.PostgresConnectionOptions(connection_timeout_seconds=10.0, statement_timeout_ms=30000, idle_transaction_timeout_ms=30000, max_connections=10, application_name='bursar-python', on_pool_error=None, instrumentation=None)

Connection, transaction-deadline, and observability controls.

• Parameters:
  • connection_timeout_seconds (float)
  • statement_timeout_ms (int)
  • idle_transaction_timeout_ms (int)
  • max_connections (int)
  • application_name (str)
  • on_pool_error (Annotated *[*Callable [ [BursarError ] , None ] | None , SkipJsonSchema ( ) ])
  • instrumentation (Annotated [Instrumentation | None , SkipJsonSchema ( ) ])

class bursar.storage.PartitionMaintenanceResult(*, status, parent_table, count, partitions_created, partitions_dropped, partition_lock_timeouts, default_partition_has_rows, has_more, error=None)

• Parameters:
  • status (Literal [ 'completed' , 'busy' , 'failed' ])
  • parent_table (Literal [ 'usage_charge_payloads' , 'billing_event_payloads' ])
  • count (int)
  • partitions_created (int)
  • partitions_dropped (int)
  • partition_lock_timeouts (int)
  • default_partition_has_rows (bool)
  • has_more (bool)
  • error (str | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.S3BillingArchive(options)

Archive received billing webhook envelopes under deterministic keys.

• Parameters: options (S3BillingArchiveOptions)

class bursar.storage.S3BillingArchiveOptions(*, bucket, region=None, credentials=None, endpoint=None, force_path_style=False, prefix='bursar', client=None, client_factory=None, owns_client=None, put_object=)

• Parameters:
  • bucket (str)
  • region (str | None)
  • credentials (S3Credentials | None)
  • endpoint (str | None)
  • force_path_style (bool)
  • prefix (str)
  • client (Annotated *[*Any , SkipValidation ( ) ] | None)
  • client_factory (Annotated *[*Callable [ [ ] , Any ] , SkipValidation ( ) ] | None)
  • owns_client (bool | None)
  • put_object (S3PutObjectOptions | Mapping *[*str , Any ])

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.S3Credentials(*, access_key_id, secret_access_key, session_token=None)

• Parameters:
  • access_key_id (str)
  • secret_access_key (str)
  • session_token (str | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.S3PutObjectOptions(*, server_side_encryption=None, sse_kms_key_id=None, sse_kms_encryption_context=None, bucket_key_enabled=None, checksum_algorithm=None, checksum_crc32=None, checksum_crc32c=None, checksum_crc64_nvme=None, checksum_sha1=None, checksum_sha256=None, checksum_sha512=None, checksum_md5=None, checksum_xxhash64=None, checksum_xxhash3=None, checksum_xxhash128=None)

Safe per-object encryption and checksum controls.

• Parameters:
  • server_side_encryption (str | None)
  • sse_kms_key_id (str | None)
  • sse_kms_encryption_context (str | None)
  • bucket_key_enabled (bool | None)
  • checksum_algorithm (str | None)
  • checksum_crc32 (str | None)
  • checksum_crc32c (str | None)
  • checksum_crc64_nvme (str | None)
  • checksum_sha1 (str | None)
  • checksum_sha256 (str | None)
  • checksum_sha512 (str | None)
  • checksum_md5 (str | None)
  • checksum_xxhash64 (str | None)
  • checksum_xxhash3 (str | None)
  • checksum_xxhash128 (str | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.StorageMaintenanceCounts(*, usage_payloads_purged, record_only_usage_purged, billing_payloads_purged, quota_usage_events_purged, quota_notifications_purged, terminal_leases_compacted, usage_rollups_purged, outbox_events_purged)

• Parameters:
  • usage_payloads_purged (int)
  • record_only_usage_purged (int)
  • billing_payloads_purged (int)
  • quota_usage_events_purged (int)
  • quota_notifications_purged (int)
  • terminal_leases_compacted (int)
  • usage_rollups_purged (int)
  • outbox_events_purged (int)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.StorageMaintenanceResult(*, status, count, has_more, batch_size=None, counts, last_maintenance_at=None, next_maintenance_at=None, error=None)

• Parameters:
  • status (Literal [ 'completed' , 'busy' , 'not_due' , 'failed' ])
  • count (int)
  • has_more (bool)
  • batch_size (int | None)
  • counts (StorageMaintenanceCounts)
  • last_maintenance_at (str | None)
  • next_maintenance_at (str | None)
  • error (str | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.UsageAnalyticsSink(*args, **kwargs)

Combined ClickHouse write and analytics read port.

class bursar.storage.UsageChargeExport(*, tenant_id, charge_id, account_id, subject_id, operation, feature, model, region, measures, dimensions, metadata, requested, charged, allowance_requested, allowance_covered, billing_disposition='billable', catalog_revision_id, plan_id, rate_card_key, pricing_snapshot, ledger_entry_id, correction_of_charge_id, idempotency_key, request_digest, event_at, created_at)

• Parameters:
  • tenant_id (str)
  • charge_id (str)
  • account_id (str)
  • subject_id (str)
  • operation (str)
  • feature (str | None)
  • model (str | None)
  • region (str | None)
  • measures (dict *[*str , Any ])
  • dimensions (dict *[*str , Any ])
  • metadata (dict *[*str , Any ])
  • requested (str)
  • charged (str)
  • allowance_requested (str)
  • allowance_covered (str)
  • billing_disposition (Literal [ 'billable' , 'record_only' ])
  • catalog_revision_id (str | None)
  • plan_id (str | None)
  • rate_card_key (str | None)
  • pricing_snapshot (dict *[*str , Any ])
  • ledger_entry_id (str | None)
  • correction_of_charge_id (str | None)
  • idempotency_key (str)
  • request_digest (str)
  • event_at (str)
  • created_at (str)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.UsageEventSink(*args, **kwargs)

class bursar.storage.UsageProjectionSchema(*args, **kwargs)

Optional non-mutating compatibility check for caller-managed schemas.

class bursar.storage.WorkerErrorSnapshot(*, at, error)

• Parameters:
  • at (str)
  • error (str)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.WorkerRunSnapshot(*, source='manual', status, started_at, completed_at, result, error=None)

• Parameters:
  • source (Literal [ 'manual' ])
  • status (Literal [ 'completed' , 'failed' ])
  • started_at (str)
  • completed_at (str)
  • result (OutboxRunResult | None)
  • error (str | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bursar.storage.WorkerState(*, configured, lifecycle, last_run, last_error)

• Parameters:
  • configured (bool)
  • lifecycle (Literal [ 'not_configured' , 'not_started' , 'running' , 'stopped' ])
  • last_run (WorkerRunSnapshot | None)
  • last_error (WorkerErrorSnapshot | None)

model_config = {'extra': 'forbid', 'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].