Queue client signatures

PyQueue(
    db_path: str = ".flexiq/flexiq.db",
    workers: int = 0,
    default_retry: int = 3,
    default_timeout: int = 300,
    default_priority: int = 0,
    result_ttl: int | None = None,
    backend: str = "sqlite",
    db_url: str | None = None,
    schema: str = "flexiq",
    pool_size: int | None = None,
    scheduler_poll_interval_ms: int = 50,
    scheduler_reap_interval: int = 100,
    scheduler_cleanup_interval: int = 1200,
    scheduler_batch_size: int | None = None,
    namespace: str | None = None,
    push_dispatch: bool | None = None,
    dlq_auto_retry_delay: int | None = None,
    dlq_auto_retry_max: int = 1,
    retention: dict[str, int] | None = None,
    auto_migrate: bool = True,
    event_sinks: str | None = None,
    event_sinks_drain: float = 5.0
)

queue.ack_message(
    topic: str,
    subscription_name: str,
    message_id: str
) -> bool

queue.ack_topic_cursor(
    topic: str,
    subscription_name: str,
    cursor: str
) -> bool

queue.acquire_lock(
    lock_name: str,
    owner_id: str,
    ttl_ms: int = 30000
) -> bool

queue.archive_old_jobs(older_than_seconds: int) -> int

queue.begin_run() -> None

queue.cancel_job(job_id: str) -> bool

queue.cancel_workflow_run(run_id: str) -> None

queue.check_fan_out_completion(
    run_id: str,
    parent_node_name: str
) -> tuple[bool, list[str]] | None

queue.close_dashboard_audit() -> None

queue.count_pending_by_queue(queue_name: str) -> int

queue.create_deferred_job(
    run_id: str,
    node_name: str,
    payload: bytes,
    task_name: str,
    queue: str,
    max_retries: int,
    timeout_ms: int,
    priority: int
) -> str

queue.dead_letters(
    limit: int = 10,
    offset: int = 0
) -> list[dict[str, Any]]

queue.dead_letters_after(
    limit: int = 10,
    after: str | None = None
) -> tuple[list[dict[str, Any]], str | None]

queue.dead_letters_by_task(
    task_name: str,
    limit: int = 10,
    offset: int = 0
) -> list[dict[str, Any]]

queue.declare_topic(
    name: str,
    mode: str,
    retention_ms: int | None = None
) -> None

queue.delete_dead(dead_id: str) -> bool

queue.delete_periodic(name: str) -> bool

queue.delete_setting(key: str) -> bool

queue.dry_run_retention(retention: dict[str, int] | None = None) -> str

queue.effective_retention() -> str | None

queue.end_run() -> None

queue.enqueue(
    task_name: str,
    payload: bytes,
    queue: str = "default",
    priority: int | None = None,
    delay_seconds: float | None = None,
    max_retries: int | None = None,
    timeout: int | None = None,
    unique_key: str | None = None,
    metadata: str | None = None,
    notes: str | None = None,
    depends_on: list[str] | None = None,
    expires: float | None = None,
    result_ttl: int | None = None,
    debounce_key: str | None = None,
    debounce_window_ms: int | None = None,
    debounce_max_wait_ms: int | None = None,
    debounce_replace_payload: bool = False,
    debounce_max_pending: int | None = None
) -> PyJob

queue.enqueue_batch(
    task_names: list[str],
    payloads: list[bytes],
    queues: list[str] | None = None,
    priorities: list[int | None] | None = None,
    max_retries_list: list[int | None] | None = None,
    timeouts: list[int | None] | None = None,
    delay_seconds_list: list[float | None] | None = None,
    unique_keys: list[str | None] | None = None,
    metadata_list: list[str | None] | None = None,
    notes_list: list[str | None] | None = None,
    expires_list: list[float | None] | None = None,
    result_ttl_list: list[int | None] | None = None
) -> list[PyJob]

queue.event_sink_stats() -> list[dict[str, Any]]

queue.expand_fan_out(
    run_id: str,
    parent_node_name: str,
    child_names: list[str],
    child_payloads: list[bytes],
    task_name: str,
    queue: str,
    max_retries: int,
    timeout_ms: int,
    priority: int
) -> list[str]

queue.extend_lock(
    lock_name: str,
    owner_id: str,
    ttl_ms: int = 30000
) -> bool

queue.fail_workflow_node(
    run_id: str,
    node_name: str,
    error: str
) -> None

queue.finalize_run_if_terminal(run_id: str) -> str | None

queue.get_base_run_node_data(
    base_run_id: str
) -> list[tuple[str, str, str | None]]

queue.get_child_workflow_runs(parent_run_id: str) -> list[PyWorkflowRun]

queue.get_dependencies(job_id: str) -> list[str]

queue.get_dependents(job_id: str) -> list[str]

queue.get_job(job_id: str) -> PyJob | None

queue.get_job_errors(job_id: str) -> list[dict[str, Any]]

queue.get_lock_info(lock_name: str) -> dict[str, Any] | None

queue.get_metrics(
    task_name: str | None = None,
    since_seconds: int = 3600
) -> list[dict[str, Any]]

queue.get_replay_history(job_id: str) -> list[dict[str, Any]]

queue.get_setting(key: str) -> str | None

queue.get_task_logs(job_id: str) -> list[dict[str, Any]]

queue.get_workflow_definition_dag(run_id: str) -> bytes

queue.get_workflow_run_detail(
    run_id: str
) -> tuple[PyWorkflowRun, list[PyWorkflowRunNode]]

queue.get_workflow_run_status(run_id: str) -> PyWorkflowRunStatus

queue.get_workflow_trace_carrier(run_id: str) -> dict[str, str]

queue.inherited_worker_steps() -> WorkerSteps | None

queue.is_cancel_requested(job_id: str) -> bool

queue.is_migrated() -> bool

queue.lease_topic_messages(
    topic: str,
    subscription_name: str,
    limit: int,
    visibility_ms: int
) -> list[tuple[str, bytes, str | None, str | None, int]]

queue.list_archived(limit: int = 50, offset: int = 0) -> list[PyJob]

queue.list_archived_after(
    limit: int = 50,
    after: str | None = None
) -> tuple[list[PyJob], str | None]

queue.list_circuit_breakers() -> list[dict[str, Any]]

queue.list_declared_topics() -> list[tuple[str, str, int | None, int]]

queue.list_jobs(
    status: str | None = None,
    queue: str | None = None,
    task_name: str | None = None,
    limit: int = 50,
    offset: int = 0,
    namespace: str | None = None
) -> list[PyJob]

queue.list_jobs_after(
    status: str | None = None,
    queue: str | None = None,
    task_name: str | None = None,
    limit: int = 50,
    after: str | None = None,
    namespace: str | None = None
) -> tuple[list[PyJob], str | None]

queue.list_jobs_filtered(
    status: str | None = None,
    queue: str | None = None,
    task_name: str | None = None,
    metadata_like: str | None = None,
    error_like: str | None = None,
    created_after: int | None = None,
    created_before: int | None = None,
    limit: int = 50,
    offset: int = 0,
    namespace: str | None = None
) -> list[PyJob]

queue.list_jobs_filtered_after(
    status: str | None = None,
    queue: str | None = None,
    task_name: str | None = None,
    metadata_like: str | None = None,
    error_like: str | None = None,
    created_after: int | None = None,
    created_before: int | None = None,
    limit: int = 50,
    after: str | None = None,
    namespace: str | None = None
) -> tuple[list[PyJob], str | None]

queue.list_paused_queues() -> list[str]

queue.list_periodic() -> list[dict[str, Any]]

queue.list_settings() -> dict[str, str]

queue.list_subscriptions(
    topic: str | None = None
) -> list[tuple[str, str, str, str, bool, bool]]

queue.list_workers() -> list[dict[str, Any]]

queue.list_workflow_runs(
    definition_name: str | None = None,
    state: str | None = None,
    limit: int = 50,
    offset: int = 0
) -> list[PyWorkflowRun]

queue.list_workflow_runs_after(
    definition_name: str | None = None,
    state: str | None = None,
    limit: int = 50,
    after: str | None = None
) -> tuple[list[PyWorkflowRun], str | None]

queue.mark_workflow_node_result(
    job_id: str,
    succeeded: bool,
    error: str | None = None,
    skip_cascade: bool = False,
    result_hash: str | None = None
) -> tuple[str, str, str | None] | None

queue.migrate() -> dict[str, Any]

queue.min_contract() -> int

queue.nack_message(
    topic: str,
    subscription_name: str,
    message_id: str
) -> bool

queue.pause_periodic(name: str) -> bool

queue.pause_queue(queue_name: str) -> None

queue.publish(
    topic: str,
    payload: bytes,
    idempotency_key: str | None = None,
    metadata: str | None = None,
    notes: str | None = None,
    priority: int | None = None,
    delay_seconds: float | None = None,
    max_retries: int | None = None,
    timeout: int | None = None,
    expires: float | None = None,
    result_ttl: int | None = None
) -> list[PyJob]

queue.purge_completed(older_than_seconds: int) -> int

queue.purge_dead(older_than_seconds: int) -> int

queue.purge_dead_by_task(task_name: str) -> int

queue.purge_queue(queue_name: str) -> int

queue.query_task_logs(
    task_name: str | None = None,
    level: str | None = None,
    since_seconds: int = 3600,
    limit: int = 100
) -> list[dict[str, Any]]

queue.read_topic_messages(
    topic: str,
    subscription_name: str,
    limit: int
) -> list[tuple[str, bytes, str | None, str | None, int]]

queue.reap_ephemeral_subscriptions(worker_id: str | None = None) -> int

queue.record_dashboard_action(
    method: str,
    path: str,
    status: int,
    username: str | None = None
) -> None

queue.register_periodic(
    name: str,
    task_name: str,
    cron_expr: str,
    args: bytes | None = None,
    queue: str = "default",
    timezone: str | None = None
) -> None

queue.register_subscription(
    topic: str,
    subscription_name: str,
    task_name: str,
    queue: str = "default",
    durable: bool = True,
    owner_worker_id: str | None = None,
    priority: int | None = None,
    max_retries: int | None = None,
    timeout_ms: int | None = None,
    mode: str = "fanout"
) -> None

queue.release_lock(lock_name: str, owner_id: str) -> bool

queue.replay_job(job_id: str) -> str

queue.request_cancel(job_id: str) -> bool

queue.request_shutdown() -> None

queue.request_worker_drain(worker_id: str) -> bool

queue.requeue_job(job_id: str) -> bool

queue.resolve_workflow_gate(
    run_id: str,
    node_name: str,
    approved: bool,
    error: str | None = None
) -> None

queue.resume_periodic(name: str) -> bool

queue.resume_queue(queue_name: str) -> None

queue.retry_dead(dead_id: str) -> str

queue.revoke_task(task_name: str) -> int

queue.run_worker(
    task_registry: dict[str, Any],
    task_configs: list[PyTaskConfig],
    queues: list[str] | None = None,
    drain_timeout_secs: int | None = None,
    tags: str | None = None,
    worker_id: str | None = None,
    resources: str | None = None,
    threads: int = 1,
    async_concurrency: int = 100,
    queue_configs: str | None = None,
    pool: str | None = None,
    app_path: str | None = None,
    mesh_config: str | None = None
) -> None

queue.set_min_contract(level: int) -> None

queue.set_setting(key: str, value: str) -> None

queue.set_setting_if(key: str, expected: str | None, value: str) -> bool

queue.set_subscription_active(
    topic: str,
    subscription_name: str,
    active: bool
) -> bool

queue.set_worker_status(worker_id: str, status: str) -> None

queue.set_workflow_node_compensated(
    run_id: str,
    node_name: str,
    completed_at: int
) -> None

queue.set_workflow_node_compensation_failed(
    run_id: str,
    node_name: str,
    error: str,
    completed_at: int
) -> None

queue.set_workflow_node_compensation_job(
    run_id: str,
    node_name: str,
    compensation_job_id: str,
    started_at: int
) -> None

queue.set_workflow_node_fan_out_count(
    run_id: str,
    node_name: str,
    count: int
) -> None

queue.set_workflow_node_running(run_id: str, node_name: str) -> None

queue.set_workflow_node_waiting_approval(
    run_id: str,
    node_name: str
) -> None

queue.set_workflow_run_compensated(
    run_id: str,
    completed_at: int
) -> None

queue.set_workflow_run_compensating(run_id: str) -> None

queue.set_workflow_run_compensation_failed(
    run_id: str,
    completed_at: int,
    error: str | None = None
) -> None

queue.set_workflow_run_completed_with_failures(run_id: str) -> None

queue.skip_workflow_node(run_id: str, node_name: str) -> None

queue.start_dashboard_audit(retention_days: int) -> None

queue.stats() -> dict[str, int]

queue.stats_all_queues() -> dict[str, dict[str, int]]

queue.stats_by_queue(queue_name: str) -> dict[str, int]

queue.submit_workflow(
    name: str,
    version: int,
    dag_bytes: bytes,
    step_metadata_json: str,
    node_payloads: dict[str, bytes],
    queue_default: str = "default",
    params_json: str | None = None,
    deferred_node_names: list[str] | None = None,
    parent_run_id: str | None = None,
    parent_node_name: str | None = None,
    cache_hit_nodes: dict[str, str] | None = None,
    traceparent: str | None = None,
    tracestate: str | None = None
) -> PyWorkflowHandle

queue.supports_steps() -> bool

queue.topic_backlog_stats() -> list[tuple[str, str, str, str, bool, bool, int, int, int, int | None]]

queue.topic_log_stats() -> list[tuple[str, str, str | None, int, int | None]]

queue.unsubscribe(topic: str, subscription_name: str) -> bool

queue.update_progress(job_id: str, progress: int) -> None

queue.worker_heartbeat(
    worker_id: str,
    resource_health: str | None = None
) -> list[str]

queue.write_task_log(
    job_id: str,
    task_name: str,
    level: str,
    message: str,
    extra: str | None = None
) -> None