code: def _new_tileables(
      self, inputs: List[TileableType], kws: List[dict] = None, **kw
  ) -> List[TileableType]:
      output_limit = kw.pop("output_limit", None)
      if output_limit is None:
          output_limit = getattr(self, "output_limit")
  
      self._set_inputs(inputs)
      if self.gpu is None:
          self.gpu = self._check_if_gpu(self._inputs)
      if getattr(self, "_key", None) is None:
          self._update_key()  # update key when inputs are set
  
      tileables = []
      for j in range(output_limit):
          create_tensor_kw = kw.copy()
          if kws:
              create_tensor_kw.update(kws[j])
          tileable = self._create_tileable(j, **create_tensor_kw)
          tileables.append(tileable)
  
      self.outputs = tileables
      if len(tileables) > 1:
          # for each output tileable, hold the reference to the other outputs
          # so that either no one or everyone are gc collected
          for j, t in enumerate(tileables):
              t.data._siblings = [
                  tileable.data
                  for tileable in tileables[:j] + tileables[j + 1 :]
              ]
      return tileables
  
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 10 for calling the TileableOperandMixin obj's underlying member method code with example usage: obj._new_tileables(inputs, kws) and returns: tileables