replit-river 0.17.12__py3-none-any.whl → 0.17.14__py3-none-any.whl

replit_river/codegen/client.py

@@ -101,6 +101,8 @@ class RiverConcreteType(BaseModel):
     items: "RiverType | None" = Field(default=None)
     const: str | int | None = Field(default=None)
     patternProperties: dict[str, "RiverType"] = Field(default_factory=lambda: dict())
+    id_: str | None = Field(default=None, alias="$id")
+    ref: str | None = Field(default=None, alias="$ref")
 
 
 class RiverUnionType(BaseModel):
@@ -158,7 +160,12 @@ def encode_type(
     base_model: str,
     in_module: list[ModuleName],
     permit_unknown_members: bool,
+    type_registry: dict[str, TypeName] | None = None,
 ) -> tuple[TypeExpression, list[ModuleName], list[FileContents], set[TypeName]]:
+    # Registry to track $id -> TypeName mappings for resolving $ref
+    if type_registry is None:
+        type_registry = {}
+
     def _make_open_union_type_expr(one_of: list[TypeExpression]) -> OpenUnionTypeExpr:
         if base_model == "RiverError":
             return OpenUnionTypeExpr(
@@ -175,6 +182,17 @@ def encode_type(
 
     encoder_name: TypeName | None = None  # defining this up here to placate mypy
     chunks: list[FileContents] = []
+
+    # Handle $ref - return a forward reference to the registered type
+    if isinstance(type, RiverConcreteType) and type.ref is not None:
+        ref_id = type.ref
+        if ref_id in type_registry:
+            # Use forward reference string for the type
+            return (TypeName(f'"{type_registry[ref_id].value}"'), [], [], set())
+        else:
+            # Unknown ref, fall back to Any
+            return (TypeName("Any"), [], [], set())
+
     if isinstance(type, RiverNotType):
         return (NoneTypeExpr(), [], [], set())
     elif isinstance(type, RiverUnionType):
@@ -269,6 +287,7 @@ def encode_type(
                                 base_model,
                                 in_module,
                                 permit_unknown_members=permit_unknown_members,
+                                type_registry=type_registry,
                             )
                             one_of.append(type_name)
                             chunks.extend(contents)
@@ -304,6 +323,7 @@ def encode_type(
                             base_model,
                             in_module,
                             permit_unknown_members=permit_unknown_members,
+                            type_registry=type_registry,
                         )
                         one_of.append(type_name)
                         chunks.extend(contents)
@@ -369,7 +389,8 @@ def encode_type(
         type = original_type
         any_of: list[TypeExpression] = []
 
-        typeddict_encoder = []
+        # Collect (type_check, encoder_expr) pairs for building ternary chain
+        encoder_parts: list[tuple[str | None, str]] = []
         for i, t in enumerate(type.anyOf):
             type_name, _, contents, _ = encode_type(
                 t,
@@ -377,39 +398,69 @@ def encode_type(
                 base_model,
                 in_module,
                 permit_unknown_members=permit_unknown_members,
+                type_registry=type_registry,
             )
             any_of.append(type_name)
             chunks.extend(contents)
             if isinstance(t, RiverConcreteType):
                 if t.type == "string":
-                    typeddict_encoder.extend(["x", " if isinstance(x, str) else "])
-                else:
-                    # TODO(dstewart): This structure changed since we were incorrectly
-                    #                 leaking ListTypeExprs into codegen. This generated
-                    #                 code is probably wrong.
+                    encoder_parts.append(("isinstance(x, str)", "x"))
+                elif t.type == "array":
                     match type_name:
                         case ListTypeExpr(inner_type_name):
-                            typeddict_encoder.append(
-                                f"encode_{render_literal_type(inner_type_name)}(x)"
+                            # Primitives don't need encoding
+                            inner_type_str = render_literal_type(inner_type_name)
+                            if inner_type_str in ("str", "int", "float", "bool", "Any"):
+                                encoder_parts.append(("isinstance(x, list)", "list(x)"))
+                            else:
+                                encoder_parts.append(
+                                    (
+                                        "isinstance(x, list)",
+                                        f"[encode_{inner_type_str}(y) for y in x]",
+                                    )
+                                )
+                        case _:
+                            encoder_parts.append(("isinstance(x, list)", "list(x)"))
+                elif t.type == "object":
+                    match type_name:
+                        case TypeName(value):
+                            encoder_parts.append(
+                                ("isinstance(x, dict)", f"encode_{value}(x)")
                             )
+                        case _:
+                            encoder_parts.append(("isinstance(x, dict)", "dict(x)"))
+                elif t.type in ("number", "integer"):
+                    match type_name:
                         case LiteralTypeExpr(const):
-                            typeddict_encoder.append(repr(const))
+                            encoder_parts.append((f"x == {repr(const)}", repr(const)))
+                        case _:
+                            encoder_parts.append(("isinstance(x, (int, float))", "x"))
+                elif t.type == "boolean":
+                    encoder_parts.append(("isinstance(x, bool)", "x"))
+                elif t.type == "null" or t.type == "undefined":
+                    encoder_parts.append(("x is None", "None"))
+                else:
+                    # Fallback for other types
+                    match type_name:
                         case TypeName(value):
-                            typeddict_encoder.append(f"encode_{value}(x)")
+                            encoder_parts.append((None, f"encode_{value}(x)"))
+                        case LiteralTypeExpr(const):
+                            encoder_parts.append((None, repr(const)))
                         case NoneTypeExpr():
-                            typeddict_encoder.append("None")
-                        case other:
-                            _o2: (
-                                DictTypeExpr
-                                | OpenUnionTypeExpr
-                                | UnionTypeExpr
-                                | LiteralType
-                            ) = other
-                            raise ValueError(
-                                f"What does it mean to have {
-                                    render_type_expr(_o2)
-                                } here?"
-                            )
+                            encoder_parts.append((None, "None"))
+                        case _:
+                            encoder_parts.append((None, "x"))
+
+        # Build the ternary chain from encoder_parts
+        typeddict_encoder = list[str]()
+        for i, (type_check, encoder_expr) in enumerate(encoder_parts):
+            is_last = i == len(encoder_parts) - 1
+            if is_last or type_check is None:
+                # Last item or no type check - just the expression
+                typeddict_encoder.append(encoder_expr)
+            else:
+                # Add expression with type check
+                typeddict_encoder.append(f"{encoder_expr} if {type_check} else")
         if permit_unknown_members:
             union = _make_open_union_type_expr(any_of)
         else:
@@ -462,6 +513,7 @@ def encode_type(
             base_model,
             in_module,
             permit_unknown_members=permit_unknown_members,
+            type_registry=type_registry,
         )
     elif isinstance(type, RiverConcreteType):
         typeddict_encoder = list[str]()
@@ -509,6 +561,7 @@ def encode_type(
                 base_model,
                 in_module,
                 permit_unknown_members=permit_unknown_members,
+                type_registry=type_registry,
             )
             typeddict_encoder.append("TODO: dstewart")
             return (ListTypeExpr(type_name), module_info, type_chunks, encoder_names)
@@ -523,10 +576,15 @@ def encode_type(
                 base_model,
                 in_module,
                 permit_unknown_members=permit_unknown_members,
+                type_registry=type_registry,
             )
             return (DictTypeExpr(type_name), module_info, type_chunks, encoder_names)
         assert type.type == "object", type.type
 
+        # Register $id for this type so $ref can resolve to it
+        if type.id_ is not None:
+            type_registry[type.id_] = prefix
+
         current_chunks: list[str] = [
             f"class {render_literal_type(prefix)}({base_model}):"
         ]
@@ -551,6 +609,7 @@ def encode_type(
                     "BaseModel" if base_model == "RiverError" else base_model,
                     in_module,
                     permit_unknown_members=permit_unknown_members,
+                    type_registry=type_registry,
                 )
                 encoder_name = None
                 chunks.extend(contents)

{replit_river-0.17.12.dist-info → replit_river-0.17.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: replit-river
-Version: 0.17.12
+Version: 0.17.14
 Summary: Replit river toolkit for Python
 Author-email: Replit <eng@replit.com>
 License: MIT License

{replit_river-0.17.12.dist-info → replit_river-0.17.14.dist-info}/RECORD

@@ -19,7 +19,7 @@ replit_river/transport_options.py,sha256=Kx3n6_x6sA69WV52EUvm-GzJhDaaewUQzbtcdPl
 replit_river/websocket_wrapper.py,sha256=xrk421A5eXTH2bjAcNeBZN96zTO6xQsl0VS9qcwus6M,814
 replit_river/codegen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 replit_river/codegen/__main__.py,sha256=LyKe1OXIyev0BuUcu43iu6zBLJzeogQ8DocxDkALD-Q,153
-replit_river/codegen/client.py,sha256=EU3cuwDegkLI9V6SG0IWPPdLQvBl6dUyrSuu0JDYGpQ,59963
+replit_river/codegen/client.py,sha256=w8CrFss2-0k0ukCtP6LlPftzSrm7wNgDmuCXTzsr9EQ,62870
 replit_river/codegen/format.py,sha256=pLa9nWlw8hTOnjzZjMsMpgcmNYiLaF5VAHNQTwwJ7Zw,285
 replit_river/codegen/run.py,sha256=InJaUDJft80pY7v2l-LoXHr8HYg3Bmb_6XQvlqgvxv4,3170
 replit_river/codegen/schema.py,sha256=y3kzrEPgzW9gKMjqiF2souZk47mE_kuFkHlsxRdD560,5344
@@ -29,7 +29,7 @@ replit_river/v2/__init__.py,sha256=Fi4wP87qHOQwaWQmVbPJOOiGfkiZ6gTWg5bF5J8je5s,1
 replit_river/v2/client.py,sha256=PQ1qz15lFTdMOs0kktBdzMUEYD66OnJJN0loYFVjdn4,7241
 replit_river/v2/client_transport.py,sha256=swtsFoWIX8nnG5cBeHMkZSZsJ5SW-VbdNHBdLtldMgU,3445
 replit_river/v2/session.py,sha256=8EMKw8bevoIrMfQBKMl3oXFlOJ91lzjmuqsm3qZN8Ts,54147
-replit_river-0.17.12.dist-info/METADATA,sha256=K3yvG8yAj4od7kQL3DxmFP3cOUoUWnx7kKHXB2XuZsM,4794
-replit_river-0.17.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-replit_river-0.17.12.dist-info/licenses/LICENSE,sha256=kyZ5E3kOH4dzPet_xD0w6xi04e-0fGT0HRMhKyLyLC0,1063
-replit_river-0.17.12.dist-info/RECORD,,
+replit_river-0.17.14.dist-info/METADATA,sha256=YWXZDV75qxfsJOebUMG6j4gOwrhFUjYzO_ADA2JMIV8,4794
+replit_river-0.17.14.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+replit_river-0.17.14.dist-info/licenses/LICENSE,sha256=kyZ5E3kOH4dzPet_xD0w6xi04e-0fGT0HRMhKyLyLC0,1063
+replit_river-0.17.14.dist-info/RECORD,,

{replit_river-0.17.12.dist-info → replit_river-0.17.14.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any