code: def set_index_columns(meta, index, columns, auto_index_allowed):
      """Handle index/column arguments, and modify `meta`
      Used in read_parquet.
      """
      ignore_index_column_intersection = False
      if columns is None:
          # User didn't specify columns, so ignore any intersection
          # of auto-detected values with the index (if necessary)
          ignore_index_column_intersection = True
          # Do not allow "un-named" fields to be read in as columns.
          # These were intended to be un-named indices at write time.
          _index = index or []
          columns = [
              c
              for c in meta.columns
              if c not in (None, NONE_LABEL) or c in _index
          ]
  
      if not set(columns).issubset(set(meta.columns)):
          raise ValueError(
              "The following columns were not found in the dataset %s\n"
              "The following columns were found %s"
              % (set(columns) - set(meta.columns), meta.columns)
          )
  
      if index:
          if isinstance(index, str):
              index = [index]
          if isinstance(columns, str):
              columns = [columns]
  
          if ignore_index_column_intersection:
              columns = [col for col in columns if col not in index]
          if set(index).intersection(columns):
              if auto_index_allowed:
                  raise ValueError(
                      "Specified index and column arguments must not intersect"
                      " (set index=False or remove the detected index from columns).\n"
                      "index: {} | column: {}".format(index, columns)
                  )
              else:
                  raise ValueError(
                      "Specified index and column arguments must not intersect.\n"
                      "index: {} | column: {}".format(index, columns)
                  )
  
      return meta[list(columns)], index, columns
  
imports: from __future__ import annotations
  import contextlib
  import math
  import warnings
  from typing import Literal
  import pandas
  import tlz
  from fsspec.core import get_fs_token_paths
  from fsspec.utils import stringify_path
  import dask
  from dask.base import tokenize
  from dask.blockwise import BlockIndex
  from dask.dataframe.backends import dataframe_creation_dispatch
  from dask.dataframe.core import DataFrame, Scalar
  from dask.dataframe.io.io import from_map
  from dask.dataframe.io.parquet.utils import Engine, _sort_and_analyze_paths, _split_user_options
  from dask.dataframe.io.utils import DataFrameIOFunction, _is_local_fs
  from dask.dataframe.methods import concat
  from dask.delayed import Delayed
  from dask.highlevelgraph import HighLevelGraph
  from dask.layers import DataFrameIOLayer
  from dask.utils import apply, import_required, natural_sort_key, parse_bytes
label_desc: Use image node_id 10 for calling a global function with example usage: set_index_columns(meta, index, columns, auto_index_allowed) and returns: meta,  index,  columns