code: def _tile(
      self,
      chunk_graph: ChunkGraph,
      tileable: TileableType,
      tile_handler: tile_gen_type,
      next_tileable_handlers: List[_TileableHandler],
      to_update_tileables: List[TileableType],
      visited: Set[EntityType],
  ):
      try:
          need_process = next(tile_handler)
  
          if isinstance(need_process, TileStatus):
              # process tile that returns progress
              self._tile_context.set_progress(
                  tileable, need_process.progress
              )
              need_process = need_process.entities
          else:
              # if progress not specified, we just update 0.4 * rest progress
              progress = self._tile_context.get_progress(tileable)
              new_progress = (
                  progress + (1.0 - progress) * DEFAULT_UPDATED_PROGRESS
              )
              self._tile_context.set_progress(tileable, new_progress)
  
          chunks = []
          if need_process is not None:
              for t in need_process:
                  if isinstance(t, CHUNK_TYPE):
                      chunks.append(self._get_data(t))
                  elif isinstance(t, TILEABLE_TYPE):
                      to_update_tileables.append(self._get_data(t))
          # not finished yet
          self._add_nodes(chunk_graph, chunks.copy(), visited, tileable)
          next_tileable_handlers.append(
              _TileableHandler(tileable, tile_handler, need_process)
          )
          # add intermediate chunks into result chunks
          # to prevent them being pruned
          chunk_graph.result_chunks.extend(
              c for c in chunks if c in chunk_graph
          )
      except StopIteration as e:
          # tile done
          tiled_tileables = e.value
          for out, tiled_tileable in zip(
              tileable.op.outputs, tiled_tileables
          ):
              out = self._get_data(out)
              tiled_tileable = self._get_data(tiled_tileable)
  
              chunks = tiled_tileable.chunks
              if chunks is None:  # pragma: no cover
                  raise ValueError(
                      f"tileable({out}) is still coarse after tile"
                  )
              chunks = [self._get_data(c) for c in chunks]
              self._tile_context[out] = tiled_tileable
              self._add_nodes(chunk_graph, chunks, visited, tileable)
  
imports: import dataclasses
  import functools
  from typing import Callable, Dict, Generator, Iterable, List, Optional, Set, Type, Union
  from ....core import FUSE_CHUNK_TYPE, CHUNK_TYPE, TILEABLE_TYPE
  from ....typing import EntityType, TileableType, ChunkType
  from ....utils import copy_tileables, build_fetch
  from ...entity.tileables import handler
  from ...mode import enter_mode
  from ..entity import TileableGraph, ChunkGraph
  from .base import AbstractGraphBuilder
label_desc: Use image node_id 6 for calling the Tiler obj's underlying member method code with example usage: obj._tile(chunk_graph, tileable, tile_handler, next_tileable_handlers, to_update_tileables, visited) without return types