{"record":{"id":"97d01b8a4c5ce7ef","repo":"apache/beam","slug":"indexing-with-a-non-bool-deferred-frame-is-not-yet-supported","errorCode":null,"errorMessage":"Indexing with a non-bool deferred frame is not yet supported. Consider using df.loc[...]","messagePattern":"Indexing with a non-bool deferred frame is not yet supported\\. Consider using df\\.loc\\[\\.\\.\\.\\]","errorType":"exception","errorClass":"NotImplementedError","httpStatus":null,"severity":"error","filePath":"sdks/python/apache_beam/dataframe/frames.py","lineNumber":2530,"sourceCode":"  def keys(self):\n    return self.columns\n\n  def __getattr__(self, name):\n    # Column attribute access.\n    if name in self._expr.proxy().columns:\n      return self[name]\n    else:\n      return object.__getattribute__(self, name)\n\n  def __getitem__(self, key):\n    # TODO: Replicate pd.DataFrame.__getitem__ logic\n    if isinstance(key, DeferredSeries) and key._expr.proxy().dtype == bool:\n      return self.loc[key]\n\n    elif isinstance(key, frame_base.DeferredBase):\n      # Fail early if key is a DeferredBase as it interacts surprisingly with\n      # key in self._expr.proxy().columns\n      raise NotImplementedError(\n          \"Indexing with a non-bool deferred frame is not yet supported. \"\n          \"Consider using df.loc[...]\")\n\n    elif isinstance(key, slice):\n      if _is_null_slice(key):\n        return self\n      elif _is_integer_slice(key):\n        # This depends on the contents of the index.\n        raise frame_base.WontImplementError(\n            \"Integer slices are not supported as they are ambiguous. Please \"\n            \"use iloc or loc with integer slices.\")\n      else:\n        return self.loc[key]\n\n    elif (\n        (isinstance(key, list) and all(key_column in self._expr.proxy().columns\n                                       for key_column in key)) or\n        key in self._expr.proxy().columns):","sourceCodeStart":2512,"sourceCodeEnd":2548,"githubUrl":"https://github.com/apache/beam/blob/12126d8942aaf848030c478b4c6a28c6af861c66/sdks/python/apache_beam/dataframe/frames.py#L2512-L2548","documentation":"For DeferredDataFrame.__getitem__, boolean-mask indexing with a DeferredSeries is supported (delegated to .loc), but indexing with any other DeferredBase (e.g. a non-bool deferred frame or deferred column expression) is not implemented. Such keys interact surprisingly with column selection logic, so the API fails early with a clear NotImplementedError instead of producing wrong results.","triggerScenarios":"df[mask_df] where mask_df is a DeferredDataFrame whose proxy dtype is not bool; indexing with a deferred column/other DeferredFrame object; forgetting .loc and passing a deferred key directly.","commonSituations":"Porting pandas patterns like df[df > 0] where df is a DeferredDataFrame (the comparison yields a deferred frame, not a bool deferred series); boolean filtering with multi-column masks.","solutions":["Use df.loc[mask] explicitly instead of df[mask] for deferred boolean masks.","Ensure the mask is a DeferredSeries of dtype bool (e.g. df['col'] > 0), not a whole DeferredDataFrame.","Convert to plain pandas (to_pandas()) for complex non-boolean deferred indexing.","Reduce the mask to a single boolean column first, then apply it via .loc."],"exampleFix":"// before\nfiltered = df[df > 0]  # deferred frame key\n// after\nfiltered = df.loc[df['value'] > 0]","handlingStrategy":"type-guard","validationCode":"if isinstance(key, DeferredBase) and not (isinstance(key, DeferredSeries) and key._expr.proxy().dtype == bool):\n    raise TypeError('use df.loc[...] with a bool DeferredSeries')","typeGuard":"def is_valid_bool_mask(key) -> bool:\n    return isinstance(key, DeferredSeries) and key._expr.proxy().dtype == bool","tryCatchPattern":"try:\n    filtered = df[mask]\nexcept NotImplementedError:\n    filtered = df.loc[mask]","preventionTips":["Always use .loc for deferred boolean filtering.","Ensure masks are single-column bool DeferredSeries (df['col'] > 0).","Avoid whole-frame comparisons like df[df > 0] in Beam DataFrames.","Fall back to pandas for exotic deferred indexing patterns."],"tags":["python","apache-beam","dataframe","boolean-indexing","not-implemented"],"backgroundTag":"unsupported-operation","analyzedSha":"12126d8942aaf848030c478b4c6a28c6af861c66","analyzedAt":"2026-09-13T01:50:10.254Z","contentChangedAt":"2026-09-13T01:50:10.254Z","schemaVersion":2},"datasetVersion":"2026-09-14T16:17:12.679Z"}