class_docstr: The context for tiling.
code: def get_chunks_meta(
      self,
      data_keys: List[str],
      fields: List[str] = None,
      error="raise",
  ) -> List[Dict]:
      if not self._task_chunks_meta:
          result = self._call(
              self._get_chunks_meta_from_service(
                  data_keys, fields=fields, error=error
              )
          )
      else:
          result = [{}] * len(data_keys)
          missing_key_indexes = []
          missing_keys = []
          for idx, key in enumerate(data_keys):
              try:
                  chunk_meta = self._task_chunks_meta[key]
              except KeyError:
                  missing_key_indexes.append(idx)
                  missing_keys.append(key)
              else:
                  meta = asdict(chunk_meta)
                  meta = {f: meta.get(f) for f in fields}
                  result[idx] = meta
          if missing_keys:
              missing_meta = self._call(
                  self._get_chunks_meta_from_service(
                      missing_keys, fields=fields, error=error
                  )
              )
              for idx, meta in zip(missing_key_indexes, missing_meta):
                  result[idx] = meta
      return result
  
imports: import logging
  from dataclasses import asdict
  from typing import Dict, List, Callable
  from .....core.context import Context
  from .....storage.base import StorageLevel
  from .....typing import ChunkType
  from .....utils import implements, lazy_import, sync_to_async
  from ....context import ThreadedServiceContext
  from .config import RayExecutionConfig
label_desc: Use image node_id 3 for calling the RayExecutionContext obj's underlying member method code with example usage: obj.get_chunks_meta(data_keys, fields, error) and returns: result