Regenerating tests

Author: blast-hardcheese

tests/codegen/rpc/generated/test_service/rpc_method.py

@@ -4,15 +4,9 @@
 import datetime
 from typing import (
     Any,
-    Callable,
-    Dict,
-    List,
     Literal,
-    Optional,
     Mapping,
     NotRequired,
-    Union,
-    Tuple,
     TypedDict,
 )
 from typing_extensions import Annotated
@@ -24,15 +18,18 @@
 import replit_river as river
 
 
-encode_Rpc_MethodInput: Callable[["Rpc_MethodInput"], Any] = lambda x: {
-    k: v
-    for (k, v) in (
-        {
-            "data": x.get("data"),
-        }
-    ).items()
-    if v is not None
-}
+def encode_Rpc_MethodInput(
+    x: "Rpc_MethodInput",
+) -> Any:
+    return {
+        k: v
+        for (k, v) in (
+            {
+                "data": x.get("data"),
+            }
+        ).items()
+        if v is not None
+    }
 
 
 class Rpc_MethodInput(TypedDict):

tests/codegen/snapshot/snapshots/test_unknown_enum/enumService/needsEnum.py

@@ -4,15 +4,9 @@
 import datetime
 from typing import (
     Any,
-    Callable,
-    Dict,
-    List,
     Literal,
-    Optional,
     Mapping,
     NotRequired,
-    Union,
-    Tuple,
     TypedDict,
 )
 from typing_extensions import Annotated
@@ -25,7 +19,11 @@
 
 
 NeedsenumInput = Literal["in_first"] | Literal["in_second"]
-encode_NeedsenumInput: Callable[["NeedsenumInput"], Any] = lambda x: x
+
+
+def encode_NeedsenumInput(x: "NeedsenumInput") -> Any:
+    return x
+
 
 NeedsenumInputTypeAdapter: TypeAdapter[Any] = TypeAdapter(NeedsenumInput)
 

tests/codegen/snapshot/snapshots/test_unknown_enum/enumService/needsEnumObject.py

@@ -4,15 +4,9 @@
 import datetime
 from typing import (
     Any,
-    Callable,
-    Dict,
-    List,
     Literal,
-    Optional,
     Mapping,
     NotRequired,
-    Union,
-    Tuple,
     TypedDict,
 )
 from typing_extensions import Annotated
@@ -24,37 +18,39 @@
 import replit_river as river
 
 
-encode_NeedsenumobjectInputOneOf_in_first: Callable[
-    ["NeedsenumobjectInputOneOf_in_first"], Any
-] = lambda x: {
-    k: v
-    for (k, v) in (
-        {
-            "$kind": x.get("kind"),
-            "value": x.get("value"),
-        }
-    ).items()
-    if v is not None
-}
+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: Literal["in_first"]
     value: str
 
 
-encode_NeedsenumobjectInputOneOf_in_second: Callable[
-    ["NeedsenumobjectInputOneOf_in_second"], Any
-] = lambda x: {
-    k: v
-    for (k, v) in (
-        {
-            "$kind": x.get("kind"),
-            "bleep": x.get("bleep"),
-        }
-    ).items()
-    if v is not None
-}
+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):
@@ -66,11 +62,16 @@ class NeedsenumobjectInputOneOf_in_second(TypedDict):
     NeedsenumobjectInputOneOf_in_first | NeedsenumobjectInputOneOf_in_second
 )
 
-encode_NeedsenumobjectInput: Callable[["NeedsenumobjectInput"], Any] = (
-    lambda x: encode_NeedsenumobjectInputOneOf_in_first(x)
-    if x["kind"] == "in_first"
-    else encode_NeedsenumobjectInputOneOf_in_second(x)
-)
+
+def encode_NeedsenumobjectInput(
+    x: "NeedsenumobjectInput",
+) -> Any:
+    return (
+        encode_NeedsenumobjectInputOneOf_in_first(x)
+        if x["kind"] == "in_first"
+        else encode_NeedsenumobjectInputOneOf_in_second(x)
+    )
+
 
 NeedsenumobjectInputTypeAdapter: TypeAdapter[Any] = TypeAdapter(NeedsenumobjectInput)
 
@@ -102,18 +103,18 @@ class NeedsenumobjectOutputFooOneOf_out_second(BaseModel):
 
 
 class NeedsenumobjectOutput(BaseModel):
-    foo: Optional[NeedsenumobjectOutputFoo] = None
+    foo: NeedsenumobjectOutputFoo | None = None
 
 
 NeedsenumobjectOutputTypeAdapter: TypeAdapter[Any] = TypeAdapter(NeedsenumobjectOutput)
 
 
 class NeedsenumobjectErrorsFooAnyOf_0(RiverError):
-    beep: Optional[Literal["err_first"]] = None
+    beep: Literal["err_first"] | None = None
 
 
 class NeedsenumobjectErrorsFooAnyOf_1(RiverError):
-    borp: Optional[Literal["err_second"]] = None
+    borp: Literal["err_second"] | None = None
 
 
 NeedsenumobjectErrorsFoo = Annotated[
@@ -125,7 +126,7 @@ class NeedsenumobjectErrorsFooAnyOf_1(RiverError):
 
 
 class NeedsenumobjectErrors(RiverError):
-    foo: Optional[NeedsenumobjectErrorsFoo] = None
+    foo: NeedsenumobjectErrorsFoo | None = None
 
 
 NeedsenumobjectErrorsTypeAdapter: TypeAdapter[Any] = TypeAdapter(NeedsenumobjectErrors)

tests/codegen/stream/generated/test_service/stream_method.py

@@ -4,15 +4,9 @@
 import datetime
 from typing import (
     Any,
-    Callable,
-    Dict,
-    List,
     Literal,
-    Optional,
     Mapping,
     NotRequired,
-    Union,
-    Tuple,
     TypedDict,
 )
 from typing_extensions import Annotated
@@ -24,15 +18,18 @@
 import replit_river as river
 
 
-encode_Stream_MethodInput: Callable[["Stream_MethodInput"], Any] = lambda x: {
-    k: v
-    for (k, v) in (
-        {
-            "data": x.get("data"),
-        }
-    ).items()
-    if v is not None
-}
+def encode_Stream_MethodInput(
+    x: "Stream_MethodInput",
+) -> Any:
+    return {
+        k: v
+        for (k, v) in (
+            {
+                "data": x.get("data"),
+            }
+        ).items()
+        if v is not None
+    }
 
 
 class Stream_MethodInput(TypedDict):