code: def read_html(
      io: FilePath | ReadBuffer[str],
      *,
      match: str | Pattern = ".+",
      flavor: str | None = None,
      header: int | Sequence[int] | None = None,
      index_col: int | Sequence[int] | None = None,
      skiprows: int | Sequence[int] | slice | None = None,
      attrs: dict[str, str] | None = None,
      parse_dates: bool = False,
      thousands: str | None = ",",
      encoding: str | None = None,
      decimal: str = ".",
      converters: dict | None = None,
      na_values: Iterable[object] | None = None,
      keep_default_na: bool = True,
      displayed_only: bool = True,
      extract_links: Literal[
          None, "header", "footer", "body", "all"
      ] = None,
      dtype_backend: DtypeBackend | lib.NoDefault = lib.no_default,
  ) -> list[DataFrame]:
      r"""
      Read HTML tables into a ``list`` of ``DataFrame`` objects.
  
      Parameters
      ----------
      io : str, path object, or file-like object
          String, path object (implementing ``os.PathLike[str]``), or file-like
          object implementing a string ``read()`` function.
          The string can represent a URL or the HTML itself. Note that
          lxml only accepts the http, ftp and file url protocols. If you have a
          URL that starts with ``'https'`` you might try removing the ``'s'``.
  
      match : str or compiled regular expression, optional
          The set of tables containing text matching this regex or string will be
          returned. Unless the HTML is extremely simple you will probably need to
          pass a non-empty string here. Defaults to '.+' (match any non-empty
          string). The default value will return all tables contained on a page.
          This value is converted to a regular expression so that there is
          consistent behavior between Beautiful Soup and lxml.
  
      flavor : str, optional
          The parsing engine to use. 'bs4' and 'html5lib' are synonymous with
          each other, they are both there for backwards compatibility. The
          default of ``None`` tries to use ``lxml`` to parse and if that fails it
          falls back on ``bs4`` + ``html5lib``.
  
      header : int or list-like, optional
          The row (or list of rows for a :class:`~pandas.MultiIndex`) to use to
          make the columns headers.
  
      index_col : int or list-like, optional
          The column (or list of columns) to use to create the index.
  
      skiprows : int, list-like or slice, optional
          Number of rows to skip after parsing the column integer. 0-based. If a
          sequence of integers or a slice is given, will skip the rows indexed by
          that sequence.  Note that a single element sequence means 'skip the nth
          row' whereas an integer means 'skip n rows'.
  
      attrs : dict, optional
          This is a dictionary of attributes that you can pass to use to identify
          the table in the HTML. These are not checked for validity before being
          passed to lxml or Beautiful Soup. However, these attributes must be
          valid HTML table attributes to work correctly. For example, ::
  
              attrs = {'id': 'table'}
  
          is a valid attribute dictionary because the 'id' HTML tag attribute is
          a valid HTML attribute for *any* HTML tag as per `this document
          <https://html.spec.whatwg.org/multipage/dom.html#global-attributes>`__. ::
  
              attrs = {'asdf': 'table'}
  
          is *not* a valid attribute dictionary because 'asdf' is not a valid
          HTML attribute even if it is a valid XML attribute.  Valid HTML 4.01
          table attributes can be found `here
          <http://www.w3.org/TR/REC-html40/struct/tables.html#h-11.2>`__. A
          working draft of the HTML 5 spec can be found `here
          <https://html.spec.whatwg.org/multipage/tables.html>`__. It contains the
          latest information on table attributes for the modern web.
  
      parse_dates : bool, optional
          See :func:`~read_csv` for more details.
  
      thousands : str, optional
          Separator to use to parse thousands. Defaults to ``','``.
  
      encoding : str, optional
          The encoding used to decode the web page. Defaults to ``None``.``None``
          preserves the previous encoding behavior, which depends on the
          underlying parser library (e.g., the parser library will try to use
          the encoding provided by the document).
  
      decimal : str, default '.'
          Character to recognize as decimal point (e.g. use ',' for European
          data).
  
      converters : dict, default None
          Dict of functions for converting values in certain columns. Keys can
          either be integers or column labels, values are functions that take one
          input argument, the cell (not column) content, and return the
          transformed content.
  
      na_values : iterable, default None
          Custom NA values.
  
      keep_default_na : bool, default True
          If na_values are specified and keep_default_na is False the default NaN
          values are overridden, otherwise they're appended to.
  
      displayed_only : bool, default True
          Whether elements with "display: none" should be parsed.
  
      extract_links : {None, "all", "header", "body", "footer"}
          Table elements in the specified section(s) with <a> tags will have their
          href extracted.
  
          .. versionadded:: 1.5.0
  
      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
  
      Returns
      -------
      dfs
          A list of DataFrames.
  
      See Also
      --------
      read_csv : Read a comma-separated values (csv) file into DataFrame.
  
      Notes
      -----
      Before using this function you should read the :ref:`gotchas about the
      HTML parsing libraries <io.html.gotchas>`.
  
      Expect to do some cleanup after you call this function. For example, you
      might need to manually assign column names if the column names are
      converted to NaN when you pass the `header=0` argument. We try to assume as
      little as possible about the structure of the table and push the
      idiosyncrasies of the HTML contained in the table to the user.
  
      This function searches for ``<table>`` elements and only for ``<tr>``
      and ``<th>`` rows and ``<td>`` elements within each ``<tr>`` or ``<th>``
      element in the table. ``<td>`` stands for "table data". This function
      attempts to properly handle ``colspan`` and ``rowspan`` attributes.
      If the function has a ``<thead>`` argument, it is used to construct
      the header, otherwise the function attempts to find the header within
      the body (by putting rows with only ``<th>`` elements into the header).
  
      Similar to :func:`~read_csv` the `header` argument is applied
      **after** `skiprows` is applied.
  
      This function will *always* return a list of :class:`DataFrame` *or*
      it will fail, e.g., it will *not* return an empty list.
  
      Examples
      --------
      See the :ref:`read_html documentation in the IO section of the docs
      <io.read_html>` for some examples of reading in HTML tables.
      """
      _importers()
  
      # Type check here. We don't want to parse only to fail because of an
      # invalid value of an integer skiprows.
      if isinstance(skiprows, numbers.Integral) and skiprows < 0:
          raise ValueError(
              "cannot skip rows starting from the end of the "
              "data (you passed a negative value)"
          )
      if extract_links not in [None, "header", "footer", "body", "all"]:
          raise ValueError(
              "`extract_links` must be one of "
              '{None, "header", "footer", "body", "all"}, got '
              f'"{extract_links}"'
          )
      validate_header_arg(header)
      check_dtype_backend(dtype_backend)
  
      io = stringify_path(io)
  
      return _parse(
          flavor=flavor,
          io=io,
          match=match,
          header=header,
          index_col=index_col,
          skiprows=skiprows,
          parse_dates=parse_dates,
          thousands=thousands,
          attrs=attrs,
          encoding=encoding,
          decimal=decimal,
          converters=converters,
          na_values=na_values,
          keep_default_na=keep_default_na,
          displayed_only=displayed_only,
          extract_links=extract_links,
          dtype_backend=dtype_backend,
      )
  
imports: from __future__ import annotations
  from collections import abc
  import numbers
  import re
  from typing import TYPE_CHECKING, Iterable, Literal, Pattern, Sequence, cast
  from pandas._libs import lib
  from pandas._typing import BaseBuffer, DtypeBackend, FilePath, ReadBuffer
  from pandas.compat._optional import import_optional_dependency
  from pandas.errors import AbstractMethodError, EmptyDataError
  from pandas.util._validators import check_dtype_backend
  from pandas.core.dtypes.common import is_list_like
  from pandas import isna
  from pandas.core.indexes.base import Index
  from pandas.core.indexes.multi import MultiIndex
  from pandas.core.series import Series
  from pandas.io.common import file_exists, get_handle, is_url, stringify_path, urlopen, validate_header_arg
  from pandas.io.formats.printing import pprint_thing
  from pandas.io.parsers import TextParser
label_desc: Use image node_id 12 for calling a global function with example usage: read_html(io) and returns: _parse