code: def dataframe_from_1d_tileables(
      d: Dict[Any, TileableType],
      index: Union[TileableType, pd.Index, list] = None,
      columns: Union[pd.Index, list] = None,
      gpu: bool = None,
      sparse: bool = False,
  ):
      data = dict()
      for k, v in d.items():
          if isinstance(v, (list, tuple)) and any(
              isinstance(sv, ENTITY_TYPE) for sv in v
          ):
              data[k] = astensor(v)
          else:
              data[k] = v
      d = data
      if columns is not None:
          tileables = [d.get(c) for c in columns]
      else:
          columns = list(d.keys())
          tileables = list(d.values())
  
      gpu = (
          next((t.op.gpu for t in tileables if hasattr(t, "op")), False)
          if gpu is None
          else gpu
      )
      dtypes = pd.Series(
          [
              t.dtype if hasattr(t, "dtype") else pd.Series(t).dtype
              for t in tileables
          ],
          index=columns,
      )
      if index is not None and not isinstance(index, ENTITY_TYPE):
          index = pd.Index(index)
      op = DataFrameFromTensor(
          input=d, index=index, columns=columns, gpu=gpu, sparse=sparse
      )
      return op(d, index, columns, dtypes)
  
imports: from collections import OrderedDict
  from typing import Any, Dict, List, Union
  import numpy
  import pandas
  from ...None import opcodes
  from ...core import ENTITY_TYPE, OutputType, recursive_tile
  from ...core.context import Context
  from ...serialization.serializables import KeyField, AnyField
  from ...tensor.core import Tensor
  from ...tensor.datasource import tensor
  from ...tensor.utils import unify_chunks
  from ...typing import EntityType, TileableType
  from ...utils import has_unknown_shape
  from ..core import INDEX_TYPE, SERIES_TYPE
  from ..operands import DataFrameOperand, DataFrameOperandMixin
  from ..utils import parse_index
label_desc: Use image node_id 2 for calling a global function with example usage: dataframe_from_1d_tileables(d, index, columns, gpu, sparse) and returns: op