code: def read_parquet(
      path: FilePath | ReadBuffer[bytes],
      engine: str = "auto",
      columns: list[str] | None = None,
      storage_options: StorageOptions | None = None,
      use_nullable_dtypes: bool | lib.NoDefault = lib.no_default,
      dtype_backend: DtypeBackend | lib.NoDefault = lib.no_default,
      filesystem: Any = None,
      filters: list[tuple] | list[list[tuple]] | None = None,
      **kwargs,
  ) -> DataFrame:
      """
      Load a parquet 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,
          gs, and file. For file URLs, a host is expected. A local file could be:
          ``file://localhost/path/to/table.parquet``.
          A file URL can also be a path to a directory that contains multiple
          partitioned parquet files. Both pyarrow and fastparquet support
          paths to directories as well as file URLs. A directory path could be:
          ``file://localhost/path/to/tables`` or ``s3://bucket/partition_dir``.
      engine : {{'auto', 'pyarrow', 'fastparquet'}}, default 'auto'
          Parquet library to use. If 'auto', then the option
          ``io.parquet.engine`` is used. The default ``io.parquet.engine``
          behavior is to try 'pyarrow', falling back to 'fastparquet' if
          'pyarrow' is unavailable.
  
          When using the ``'pyarrow'`` engine and no storage options are provided
          and a filesystem is implemented by both ``pyarrow.fs`` and ``fsspec``
          (e.g. "s3://"), then the ``pyarrow.fs`` filesystem is attempted first.
          Use the filesystem keyword with an instantiated fsspec filesystem
          if you wish to use its implementation.
      columns : list, default=None
          If not None, only these columns will be read from the file.
      {storage_options}
  
          .. versionadded:: 1.3.0
  
      use_nullable_dtypes : bool, default False
          If True, use dtypes that use ``pd.NA`` as missing value indicator
          for the resulting DataFrame. (only applicable for the ``pyarrow``
          engine)
          As new dtypes are added that support ``pd.NA`` in the future, the
          output with this option will change to use those dtypes.
          Note: this is an experimental option, and behaviour (e.g. additional
          support dtypes) may change without notice.
  
          .. deprecated:: 2.0
  
      dtype_backend : {{'numpy_nullable', 'pyarrow'}}, default 'numpy_nullable'
          Back-end data type applied to the resultant :class:`DataFrame`
          (still experimental). Behaviour is as follows:
  
          * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
            (default).
          * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
            DataFrame.
  
          .. versionadded:: 2.0
  
      filesystem : fsspec or pyarrow filesystem, default None
          Filesystem object to use when reading the parquet file. Only implemented
          for ``engine="pyarrow"``.
  
          .. versionadded:: 2.1.0
  
      filters : List[Tuple] or List[List[Tuple]], default None
          To filter out data.
          Filter syntax: [[(column, op, val), ...],...]
          where op is [==, =, >, >=, <, <=, !=, in, not in]
          The innermost tuples are transposed into a set of filters applied
          through an `AND` operation.
          The outer list combines these sets of filters through an `OR`
          operation.
          A single list of tuples can also be used, meaning that no `OR`
          operation between set of filters is to be conducted.
  
          Using this argument will NOT result in row-wise filtering of the final
          partitions unless ``engine="pyarrow"`` is also specified.  For
          other engines, filtering is only performed at the partition level, that is,
          to prevent the loading of some row-groups and/or files.
  
          .. versionadded:: 2.1.0
  
      **kwargs
          Any additional kwargs are passed to the engine.
  
      Returns
      -------
      DataFrame
  
      See Also
      --------
      DataFrame.to_parquet : Create a parquet object that serializes a DataFrame.
  
      Examples
      --------
      >>> original_df = pd.DataFrame(
      ...     {{"foo": range(5), "bar": range(5, 10)}}
      ...    )
      >>> original_df
         foo  bar
      0    0    5
      1    1    6
      2    2    7
      3    3    8
      4    4    9
      >>> df_parquet_bytes = original_df.to_parquet()
      >>> from io import BytesIO
      >>> restored_df = pd.read_parquet(BytesIO(df_parquet_bytes))
      >>> restored_df
         foo  bar
      0    0    5
      1    1    6
      2    2    7
      3    3    8
      4    4    9
      >>> restored_df.equals(original_df)
      True
      >>> restored_bar = pd.read_parquet(BytesIO(df_parquet_bytes), columns=["bar"])
      >>> restored_bar
          bar
      0    5
      1    6
      2    7
      3    8
      4    9
      >>> restored_bar.equals(original_df[['bar']])
      True
  
      The function uses `kwargs` that are passed directly to the engine.
      In the following example, we use the `filters` argument of the pyarrow
      engine to filter the rows of the DataFrame.
  
      Since `pyarrow` is the default engine, we can omit the `engine` argument.
      Note that the `filters` argument is implemented by the `pyarrow` engine,
      which can benefit from multithreading and also potentially be more
      economical in terms of memory.
  
      >>> sel = [("foo", ">", 2)]
      >>> restored_part = pd.read_parquet(BytesIO(df_parquet_bytes), filters=sel)
      >>> restored_part
          foo  bar
      0    3    8
      1    4    9
      """
  
      impl = get_engine(engine)
  
      if use_nullable_dtypes is not lib.no_default:
          msg = (
              "The argument 'use_nullable_dtypes' is deprecated and will be removed "
              "in a future version."
          )
          if use_nullable_dtypes is True:
              msg += "Use dtype_backend='numpy_nullable' instead of use_nullable_dtype=True."
          warnings.warn(
              msg, FutureWarning, stacklevel=find_stack_level()
          )
      else:
          use_nullable_dtypes = False
      check_dtype_backend(dtype_backend)
  
      return impl.read(
          path,
          columns=columns,
          filters=filters,
          storage_options=storage_options,
          use_nullable_dtypes=use_nullable_dtypes,
          dtype_backend=dtype_backend,
          filesystem=filesystem,
          **kwargs,
      )
  
imports: from __future__ import annotations
  import io
  import json
  import os
  from typing import TYPE_CHECKING, Any, Literal
  import warnings
  from warnings import catch_warnings
  from pandas._config import using_pyarrow_string_dtype
  from pandas._config.config import _get_option
  from pandas._libs import lib
  from pandas.compat._optional import import_optional_dependency
  from pandas.errors import AbstractMethodError
  from pandas.util._decorators import doc
  from pandas.util._exceptions import find_stack_level
  from pandas.util._validators import check_dtype_backend
  import pandas
  from pandas import DataFrame, get_option
  from pandas.core.shared_docs import _shared_docs
  from pandas.io._util import arrow_string_types_mapper
  from pandas.io.common import IOHandles, get_handle, is_fsspec_url, is_url, stringify_path
label_desc: Use image node_id 4 for calling a global function with example usage: read_parquet(path, engine, columns, storage_options, use_nullable_dtypes, dtype_backend, filesystem, filters) and returns: impl