code: def read_orc(
      path: FilePath | ReadBuffer[bytes],
      columns: list[str] | None = None,
      dtype_backend: DtypeBackend | lib.NoDefault = lib.no_default,
      **kwargs,
  ) -> DataFrame:
      """
      Load an ORC object from the file path, returning a DataFrame.
  
      Parameters
      ----------
      path : str, path object, or file-like object
          String, path object (implementing ``os.PathLike[str]``), or file-like
          object implementing a binary ``read()`` function. The string could be a URL.
          Valid URL schemes include http, ftp, s3, and file. For file URLs, a host is
          expected. A local file could be:
          ``file://localhost/path/to/table.orc``.
      columns : list, default None
          If not None, only these columns will be read from the file.
          Output always follows the ordering of the file and not the columns list.
          This mirrors the original behaviour of
          :external+pyarrow:py:meth:`pyarrow.orc.ORCFile.read`.
      dtype_backend : {"numpy_nullable", "pyarrow"}, defaults to NumPy backed DataFrames
          Which dtype_backend to use, e.g. whether a DataFrame should have NumPy
          arrays, nullable dtypes are used for all dtypes that have a nullable
          implementation when "numpy_nullable" is set, pyarrow is used for all
          dtypes if "pyarrow" is set.
  
          The dtype_backends are still experimential.
  
          .. versionadded:: 2.0
  
      **kwargs
          Any additional kwargs are passed to pyarrow.
  
      Returns
      -------
      DataFrame
  
      Notes
      -----
      Before using this function you should read the :ref:`user guide about ORC <io.orc>`
      and :ref:`install optional dependencies <install.warn_orc>`.
      """
      # we require a newer version of pyarrow than we support for parquet
  
      orc = import_optional_dependency("pyarrow.orc")
  
      check_dtype_backend(dtype_backend)
  
      with get_handle(path, "rb", is_text=False) as handles:
          orc_file = orc.ORCFile(handles.handle)
          pa_table = orc_file.read(columns=columns, **kwargs)
      if dtype_backend is not lib.no_default:
          if dtype_backend == "pyarrow":
              df = pa_table.to_pandas(types_mapper=pd.ArrowDtype)
          else:
              from pandas.io._util import _arrow_dtype_mapping
  
              mapping = _arrow_dtype_mapping()
              df = pa_table.to_pandas(types_mapper=mapping.get)
          return df
      else:
          return pa_table.to_pandas()
  
file_path: catboost/contrib/python/pandas/py3/pandas/io/orc.py
imports: from __future__ import annotations
  import io
  from types import ModuleType
  from typing import Any, Literal
  from pandas._libs import lib
  from pandas._typing import DtypeBackend, FilePath, ReadBuffer, WriteBuffer
  from pandas.compat._optional import import_optional_dependency
  from pandas.util._validators import check_dtype_backend
  from pandas.core.dtypes.common import is_categorical_dtype, is_interval_dtype, is_period_dtype, is_unsigned_integer_dtype
  import pandas
  from pandas.core.frame import DataFrame
  from pandas.io.common import get_handle
label_desc: Use image node_id 1 for calling a global function with example usage: read_orc(path, columns, dtype_backend) and returns: df, pa_table