class_docstr: Hold all parsed data to serve for user requests.
class_docstr_tok: ["Hold","all","parsed","data","to","serve","for","user","requests","."]
code: def get_operator_table(  # noqa: C901  Todo: Optimize code
      self, group_by="op_name", search_name=None, time_unit="ms"
  ):
      if not self.operator_parser:
          return
  
      def get_children_data(event):
          datas = []
          for innerop_name, item in event.operator_inners.items():
              if item.cpu_time == 0:
                  cpu_ratio = 0
              else:
                  cpu_ratio = float(item.cpu_time) / event.cpu_time
              if item.general_gpu_time == 0:
                  gpu_ratio = 0
              else:
                  gpu_ratio = (
                      float(item.general_gpu_time)
                      / event.general_gpu_time
                  )
              data = {
                  "name": innerop_name,
                  "calls": item.call,
                  "cpu_total_time": format_time(
                      item.cpu_time, time_unit
                  ),
                  "cpu_avg_time": format_time(
                      item.avg_cpu_time, time_unit
                  ),
                  "cpu_max_time": format_time(
                      item.max_cpu_time, time_unit
                  ),
                  "cpu_min_time": format_time(
                      item.min_cpu_time, time_unit
                  ),
                  "cpu_ratio": format_ratio(cpu_ratio),
                  "gpu_total_time": format_time(
                      item.general_gpu_time, time_unit
                  ),
                  "gpu_avg_time": format_time(
                      item.avg_general_gpu_time, time_unit
                  ),
                  "gpu_max_time": format_time(
                      item.max_general_gpu_time, time_unit
                  ),
                  "gpu_min_time": format_time(
                      item.min_general_gpu_time, time_unit
                  ),
                  "gpu_ratio": format_ratio(gpu_ratio),
              }
              datas.append(data)
          return datas
  
      data = OrderedDict()
      data["events"] = []
      total_cpu_time = 0
      total_gpu_time = 0
      for name, event in self.operator_items.items():
          total_cpu_time += event.cpu_time
          total_gpu_time += event.general_gpu_time
      if not search_name:
          if group_by == "op_name":
              if self.has_gpu:
                  data["column_name"] = [
                      "name",
                      "calls",
                      "cpu_total_time",
                      "cpu_avg_time",
                      "cpu_max_time",
                      "cpu_min_time",
                      "cpu_ratio",
                      "gpu_total_time",
                      "gpu_avg_time",
                      "gpu_max_time",
                      "gpu_min_time",
                      "gpu_ratio",
                  ]
                  data["has_gpu"] = True
              else:
                  data["column_name"] = [
                      "name",
                      "calls",
                      "cpu_total_time",
                      "cpu_avg_time",
                      "cpu_max_time",
                      "cpu_min_time",
                      "cpu_ratio",
                  ]
                  data["has_gpu"] = False
              if self.has_gpu:
                  sorted_items = sorted(
                      self.operator_items.items(),
                      key=lambda x: x[1].general_gpu_time,
                      reverse=True,
                  )
              else:
                  sorted_items = sorted(
                      self.operator_items.items(),
                      key=lambda x: x[1].cpu_time,
                      reverse=True,
                  )
              for name, event in sorted_items:
                  if self.has_gpu:
                      children_events = get_children_data(event)
                      if children_events:
                          data["events"].append(
                              {
                                  "name": name,
                                  "calls": event.call,
                                  "children": children_events,
                                  "cpu_total_time": format_time(
                                      event.cpu_time, time_unit
                                  ),
                                  "cpu_avg_time": format_time(
                                      event.avg_cpu_time, time_unit
                                  ),
                                  "cpu_max_time": format_time(
                                      event.max_cpu_time, time_unit
                                  ),
                                  "cpu_min_time": format_time(
                                      event.min_cpu_time, time_unit
                                  ),
                                  "cpu_ratio": format_ratio(
                                      event.cpu_time / total_cpu_time
                                      if total_cpu_time != 0
                                      else 0.0
                                  ),
                                  "gpu_total_time": format_time(
                                      event.general_gpu_time, time_unit
                                  ),
                                  "gpu_avg_time": format_time(
                                      event.avg_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_max_time": format_time(
                                      event.max_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_min_time": format_time(
                                      event.min_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_ratio": format_ratio(
                                      event.general_gpu_time
                                      / total_gpu_time
                                      if total_gpu_time != 0
                                      else 0.0
                                  ),
                              }
                          )
                      else:
                          data["events"].append(
                              {
                                  "name": name,
                                  "calls": event.call,
                                  "cpu_total_time": format_time(
                                      event.cpu_time, time_unit
                                  ),
                                  "cpu_avg_time": format_time(
                                      event.avg_cpu_time, time_unit
                                  ),
                                  "cpu_max_time": format_time(
                                      event.max_cpu_time, time_unit
                                  ),
                                  "cpu_min_time": format_time(
                                      event.min_cpu_time, time_unit
                                  ),
                                  "cpu_ratio": format_ratio(
                                      event.cpu_time / total_cpu_time
                                      if total_cpu_time != 0
                                      else 0.0
                                  ),
                                  "gpu_total_time": format_time(
                                      event.general_gpu_time, time_unit
                                  ),
                                  "gpu_avg_time": format_time(
                                      event.avg_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_max_time": format_time(
                                      event.max_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_min_time": format_time(
                                      event.min_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_ratio": format_ratio(
                                      event.general_gpu_time
                                      / total_gpu_time
                                      if total_gpu_time != 0
                                      else 0.0
                                  ),
                              }
                          )
                  else:
                      children_events = get_children_data(event)
                      if children_events:
                          data["events"].append(
                              {
                                  "name": name,
                                  "calls": event.call,
                                  "children": children_events,
                                  "cpu_total_time": format_time(
                                      event.cpu_time, time_unit
                                  ),
                                  "cpu_avg_time": format_time(
                                      event.avg_cpu_time, time_unit
                                  ),
                                  "cpu_max_time": format_time(
                                      event.max_cpu_time, time_unit
                                  ),
                                  "cpu_min_time": format_time(
                                      event.min_cpu_time, time_unit
                                  ),
                                  "cpu_ratio": format_ratio(
                                      event.cpu_time / total_cpu_time
                                      if total_cpu_time != 0
                                      else 0.0
                                  ),
                              }
                          )
                      else:
                          data["events"].append(
                              {
                                  "name": name,
                                  "calls": event.call,
                                  "cpu_total_time": format_time(
                                      event.cpu_time, time_unit
                                  ),
                                  "cpu_avg_time": format_time(
                                      event.avg_cpu_time, time_unit
                                  ),
                                  "cpu_max_time": format_time(
                                      event.max_cpu_time, time_unit
                                  ),
                                  "cpu_min_time": format_time(
                                      event.min_cpu_time, time_unit
                                  ),
                                  "cpu_ratio": format_ratio(
                                      event.cpu_time / total_cpu_time
                                      if total_cpu_time != 0
                                      else 0.0
                                  ),
                              }
                          )
  
          else:
              if self.has_gpu:
                  data["column_name"] = [
                      "name",
                      "calls",
                      "input_shape",
                      "cpu_total_time",
                      "cpu_avg_time",
                      "cpu_max_time",
                      "cpu_min_time",
                      "cpu_ratio",
                      "gpu_total_time",
                      "gpu_avg_time",
                      "gpu_max_time",
                      "gpu_min_time",
                      "gpu_ratio",
                  ]
                  data["has_gpu"] = True
              else:
                  data["column_name"] = [
                      "name",
                      "calls",
                      "input_shape",
                      "cpu_total_time",
                      "cpu_avg_time",
                      "cpu_max_time",
                      "cpu_min_time",
                      "cpu_ratio",
                  ]
                  data["has_gpu"] = False
              new_arrange_data = {}
              for (
                  op_name,
                  items_with_input_shape,
              ) in self.operator_items_with_input_shape.items():
                  for (
                      input_shape,
                      item,
                  ) in items_with_input_shape.items():
                      new_arrange_data[(op_name, input_shape)] = item
              if self.has_gpu:
                  sorted_items = sorted(
                      new_arrange_data.items(),
                      key=lambda x: x[1].general_gpu_time,
                      reverse=True,
                  )
              else:
                  sorted_items = sorted(
                      new_arrange_data.items(),
                      key=lambda x: x[1].cpu_time,
                      reverse=True,
                  )
              for (name, input_shape), event in sorted_items:
                  if not input_shape:
                      shape_string = []
                  else:
                      shapes = input_shape.split("\t")[:-1]
                      shape_string = [
                          "{}:{}".format(*shape.split("-"))
                          for shape in shapes
                      ]
                  if self.has_gpu:
                      children_events = get_children_data(event)
                      if children_events:
                          data["events"].append(
                              {
                                  "name": name,
                                  "calls": event.call,
                                  "children": children_events,
                                  "input_shape": shape_string,
                                  "cpu_total_time": format_time(
                                      event.cpu_time, time_unit
                                  ),
                                  "cpu_avg_time": format_time(
                                      event.avg_cpu_time, time_unit
                                  ),
                                  "cpu_max_time": format_time(
                                      event.max_cpu_time, time_unit
                                  ),
                                  "cpu_min_time": format_time(
                                      event.min_cpu_time, time_unit
                                  ),
                                  "cpu_ratio": format_ratio(
                                      event.cpu_time / total_cpu_time
                                      if total_cpu_time != 0
                                      else 0.0
                                  ),
                                  "gpu_total_time": format_time(
                                      event.general_gpu_time, time_unit
                                  ),
                                  "gpu_avg_time": format_time(
                                      event.avg_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_max_time": format_time(
                                      event.max_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_min_time": format_time(
                                      event.min_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_ratio": format_ratio(
                                      event.general_gpu_time
                                      / total_gpu_time
                                      if total_gpu_time != 0
                                      else 0.0
                                  ),
                              }
                          )
                      else:
                          data["events"].append(
                              {
                                  "name": name,
                                  "calls": event.call,
                                  "input_shape": shape_string,
                                  "cpu_total_time": format_time(
                                      event.cpu_time, time_unit
                                  ),
                                  "cpu_avg_time": format_time(
                                      event.avg_cpu_time, time_unit
                                  ),
                                  "cpu_max_time": format_time(
                                      event.max_cpu_time, time_unit
                                  ),
                                  "cpu_min_time": format_time(
                                      event.min_cpu_time, time_unit
                                  ),
                                  "cpu_ratio": format_ratio(
                                      event.cpu_time / total_cpu_time
                                      if total_cpu_time != 0
                                      else 0.0
                                  ),
                                  "gpu_total_time": format_time(
                                      event.general_gpu_time, time_unit
                                  ),
                                  "gpu_avg_time": format_time(
                                      event.avg_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_max_time": format_time(
                                      event.max_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_min_time": format_time(
                                      event.min_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_ratio": format_ratio(
                                      event.general_gpu_time
                                      / total_gpu_time
                                      if total_gpu_time != 0
                                      else 0.0
                                  ),
                              }
                          )
                  else:
                      children_events = get_children_data(event)
                      if children_events:
                          data["events"].append(
                              {
                                  "name": name,
                                  "calls": event.call,
                                  "children": children_events,
                                  "input_shape": shape_string,
                                  "cpu_total_time": format_time(
                                      event.cpu_time, time_unit
                                  ),
                                  "cpu_avg_time": format_time(
                                      event.avg_cpu_time, time_unit
                                  ),
                                  "cpu_max_time": format_time(
                                      event.max_cpu_time, time_unit
                                  ),
                                  "cpu_min_time": format_time(
                                      event.min_cpu_time, time_unit
                                  ),
                                  "cpu_ratio": format_ratio(
                                      event.cpu_time / total_cpu_time
                                      if total_cpu_time != 0
                                      else 0.0
                                  ),
                              }
                          )
                      else:
                          data["events"].append(
                              {
                                  "name": name,
                                  "calls": event.call,
                                  "input_shape": shape_string,
                                  "cpu_total_time": format_time(
                                      event.cpu_time, time_unit
                                  ),
                                  "cpu_avg_time": format_time(
                                      event.avg_cpu_time, time_unit
                                  ),
                                  "cpu_max_time": format_time(
                                      event.max_cpu_time, time_unit
                                  ),
                                  "cpu_min_time": format_time(
                                      event.min_cpu_time, time_unit
                                  ),
                                  "cpu_ratio": format_ratio(
                                      event.cpu_time / total_cpu_time
                                      if total_cpu_time != 0
                                      else 0.0
                                  ),
                              }
                          )
  
      else:
          if self.has_gpu:
              sorted_items = sorted(
                  self.operator_items.items(),
                  key=lambda x: x[1].general_gpu_time,
                  reverse=True,
              )
          else:
              sorted_items = sorted(
                  self.operator_items.items(),
                  key=lambda x: x[1].cpu_time,
                  reverse=True,
              )
  
          results = []
          for op_name, item in sorted_items:
              if search_name in op_name:
                  results.append(op_name)
  
          if group_by == "op_name":
              if self.has_gpu:
                  data["column_name"] = [
                      "name",
                      "calls",
                      "cpu_total_time",
                      "cpu_avg_time",
                      "cpu_max_time",
                      "cpu_min_time",
                      "cpu_ratio",
                      "gpu_total_time",
                      "gpu_avg_time",
                      "gpu_max_time",
                      "gpu_min_time",
                      "gpu_ratio",
                  ]
                  data["has_gpu"] = True
              else:
                  data["column_name"] = [
                      "name",
                      "calls",
                      "cpu_total_time",
                      "cpu_avg_time",
                      "cpu_max_time",
                      "cpu_min_time",
                      "cpu_ratio",
                  ]
                  data["has_gpu"] = False
              for op_name in results:
                  event = self.operator_items[op_name]
                  if self.has_gpu:
                      children_events = get_children_data(event)
                      if children_events:
                          data["events"].append(
                              {
                                  "name": op_name,
                                  "calls": event.call,
                                  "children": children_events,
                                  "cpu_total_time": format_time(
                                      event.cpu_time, time_unit
                                  ),
                                  "cpu_avg_time": format_time(
                                      event.avg_cpu_time, time_unit
                                  ),
                                  "cpu_max_time": format_time(
                                      event.max_cpu_time, time_unit
                                  ),
                                  "cpu_min_time": format_time(
                                      event.min_cpu_time, time_unit
                                  ),
                                  "cpu_ratio": format_ratio(
                                      event.cpu_time / total_cpu_time
                                      if total_cpu_time != 0
                                      else 0.0
                                  ),
                                  "gpu_total_time": format_time(
                                      event.general_gpu_time, time_unit
                                  ),
                                  "gpu_avg_time": format_time(
                                      event.avg_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_max_time": format_time(
                                      event.max_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_min_time": format_time(
                                      event.min_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_ratio": format_ratio(
                                      event.general_gpu_time
                                      / total_gpu_time
                                      if total_gpu_time != 0
                                      else 0.0
                                  ),
                              }
                          )
                      else:
                          data["events"].append(
                              {
                                  "name": op_name,
                                  "calls": event.call,
                                  "cpu_total_time": format_time(
                                      event.cpu_time, time_unit
                                  ),
                                  "cpu_avg_time": format_time(
                                      event.avg_cpu_time, time_unit
                                  ),
                                  "cpu_max_time": format_time(
                                      event.max_cpu_time, time_unit
                                  ),
                                  "cpu_min_time": format_time(
                                      event.min_cpu_time, time_unit
                                  ),
                                  "cpu_ratio": format_ratio(
                                      event.cpu_time / total_cpu_time
                                      if total_cpu_time != 0
                                      else 0.0
                                  ),
                                  "gpu_total_time": format_time(
                                      event.general_gpu_time, time_unit
                                  ),
                                  "gpu_avg_time": format_time(
                                      event.avg_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_max_time": format_time(
                                      event.max_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_min_time": format_time(
                                      event.min_general_gpu_time,
                                      time_unit,
                                  ),
                                  "gpu_ratio": format_ratio(
                                      event.general_gpu_time
                                      / total_gpu_time
                                      if total_gpu_time != 0
                                      else 0.0
                                  ),
                              }
                          )
  
                  else:
                      children_events = get_children_data(event)
                      if children_events:
                          data["events"].append(
                              {
                                  "name": op_name,
                                  "calls": event.call,
                                  "children": children_events,
                                  "cpu_total_time": format_time(
                                      event.cpu_time, time_unit
                                  ),
                                  "cpu_avg_time": format_time(
                                      event.avg_cpu_time, time_unit
                                  ),
                                  "cpu_max_time": format_time(
                                      event.max_cpu_time, time_unit
                                  ),
                                  "cpu_min_time": format_time(
                                      event.min_cpu_time, time_unit
                                  ),
                                  "cpu_ratio": format_ratio(
                                      event.cpu_time / total_cpu_time
                                      if total_cpu_time != 0
                                      else 0.0
                                  ),
                              }
                          )
                      else:
                          data["events"].append(
                              {
                                  "name": op_name,
                                  "calls": event.call,
                                  "cpu_total_time": format_time(
                                      event.cpu_time, time_unit
                                  ),
                                  "cpu_avg_time": format_time(
                                      event.avg_cpu_time, time_unit
                                  ),
                                  "cpu_max_time": format_time(
                                      event.max_cpu_time, time_unit
                                  ),
                                  "cpu_min_time": format_time(
                                      event.min_cpu_time, time_unit
                                  ),
                                  "cpu_ratio": format_ratio(
                                      event.cpu_time / total_cpu_time
                                      if total_cpu_time != 0
                                      else 0.0
                                  ),
                              }
                          )
  
          else:
              if self.has_gpu:
                  data["column_name"] = [
                      "name",
                      "calls",
                      "input_shape",
                      "cpu_total_time",
                      "cpu_avg_time",
                      "cpu_max_time",
                      "cpu_min_time",
                      "cpu_ratio",
                      "gpu_total_time",
                      "gpu_avg_time",
                      "gpu_max_time",
                      "gpu_min_time",
                      "gpu_ratio",
                  ]
                  data["has_gpu"] = True
              else:
                  data["column_name"] = [
                      "name",
                      "calls",
                      "input_shape",
                      "cpu_total_time",
                      "cpu_avg_time",
                      "cpu_max_time",
                      "cpu_min_time",
                      "cpu_ratio",
                  ]
                  data["has_gpu"] = False
              for op_name in results:
                  for (
                      input_shape,
                      event,
                  ) in self.operator_items_with_input_shape[
                      op_name
                  ].items():
                      if not input_shape:
                          shape_string = []
                      else:
                          shapes = input_shape.split("\t")[:-1]
                          shape_string = [
                              "{}:{}".format(*shape.split("-"))
                              for shape in shapes
                          ]
                      if self.has_gpu:
                          children_events = get_children_data(event)
                          if children_events:
                              data["events"].append(
                                  {
                                      "name": op_name,
                                      "calls": event.call,
                                      "children": children_events,
                                      "input_shape": shape_string,
                                      "cpu_total_time": format_time(
                                          event.cpu_time, time_unit
                                      ),
                                      "cpu_avg_time": format_time(
                                          event.avg_cpu_time, time_unit
                                      ),
                                      "cpu_max_time": format_time(
                                          event.max_cpu_time, time_unit
                                      ),
                                      "cpu_min_time": format_time(
                                          event.min_cpu_time, time_unit
                                      ),
                                      "cpu_ratio": format_ratio(
                                          event.cpu_time
                                          / total_cpu_time
                                          if total_cpu_time != 0
                                          else 0.0
                                      ),
                                      "gpu_total_time": format_time(
                                          event.general_gpu_time,
                                          time_unit,
                                      ),
                                      "gpu_avg_time": format_time(
                                          event.avg_general_gpu_time,
                                          time_unit,
                                      ),
                                      "gpu_max_time": format_time(
                                          event.max_general_gpu_time,
                                          time_unit,
                                      ),
                                      "gpu_min_time": format_time(
                                          event.min_general_gpu_time,
                                          time_unit,
                                      ),
                                      "gpu_ratio": format_ratio(
                                          event.general_gpu_time
                                          / total_gpu_time
                                          if total_gpu_time != 0
                                          else 0.0
                                      ),
                                  }
                              )
                          else:
                              data["events"].append(
                                  {
                                      "name": op_name,
                                      "calls": event.call,
                                      "input_shape": shape_string,
                                      "cpu_total_time": format_time(
                                          event.cpu_time, time_unit
                                      ),
                                      "cpu_avg_time": format_time(
                                          event.avg_cpu_time, time_unit
                                      ),
                                      "cpu_max_time": format_time(
                                          event.max_cpu_time, time_unit
                                      ),
                                      "cpu_min_time": format_time(
                                          event.min_cpu_time, time_unit
                                      ),
                                      "cpu_ratio": format_ratio(
                                          event.cpu_time
                                          / total_cpu_time
                                          if total_cpu_time != 0
                                          else 0.0
                                      ),
                                      "gpu_total_time": format_time(
                                          event.general_gpu_time,
                                          time_unit,
                                      ),
                                      "gpu_avg_time": format_time(
                                          event.avg_general_gpu_time,
                                          time_unit,
                                      ),
                                      "gpu_max_time": format_time(
                                          event.max_general_gpu_time,
                                          time_unit,
                                      ),
                                      "gpu_min_time": format_time(
                                          event.min_general_gpu_time,
                                          time_unit,
                                      ),
                                      "gpu_ratio": format_ratio(
                                          event.general_gpu_time
                                          / total_gpu_time
                                          if total_gpu_time != 0
                                          else 0.0
                                      ),
                                  }
                              )
                      else:
                          children_events = get_children_data(event)
                          if children_events:
                              data["events"].append(
                                  {
                                      "name": op_name,
                                      "calls": event.call,
                                      "children": get_children_data(
                                          event
                                      ),
                                      "input_shape": shape_string,
                                      "cpu_total_time": format_time(
                                          event.cpu_time, time_unit
                                      ),
                                      "cpu_avg_time": format_time(
                                          event.avg_cpu_time, time_unit
                                      ),
                                      "cpu_max_time": format_time(
                                          event.max_cpu_time, time_unit
                                      ),
                                      "cpu_min_time": format_time(
                                          event.min_cpu_time, time_unit
                                      ),
                                      "cpu_ratio": format_ratio(
                                          event.cpu_time
                                          / total_cpu_time
                                          if total_cpu_time != 0
                                          else 0.0
                                      ),
                                  }
                              )
                          else:
                              data["events"].append(
                                  {
                                      "name": op_name,
                                      "calls": event.call,
                                      "input_shape": shape_string,
                                      "cpu_total_time": format_time(
                                          event.cpu_time, time_unit
                                      ),
                                      "cpu_avg_time": format_time(
                                          event.avg_cpu_time, time_unit
                                      ),
                                      "cpu_max_time": format_time(
                                          event.max_cpu_time, time_unit
                                      ),
                                      "cpu_min_time": format_time(
                                          event.min_cpu_time, time_unit
                                      ),
                                      "cpu_ratio": format_ratio(
                                          event.cpu_time
                                          / total_cpu_time
                                          if total_cpu_time != 0
                                          else 0.0
                                      ),
                                  }
                              )
      return data
  
imports: from collections import defaultdict
  from collections import OrderedDict
  from .parser.distributed_parser import DistributedParser
  from .parser.kernel_parser import KernelParser
  from .parser.memory_parser import MemoryParser
  from .parser.operator_parser import OperatorParser
  from .parser.overview_parser import CPUType
  from .parser.overview_parser import GPUType
  from .parser.overview_parser import OverviewParser
  from .parser.trace_parser import TraceParser
  from .parser.utils import format_float
  from .parser.utils import format_memory
  from .parser.utils import format_ratio
  from .parser.utils import format_time
  from .parser.utils import traverse_tree
label_desc: Use image node_id 11 for calling the ProfilerData obj's underlying member method code with example usage: obj.get_operator_table(group_by, search_name, time_unit) and returns: data, datas