GitHub

API reference for rpc.

Remote procedure calls (Effect's effect/rpc).

Re-exports

Values

AttributeTypeDescription
forkWrap

Run the handler's result outside the server's concurrency limit (Effect's Rpc.fork).

uninterruptibleWrap

Run the handler's result uninterruptibly (Effect's Rpc.uninterruptible).

Classes

Functions

exit_schema

exit_schema(rpc) -> S.ExitSchema[Any, Any, Any, Any, Any, Any]

The schema of rpc's exits: its success (None for a stream) or a failure with its error, its stream's error or a middleware's.

ParameterTypeDescription
rpcAnyRpc

Returns S.ExitSchema[Any, Any, Any, Any, Any, Any]

def exit_schema(rpc: AnyRpc) -> S.ExitSchema[Any, Any, Any, Any, Any, Any]:
    """The schema of ``rpc``'s exits: its success (``None`` for a stream)
    or a failure with its error, its stream's error or a middleware's."""
    cached = _exit_schemas.get(id(rpc))
    if cached is not None and cached[0] is rpc:
        return cached[1]  # pyright: ignore[reportReturnType]
    failures: list[Top] = [rpc.error_schema]
    streams = get_stream_schemas(rpc.success_schema)
    if streams is not None and streams.error not in failures:
        failures.append(streams.error)
    for middleware in rpc.middlewares:
        for error in middleware.errors():
            if error not in failures:
                failures.append(error)
    schema = S.Exit(
        S.Null if streams is not None else rpc.success_schema,
        S.Union(*failures),
        rpc.defect_schema,
    )
    _exit_schemas[id(rpc)] = (rpc, schema)
    return schema

make

make[T: LiteralString, P = None, A = None, E1 = Never](tag: T, *, payload: _C[P] | None = None, success: _C[A] | None = None, error: _C[E1] | None = None, defect: Codec[object, Any, Never, Never] | None = None, stream: Literal[True]) -> StreamRpc[P, A, E1, Never, Never, T]
make[T: LiteralString, P = None, A = None, EE = Never](tag: T, *, payload: _C[P] | None = None, success: StreamSchema[A, EE], error: _C[EE] | None = None, defect: Codec[object, Any, Never, Never] | None = None, stream: Literal[False] = False) -> StreamRpc[P, A, EE, Never, Never, T]
make[T: LiteralString, P = None, S1 = None, E1 = Never](tag: T, *, payload: _C[P] | None = None, success: _C[S1] | None = None, error: _C[E1] | None = None, defect: Codec[object, Any, Never, Never] | None = None, stream: Literal[False] = False) -> Rpc[P, S1, E1, Never, Never, T]
make[P = None, A = None, E1 = Never](tag: str, *, payload: _C[P] | None = None, success: _C[A] | None = None, error: _C[E1] | None = None, defect: Codec[object, Any, Never, Never] | None = None, stream: Literal[True]) -> StreamRpc[P, A, E1]
make[P = None, A = None, EE = Never](tag: str, *, payload: _C[P] | None = None, success: StreamSchema[A, EE], error: _C[EE] | None = None, defect: Codec[object, Any, Never, Never] | None = None, stream: Literal[False] = False) -> StreamRpc[P, A, EE]
make[P = None, S1 = None, E1 = Never](tag: str, *, payload: _C[P] | None = None, success: _C[S1] | None = None, error: _C[E1] | None = None, defect: Codec[object, Any, Never, Never] | None = None, stream: Literal[False] = False) -> Rpc[P, S1, E1]

An RPC named tag (Effect's Rpc.make). Its payload defaults to None, its success to None and its error to none. With stream=True it succeeds with a stream of success items failing with error. defect is the schema of its defects (S.Defect() by default).

ParameterTypeDescription
tag
payload= None
success= None
error= None
defect= None
stream= False
@overload
def make[T: LiteralString, P = None, A = None, E1 = Never](
    tag: T,
    *,
    payload: _C[P] | None = None,
    success: _C[A] | None = None,
    error: _C[E1] | None = None,
    defect: Codec[object, Any, Never, Never] | None = None,
    stream: Literal[True],
) -> StreamRpc[P, A, E1, Never, Never, T]: ...
@overload
def make[T: LiteralString, P = None, A = None, EE = Never](  # pyright: ignore[reportOverlappingOverload]
    tag: T,
    *,
    payload: _C[P] | None = None,
    success: StreamSchema[A, EE],
    error: _C[EE] | None = None,
    defect: Codec[object, Any, Never, Never] | None = None,
    stream: Literal[False] = False,
) -> StreamRpc[P, A, EE, Never, Never, T]: ...
@overload
def make[T: LiteralString, P = None, S1 = None, E1 = Never](
    tag: T,
    *,
    payload: _C[P] | None = None,
    success: _C[S1] | None = None,
    error: _C[E1] | None = None,
    defect: Codec[object, Any, Never, Never] | None = None,
    stream: Literal[False] = False,
) -> Rpc[P, S1, E1, Never, Never, T]: ...
@overload
def make[P = None, A = None, E1 = Never](
    tag: str,
    *,
    payload: _C[P] | None = None,
    success: _C[A] | None = None,
    error: _C[E1] | None = None,
    defect: Codec[object, Any, Never, Never] | None = None,
    stream: Literal[True],
) -> StreamRpc[P, A, E1]: ...
@overload
def make[P = None, A = None, EE = Never](
    tag: str,
    *,
    payload: _C[P] | None = None,
    success: StreamSchema[A, EE],
    error: _C[EE] | None = None,
    defect: Codec[object, Any, Never, Never] | None = None,
    stream: Literal[False] = False,
) -> StreamRpc[P, A, EE]: ...
@overload
def make[P = None, S1 = None, E1 = Never](
    tag: str,
    *,
    payload: _C[P] | None = None,
    success: _C[S1] | None = None,
    error: _C[E1] | None = None,
    defect: Codec[object, Any, Never, Never] | None = None,
    stream: Literal[False] = False,
) -> Rpc[P, S1, E1]: ...
def make(
    tag: str,
    *,
    payload: Top | None = None,
    success: Top | None = None,
    error: Top | None = None,
    defect: Codec[object, Any, Never, Never] | None = None,
    stream: bool = False,
) -> Any:
    """An RPC named ``tag`` (Effect's ``Rpc.make``). Its payload defaults to
    ``None``, its success to ``None`` and its error to none. With
    ``stream=True`` it succeeds with a stream of ``success`` items failing
    with ``error``. ``defect`` is the schema of its defects
    (``S.Defect()`` by default)."""
    success_schema: Top = S.Null if success is None else success.__codec__()
    error_schema: Top = S.Never if error is None else error.__codec__()
    if stream:
        streamed: Top = StreamOf(success_schema, error_schema)
        success_schema, error_schema = streamed, S.Never
    is_stream = isinstance(success_schema, StreamSchema)
    cls = cast("type[AnyRpc]", StreamRpc if is_stream else Rpc)
    return cls(
        tag,
        S.Null if payload is None else payload.__codec__(),
        success_schema,
        error_schema,
        S.Defect() if defect is None else defect.__codec__(),
    )

wrap

wrap(*, fork=None, uninterruptible=None) -> Wrap

Effect's Rpc.wrap.

ParameterTypeDescription
forkbool | None = None
uninterruptiblebool | None = None

Returns Wrap

def wrap(*, fork: bool | None = None, uninterruptible: bool | None = None) -> Wrap:
    """Effect's ``Rpc.wrap``."""
    return Wrap(fork, uninterruptible)

Modules