Fix a bunch of range/tuple/array operations (#946)

Generate `std.range`/`std.tuple`, follownig the approach of #939.

Then, fix calling functions in QB when range[_T_anypoint] or
array[_T_anytype] used, by specifically checking ParametricType
subclasses against GenericAlias[T].

Author: msullivan

gel/_internal/_codegen/_models/_pydantic.py

@@ -1506,14 +1506,6 @@ def get_type(
                 else ImportTime.runtime
             )
 
-        if (
-            import_time is ImportTime.typecheck_runtime
-            or import_time is ImportTime.late_runtime
-        ):
-            foreign_import_time = ImportTime.runtime
-        else:
-            foreign_import_time = import_time
-
         if reflection.is_array_type(stype):
             arr = self.get_object(
                 SchemaPath('std', 'array'),
@@ -1529,8 +1521,9 @@ def get_type(
             return f"{arr}[{elem_type}]"
 
         elif reflection.is_tuple_type(stype):
-            tup = self.import_name(
-                BASE_IMPL, "Tuple", import_time=foreign_import_time
+            tup = self.get_object(
+                SchemaPath('std', 'tuple'),
+                aspect=ModuleAspect.SHAPES,
             )
             elem_types = [
                 self.get_type(
@@ -1545,8 +1538,9 @@ def get_type(
             return f"{tup}[{', '.join(elem_types)}]"
 
         elif reflection.is_range_type(stype):
-            rang = self.import_name(
-                BASE_IMPL, "Range", import_time=foreign_import_time
+            rang = self.get_object(
+                SchemaPath('std', 'range'),
+                aspect=ModuleAspect.SHAPES,
             )
             elem_type = self.get_type(
                 stype.get_element_type(self._types),
@@ -1558,11 +1552,13 @@ def get_type(
             return f"{rang}[{elem_type}]"
 
         elif reflection.is_multi_range_type(stype):
-            rang_el = self.import_name(
-                BASE_IMPL, "Range", import_time=foreign_import_time
+            rang_el = self.get_object(
+                SchemaPath('std', 'range'),
+                aspect=ModuleAspect.SHAPES,
             )
-            rang = self.import_name(
-                BASE_IMPL, "MultiRange", import_time=foreign_import_time
+            rang = self.get_object(
+                SchemaPath('std', 'multirange'),
+                aspect=ModuleAspect.SHAPES,
             )
             elem_type = self.get_type(
                 stype.get_element_type(self._types),
@@ -2420,12 +2416,13 @@ def write_generic_types(
                 tname = gt.name
                 tmeta = f"__{tname}_meta__"
                 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":
-                        self.write(f"__hash__ = {type_}.__hash__")
-                    elif not un_ops and not bin_ops:
-                        self.write("pass")
+                    self._write_prefix_operator_methods(ptype)
+                    self._write_infix_operator_methods(ptype)
+                    # We have custom __eq__ functions for codegen
+                    # purposes...  but when applied to two normal
+                    # types they still behave as identity, so keep the
+                    # normal __hash__.
+                    self.write(f"__hash__ = {type_}.__hash__")
 
                 class_kwargs["metaclass"] = tmeta
 

gel/_internal/_typing_dispatch.py

@@ -36,12 +36,57 @@
 from gel._internal import _namespace
 from gel._internal import _typing_eval
 from gel._internal import _typing_inspect
+from gel._internal import _typing_parametric
 from gel._internal._utils import type_repr
 
 _P = ParamSpec("_P")
 _R_co = TypeVar("_R_co", covariant=True)
 
 
+def _resolve_to_bound(tp: Any, fn: Any) -> Any:
+    if isinstance(tp, TypeVar):
+        tp = tp.__bound__
+        ns = _namespace.module_ns_of(fn)
+        tp = _typing_eval.resolve_type(tp, globals=ns)
+
+    return tp
+
+
+def _issubclass(lhs: Any, tp: Any, fn: Any) -> bool:
+    # NB: Much more limited than _isinstance below.
+
+    # The only special case here is handling subtyping on
+    # our ParametricTypes. ParametricType creates bona fide
+    # subclasses when indexed with concrete types, but GenericAlias
+    # when indexed with type variables.
+    #
+    # This handles the case where the RHS of issubclass is a
+    # GenericAlias over one of our ParametricTypes by comparing the
+    # types for equality and then checking that the concrete types are
+    # subtypes of the variable bounds.
+    # This lets us handle cases like:
+    # std.array[Object] <: std.array[_T_anytype].
+    if _typing_inspect.is_generic_alias(tp):
+        origin = typing.get_origin(tp)
+        args = typing.get_args(tp)
+        if issubclass(origin, _typing_parametric.ParametricType):
+            if (
+                not issubclass(lhs, _typing_parametric.ParametricType)
+                or lhs.__parametric_origin__ is not origin
+                or lhs.__parametric_type_args__ is None
+            ):
+                return False
+
+            targs = lhs.__parametric_type_args__[origin]
+            return all(
+                _issubclass(l, _resolve_to_bound(r, fn), fn)
+                for l, r in zip(targs, args, strict=True)
+            )
+
+    # In other cases,
+    return issubclass(lhs, tp)  # pyright: ignore [reportArgumentType]
+
+
 def _isinstance(obj: Any, tp: Any, fn: Any) -> bool:
     # Handle Any type - matches everything
     if tp is Any:
@@ -62,17 +107,16 @@ def _isinstance(obj: Any, tp: Any, fn: Any) -> bool:
         origin = typing.get_origin(tp)
         args = typing.get_args(tp)
         if origin is type:
-            atype = args[0]
-            if isinstance(atype, TypeVar):
-                atype = atype.__bound__
-                ns = _namespace.module_ns_of(fn)
-                atype = _typing_eval.resolve_type(atype, globals=ns)
+            atype = _resolve_to_bound(args[0], fn)
 
             if isinstance(obj, type):
                 return issubclass(obj, atype)
+            # NB: This is to handle the case where obj is something
+            # like a qb BaseAlias, where it has some fictitious
+            # associated type that isn't really its runtime type.
             elif (mroent := getattr(obj, "__mro_entries__", None)) is not None:
                 genalias_mro = mroent((obj,))
-                return any(issubclass(c, atype) for c in genalias_mro)
+                return any(_issubclass(c, atype, fn) for c in genalias_mro)
             else:
                 return False
 
@@ -141,6 +185,10 @@ def _isinstance(obj: Any, tp: Any, fn: Any) -> bool:
         else:
             # For other generic types, fall back to checking the origin
             return isinstance(obj, origin)
+
+    elif isinstance(tp, TypeVar):
+        return _isinstance(obj, _resolve_to_bound(tp, fn), fn)
+
     else:
         raise TypeError(f"_isinstance() argument 2 is {tp!r}")
 

gel/_internal/ruff.toml

@@ -59,4 +59,5 @@ extend-ignore = [
     "UP045",   # non-pep604-annotation-optional
     "PLR5501", # collapsible-else-if
     "FURB103", # don't use open and write
+    "E741",    # ambiguous variable names
 ]

pyproject.toml

@@ -222,6 +222,7 @@ extend-ignore = [
     "E252", # missing-whitespace-around-parameter-equals
     "F541", # f-string-missing-placeholders
     "Q000", # prefer double quotes
+    "E741", # ambiguous variable names
 ]
 
 [tool.ruff.format]

tests/test_model_generator.py

@@ -6501,9 +6501,17 @@ def test_modelgen_operators_string_contains_and_patterns(self):
         for user in users_with_char:
             self.assertTrue(search_char in user.name.lower())
 
-    @tb.xfail
+    def test_modelgen_operators_range_eq(self):
+        from models.orm import default
+
+        res = self.client.query(
+            default.RangeTest.filter(
+                lambda u: u.int_range == u.int_range
+            )
+        )
+        self.assertEqual(len(res), 1)
+
     def test_modelgen_operators_range_contains(self):
-        """Test string containment and pattern matching operators"""
         from models.orm import default, std
 
         res = self.client.query(

tests/test_qb.py

@@ -1343,6 +1343,15 @@ def test_qb_poly_07(self):
             self.assertEqual(c.kind, kind)
             self.assertIsInstance(c, default.Chocolate)
 
+    def test_qb_array_agg_01(self):
+        from models.orm import default, std
+
+        agg = std.array_agg(default.User)
+        unpack = std.array_unpack(agg)
+
+        res = self.client.query(unpack)
+        self.assertEqual(len(res), 6)
+
 
 class TestQueryBuilderModify(tb.ModelTestCase):
     """This test suite is for data manipulation using QB."""