code: def _new_chunks(
      self, inputs: List[ChunkType], kws: List[Dict] = None, **kw
  ) -> List[ChunkType]:
      output_limit = kw.pop("output_limit", None)
      if output_limit is None:
          output_limit = self.output_limit
      if isinstance(output_limit, float) and kws:
          output_limit = len(kws)
  
      self.check_inputs(inputs)
      self._set_inputs(inputs)
      if self.gpu is None:
          self.gpu = self._check_if_gpu(self._inputs)
      if self._key is None:
          self._update_key()
  
      chunks = []
      for j in range(output_limit):
          create_chunk_kw = kw.copy()
          if kws:
              create_chunk_kw.update(kws[j])
          index = create_chunk_kw.pop("index", None)
          chunk = self._create_chunk(j, index, **create_chunk_kw)
          chunks.append(chunk)
  
      self.outputs = chunks
      if len(chunks) > 1:
          # for each output chunk, hold the reference to the other outputs
          # so that either no one or everyone are gc collected
          for j, t in enumerate(chunks):
              t.data._siblings = [
                  c.data for c in chunks[:j] + chunks[j + 1 :]
              ]
      return chunks
  
imports: import sys
  from typing import Any, Callable, Dict, List, Tuple, Type, Union
  import numpy
  from ...metrics import Metrics
  from ...typing import TileableType, ChunkType, OperandType
  from ...utils import calc_data_size
  from ..context import Context
  from ..mode import is_eager_mode
  from ..entity import OutputType, ExecutableTuple, get_chunk_types, get_tileable_types, get_output_types, get_fetch_class
label_desc: Use image node_id 5 for calling the TileableOperandMixin obj's underlying member method code with example usage: obj._new_chunks(inputs, kws) and returns: chunks