Remote procedure calls (Effect's effect/rpc).
Re-exports#
- From
pyfect.rpc.client_error:RpcClientDefect,RpcClientError - From
pyfect.rpc.group:access_handler,HandlerOf,Handlers,HandlersFor,RpcGroup,RpcGroupWith,to_layer_handler - From
pyfect.rpc.middleware:RpcMiddleware
Values#
| Attribute | Type | Description |
|---|---|---|
fork | Wrap | Run the handler's result outside the server's concurrency limit
(Effect's |
uninterruptible | Wrap | Run the handler's result uninterruptibly (Effect's |
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.
| Parameter | Type | Description |
|---|---|---|
rpc | AnyRpc |
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 schemamake#
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).
| Parameter | Type | Description |
|---|---|---|
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) -> WrapEffect's Rpc.wrap.
| Parameter | Type | Description |
|---|---|---|
fork | bool | None = None | |
uninterruptible | bool | None = None |
Returns Wrap
def wrap(*, fork: bool | None = None, uninterruptible: bool | None = None) -> Wrap:
"""Effect's ``Rpc.wrap``."""
return Wrap(fork, uninterruptible)