Add cast functions.

Author: dnwpark

gel/_internal/_codegen/_models/_pydantic.py

@@ -2356,37 +2356,39 @@ def write_generic_types(
             t_anypt = self.declare_typevar("_T_anypoint", bound=anypoint)
             self.write(f'_Tt = {typevartup}("_Tt")')
 
+            # Order the bases with more specific types first so that
+            # __gel_reflection__ is resolved correctly.
             generics = {
                 SchemaPath("std", "anytype"): [
                     geltype,
                 ],
                 SchemaPath("std", "anyobject"): [
-                    "anytype",
                     gelmodel,
+                    "anytype",
                 ],
                 SchemaPath("std", "anytuple"): [
-                    "anytype",
                     anytuple,
+                    "anytype",
                 ],
                 SchemaPath("std", "anynamedtuple"): [
-                    "anytuple",
                     anynamedtuple,
+                    "anytuple",
                 ],
                 SchemaPath("std", "tuple"): [
-                    "anytuple",
                     f"{tup}[{unpack}[_Tt]]",
+                    "anytuple",
                 ],
                 SchemaPath("std", "array"): [
-                    "anytype",
                     f"{arr}[{t_anytype}]",
+                    "anytype",
                 ],
                 SchemaPath("std", "range"): [
-                    "anytype",
                     f"{rang}[{t_anypt}]",
+                    "anytype",
                 ],
                 SchemaPath("std", "multirange"): [
-                    "anytype",
                     f"{mrang}[{t_anypt}]",
+                    "anytype",
                 ],
             }
 
@@ -2441,7 +2443,7 @@ def write_generic_types(
                 with self._class_def(tmeta, meta_bases):
                     un_ops = self._write_prefix_operator_methods(ptype)
                     bin_ops = self._write_infix_operator_methods(ptype)
-                    if gt.name == "anytype":
+                    if gt.name in {"anytype", "anytuple"}:
                         self.write(f"__hash__ = {type_}.__hash__")
                     elif not un_ops and not bin_ops:
                         self.write("pass")
@@ -2536,7 +2538,36 @@ def _write_enum_scalar_type(
             self.write_description(stype)
             for value in stype.enum_values:
                 self.write(f"{ident(value)} = {value!r}")
+
+            self.write()
             self.write_type_reflection(stype)
+
+            # cast method
+            expr_compat = self.import_name(BASE_IMPL, "ExprCompatible")
+
+            type_ = self.import_name("builtins", "type")
+            self_ = self.import_name("typing_extensions", "Self")
+            type_self = f"{type_}[{self_}]"
+
+            aexpr = self.import_name(BASE_IMPL, "AnnotatedExpr")
+            cast_op = self.import_name(BASE_IMPL, "CastOp")
+
+            self.write()
+            with self._classmethod_def(
+                "cast",
+                [f"expr: {expr_compat}"],
+                type_self,
+            ):
+                self.write(f"return {aexpr}(  # type: ignore [return-value]")
+                with self.indented():
+                    self.write("cls,")
+                    self.write(f"{cast_op}(")
+                    with self.indented():
+                        self.write("expr=expr,")
+                        self.write("type_=cls.__gel_reflection__.name,")
+                    self.write(")")
+                self.write(")")
+
         self.write_section_break()
 
     def _write_scalar_type(
@@ -2627,6 +2658,8 @@ def _write_regular_scalar_type(
 
             self.export("anyenum")
 
+        is_generic = type_name in GENERIC_TYPES
+
         if not runtime_parents:
             typecheck_parents = [self.get_type(self._types_by_name["anytype"])]
             runtime_parents = typecheck_parents
@@ -2728,6 +2761,22 @@ def _write_regular_scalar_type(
                     ):
                         self.write("...")
 
+                # cast method
+                if not is_generic:
+                    expr_compat = self.import_name(BASE_IMPL, "ExprCompatible")
+
+                    type_ = self.import_name("builtins", "type")
+                    self_ = self.import_name("typing_extensions", "Self")
+                    type_self = f"{type_}[{self_}]"
+
+                    self.write()
+                    with self._classmethod_def(
+                        "cast",
+                        [f"expr: {expr_compat}"],
+                        type_self,
+                    ):
+                        self.write("...")
+
         self.write()
 
         with self.not_type_checking():
@@ -2742,6 +2791,37 @@ def _write_regular_scalar_type(
                     self.write()
                 self.write_type_reflection(stype)
 
+                # cast method
+                if not is_generic:
+                    expr_compat = self.import_name(BASE_IMPL, "ExprCompatible")
+
+                    type_ = self.import_name("builtins", "type")
+                    self_ = self.import_name("typing_extensions", "Self")
+                    type_self = f"{type_}[{self_}]"
+
+                    aexpr = self.import_name(BASE_IMPL, "AnnotatedExpr")
+                    cast_op = self.import_name(BASE_IMPL, "CastOp")
+
+                    self.write()
+                    with self._classmethod_def(
+                        "cast",
+                        [f"expr: {expr_compat}"],
+                        type_self,
+                    ):
+                        self.write(
+                            f"return {aexpr}(  # type: ignore [return-value]"
+                        )
+                        with self.indented():
+                            self.write("cls,")
+                            self.write(f"{cast_op}(")
+                            with self.indented():
+                                self.write("expr=expr,")
+                                self.write(
+                                    "type_=cls.__gel_reflection__.name,"
+                                )
+                            self.write(")")
+                        self.write(")")
+
         self.write_section_break()
 
     def render_callable_return_type(

gel/_internal/_qbmodel/_abstract/_primitive.py

@@ -269,6 +269,22 @@ def _reconstruct_from_pickle(
     def __gel_get_py_type__(cls) -> type:
         return list
 
+    def __edgeql_literal__(self) -> _qb.Literal:
+        return _qb.Literal(
+            type_=type(self).__gel_reflection__.name,
+            val=self,
+        )
+
+    @classmethod
+    def cast(cls, expr: _qb.ExprCompatible) -> type[Array[_T]]:
+        return _qb.AnnotatedExpr(  # type: ignore [return-value]
+            cls,
+            _qb.CastOp(
+                expr=expr,
+                type_=cls.__gel_reflection__.name,
+            ),
+        )
+
 
 _Ts = TypeVarTuple("_Ts")
 
@@ -335,6 +351,22 @@ class __gel_reflection__(GelPrimitiveType.__gel_reflection__):  # noqa: N801
     def __gel_get_py_type__(cls) -> type:
         return tuple
 
+    def __edgeql_literal__(self) -> _qb.Literal:
+        return _qb.Literal(
+            type_=type(self).__gel_reflection__.name,
+            val=self,
+        )
+
+    @classmethod
+    def cast(cls, expr: _qb.ExprCompatible) -> type[Tuple[Unpack[_Ts]]]:
+        return _qb.AnnotatedExpr(  # type: ignore [return-value]
+            cls,
+            _qb.CastOp(
+                expr=expr,
+                type_=cls.__gel_reflection__.name,
+            ),
+        )
+
 
 if TYPE_CHECKING:
 
@@ -374,6 +406,16 @@ class __gel_reflection__(GelPrimitiveType.__gel_reflection__):  # noqa: N801
 
         return __gel_reflection__
 
+    @classmethod
+    def cast(cls, expr: _qb.ExprCompatible) -> type[Range[_T]]:
+        return _qb.AnnotatedExpr(  # type: ignore [return-value]
+            cls,
+            _qb.CastOp(
+                expr=expr,
+                type_=cls.__gel_reflection__.name,
+            ),
+        )
+
 
 if TYPE_CHECKING:
 

gel/models/pydantic.py

@@ -22,6 +22,7 @@
     OPERAND_IS_ALIAS,
     AnnotatedExpr,
     BaseAlias,
+    CastOp,
     EmptyDirection,
     Direction,
     GelLinkMetadata,
@@ -116,6 +117,7 @@
     "ArrayMeta",
     "BaseAlias",
     "Cardinality",
+    "CastOp",
     "ComputedLink",
     "ComputedLinkWithProps",
     "ComputedMultiLink",