code: def read_orc(
      filepath_or_buffer,
      engine="cudf",
      columns=None,
      filters=None,
      stripes=None,
      skiprows=None,
      num_rows=None,
      use_index=True,
      timestamp_type=None,
      use_python_file_object=True,
      storage_options=None,
      bytes_per_thread=None,
  ):
      """{docstring}"""
      from cudf import DataFrame
  
      if skiprows is not None:
          # Do not remove until cuIO team approves its removal.
          warnings.warn(
              "skiprows is deprecated and will be removed.",
              FutureWarning,
          )
  
      if num_rows is not None:
          # Do not remove until cuIO team approves its removal.
          warnings.warn(
              "num_rows is deprecated and will be removed.",
              FutureWarning,
          )
  
      # Multiple sources are passed as a list. If a single source is passed,
      # wrap it in a list for unified processing downstream.
      if not is_list_like(filepath_or_buffer):
          filepath_or_buffer = [filepath_or_buffer]
  
      # Each source must have a correlating stripe list. If a single stripe list
      # is provided rather than a list of list of stripes then extrapolate that
      # stripe list across all input sources
      if stripes is not None:
          if any(not isinstance(stripe, list) for stripe in stripes):
              stripes = [stripes]
  
          # Must ensure a stripe for each source is specified, unless None
          if not len(stripes) == len(filepath_or_buffer):
              raise ValueError(
                  "A list of stripes must be provided for each input source"
              )
  
      filepaths_or_buffers = []
      for source in filepath_or_buffer:
          if ioutils.is_directory(
              path_or_data=source, storage_options=storage_options
          ):
              fs = ioutils._ensure_filesystem(
                  passed_filesystem=None,
                  path=source,
                  storage_options=storage_options,
              )
              source = stringify_path(source)
              source = fs.sep.join([source, "*.orc"])
  
          (
              tmp_source,
              compression,
          ) = ioutils.get_reader_filepath_or_buffer(
              path_or_data=source,
              compression=None,
              use_python_file_object=use_python_file_object,
              storage_options=storage_options,
              bytes_per_thread=bytes_per_thread,
          )
          if compression is not None:
              raise ValueError(
                  "URL content-encoding decompression is not supported"
              )
          if isinstance(tmp_source, list):
              filepaths_or_buffers.extend(tmp_source)
          else:
              filepaths_or_buffers.append(tmp_source)
  
      if filters is not None:
          selected_stripes = _filter_stripes(
              filters, filepaths_or_buffers, stripes, skiprows, num_rows
          )
  
          # Return empty if everything was filtered
          if len(selected_stripes) == 0:
              return _make_empty_df(filepaths_or_buffers[0], columns)
          else:
              stripes = selected_stripes
  
      if engine == "cudf":
          return DataFrame._from_data(
              *liborc.read_orc(
                  filepaths_or_buffers,
                  columns,
                  stripes,
                  skiprows,
                  num_rows,
                  use_index,
                  timestamp_type,
              )
          )
      else:
          from pyarrow import orc
  
          def read_orc_stripe(orc_file, stripe, columns):
              pa_table = orc_file.read_stripe(stripe, columns)
              if isinstance(pa_table, pa.RecordBatch):
                  pa_table = pa.Table.from_batches([pa_table])
              return pa_table
  
          warnings.warn("Using CPU via PyArrow to read ORC dataset.")
          if len(filepath_or_buffer) > 1:
              raise NotImplementedError(
                  "Using CPU via PyArrow only supports a single a "
                  "single input source"
              )
  
          orc_file = orc.ORCFile(filepath_or_buffer[0])
          if stripes is not None and len(stripes) > 0:
              for stripe_source_file in stripes:
                  pa_tables = [
                      read_orc_stripe(orc_file, i, columns)
                      for i in stripe_source_file
                  ]
                  pa_table = pa.concat_tables(pa_tables)
          else:
              pa_table = orc_file.read(columns=columns)
          df = cudf.DataFrame.from_arrow(pa_table)
  
      return df
  
file_path: cudf/python/cudf/cudf/io/orc.py
imports: import datetime
  import warnings
  import pyarrow
  from fsspec.utils import stringify_path
  import cudf
  from cudf._lib import orc
  from cudf.api.types import is_list_like
  from cudf.utils import ioutils
  from cudf.utils.metadata import orc_column_statistics_pb2
label_desc: Use image node_id 6 for calling a global function with example usage: read_orc(filepath_or_buffer, engine, columns, filters, stripes, skiprows, num_rows, use_index, timestamp_type, use_python_file_object, storage_options, bytes_per_thread) and returns: df, DataFrame, _make_empty_df, pa_table