code: def execute(
      cls, ctx: Union[dict, Context], op: "DataFrameBloomFilter"
  ):
      if op.execution_stage == "build":
          on = op.on
          in_data = ctx[op.inputs[0].key]
          if cls._filter_on_index(on, in_data):
              bloom_filter = cls._build_index_filter(in_data, op)
          elif isinstance(on, str):
              bloom_filter = cls._build_series_filter(in_data, op)
          else:
              bloom_filter = cls._build_dataframe_filter(in_data, op)
          ctx[op.outputs[0].key] = bloom_filter
      elif op.execution_stage == "union":
          # union bloom filters
          filters = [ctx[inp.key] for inp in op.inputs]
          out = filters[0]
          for f in filters[1:]:
              out.union(f)
          ctx[op.outputs[0].key] = out
      elif op.execution_stage == "filter":
          on = op.on
          in_data = ctx[op.inputs[0].key]
          bloom_filter = ctx[op.inputs[1].key]
          if cls._filter_on_index(on, in_data):
              if isinstance(in_data.index, pd.MultiIndex):
                  idx = in_data.index.names.index(on)
                  ctx[op.outputs[0].key] = in_data[
                      in_data.index.map(
                          lambda x: x[idx] in bloom_filter
                      )
                  ]
              else:
                  ctx[op.outputs[0].key] = in_data[
                      in_data.index.map(lambda x: x in bloom_filter)
                  ]
          else:
              row_func = lambda row: cls._get_value(row) in bloom_filter
              if isinstance(on, str):
                  # series
                  try:
                      filtered = in_data[in_data[on].map(row_func)]
                  except TypeError:
                      converted_data = in_data.astype(str)
                      filtered = in_data[
                          converted_data[on].map(row_func)
                      ]
                  ctx[op.outputs[0].key] = filtered
              else:
                  # dataframe
                  try:
                      filtered = in_data[
                          in_data[on].apply(row_func, axis=1)
                      ]
                  except TypeError:
                      converted_data = in_data.astype(
                          cls._convert_to_hashable_dtypes(
                              in_data.dtypes
                          )
                      )
                      filtered = in_data[
                          converted_data[on].apply(row_func, axis=1)
                      ]
                  ctx[op.outputs[0].key] = filtered
  
      else:  # pragma: no cover
          raise ValueError(
              f"Unknown execution stage: {op.execution_stage}"
          )
  
imports: from typing import Union, List, Any
  import numpy
  import pandas
  from ...config import options
  from ...core import OutputType
  from ...core.context import Context
  from ...lib.bloom_filter import BloomFilter
  from ...serialization.serializables import AnyField, Int64Field, Float64Field, StringField
  from ...None import opcodes
  from ...typing import TileableType
  from ..operands import DataFrameOperandMixin, DataFrameOperand
  from ..utils import parse_index
label_desc: Use image node_id 10 for calling the DataFrameBloomFilter obj's underlying member method code with example usage: obj.execute(cls, ctx, op) without return types