code: def from_array(x, chunksize=50000, columns=None, meta=None):
      """Read any sliceable array into a Dask Dataframe
  
      Uses getitem syntax to pull slices out of the array.  The array need not be
      a NumPy array but must support slicing syntax
  
          x[50000:100000]
  
      and have 2 dimensions:
  
          x.ndim == 2
  
      or have a record dtype:
  
          x.dtype == [('name', 'O'), ('balance', 'i8')]
  
      Parameters
      ----------
      x : array_like
      chunksize : int, optional
          The number of rows per partition to use.
      columns : list or string, optional
          list of column names if DataFrame, single string if Series
      meta : object, optional
          An optional `meta` parameter can be passed for dask
          to specify the concrete dataframe type to use for partitions of
          the Dask dataframe. By default, pandas DataFrame is used.
  
      Returns
      -------
      dask.DataFrame or dask.Series
          A dask DataFrame/Series
      """
      if isinstance(x, da.Array):
          return from_dask_array(x, columns=columns, meta=meta)
  
      meta = _meta_from_array(x, columns, meta=meta)
  
      divisions = tuple(range(0, len(x), chunksize))
      divisions = divisions + (len(x) - 1,)
      token = tokenize(x, chunksize, columns)
      name = "from_array-" + token
  
      dsk = {}
      for i in range(0, int(ceil(len(x) / chunksize))):
          data = (getitem, x, slice(i * chunksize, (i + 1) * chunksize))
          if is_series_like(meta):
              dsk[name, i] = (
                  type(meta),
                  data,
                  None,
                  meta.dtype,
                  meta.name,
              )
          else:
              dsk[name, i] = (type(meta), data, None, meta.columns)
      return new_dd_object(dsk, name, meta, divisions)
  
imports: from __future__ import annotations
  from collections.abc import Iterable
  from functools import partial
  from math import ceil
  from operator import getitem
  from threading import Lock
  from typing import TYPE_CHECKING, Literal, overload
  import numpy
  import pandas
  import dask.array
  from dask.base import is_dask_collection, tokenize
  from dask.blockwise import BlockwiseDepDict, blockwise
  from dask.dataframe._compat import is_any_real_numeric_dtype
  from dask.dataframe.backends import dataframe_creation_dispatch
  from dask.dataframe.core import DataFrame, Index, Series, _concat, _emulate, _Frame, apply_and_enforce, has_parallel_type, new_dd_object
  from dask.dataframe.dispatch import meta_lib_from_array
  from dask.dataframe.io.utils import DataFrameIOFunction
  from dask.dataframe.utils import check_meta, insert_meta_param_description, is_series_like, make_meta
  from dask.delayed import Delayed, delayed
  from dask.highlevelgraph import HighLevelGraph
  from dask.layers import DataFrameIOLayer
  from dask.utils import M, funcname, is_arraylike
label_desc: Use image node_id 2 for calling a global function with example usage: from_array(x, chunksize, columns, meta) and returns: new_dd_object, from_dask_array