code: def tile(cls, op: "BaseDataFrameExpandingAgg"):
      axis = op.axis
  
      in_df = op.inputs[0]
      out_df = op.outputs[0]
  
      if in_df.chunk_shape[op.axis] == 1:
          return cls._tile_single(op)
  
      dtypes_mapping, new_nsplits = cls._remap_dtypes(in_df, out_df)
      new_chunk_shape = tuple(len(split) for split in new_nsplits)
  
      data_chunks = []
      summary_chunks = np.empty(new_chunk_shape, dtype=object)
      stage_info_dict = dict()
      for c in in_df.chunks:
          try:
              if out_df.ndim == 2:
                  new_axis_idx, new_dtypes = dtypes_mapping[
                      c.index[1] if c.ndim > 1 else 0
                  ]
              else:
                  new_axis_idx, new_dtypes = None, None
          except KeyError:
              continue
  
          new_index = (c.index[0], new_axis_idx)
  
          try:
              stage_info = stage_info_dict[new_index[1]]
          except KeyError:
              cols = c.dtypes.index if c.ndim == 2 else None
              stage_info = stage_info_dict[
                  new_index[1]
              ] = cls._gen_chunk_stage_info(
                  op, cols, min_periods=op.min_periods
              )
  
          chunk_op = op.copy().reset_key()
          chunk_op._output_agg = (
              c.index[axis] != in_df.chunk_shape[axis] - 1
          )
          chunk_op.stage = OperandStage.map
          chunk_op._map_sources = stage_info.map_sources
          chunk_op._map_groups = stage_info.map_groups
          chunk_op._key_to_funcs = stage_info.key_to_funcs
  
          if out_df.ndim == 2:
              kw0 = dict(
                  dtypes=new_dtypes,
                  index=new_index,
                  shape=(c.shape[0], len(new_dtypes)),
                  index_value=c.index_value,
                  columns_value=parse_index(
                      new_dtypes.index, store_data=True
                  ),
              )
              kw1 = kw0.copy()
              kw1["shape"] = (
                  (1, len(new_dtypes)) if axis == 0 else (c.shape[0], 1)
              )
          else:
              kw0 = dict(
                  dtype=out_df.dtype,
                  index=c.index,
                  shape=c.shape,
                  name=c.name,
                  index_value=c.index_value,
              )
              kw1 = kw0.copy()
              kw1["shape"] = (1,)
          out_chunks = chunk_op.new_chunks([c], [kw0, kw1])
          data_chunks.append(out_chunks[0])
          if chunk_op.output_agg:
              summary_chunks[new_index] = out_chunks[1]
  
      chunks = []
      for c in data_chunks:
          stage_info = stage_info_dict[
              c.index[1] if c.ndim > 1 else None
          ]
  
          chunk_op = op.copy().reset_key()
          chunk_op._output_agg = False
          chunk_op.stage = OperandStage.combine
          chunk_op._map_groups = stage_info.map_groups
          chunk_op._combine_sources = stage_info.combine_sources
          chunk_op._combine_columns = stage_info.combine_columns
          chunk_op._combine_funcs = stage_info.combine_funcs
          chunk_op._key_to_funcs = stage_info.key_to_funcs
          chunk_op._min_periods_func_name = (
              stage_info.min_periods_func_name
          )
  
          params = c.params.copy()
          if c.ndim == 2:
              summary_inputs = list(
                  summary_chunks[: c.index[0], c.index[1]]
              )
          else:
              summary_inputs = list(summary_chunks[: c.index[0]])
  
          if len(summary_inputs) > 1:
              concat_op = DataFrameConcat(
                  output_types=out_df.op.output_types, axis=op.axis
              )
              concat_summary = concat_op.new_chunk(summary_inputs)
              chunks.append(
                  chunk_op.new_chunk([c, concat_summary], **params)
              )
          elif len(summary_inputs) == 1:
              chunks.append(
                  chunk_op.new_chunk([c, summary_inputs[0]], **params)
              )
          else:
              chunks.append(chunk_op.new_chunk([c], **params))
  
      df_op = op.copy().reset_key()
      params = out_df.params.copy()
      params.update(dict(chunks=chunks, nsplits=new_nsplits))
      return df_op.new_tileables([in_df], **params)
  
imports: from collections import namedtuple, OrderedDict
  from collections.abc import Iterable
  from typing import Dict
  import numpy
  import pandas
  from ...core.operand import OperandStage
  from ...serialization.serializables import AnyField, BoolField, Int32Field, Int64Field, DictField, StringField
  from ...utils import tokenize
  from ..core import DATAFRAME_TYPE
  from ..merge import DataFrameConcat
  from ..operands import DataFrameOperand, DataFrameOperandMixin
  from ..utils import build_df, parse_index, build_empty_series, filter_dtypes_by_index
label_desc: Use image node_id 23 for calling the BaseDataFrameExpandingAgg obj's underlying member method code with example usage: obj.tile(cls, op) and returns: df_op, cls