code: def _read_parquet(path, columns=None, storage_options=None, **kwargs):
      """
      Load a Parquet object from the file path, returning a GeoDataFrame.
  
      You can read a subset of columns in the file using the ``columns`` parameter.
      However, the structure of the returned GeoDataFrame will depend on which
      columns you read:
  
      * if no geometry columns are read, this will raise a ``ValueError`` - you
        should use the pandas `read_parquet` method instead.
      * if the primary geometry column saved to this file is not included in
        columns, the first available geometry column will be set as the geometry
        column of the returned GeoDataFrame.
  
      Supports versions 0.1.0, 0.4.0 and 1.0.0 of the GeoParquet
      specification at: https://github.com/opengeospatial/geoparquet
  
      If 'crs' key is not present in the GeoParquet metadata associated with the
      Parquet object, it will default to "OGC:CRS84" according to the specification.
  
      Requires 'pyarrow'.
  
      .. versionadded:: 0.8
  
      Parameters
      ----------
      path : str, path object
      columns : list-like of strings, default=None
          If not None, only these columns will be read from the file.  If
          the primary geometry column is not included, the first secondary
          geometry read from the file will be set as the geometry column
          of the returned GeoDataFrame.  If no geometry columns are present,
          a ``ValueError`` will be raised.
      storage_options : dict, optional
          Extra options that make sense for a particular storage connection, e.g. host,
          port, username, password, etc. For HTTP(S) URLs the key-value pairs are
          forwarded to urllib as header options. For other URLs (e.g. starting with
          "s3://", and "gcs://") the key-value pairs are forwarded to fsspec. Please
          see fsspec and urllib for more details.
  
          When 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 preferred. Provide the instantiated fsspec filesystem using
          the ``filesystem`` keyword if you wish to use its implementation.
      **kwargs
          Any additional kwargs passed to pyarrow.parquet.read_table().
  
      Returns
      -------
      GeoDataFrame
  
      Examples
      --------
      >>> df = geopandas.read_parquet("data.parquet")  # doctest: +SKIP
  
      Specifying columns to read:
  
      >>> df = geopandas.read_parquet(
      ...     "data.parquet",
      ...     columns=["geometry", "pop_est"]
      ... )  # doctest: +SKIP
      """
  
      parquet = import_optional_dependency(
          "pyarrow.parquet",
          extra="pyarrow is required for Parquet support.",
      )
      import geopandas.io._pyarrow_hotfix  # noqa: F401
  
      # TODO(https://github.com/pandas-dev/pandas/pull/41194): see if pandas
      # adds filesystem as a keyword and match that.
      filesystem = kwargs.pop("filesystem", None)
      filesystem, path = _get_filesystem_path(
          path, filesystem=filesystem, storage_options=storage_options
      )
  
      path = _expand_user(path)
      kwargs["use_pandas_metadata"] = True
      table = parquet.read_table(
          path, columns=columns, filesystem=filesystem, **kwargs
      )
  
      # read metadata separately to get the raw Parquet FileMetaData metadata
      # (pyarrow doesn't properly exposes those in schema.metadata for files
      # created by GDAL - https://issues.apache.org/jira/browse/ARROW-16688)
      metadata = None
      if (
          table.schema.metadata is None
          or b"geo" not in table.schema.metadata
      ):
          try:
              # read_metadata does not accept a filesystem keyword, so need to
              # handle this manually (https://issues.apache.org/jira/browse/ARROW-16719)
              if filesystem is not None:
                  pa_filesystem = _ensure_arrow_fs(filesystem)
                  with pa_filesystem.open_input_file(path) as source:
                      metadata = parquet.read_metadata(source).metadata
              else:
                  metadata = parquet.read_metadata(path).metadata
          except Exception:
              pass
  
      return _arrow_to_geopandas(table, metadata)
  
imports: from packaging.version import Version
  import json
  import warnings
  import numpy
  from pandas import DataFrame, Series
  from geopandas._compat import import_optional_dependency
  from geopandas.array import from_wkb
  from geopandas import GeoDataFrame
  import geopandas
  from .file import _expand_user
label_desc: Use image node_id 14 for calling a global function with example usage: _read_parquet(path, columns, storage_options) and returns: _arrow_to_geopandas