GitHub

incoming_message

API reference for incoming_message.

What incoming messages (responses here) share, and the schema decoders of their bodies and headers (Effect's HttpIncomingMessage).

Types

TypeDefinitionDescription
Revivertype Reviver = JsonReviver

JSON.parse's reviver (getter.JsonReviver).

Classes

Functions

schema_body_json

schema_body_json[T, RD](schema, *, reviver=None, **options) -> MessageDecoder[T, RD]

A decoder of a message's JSON body by schema. With a reviver the text is parsed with it; an empty body is None either way.

ParameterTypeDescription
schemaCodec[T, object, RD, object]
reviverReviver | None = None
optionsUnpack[ParseOptions] = {}

Returns MessageDecoder[T, RD]

def schema_body_json[T, RD](
    schema: Codec[T, object, RD, object],
    *,
    reviver: Reviver | None = None,
    **options: Unpack[ParseOptions],
) -> MessageDecoder[T, RD]:
    """A decoder of a message's JSON body by ``schema``. With a ``reviver``
    the text is parsed with it; an empty body is ``None`` either way."""
    decode = decode_unknown_effect(to_codec_json(schema), **options)

    def run[E](message: HttpIncomingMessage[E]) -> Effect[T, E | SchemaError, RD]:
        if reviver is None:
            return message.json.flat_map(decode)
        revive_with = reviver

        def from_text(body: str) -> Effect[T, E | SchemaError, RD]:
            if body == "":
                return message.json.flat_map(decode)
            return _parse_json(body).flat_map(lambda parsed: decode(revive(parsed, revive_with)))

        return message.text.flat_map(from_text)

    return run

schema_body_url_params

schema_body_url_params[T, RD](schema, **options) -> MessageDecoder[T, RD]

A decoder of a form-encoded body: schema gets each name mapped to its value, or to its values when repeated.

ParameterTypeDescription
schemaCodec[T, object, RD, object]
optionsUnpack[ParseOptions] = {}

Returns MessageDecoder[T, RD]

def schema_body_url_params[T, RD](
    schema: Codec[T, object, RD, object], **options: Unpack[ParseOptions]
) -> MessageDecoder[T, RD]:
    """A decoder of a form-encoded body: ``schema`` gets each name mapped
    to its value, or to its values when repeated."""
    decode = decode_unknown_effect(schema, **options)

    def run[E](message: HttpIncomingMessage[E]) -> Effect[T, E | SchemaError, RD]:
        return message.url_params_body.flat_map(lambda params: decode(params.to_record()))

    return run

schema_headers

schema_headers[T, RD](schema, **options) -> Callable[[HttpIncomingMessage[object]], Effect[T, SchemaError, RD]]

A decoder of a message's headers (lowercased names) by schema.

ParameterTypeDescription
schemaCodec[T, object, RD, object]
optionsUnpack[ParseOptions] = {}

Returns Callable[[HttpIncomingMessage[object]], Effect[T, SchemaError, RD]]

def schema_headers[T, RD](
    schema: Codec[T, object, RD, object], **options: Unpack[ParseOptions]
) -> Callable[[HttpIncomingMessage[object]], Effect[T, SchemaError, RD]]:
    """A decoder of a message's headers (lowercased names) by ``schema``."""
    decode = decode_unknown_effect(schema, **options)
    return lambda message: decode(dict(message.headers))

revive

revive(value, reviver) -> object

value walked as JSON.parse walks it with reviver.

ParameterTypeDescription
valueobject
reviverJsonReviver

Returns object

def revive(value: object, reviver: JsonReviver) -> object:
    """``value`` walked as ``JSON.parse`` walks it with ``reviver``."""
    return _revive(reviver, "", value)