river-python/tests/v1/codegen/snapshot/snapshots/test_unknown_enum/enumService/needsEnumObject.py at 8c0a0f3eb87da35647169d2649e2ff37ff735512 · replit/river-python · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
# Code generated by river.codegen. DO NOT EDIT.
from collections.abc import AsyncIterable, AsyncIterator
import datetime
from typing import (
    Any,
    Literal,
    Mapping,
    NotRequired,
    TypedDict,
    cast,
)
from typing_extensions import Annotated

from pydantic import BaseModel, Field, TypeAdapter, WrapValidator
from replit_river.error_schema import RiverError
from replit_river.client import (
    RiverUnknownError,
    translate_unknown_error,
    RiverUnknownValue,
    translate_unknown_value,
)

import replit_river as river


def encode_NeedsenumobjectInputOneOf_in_first(
    x: "NeedsenumobjectInputOneOf_in_first",
) -> Any:
    return {
        k: v
        for (k, v) in (
            {
                "$kind": x.get("kind"),
                "value": x.get("value"),
            }
        ).items()
        if v is not None
    }


class NeedsenumobjectInputOneOf_in_first(TypedDict):
    kind: Annotated[Literal["in_first"], Field(alias="$kind")]
    value: str


def encode_NeedsenumobjectInputOneOf_in_second(
    x: "NeedsenumobjectInputOneOf_in_second",
) -> Any:
    return {
        k: v
        for (k, v) in (
            {
                "$kind": x.get("kind"),
                "bleep": x.get("bleep"),
            }
        ).items()
        if v is not None
    }


class NeedsenumobjectInputOneOf_in_second(TypedDict):
    kind: Annotated[Literal["in_second"], Field(alias="$kind")]
    bleep: int


NeedsenumobjectInput = (
    NeedsenumobjectInputOneOf_in_first | NeedsenumobjectInputOneOf_in_second
)


def encode_NeedsenumobjectInput(
    x: "NeedsenumobjectInput",
) -> Any:
    return (
        encode_NeedsenumobjectInputOneOf_in_first(
            cast("NeedsenumobjectInputOneOf_in_first", x)
        )
        if x["kind"] == "in_first"
        else encode_NeedsenumobjectInputOneOf_in_second(
            cast("NeedsenumobjectInputOneOf_in_second", x)
        )
    )


class NeedsenumobjectOutputFooOneOf_out_first(BaseModel):
    kind: Annotated[Literal["out_first"], Field(alias="$kind")] = "out_first"
    foo: int


class NeedsenumobjectOutputFooOneOf_out_second(BaseModel):
    kind: Annotated[Literal["out_second"], Field(alias="$kind")] = "out_second"
    bar: int


NeedsenumobjectOutputFoo = Annotated[
    NeedsenumobjectOutputFooOneOf_out_first
    | NeedsenumobjectOutputFooOneOf_out_second
    | RiverUnknownValue,
    WrapValidator(translate_unknown_value),
]


class NeedsenumobjectOutput(BaseModel):
    foo: NeedsenumobjectOutputFoo | None = Field(default=None)


NeedsenumobjectOutputTypeAdapter: TypeAdapter[NeedsenumobjectOutput] = TypeAdapter(
    NeedsenumobjectOutput
)


class NeedsenumobjectErrorsFooAnyOf_0(BaseModel):
    beep: Literal["err_first"] | None = Field(default=None)


class NeedsenumobjectErrorsFooAnyOf_1(BaseModel):
    borp: Literal["err_second"] | None = Field(default=None)


NeedsenumobjectErrorsFoo = Annotated[
    NeedsenumobjectErrorsFooAnyOf_0
    | NeedsenumobjectErrorsFooAnyOf_1
    | RiverUnknownValue,
    WrapValidator(translate_unknown_value),
]


class NeedsenumobjectErrors(RiverError):
    foo: NeedsenumobjectErrorsFoo | None = Field(default=None)


NeedsenumobjectErrorsTypeAdapter: TypeAdapter[NeedsenumobjectErrors] = TypeAdapter(
    NeedsenumobjectErrors
)