chalkruntime 3.43.76__tar.gz → 3.43.78__tar.gz

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalkruntime
-Version: 3.43.76
+Version: 3.43.78
 Summary: Runtime support library for Chalk AI
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/graph/convert_chalkpy_underscore.py

@@ -654,7 +654,7 @@ def _build_struct_pack_expression(
     return UnderscoreOperationExpression(
         operands=FrozenNamedCollection(struct_values),
         operation=get_struct_pack_operation(
-            tuple(struct_names),  # ty: ignore[invalid-argument-type]
+            tuple(struct_names),
             tuple(value.underscore_result_type.scalar_type for value in struct_values),  # pyright: ignore[reportAttributeAccessIssue]  # ty: ignore[unresolved-attribute]
         ),
         args=tuple(struct_names),

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/graph/feature.py

@@ -765,7 +765,7 @@ class NestedFeatureType(NamedFeatureType, FeatureType, Generic[_InputT_co]):
         return NestedFeatureType(
             path=self.path[len(path) + 1 :],
             underlying_ref=self.underlying,
-        )  # ty:ignore[invalid-return-type]
+        )
 
     @staticmethod
     def absolute_to(
@@ -1124,7 +1124,7 @@ def canonicalize_typ(x: object):
         return _to_old_style_type(x)
     origin = _to_old_style_type(origin)
     args = tuple(canonicalize_typ(x) for x in args)
-    return origin[args]  # type: ignore -- pyright doesn't understand metaprogramming
+    return origin[args]  # pyright: ignore -- pyright doesn't understand metaprogramming
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
@@ -3241,7 +3241,7 @@ def all_has_many_subfeatures(
     if isinstance(ft, NestedFeatureType):
         # FIXME: Support parsing nested has-many using index notation e.g.
         # User.accounts[Account.type == 'CHECKING', Account.transactions[Transaction.amount > 100, Transaction.amount]]
-        for i, x in enumerate(list(ft.walk_path_joins())):  # ty:ignore[invalid-argument-type]
+        for i, x in enumerate(list(ft.walk_path_joins())):
             if isinstance(x, HasManyFeatureType):
                 if i == 0:
                     subfeatures.append(x)
@@ -3261,7 +3261,7 @@ def all_has_many_subfeatures(
         assert isinstance(ft, NestedFeatureType)
         subfeatures[-1] = has_many_subfeatures_to_projection(
             subfeatures[-1],
-            [x.relative_to(subfeatures[-1]) for x in ft.flatten(graph)],  # ty:ignore[invalid-argument-type]
+            [x.relative_to(subfeatures[-1]) for x in ft.flatten(graph)],
         )
     return tuple(subfeatures)
 
@@ -3485,7 +3485,7 @@ def is_primary_key_feature_type(ft: object) -> TypeGuard[ScalarFeatureType]:
 def is_optional_has_one(ft: FeatureType) -> bool:
     return isinstance(ft, NestedFeatureType) and any(
         isinstance(feature_step, HasOneFeatureType) and feature_step.is_feature_nullable
-        for feature_step in ft.walk_all_steps()  # ty:ignore[invalid-argument-type]
+        for feature_step in ft.walk_all_steps()
     )
 
 

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/graph/filter_conversion.py

@@ -177,8 +177,8 @@ class FilterParsedConverter(Generic[TExpr]):
             # LHS is literal. Encode it into the rhs_dtype
             assert rhs_converter is not None, "One side of the filter must be an expression"
             if not self._ff._is_expr(lhs):  # pyright:ignore[reportPrivateUsage]
-                lhs_pa_scalar: pa.Scalar = rhs_converter.from_json_to_pyarrow([lhs])[0]  # pyright: ignore  # ty: ignore[invalid-assignment, invalid-argument-type]
-                lhs = self._ff.lit(lhs_pa_scalar.as_py(), rhs_converter.pyarrow_dtype)
+                lhs_pa_values = rhs_converter.from_json_to_pyarrow([lhs])  # pyright: ignore  # ty: ignore[invalid-argument-type]
+                lhs = self._ff.lit(lhs_pa_values.to_pylist()[0], rhs_converter.pyarrow_dtype)
         if rhs_converter is None:
             # RHS is literal. Encode it into the lhs_dtype
             assert lhs_converter is not None, "One side of the filter must be an expression"
@@ -190,9 +190,9 @@ class FilterParsedConverter(Generic[TExpr]):
                         for rhs_scalar in lhs_converter.from_json_to_pyarrow(rhs)  # pyright: ignore  # ty:ignore[invalid-argument-type]
                     ]
                 else:
-                    rhs_pa_scalar = lhs_converter.from_json_to_pyarrow([rhs])[0]  # pyright: ignore  # ty: ignore[invalid-argument-type]
+                    rhs_pa_values = lhs_converter.from_json_to_pyarrow([rhs])  # pyright: ignore  # ty: ignore[invalid-argument-type]
                     rhs = self._ff.lit(
-                        rhs_pa_scalar.as_py(),  # ty: ignore[unresolved-attribute]
+                        rhs_pa_values.to_pylist()[0],
                         lhs_converter.pyarrow_dtype,
                     )
 

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/graph/materializations.py

@@ -78,7 +78,7 @@ class TimeSeriesRuleParsedAggregationType(Enum):
                         "n": pa.int64(),
                         "sort_by": pa.large_list(pa.field("element", input_types[1])),
                         "values": pa.large_list(pa.field("element", input_types[0])),
-                    }  # ty: ignore[invalid-argument-type]
+                    }.items()
                 )
             case TimeSeriesRuleParsedAggregationType.SetAgg:
                 # set_agg's intermediate state is a deduplicated array of input values. The list

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/graph/protograph_deserializer.py

@@ -1383,7 +1383,7 @@ class FromProtoConverter:
                 "min_length_arrow",
                 "max_length_arrow",
             ]:
-                value = _extract_validation(v, name)  # pyright: ignore  # ty:ignore[invalid-argument-type]
+                value = _extract_validation(v, name)  # pyright: ignore
                 validation_dict: dict[str, int | float | None] = {
                     "min": None,
                     "max": None,
@@ -2453,7 +2453,7 @@ class FromProtoConverter:
                 send_to=send_to,
                 output_features=output_features,
                 feature_expressions=transformations,
-                format=r.message_producer.format,  # ty:ignore[invalid-argument-type]
+                format=r.message_producer.format,
                 message_key=message_key,
             )
 
@@ -2819,7 +2819,7 @@ class FromProtoConverter:
             if r.HasField("incremental_settings")
             else None,
             is_externally_defined=is_externally_defined,
-            output_row_order=output_row_order,  # ty:ignore[invalid-argument-type]
+            output_row_order=output_row_order,
             max_batch_size=max_batch_size,
             venv=r.venv if r.HasField("venv") else None,
             postprocessing=postprocessing_expr,

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/graph/singletons.py

@@ -102,7 +102,7 @@ class SingletonGraphAugmenter:
                     # we need to replace the singleton feature with the has-one feature.
                     arg_through_has_one = SingletonGraphAugmenter.nest_singleton_feature(arg, ns)
                     assert isinstance(r.inputs, list)
-                    r.inputs[i] = arg_through_has_one  # ty:ignore[invalid-assignment]
+                    r.inputs[i] = arg_through_has_one
 
         if r.output and len(r.output.features) == 1:
             df_type = r.output.features[0]

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/graph/stream_resolver.py

@@ -52,7 +52,7 @@ from libchalk.chalktable import Expr
 
 if TYPE_CHECKING:
     from pydantic import BaseModel
-    from pydantic.fields import FieldInfo, ModelField  # ty:ignore[unresolved-import]
+    from pydantic.fields import FieldInfo, ModelField
 
 
 PydanticType = TypeVar("PydanticType", bound="BaseModel")
@@ -73,7 +73,7 @@ def _convert_field_v2(name: str, info: "FieldInfo") -> pa.Field:
     nullable = info.is_required() is False  # pyright: ignore  # ty: ignore[unresolved-attribute] -- two versions of pydantic
 
     alias = info.alias
-    typ_ = rich_to_pyarrow(annotation, alias if alias is not None else name)  # ty:ignore[invalid-argument-type]
+    typ_ = rich_to_pyarrow(annotation, alias if alias is not None else name)
     return pa.field(
         metadata={"chalk_field_name": name},
         name=name,

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/graph/underscore.py

@@ -1829,11 +1829,13 @@ class UnderscoreMaterializedStateOperation(UnderscoreValue):
         return UnderscoreResultScalarType(
             scalar_type=pa.large_list(
                 pa.struct(
-                    {"ts": pa.timestamp("ns", "UTC")}
-                    | {
-                        ty.time_series_rule_name(): ty.bucket_result_type(input_types)
-                        for ty in convert_materialized_aggregation_type_to_timeseries_rule_aggregation_type(agg_ty)
-                    }  # ty: ignore[invalid-argument-type]
+                    (
+                        {"ts": pa.timestamp("ns", "UTC")}
+                        | {
+                            ty.time_series_rule_name(): ty.bucket_result_type(input_types)
+                            for ty in convert_materialized_aggregation_type_to_timeseries_rule_aggregation_type(agg_ty)
+                        }
+                    ).items()
                 )
             )
         )

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/graph/variables.py

@@ -53,23 +53,23 @@ def _parse_python_type(value: object) -> types_pb.Ty:
     return _any_proto_ty
 
 
-_missing = object()
-
-
 def get_variables(variables: Iterable[types_pb.CodeVariable]) -> Iterable[types_pb.CodeVariableValue]:
     for variable in variables:
         try:
             module = importlib.import_module(variable.module)
         except ImportError:
             continue
-        if (value := getattr(module, variable.name, _missing)) is not _missing:
-            ty = _parse_python_type(value)
-            try:
-                proto_scalar = pa_scalar_to_proto(pa.scalar(value))  # ty: ignore[no-matching-overload]
-            except Exception:
-                continue
+        try:
+            value = getattr(module, variable.name)
+        except AttributeError:
+            continue
+        ty = _parse_python_type(value)
+        try:
+            proto_scalar = pa_scalar_to_proto(pa.scalar(value))
+        except Exception:
+            continue
 
-            yield types_pb.CodeVariableValue(
-                variable=variable,
-                value=types_pb.SymbolicConst(value=proto_scalar, ty=ty),
-            )
+        yield types_pb.CodeVariableValue(
+            variable=variable,
+            value=types_pb.SymbolicConst(value=proto_scalar, ty=ty),
+        )

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/invoker/batch_result_collector.py

@@ -744,10 +744,10 @@ class ResultCollector:
             TS_COL_NAME,
             pa.nulls(len(result), pa.timestamp("us", "UTC")).fill_null(cast(Any, execution_timestamp)),
         )
-        result = result.append_column(
-            INDEX_COL_NAME,
-            pa.nulls(len(result), pa.int64()).fill_null(index),  # ty: ignore[invalid-argument-type]
-        )
+        index_column = pa.nulls(len(result), pa.int64())
+        if index is not None:
+            index_column = index_column.fill_null(index)
+        result = result.append_column(INDEX_COL_NAME, index_column)
         try:
             result = pa_cast(result, self._metadata.pa_schema)
         except Exception as e:
@@ -820,15 +820,9 @@ class ResultCollector:
                                 # This is a weird hack -- this is a much faster way of going from @features
                                 # classes to arrow list[struct] type for resolvers that do things like return
                                 # Features[Account.transactions]
-                                struct = (
-                                    DataFrame(values[0])  # ty:ignore[unresolved-attribute]
-                                    .to_polars()
-                                    .collect()
-                                    .to_struct("foo")
-                                    .to_frame()
-                                )
+                                struct = DataFrame(values[0]).to_polars().collect().to_struct("foo").to_frame()
 
-                                grouped = struct.group_by(pl.lit(1))  # ty:ignore[unresolved-attribute]
+                                grouped = struct.group_by(pl.lit(1))
 
                                 pa_arr = grouped.all()["foo"].to_arrow()
                             else:
@@ -983,7 +977,7 @@ class ResultCollector:
         error: ChalkError,
     ):
         if pkey is not None:
-            error = error.copy(update={"display_primary_key": str(pkey)})  # ty:ignore[deprecated]
+            error = error.copy(update={"display_primary_key": str(pkey)})
         # Do we want to keep track of all the samples that errored? or just the observed at and pkey?
         self._errors.append(_InvocationError(index=index, error=error))
         if self._metadata.is_one_to_one_resolver and index is not None:
@@ -1032,13 +1026,11 @@ class ResultCollector:
                 # All are valid
                 col = col.fill_null(default)
             else:
-                assert not pc.any(
-                    pc.and_(col.is_valid(), pc.invert(is_valid))
-                ).as_py(), (  # ty:ignore[unresolved-attribute]
+                assert not pc.any(pc.and_(col.is_valid(), pc.invert(is_valid))).as_py(), (
                     "If a row is marked as invalid, then all values must be null"
                 )
-                col = pc.if_else(  # ty:ignore[unresolved-attribute]
-                    pc.or_(  # ty:ignore[unresolved-attribute]
+                col = pc.if_else(
+                    pc.or_(
                         col.is_valid(),
                         is_valid,
                     ),
@@ -1116,20 +1108,20 @@ def _df_has_duplicate_rows(
         return
     df = lazy_df.collect()
     if ts_fqn is None:
-        mask = df.select(pl.col(pkey_fqn)).is_duplicated()  # ty:ignore[unresolved-attribute]
+        mask = df.select(pl.col(pkey_fqn)).is_duplicated()
         if not mask.any():
             return
-        values = _sample_duplicate_rows(df.filter(mask), [pkey_fqn])  # ty:ignore[unresolved-attribute]
+        values = _sample_duplicate_rows(df.filter(mask), [pkey_fqn])
         return _DuplicateReturn(
             pkeys=values[pkey_fqn],
             timestamps=None,
             pkey_fqn=pkey_fqn,
             ts_fqn=ts_fqn,
         )
-    mask = df.select(pl.struct(pkey_fqn, ts_fqn)).is_duplicated()  # ty:ignore[unresolved-attribute]
+    mask = df.select(pl.struct(pkey_fqn, ts_fqn)).is_duplicated()
     if not mask.any():
         return
-    values = _sample_duplicate_rows(df.filter(mask), [pkey_fqn, ts_fqn])  # ty:ignore[unresolved-attribute]
+    values = _sample_duplicate_rows(df.filter(mask), [pkey_fqn, ts_fqn])
     return _DuplicateReturn(
         pkeys=values[pkey_fqn],
         timestamps=values[ts_fqn],

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/invoker/resolver_input.py

@@ -129,9 +129,7 @@ class LocalResolverInputs:
                 meta_col_name = get_metadata_col_name(column_name)
                 if meta_col_name in scalarish_features.column_names:
                     invalid_rows = scalarish_features.column(column_name).filter(
-                        pc.invert(
-                            pa_is_value_valid(scalarish_features[meta_col_name])
-                        )  # ty:ignore[unresolved-attribute]
+                        pc.invert(pa_is_value_valid(scalarish_features[meta_col_name]))
                     )
                     assert len(invalid_rows) == invalid_rows.null_count, (
                         "All invalid rows should already have null values"

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/invoker/resolver_input_upload.py

@@ -105,7 +105,7 @@ class StrictResolverInputUploadClient(ResolverInputUploadClient):
                     packed_arr = (
                         pl.concat([df.to_polars().select(pl.struct(pl.all()).implode().alias("packed")) for df in dfs])
                         .collect()
-                        .get_column("packed")  # ty:ignore[unresolved-attribute]
+                        .get_column("packed")
                         .to_arrow()
                     )
                     all_arrays[f"{arg_idx}_packed_df"] = packed_arr

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/invoker/resolver_raw_output_parsing.py

@@ -360,7 +360,7 @@ def resolver_raw_output_to_table(
         pkey_column = table.column(pkey_feature_fqn)
         # Only check for empty strings if pkey is a string type
         if pa.types.is_string(pkey_column.type) or pa.types.is_large_string(pkey_column.type):
-            has_empty_pkey = pc.any(pc.equal(pkey_column, pa.scalar(""))).as_py()  # ty:ignore[unresolved-attribute]
+            has_empty_pkey = pc.any(pc.equal(pkey_column, pa.scalar(""))).as_py()
 
             if has_empty_pkey:
                 return (

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/invoker/vectorized_hasmany_sampler.py

@@ -718,9 +718,7 @@ class PolarsVectorizedHasManySampler(VectorizedHasManySampler):
             if INDEX_COL_NAME in hm_lf.columns and has_many_feature.underlying.get_nearest_neighbor_join_info():
                 unique_on.append(INDEX_COL_NAME)
             hm_lf_unique = hm_lf.unique(subset=unique_on)
-            if (hm_lf_unique_len := len(hm_lf_unique.lazy().collect())) != (  # ty:ignore[invalid-argument-type]
-                hm_lf_len := len(hm_lf.lazy().collect())  # ty:ignore[invalid-argument-type]
-            ):
+            if (hm_lf_unique_len := len(hm_lf_unique.lazy().collect())) != (hm_lf_len := len(hm_lf.lazy().collect())):
                 warnings.warn(
                     f"Got duplicated results for {has_many_feature}: Num unique elements: {hm_lf_unique_len}/{hm_lf_len}"
                 )
@@ -860,7 +858,7 @@ class PolarsVectorizedHasManySampler(VectorizedHasManySampler):
                 )
                 # try filtering out any rows that definitely don't meet ts consistency criteria to reduce join size
                 final_hm_lf_for_join = (
-                    final_hm_lf_for_join.lazy()  # ty:ignore[unresolved-attribute]
+                    final_hm_lf_for_join.lazy()
                     .join(
                         resolver_inputs_greatest_ts_per_input.lazy(),
                         right_on=left_join_cols,
@@ -890,13 +888,13 @@ class PolarsVectorizedHasManySampler(VectorizedHasManySampler):
                 how="inner",
             )
             ungrouped_relevant_rows = ungrouped_relevant_rows.join(
-                final_hm_lf_for_join.lazy(),  # ty:ignore[unresolved-attribute]
+                final_hm_lf_for_join.lazy(),
                 on=INDEX_COL_NAME,
                 how="inner",
             )
         else:
             ungrouped_relevant_rows = final_resolver_inputs_for_join.lazy().join(
-                final_hm_lf_for_join.lazy(),  # ty:ignore[unresolved-attribute]
+                final_hm_lf_for_join.lazy(),
                 left_on=left_join_cols,
                 right_on=right_join_cols,
                 how="inner",
@@ -971,19 +969,13 @@ class PolarsVectorizedHasManySampler(VectorizedHasManySampler):
         with safe_trace("VectorizedHasManySampler_get_grouped_rows_ungrouped_relevant_rows_collect"):
             ungrouped_relevant_rows_collected = ungrouped_relevant_rows.select(expected_cols).lazy().collect()
 
-        group_input_indices: list[int] = (
-            groups.select(RESOLVER_INPUT_IDX_COL_NAME).to_series().to_list()  # ty:ignore[unresolved-attribute]
-        )
-        group_pkeys = (
-            groups.select(pl.exclude(GROUP_TEMP_COL_NAME)).to_series().to_list()  # ty:ignore[unresolved-attribute]
-        )
-        group_indices_list: list[int] = (
-            groups.select(GROUP_TEMP_COL_NAME).to_series().to_list()  # ty:ignore[unresolved-attribute]
-        )
+        group_input_indices: list[int] = groups.select(RESOLVER_INPUT_IDX_COL_NAME).to_series().to_list()
+        group_pkeys = groups.select(pl.exclude(GROUP_TEMP_COL_NAME)).to_series().to_list()
+        group_indices_list: list[int] = groups.select(GROUP_TEMP_COL_NAME).to_series().to_list()
 
         # Perform validation on df schema overall. That way we can skip validation for each group, which would be
         # redundant since each group has the same schema.
-        _validate_df_schema(ungrouped_relevant_rows_collected, graph=graph)  # ty:ignore[invalid-argument-type]
+        _validate_df_schema(ungrouped_relevant_rows_collected, graph=graph)
 
         # Map the index of the group to a tuple where the first element is the primary key for that group, and the
         # second item is a Series of indices (relative to ungrouped_relevant_rows) that specify the row indices for
@@ -992,7 +984,7 @@ class PolarsVectorizedHasManySampler(VectorizedHasManySampler):
             groups_dict = {
                 group_index: (
                     group_pkey,
-                    ungrouped_relevant_rows_collected[group_indices],  # ty:ignore[not-subscriptable]
+                    ungrouped_relevant_rows_collected[group_indices],
                 )
                 for group_indices, group_pkey, group_index in zip(group_indices_list, group_pkeys, group_input_indices)
             }
@@ -1020,12 +1012,7 @@ class PolarsVectorizedHasManySampler(VectorizedHasManySampler):
             # run in a time that scales with the pre-sliced (i.e. len(ungrouped_relevant_rows) size. This causes
             # issues down the line that can slow down resolvers that try to perform ops on it. It's possible a
             # future version polars will fix this issue, but for now this avoids it.
-            empty_polars_df = (
-                ungrouped_relevant_rows.slice(0, 0)
-                .select(self._expected_col_names)
-                .collect()
-                .lazy()  # ty:ignore[unresolved-attribute]
-            )
+            empty_polars_df = ungrouped_relevant_rows.slice(0, 0).select(self._expected_col_names).collect().lazy()
             empty_chalk_df: DataFrame = DataFrame(  # ... just get Chalk DF metadata right using one of them.
                 empty_polars_df,
                 missing_value_strategy="default_or_allow",
@@ -1103,7 +1090,7 @@ class PolarsVectorizedHasManySampler(VectorizedHasManySampler):
                 pl.col(str(has_many_feature))
             )
         result = ans.select([RESOLVER_INPUT_IDX_COL_NAME, str(has_many_feature)]).collect()
-        return result  # ty:ignore[invalid-return-type]
+        return result
 
     def join_df_and_pack_into_struct(self) -> pl.DataFrame:
         """
@@ -1220,7 +1207,7 @@ class PyArrowVectorizedHasManySampler(VectorizedHasManySampler):
 
             # Sort by pkey, then by ts.
             # This means that all entries with the same pkey will be contiguous.
-            sorted_indices = pc.sort_indices(  # ty:ignore[unresolved-attribute]
+            sorted_indices = pc.sort_indices(
                 hm_table,
                 sort_keys=[
                     (foreign_pkey_feature.root_fqn, "ascending"),
@@ -1251,8 +1238,8 @@ class PyArrowVectorizedHasManySampler(VectorizedHasManySampler):
                         pa.nulls(1, type=col_foreign_pkeys.type),
                     ]
                 )
-                replaced_observed_at_array = pc.if_else(  # ty:ignore[unresolved-attribute]
-                    pc.equal(col_foreign_pkeys, col_foreign_pkeys_shifted),  # ty:ignore[unresolved-attribute]
+                replaced_observed_at_array = pc.if_else(
+                    pc.equal(col_foreign_pkeys, col_foreign_pkeys_shifted),
                     replaced_observed_at_array,
                     pa.scalar(None, replaced_observed_at_array.type),
                 )
@@ -1274,9 +1261,7 @@ class PyArrowVectorizedHasManySampler(VectorizedHasManySampler):
         ts_col = hm_table.column(TS_COL_NAME)
 
         # Use coalesce to replace null values in foreign_ts_col with values from ts_col
-        combined_array = pc.if_else(
-            pc.is_valid(foreign_ts_col), foreign_ts_col, ts_col
-        )  # ty:ignore[unresolved-attribute]
+        combined_array = pc.if_else(pc.is_valid(foreign_ts_col), foreign_ts_col, ts_col)
         # combined_array = pc.coalesce([foreign_ts_col, ts_col])
 
         # Replace the original column in the table
@@ -1339,38 +1324,32 @@ class PyArrowVectorizedHasManySampler(VectorizedHasManySampler):
 
         # Now we need to filter out rows in the has many dataframe whose timestamps make them inapplicable.
         with safe_trace("_produce_resolver_args_has_many_has_many___get_ungrouped_rows_pa_filter"):
-            hm_oat_before_cond_1 = pc.less_equal(  # ty:ignore[unresolved-attribute]
+            hm_oat_before_cond_1 = pc.less_equal(
                 ungrouped_relevant_rows_table.column(OBSERVED_AT_FEATURE_COL_NAME),
                 ungrouped_relevant_rows_table.column(RESOLVER_INPUT_PREFIX + TS_COL_NAME),
             )
 
             hm_oat_before_cond_1 = pc.fill_null(hm_oat_before_cond_1, False)  # ty: ignore[invalid-argument-type]
 
-            hm_oat_before_cond_2 = pc.is_null(
-                ungrouped_relevant_rows_table.column(OBSERVED_AT_FEATURE_COL_NAME)
-            )  # ty:ignore[unresolved-attribute]
-            hm_oat_before_input_ts_expr = pc.or_(
-                hm_oat_before_cond_1, hm_oat_before_cond_2
-            )  # ty:ignore[unresolved-attribute]
+            hm_oat_before_cond_2 = pc.is_null(ungrouped_relevant_rows_table.column(OBSERVED_AT_FEATURE_COL_NAME))
+            hm_oat_before_input_ts_expr = pc.or_(hm_oat_before_cond_1, hm_oat_before_cond_2)
 
-            hm_oat_after_cond_1 = pc.less(  # ty:ignore[unresolved-attribute]
+            hm_oat_after_cond_1 = pc.less(
                 ungrouped_relevant_rows_table.column(RESOLVER_INPUT_PREFIX + TS_COL_NAME),
                 ungrouped_relevant_rows_table.column(REPLACED_OBSERVED_AT_FEATURE_COL_NAME),
             )
 
             hm_oat_after_cond_1 = pc.fill_null(hm_oat_after_cond_1, False)  # ty: ignore[invalid-argument-type]
 
-            hm_oat_after_cond_2 = pc.is_null(  # ty:ignore[unresolved-attribute]
+            hm_oat_after_cond_2 = pc.is_null(
                 ungrouped_relevant_rows_table.column(REPLACED_OBSERVED_AT_FEATURE_COL_NAME)
             )
-            hm_oat_after_input_ts_expr = pc.or_(
-                hm_oat_after_cond_1, hm_oat_after_cond_2
-            )  # ty:ignore[unresolved-attribute]
+            hm_oat_after_input_ts_expr = pc.or_(hm_oat_after_cond_1, hm_oat_after_cond_2)
 
             # Combine the bf and af expressions
-            ts_consistency_expr = pc.and_(  # ty: ignore[no-matching-overload]
+            ts_consistency_expr = pc.and_(
                 hm_oat_before_input_ts_expr, hm_oat_after_input_ts_expr
-            )
+            )  # ty: ignore[no-matching-overload]
             ungrouped_relevant_rows_table = ungrouped_relevant_rows_table.filter(ts_consistency_expr)
 
         # Apply all the polars filters that were generated from the dataframe filters (like last 7 days, last month,
@@ -1402,14 +1381,12 @@ class PyArrowVectorizedHasManySampler(VectorizedHasManySampler):
                 pl_filter_mask = converter.fill_null(pl_filter_mask, converter.lit(False, pa.bool_()))
                 ungrouped_relevant_rows_df = ungrouped_relevant_rows_df.filter(pl_filter_mask)
                 ungrouped_relevant_rows_table = pa_cast(
-                    ungrouped_relevant_rows_df.collect().to_arrow(),  # ty:ignore[unresolved-attribute]
-                    ungrouped_relevant_rows_table.schema,  # ty:ignore[unresolved-attribute]
+                    ungrouped_relevant_rows_df.collect().to_arrow(),
+                    ungrouped_relevant_rows_table.schema,
                 )
 
         # Filter for rows where the foreign primary key is not null
-        non_null_mask = pc.is_valid(
-            ungrouped_relevant_rows_table.column(foreign_pkey_feature.root_fqn)
-        )  # ty:ignore[unresolved-attribute]
+        non_null_mask = pc.is_valid(ungrouped_relevant_rows_table.column(foreign_pkey_feature.root_fqn))
         ungrouped_relevant_rows_table = ungrouped_relevant_rows_table.filter(non_null_mask)
 
         # Get the columns we want
@@ -1444,28 +1421,22 @@ class PyArrowVectorizedHasManySampler(VectorizedHasManySampler):
             mask = None
             for j, group_key in enumerate(group_keys):
                 if mask is None:
-                    mask = pc.and_(  # ty: ignore[unresolved-attribute]
+                    mask = pc.and_(
                         pc.fill_null(
                             pc.equal(ungrouped_relevant_rows_table.column(self._right_join_cols[j]), group_key),
                             False,  # ty: ignore[invalid-argument-type]
                         ),
-                        pc.equal(
-                            ungrouped_relevant_rows_table.column(RESOLVER_INPUT_IDX_COL_NAME), pa.scalar(i)
-                        ),  # ty: ignore[unresolved-attribute]
+                        pc.equal(ungrouped_relevant_rows_table.column(RESOLVER_INPUT_IDX_COL_NAME), pa.scalar(i)),
                     )
                 else:
-                    mask = pc.and_(  # ty:ignore[unresolved-attribute]
+                    mask = pc.and_(
                         mask,
-                        pc.and_(  # ty: ignore[unresolved-attribute]
+                        pc.and_(
                             pc.fill_null(
-                                pc.equal(
-                                    ungrouped_relevant_rows_table.column(self._right_join_cols[j]), group_key
-                                ),  # ty: ignore[unresolved-attribute]
+                                pc.equal(ungrouped_relevant_rows_table.column(self._right_join_cols[j]), group_key),
                                 False,  # ty: ignore[invalid-argument-type]
                             ),
-                            pc.equal(
-                                ungrouped_relevant_rows_table.column(RESOLVER_INPUT_IDX_COL_NAME), pa.scalar(i)
-                            ),  # ty:ignore[unresolved-attribute]
+                            pc.equal(ungrouped_relevant_rows_table.column(RESOLVER_INPUT_IDX_COL_NAME), pa.scalar(i)),
                         ),
                     )
             assert mask is not None, "the mask should always be constructed by this point"
@@ -1620,7 +1591,7 @@ class NestedHasManySampler:
             unique_resolver_inputs=outer_unique,
             enable_indexed_has_many_joins=False,
             allow_planner_postponed_has_many_sampling_planner_option=self._allow_postponed,
-        ).collect()  # ty:ignore[invalid-assignment]
+        ).collect()
 
         # --- Step 2: rename outer idx to backup so inner samplers get fresh row indices ---
         # current_rows has _OUTER_IDX=outer_idx, course cols — no RESOLVER_INPUT_IDX_COL_NAME
@@ -1723,7 +1694,7 @@ def _get_expected_pl_dtype_for_feature(
         for path_obj in ft.path:
             if is_underlying_has_many(path_obj.parent):
                 dtype = pl.List(inner=dtype)  # pyright: ignore - polars backcompat
-    return cast(pl.DataType, dtype)  # ty:ignore[invalid-return-type]
+    return cast(pl.DataType, dtype)
 
 
 def _validate_df_schema(underlying: Union[pl.DataFrame, pl.LazyFrame], graph: ResolvedGraph):
@@ -1739,7 +1710,7 @@ def _validate_df_schema(underlying: Union[pl.DataFrame, pl.LazyFrame], graph: Re
         if actual_dtype == expected_dtype:
             continue
         if isinstance(underlying, pl.LazyFrame):
-            underlying = underlying.collect()  # ty:ignore[invalid-assignment]
+            underlying = underlying.collect()
         assert isinstance(underlying, pl.DataFrame)
         if len(underlying) == underlying.get_column(root_fqn).null_count() and actual_dtype != expected_dtype:
             # If all values are null, then replace with a null series of the correct datatype
@@ -1749,7 +1720,7 @@ def _validate_df_schema(underlying: Union[pl.DataFrame, pl.LazyFrame], graph: Re
                 _generate_empty_series_for_dtype(
                     root_fqn,
                     expected_dtype,
-                    len(underlying),  # ty:ignore[invalid-argument-type]
+                    len(underlying),
                 )
             )
         elif (
@@ -1763,7 +1734,7 @@ def _validate_df_schema(underlying: Union[pl.DataFrame, pl.LazyFrame], graph: Re
                     f"Values for list feature `{root_fqn}` could not be deserialized from a JSON string to dtype `{expected_dtype}`."
                 ) from e
 
-            deser_actual_dtype = underlying[root_fqn].dtype  # ty:ignore[unresolved-attribute]
+            deser_actual_dtype = underlying[root_fqn].dtype
             if deser_actual_dtype != expected_dtype:
                 raise TypeError(
                     f"Values for list feature `{root_fqn}` could not be deserialized from a JSON string to dtype `{expected_dtype}`. Found type {deser_actual_dtype}, instead."
@@ -1773,12 +1744,12 @@ def _validate_df_schema(underlying: Union[pl.DataFrame, pl.LazyFrame], graph: Re
             # dictionaries / dataclasses are of the correct type
             col = pl.col(root_fqn).cast(expected_dtype)
             try:
-                underlying = underlying.with_columns(underlying.select(col))  # ty:ignore[invalid-argument-type]
+                underlying = underlying.with_columns(underlying.select(col))
             except (pl.exceptions.ComputeError, PolarsPanicErrorCompat) as e:
                 try:
                     series = pl.from_arrow(
                         underlying.select(pl.col(root_fqn))
-                        .to_arrow()[root_fqn]  # ty:ignore[unresolved-attribute]
+                        .to_arrow()[root_fqn]
                         .cast(feature.resolve_pyarrow_dtype(graph))
                     )
                     assert isinstance(series, pl.Series)

{chalkruntime-3.43.76 → chalkruntime-3.43.78}/chalkruntime/loader/converter.py

@@ -483,7 +483,7 @@ class RegistryConverter:
                 )
             return FilterParsed(
                 lhs=self._convert_filter(f.lhs),
-                operation=f.operation,  # ty:ignore[invalid-argument-type]
+                operation=f.operation,
                 rhs=self._convert_filter(f.rhs),
             )
         if f.operation == "not":