code: def last_in_date_group(
      df,
      data_query_cutoff_times,
      assets,
      reindex=True,
      have_sids=True,
      extra_groupers=None,
  ):
      """
      Determine the last piece of information known on each date in the date
  
      index for each group. Input df MUST be sorted such that the correct last
      item is chosen from each group.
  
      Parameters
      ----------
      df : pd.DataFrame
          The DataFrame containing the data to be grouped. Must be sorted so that
          the correct last item is chosen from each group.
      data_query_cutoff_times : pd.DatetimeIndex
          The dates to use for grouping and reindexing.
      assets : pd.Int64Index
          The assets that should be included in the column multiindex.
      reindex : bool
          Whether or not the DataFrame should be reindexed against the date
          index. This will add back any dates to the index that were grouped
          away.
      have_sids : bool
          Whether or not the DataFrame has sids. If it does, they will be used
          in the groupby.
      extra_groupers : list of str
          Any extra field names that should be included in the groupby.
  
      Returns
      -------
      last_in_group : pd.DataFrame
          A DataFrame with dates as the index and fields used in the groupby as
          levels of a multiindex of columns.
  
      """
      idx = [
          data_query_cutoff_times[
              data_query_cutoff_times.searchsorted(
                  df[TS_FIELD_NAME].values,
              )
          ]
      ]
      if have_sids:
          idx += [SID_FIELD_NAME]
      if extra_groupers is None:
          extra_groupers = []
      idx += extra_groupers
  
      last_in_group = (
          df.drop(TS_FIELD_NAME, axis=1)
          .groupby(
              idx,
              sort=False,
          )
          .last()
      )
  
      # For the number of things that we're grouping by (except TS), unstack
      # the df. Done this way because of an unresolved pandas bug whereby
      # passing a list of levels with mixed dtypes to unstack causes the
      # resulting DataFrame to have all object-type columns.
      for _ in range(len(idx) - 1):
          last_in_group = last_in_group.unstack(-1)
  
      if reindex:
          if have_sids:
              cols = last_in_group.columns
              last_in_group = last_in_group.reindex(
                  index=data_query_cutoff_times,
                  columns=pd.MultiIndex.from_product(
                      tuple(cols.levels[0 : len(extra_groupers) + 1])
                      + (assets,),
                      names=cols.names,
                  ),
              )
          else:
              last_in_group = last_in_group.reindex(
                  data_query_cutoff_times
              )
  
      return last_in_group
  
file_path: zipline/zipline/pipeline/loaders/utils.py
imports: import numpy
  import pandas
  from zipline.errors import NoFurtherDataError
  from zipline.pipeline.common import TS_FIELD_NAME, SID_FIELD_NAME
  from zipline.utils.numpy_utils import categorical_dtype
label_desc: Use image node_id 5 for calling a global function with example usage: last_in_date_group(df, data_query_cutoff_times, assets, reindex, have_sids, extra_groupers) and returns: last_in_group