pyfect-dev 0.1.0__py3-none-any.whl

pyfect/workflow/durable_deferred.py

@@ -0,0 +1,403 @@
+"""Named wait points of a workflow execution (Effect's
+``effect/workflow/DurableDeferred``)::
+
+    approval = durable_deferred.make("approval", success=S.Boolean)
+
+    # in the workflow: suspend until someone completes it
+    approved = yield from approval.wait()
+
+    # anywhere else, with the token the workflow handed out
+    yield from approval.succeed(token=token, value=True)
+
+A deferred's result is stored by the engine, encoded by its schemas, so a
+replay of the workflow reads it instead of waiting. A token names the
+workflow, the execution and the deferred, so code outside the workflow
+can complete the right wait point.
+"""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+import base64
+from collections.abc import Generator, Mapping, Sequence
+from typing import TYPE_CHECKING, Any, Never, NewType, cast
+from weakref import WeakKeyDictionary
+
+from pyfect import _json_text
+from pyfect._concurrency import race_all as race_all_effects
+from pyfect._core import Effect
+from pyfect._effect_args import require_effect
+from pyfect._js import text_encode
+from pyfect.brand import Brand
+from pyfect.cause import Cause, Interrupt, from_reasons
+from pyfect.effect import from_exit, gen, provide_service, succeed, sync
+from pyfect.exit import Exit, Failure, Success
+from pyfect.schema import (
+    Class,
+    Codec,
+    Defect,
+    ExitSchema,
+    String,
+    StringFromBase64Url,
+    Tuple,
+    decode_sync,
+    decode_to,
+    encode_sync,
+    field,
+    from_brand,
+    from_json_string,
+    to_codec_json,
+)
+from pyfect.schema import Exit as ExitOf
+from pyfect.schema import Never as NeverSchema
+from pyfect.schema import Null as NullSchema
+from pyfect.schema.transformation import transform
+from pyfect.workflow._services import (
+    WorkflowEngine,
+    WorkflowEngineService,
+    WorkflowInstance,
+    WorkflowInstanceService,
+)
+from pyfect.workflow._suspension import suspend as suspend_run
+from pyfect.workflow._suspension import wrap_activity_result
+from pyfect.workflow.activity import CurrentAttempt, Exactly, codec_of
+
+if TYPE_CHECKING:
+    from pyfect.workflow.workflow import Workflow
+
+Token = NewType("Token", str)
+"""A string naming a workflow, an execution and a deferred."""
+
+TokenSchema = String.pipe(from_brand(Brand[str, Token].nominal()))
+"""Tokens (Effect's ``DurableDeferred.Token``)."""
+
+
+class TokenParsed(Class):
+    """A token taken apart."""
+
+    workflow_name: str = field(String, key="workflowName")
+    execution_id: str = field(String, key="executionId")
+    deferred_name: str = field(String, key="deferredName")
+
+    @property
+    def as_token(self) -> Token:
+        """The token: base64url of the JSON ``[workflow, execution,
+        deferred]``, as Effect writes it."""
+        text = _json_text.stringify([self.workflow_name, self.execution_id, self.deferred_name])
+        return Token(base64.urlsafe_b64encode(text_encode(text)).decode().rstrip("="))
+
+    @staticmethod
+    def from_string(token: str) -> TokenParsed:
+        """Parse ``token``; raises ``SchemaError`` if it is not one."""
+        return decode_sync(TOKEN_FROM_STRING)(token)
+
+    @staticmethod
+    def encode(parsed: TokenParsed) -> str:
+        return encode_sync(TOKEN_FROM_STRING)(parsed)
+
+
+def _to_fields(parts: tuple[str, str, str]) -> Mapping[str, object]:
+    return {"workflowName": parts[0], "executionId": parts[1], "deferredName": parts[2]}
+
+
+def _from_fields(fields: Mapping[str, object]) -> tuple[str, str, str]:
+    return (
+        cast("str", fields["workflowName"]),
+        cast("str", fields["executionId"]),
+        cast("str", fields["deferredName"]),
+    )
+
+
+TOKEN_FROM_STRING = StringFromBase64Url.pipe(
+    decode_to(from_json_string(Tuple(String, String, String)))
+).pipe(decode_to(TokenParsed, transform(decode=_to_fields, encode=_from_fields)))
+"""Tokens as strings, decoded to ``TokenParsed`` (Effect's
+``TokenParsed.FromString``)."""
+
+
+class DurableDeferred[A, E = Never]:
+    """A named wait point of a workflow execution whose result is an ``A``
+    or an ``E`` failure. Make one with ``make``."""
+
+    __slots__ = ("error_schema", "exit_schema", "name", "success_schema")
+
+    def __init__(
+        self,
+        name: str,
+        *,
+        success: Codec[A, Any, Never, Never],
+        error: Codec[E, Any, Never, Never],
+    ) -> None:
+        self.name = name
+        self.success_schema = success
+        self.error_schema = error
+        self.exit_schema: ExitSchema[A, E, Any, Any, Never, Never] = ExitOf(
+            to_codec_json(success), to_codec_json(error), to_codec_json(Defect())
+        )
+
+    def __repr__(self) -> str:
+        return f"DurableDeferred({self.name!r})"
+
+    @property
+    def with_activity_attempt(self) -> Effect[DurableDeferred[A, E]]:
+        """This deferred named for the current activity attempt
+        (``"{name}/{attempt}"``)."""
+        return CurrentAttempt().map(
+            lambda attempt: DurableDeferred(
+                f"{self.name}/{attempt}", success=self.success_schema, error=self.error_schema
+            )
+        )
+
+    def wait(self) -> Effect[A, E, WorkflowEngine | WorkflowInstance]:
+        """The deferred's result, suspending the execution until it has one
+        (Effect's ``DurableDeferred.await``)."""
+        return await_(self)
+
+    def into[R](
+        self, effect: Effect[A, E, R]
+    ) -> Effect[A, E, R | WorkflowEngine | WorkflowInstance]:
+        """Run ``effect`` and record its exit as this deferred's result,
+        waking executions waiting on it.
+
+        ``effect`` and the write count as one in-flight activity of the
+        workflow, so siblings parked on durable waits do not suspend the
+        run until the exit is recorded. If ``effect`` parks on a durable
+        wait itself, the run suspends once the other activities finish and
+        nothing is recorded. Completing a deferred the run waits on still
+        replays the run."""
+        require_effect(effect, "effect")
+        return _record_held(effect, self, check_cache=False)
+
+    def token(self) -> Effect[Token, Never, WorkflowInstance]:
+        """The token of this deferred in the current execution."""
+        return WorkflowInstance().map(
+            lambda instance: (
+                TokenParsed(
+                    workflow_name=instance.workflow.tag,
+                    execution_id=instance.execution_id,
+                    deferred_name=self.name,
+                ).as_token
+            )
+        )
+
+    def token_from_execution_id(
+        self, *, workflow: Workflow[Any, Any, Any], execution_id: str
+    ) -> Token:
+        return TokenParsed(
+            workflow_name=workflow.tag, execution_id=execution_id, deferred_name=self.name
+        ).as_token
+
+    def token_from_payload[P](
+        self, *, workflow: Workflow[P, Any, Any], payload: P
+    ) -> Effect[Token]:
+        return workflow.execution_id(payload).map(
+            lambda execution_id: self.token_from_execution_id(
+                workflow=workflow, execution_id=execution_id
+            )
+        )
+
+    def done(self, *, token: str, exit: Exit[A, E]) -> Effect[None, Never, WorkflowEngine]:
+        """Record ``exit`` as the result of the deferred ``token`` names,
+        waking its execution. A token naming another deferred is a defect
+        (Effect writes ``exit`` into that deferred, with this one's schema)."""
+
+        def body() -> Generator[Effect[Any, Never, Any], Any]:
+            engine = yield from WorkflowEngine()
+            parsed = TokenParsed.from_string(token)
+            if parsed.deferred_name != self.name:
+                raise ValueError(
+                    f"token names the deferred {parsed.deferred_name!r}, not {self.name!r}"
+                )
+            yield from engine.deferred_done(
+                self,
+                workflow_name=parsed.workflow_name,
+                execution_id=parsed.execution_id,
+                deferred_name=parsed.deferred_name,
+                exit=exit,
+            )
+
+        return gen(body)
+
+    def succeed(self, *, token: str, value: A) -> Effect[None, Never, WorkflowEngine]:
+        return self.done(token=token, exit=Success(value))
+
+    def fail(self, *, token: str, error: E) -> Effect[None, Never, WorkflowEngine]:
+        from pyfect.cause import fail as fail_cause_of
+
+        return self.done(token=token, exit=Failure(fail_cause_of(error)))
+
+    def fail_cause(self, *, token: str, cause: Cause[E]) -> Effect[None, Never, WorkflowEngine]:
+        return self.done(token=token, exit=Failure(cause))
+
+
+def make[A = None, E = Never](
+    name: str,
+    *,
+    success: Codec[A, Any, Never, Never] | None = None,
+    error: Codec[E, Any, Never, Never] | None = None,
+) -> DurableDeferred[A, E]:
+    """A deferred named ``name`` (unique within its workflow). ``success``
+    defaults to ``None`` (Effect's ``Void``), ``error`` to none."""
+    return DurableDeferred(
+        name,
+        success=cast("Codec[A, Any, Never, Never]", NullSchema) if success is None else success,
+        error=cast("Codec[E, Any, Never, Never]", NeverSchema) if error is None else error,
+    )
+
+
+# --- waits and the runs that own them ---------------------------------------------------
+
+_await_owners: WeakKeyDictionary[WorkflowInstanceService, list[str]] = WeakKeyDictionary()
+"""The waits registered under the instance copy of a ``_record_held`` body."""
+
+
+def _register_await(instance: WorkflowInstanceService, name: str) -> None:
+    instance.awaited_deferreds[name] = instance.awaited_deferreds.get(name, 0) + 1
+    owned = _await_owners.get(instance)
+    if owned is not None:
+        owned.append(name)
+
+
+def _release_awaits(instance: WorkflowInstanceService, names: list[str]) -> None:
+    for name in names:
+        count = instance.awaited_deferreds[name] - 1
+        if count == 0:
+            del instance.awaited_deferreds[name]
+        else:
+            instance.awaited_deferreds[name] = count
+
+
+def await_[A, E](self: DurableDeferred[A, E]) -> Effect[A, E, WorkflowEngine | WorkflowInstance]:
+    """``self``'s result, suspending the execution until there is one."""
+
+    def body() -> Generator[Effect[Any, Any, Any], Any, A]:
+        engine = yield from WorkflowEngine()
+        instance = yield from WorkflowInstance()
+        # Register before the read, so any later completion can preempt the run.
+        _register_await(instance, self.name)
+        found = yield from wrap_activity_result(engine.deferred_result(self), lambda e: e is None)
+        if found is None:
+            return (yield from suspend_run(instance))
+        return (yield from from_exit(found))
+
+    return gen(body)
+
+
+def _record_exit(
+    engine: WorkflowEngineService,
+    instance: WorkflowInstanceService,
+    self: DurableDeferred[Any, Any],
+    ex: Exit[Any, Any],
+) -> Effect[None]:
+    """Record ``ex`` into ``self``. An exit of interrupts only is no result
+    (the effect suspended, was preempted or interrupted); interrupts mixed
+    into a failure are dropped from the recorded cause."""
+    if isinstance(ex, Failure):
+        if ex.cause.has_interrupts_only:
+            return succeed(None)
+        if ex.cause.has_interrupts:
+            ex = Failure(from_reasons(r for r in ex.cause.reasons if not isinstance(r, Interrupt)))
+    return engine.deferred_done(
+        self,
+        workflow_name=instance.workflow.tag,
+        execution_id=instance.execution_id,
+        deferred_name=self.name,
+        exit=ex,
+    )
+
+
+def _record_held[A, E, R](
+    effect: Effect[A, E, R], self: DurableDeferred[Any, Any], *, check_cache: bool
+) -> Effect[A, E, R | WorkflowEngine | WorkflowInstance]:
+    """Run ``effect`` as one activity of the workflow and record its exit
+    into ``self`` (with ``check_cache``, a recorded exit is returned
+    instead). The hold spans the lookup, ``effect`` and the write, so a
+    parked sibling cannot suspend the run before the continuation starts."""
+
+    def body() -> Generator[Effect[Any, Any, Any], Any, A]:
+        engine = yield from WorkflowEngine()
+        instance = yield from WorkflowInstance()
+
+        def held() -> Generator[Effect[Any, Any, Any], Any, Exit[A, E] | None]:
+            if check_cache:
+                cached = yield from engine.deferred_result(self)
+                if cached is not None:
+                    return cached
+            # ``effect`` counts on its own activity state, so a durable wait
+            # inside it waits for its own siblings, not for this hold. The
+            # copy starts unsuspended: a parked arm of an enclosing race
+            # leaves that copy marked suspended.
+            local = instance.copy()
+            # A losing branch parked on a durable wait has exited when the
+            # race settles, so this body owns the waits registered beneath it.
+            owned: list[str] = []
+            _await_owners[local] = owned
+            # A parked ``effect`` interrupts the fiber it runs on; the child
+            # keeps that from skipping the suspension handling below.
+            fiber = yield from (
+                effect.pipe(provide_service(WorkflowInstance, local))
+                .on_exit(lambda ex: _record_exit(engine, instance, self, ex))
+                .fork(start_immediately=True)
+            )
+
+            def settle(ex: Exit[A, E]) -> Exit[A, E] | None:
+                if local.suspended and isinstance(ex, Failure) and ex.cause.has_interrupts_only:
+                    return None
+                return ex
+
+            def release(result: Exit[Exit[A, E] | None, Never]) -> Effect[None]:
+                def run() -> None:
+                    if isinstance(result, Success) and result.value is not None:
+                        _release_awaits(instance, owned)
+                    else:
+                        parent = _await_owners.get(instance)
+                        if parent is not None:
+                            parent.extend(owned)
+
+                return sync(run)
+
+            return (
+                yield from fiber.await_exit()
+                .on_interrupt(fiber.interrupt())
+                .map(settle)
+                .on_exit(release)
+            )
+
+        # Every branch parked: release the hold and let the enclosing
+        # activities finish before suspending.
+        found = yield from wrap_activity_result(gen(held), lambda e: e is None)
+        if found is None:
+            return (yield from suspend_run(instance))
+        return (yield from from_exit(found))
+
+    return gen(body)
+
+
+def race_all[A, E, R](
+    *,
+    name: str,
+    success: Exactly[A],
+    error: Exactly[E],
+    effects: Sequence[Effect[A, E, R]],
+) -> Effect[A, E, R | WorkflowEngine | WorkflowInstance]:
+    """Race ``effects`` durably: the first to succeed wins (or the last
+    failure), its exit is recorded, and a replay gets the recorded exit
+    without running them again."""
+    if not effects:
+        raise ValueError("race_all needs at least one effect")
+    deferred: DurableDeferred[A, E] = DurableDeferred(
+        f"raceAll/{name}", success=codec_of(success), error=codec_of(error)
+    )
+    return _record_held(race_all_effects(*effects), deferred, check_cache=True)
+
+
+__all__ = [
+    "TOKEN_FROM_STRING",
+    "DurableDeferred",
+    "Token",
+    "TokenParsed",
+    "TokenSchema",
+    "await_",
+    "make",
+    "race_all",
+]

pyfect/workflow/durable_queue.py

@@ -0,0 +1,259 @@
+"""Work a workflow hands to persisted background workers (Effect's
+``effect/workflow/DurableQueue``)::
+
+    Emails = durable_queue.make(
+        name="emails",
+        payload=S.Struct(Email),
+        idempotency_key=lambda email: email["id"],
+    )
+
+    # in a workflow: offer the item and suspend until a worker is done
+    yield from Emails.process({"id": "welcome-ada", "to": "ada@example.com"})
+
+    # in a worker process
+    EmailWorker = Emails.worker(send_email, concurrency=5)
+
+``process`` offers the item to the ``PersistedQueue`` named
+``DurableQueue/<name>`` with a ``DurableDeferred`` token, then suspends;
+a worker takes it, runs the handler and records the handler's ``Exit``
+through the token, which resumes the workflow with the typed success or
+error.
+
+Delivery is at-least-once: a crash between the handler's success and the
+acknowledgement delivers the item again, so handlers must be idempotent.
+An item out of attempts is dead-lettered: its deferred never resolves and
+the workflow stays parked until the item is requeued out of band (the
+id-based de-duplication keeps replays from resurrecting it). Run
+``persisted_queue.layer_cleanup`` in one instance to prune old items.
+
+A worker killed while it holds an item stalls that item until its lock
+expires: 120 seconds by default with ``persisted_queue.layer_store_sql`` and
+90 with ``layer_store_redis``. Set it with ``lock_expiration=`` on the store.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Generator
+from typing import Any, Never, TypedDict, cast
+
+from pyfect._core import Effect
+from pyfect.effect import die, fail, gen, never
+from pyfect.exit import Exit
+from pyfect.layer import Layer, effect_discard
+from pyfect.logger import log_warning
+from pyfect.persistence import persisted_queue
+from pyfect.persistence.persisted_queue import PersistedQueueError, PersistedQueueFactory
+from pyfect.schedule import Schedule, exponential, min, spaced
+from pyfect.schema import Bottom, Codec, SchemaError, Struct
+from pyfect.scope import Scope
+from pyfect.tracer import ExternalSpan, Span, use_span
+from pyfect.workflow._services import WorkflowEngine, WorkflowInstance
+from pyfect.workflow.activity import idempotency_key as activity_idempotency_key
+from pyfect.workflow.durable_deferred import DurableDeferred, Token, TokenParsed, TokenSchema
+from pyfect.workflow.durable_deferred import make as make_deferred
+
+
+class _QueueItem(TypedDict):
+    token: Token
+    traceId: str
+    spanId: str
+    sampled: bool
+    payload: object
+
+
+"""What the queue stores: the item and the token and span to answer to."""
+
+_queue_schemas: dict[int, tuple[object, Bottom[_QueueItem, Any, Never, Never]]] = {}
+
+
+def _queue_schema(payload: Codec[Any, Any, Never, Never]) -> Bottom[_QueueItem, Any, Never, Never]:
+    cached = _queue_schemas.get(id(payload))
+    if cached is not None and cached[0] is payload:
+        return cached[1]
+    schema = Struct(_QueueItem, token=TokenSchema, payload=payload)
+    _queue_schemas[id(payload)] = (payload, schema)
+    return schema
+
+
+DEFAULT_RETRY_SCHEDULE: Schedule[Any, Any, Any, Any] = min(exponential(0.5, 1.5), spaced(60))
+"""How ``process`` retries a failed offer: exponential from 500 ms, at most
+a minute apart."""
+
+
+class DurableQueue[P, A = None, E = Never]:
+    """A queue of ``P`` items whose workers succeed with ``A`` or fail with
+    ``E``. Make one with ``make``."""
+
+    __slots__ = ("deferred", "idempotency_key", "name", "payload_schema")
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        payload_schema: Codec[P, Any, Never, Never],
+        idempotency_key: Callable[[P], str],
+        deferred: DurableDeferred[A, E],
+    ) -> None:
+        self.name = name
+        self.payload_schema = payload_schema
+        self.idempotency_key = idempotency_key
+        self.deferred = deferred
+
+    def __repr__(self) -> str:
+        return f"DurableQueue({self.name!r})"
+
+    def _item_deferred(self, name: str) -> DurableDeferred[A, E]:
+        """The deferred one queued item answers through."""
+        return DurableDeferred(
+            name, success=self.deferred.success_schema, error=self.deferred.error_schema
+        )
+
+    def _item_done(self, token: Token, exit: Exit[A, E]) -> Effect[None, Never, WorkflowEngine]:
+        """Answer the item ``token`` names, through its own deferred (a
+        deferred refuses a token naming another one)."""
+        return self._item_deferred(TokenParsed.from_string(token).deferred_name).done(
+            token=token, exit=exit
+        )
+
+    def process(
+        self, payload: P, *, retry_schedule: Schedule[Any, Any, Any, Any] | None = None
+    ) -> Effect[A, E, WorkflowEngine | WorkflowInstance | PersistedQueueFactory]:
+        """Offer ``payload`` and wait (suspended) for a worker to process
+        it. A failed offer is retried on ``retry_schedule`` (logged), then
+        is a defect."""
+
+        def body() -> Generator[Effect[Any, Any, Any], Any, A]:
+            made = self.payload_schema.__codec__().make(payload)
+            queue_name = f"DurableQueue/{self.name}"
+            queue = yield from persisted_queue.make(
+                name=queue_name, schema=_queue_schema(self.payload_schema)
+            )
+            item_id = yield from activity_idempotency_key(
+                f"{queue_name}/{self.idempotency_key(made)}"
+            )
+            deferred = self._item_deferred(f"{self.deferred.name}/{item_id}")
+            token = yield from deferred.token()
+
+            def offer(span: Span) -> Effect[None]:
+                item: _QueueItem = {
+                    "token": token,
+                    "payload": made,
+                    "traceId": span.trace_id,
+                    "spanId": span.span_id,
+                    "sampled": span.sampled,
+                }
+
+                def schema_defect(
+                    error: PersistedQueueError | SchemaError,
+                ) -> Effect[Never, PersistedQueueError]:
+                    return die(error) if isinstance(error, SchemaError) else fail(error)
+
+                return (
+                    queue.offer(item, id=item_id)
+                    .tap_cause(log_warning)
+                    .catch_all(schema_defect)
+                    .retry(DEFAULT_RETRY_SCHEDULE if retry_schedule is None else retry_schedule)
+                    .or_die()
+                    .as_void()
+                    .annotate_logs(
+                        {
+                            "package": "effect",
+                            "module": "DurableQueue",
+                            "fiber": "process",
+                            "queueName": self.name,
+                        }
+                    )
+                )
+
+            yield from use_span(
+                f"DurableQueue/{self.name}/process", offer, attributes={"id": item_id}
+            )
+            return (yield from deferred.wait())
+
+        return gen(body)
+
+    def make_worker[R = Never](
+        self,
+        f: Callable[[P], Effect[A, E, R]],
+        *,
+        concurrency: int = 1,
+    ) -> Effect[Never, Never, WorkflowEngine | PersistedQueueFactory | R]:
+        """Take items forever, ``concurrency`` at a time, recording each
+        handler's exit for the workflow that offered it. A failure is
+        logged and the worker goes on."""
+
+        def body() -> Generator[Effect[Any, Any, Any], Any, Any]:
+            queue = yield from persisted_queue.make(
+                name=f"DurableQueue/{self.name}", schema=_queue_schema(self.payload_schema)
+            )
+
+            def handle(
+                item: _QueueItem, _meta: persisted_queue.Metadata
+            ) -> Effect[None, Never, Any]:
+                payload = cast("P", item["payload"])
+                return (
+                    f(payload)
+                    .exit()
+                    .flat_map(lambda ex: self._item_done(item["token"], ex))
+                    .with_span(
+                        f"DurableQueue/{self.name}/worker",
+                        capture_stack_trace=False,
+                        parent=ExternalSpan(
+                            trace_id=item["traceId"],
+                            span_id=item["spanId"],
+                            sampled=item["sampled"],
+                        ),
+                    )
+                )
+
+            worker = (
+                queue.take(handle)
+                .catch_cause(log_warning)
+                .forever()
+                .annotate_logs(
+                    {
+                        "package": "effect",
+                        "module": "DurableQueue",
+                        "fiber": "worker",
+                        "queueName": self.name,
+                    }
+                )
+            )
+            yield from worker.replicate_effect(concurrency, concurrency=concurrency, discard=True)
+            return (yield from never)
+
+        return gen(body)
+
+    def worker[R = Never](
+        self, f: Callable[[P], Effect[A, E, R]], *, concurrency: int = 1
+    ) -> Layer[Never, Never, WorkflowEngine | PersistedQueueFactory | R]:
+        """A layer running ``make_worker`` in the background."""
+        started: Effect[object, Never, Any] = self.make_worker(
+            f, concurrency=concurrency
+        ).fork_scoped()
+        return cast(
+            "Layer[Never, Never, WorkflowEngine | PersistedQueueFactory | R]",
+            effect_discard(cast("Effect[object, Never, Scope]", started)),
+        )
+
+
+def make[P, A = None, E = Never](
+    *,
+    name: str,
+    payload: Codec[P, Any, Never, Never],
+    idempotency_key: Callable[[P], str],
+    success: Codec[A, Any, Never, Never] | None = None,
+    error: Codec[E, Any, Never, Never] | None = None,
+) -> DurableQueue[P, A, E]:
+    """A queue named ``name`` of ``payload`` items; ``idempotency_key``
+    names an item within its workflow execution. ``success`` defaults to
+    ``None``, ``error`` to none."""
+    return DurableQueue(
+        name=name,
+        payload_schema=payload,
+        idempotency_key=idempotency_key,
+        deferred=make_deferred(f"DurableQueue/{name}", success=success, error=error),
+    )
+
+
+__all__ = ["DEFAULT_RETRY_SCHEDULE", "DurableQueue", "make"]