GitHub

ResponseError

API reference for ResponseError.

The server answered with GraphQL errors (a query or mutation fails on any, even with partial data, which is kept raw here). status and headers are what the transport reported. retry_after reads the Retry-After header when the error is made; is_retryable holds for status 429 or 5xx, or any valid Retry-After.

Attributes

AttributeTypeDescription
errorstuple[GraphQLError, ...] = S.field(S.NonEmptyArray(GRAPHQL_ERROR))
dataS.JsonValue = S.field(S.Union(S.Json, Undefined), default=None)
extensionsMapping[str, S.JsonValue] | None = S.field(S.Union(_JSON_OBJECT, Undefined), default=None)
statusint | None = S.field(S.Union(S.Int, Undefined), default=None)
headersHeaders | None = S.field(S.Union(HEADERS, Undefined), default=None)
retry_afterDuration | None
is_retryablebool
messagestr

Functions

fields

fields() -> Mapping[str, Bottom[object, object, Never, Never]]

Each field's schema, the tag's first in a tagged class.

Returns Mapping[str, Bottom[object, object, Never, Never]]

@classmethod
def fields(cls) -> Mapping[str, Bottom[object, object, Never, Never]]:
    """Each field's schema, the tag's first in a tagged class."""
    shape = _shape_of(cls)
    schemas = shape.schemas
    if shape.tag is None:
        return dict(schemas)
    tag: Bottom[object, object, Never, Never] = Bottom(ast.Literal(shape.tag))
    return {"_tag": tag, **schemas}

make

make(input, **options) -> Self

input checked against the class's schema (its checks included); raises SchemaError. Construct with cls(...); an instance is kept as it is.

ParameterTypeDescription
inputSelf
optionsUnpack[ParseOptions] = {}

Returns Self

@classmethod
def make(cls, input: Self, /, **options: Unpack[ParseOptions]) -> Self:
    """``input`` checked against the class's schema (its checks
    included); raises ``SchemaError``. Construct with ``cls(...)``; an
    instance is kept as it is."""
    shape = _shape_of(cls)
    return make_class_sync(
        cls.ast.to_type(),
        input,
        options,
        lambda fields: cast("Self", shape.construct(dict(fields))),
    )

make_option

make_option(input, **options) -> Option[Self]
ParameterTypeDescription
inputSelf
optionsUnpack[ParseOptions] = {}

Returns Option[Self]

@classmethod
def make_option(cls, input: Self, /, **options: Unpack[ParseOptions]) -> Option[Self]:
    return cls.__codec__().make_option(input, **options)

make_effect

make_effect(input, **options) -> Effect[Self, Issue]
ParameterTypeDescription
inputSelf
optionsUnpack[ParseOptions] = {}

Returns Effect[Self, Issue]

@classmethod
def make_effect(cls, input: Self, /, **options: Unpack[ParseOptions]) -> Effect[Self, Issue]:
    return cls.__codec__().make_effect(input, **options)

annotate

annotate(**annotations) -> Bottom[Self, Mapping[str, object]]

The class's schema with annotations (a new schema, not a class).

ParameterTypeDescription
annotationsobject = {}

Returns Bottom[Self, Mapping[str, object]]

@classmethod
def annotate(cls, /, **annotations: object) -> Bottom[Self, Mapping[str, object]]:
    """The class's schema with annotations (a new schema, not a class)."""
    return cls.__codec__().annotate(**annotations)

check

check(first, *rest) -> Bottom[Self, Mapping[str, object]]

The class's schema with checks (a new schema, not a class).

ParameterTypeDescription
firstCheck[Self]
restCheck[Self] = ()

Returns Bottom[Self, Mapping[str, object]]

@classmethod
def check(cls, first: Check[Self], /, *rest: Check[Self]) -> Bottom[Self, Mapping[str, object]]:
    """The class's schema with checks (a new schema, not a class)."""
    return cls.__codec__().check(first, *rest)

pipe

pipe[B](f) -> B
ParameterTypeDescription
fCallable[[type[Self]], B]

Returns B

@classmethod
def pipe[B](cls, f: Callable[[type[Self]], B], /) -> B:
    return f(cls)