code: def read_html(
      io: Union[str, Any],
      match: str = ".+",
      flavor: Optional[str] = None,
      header: Optional[Union[int, List[int]]] = None,
      index_col: Optional[Union[int, List[int]]] = None,
      skiprows: Optional[Union[int, List[int], slice]] = None,
      attrs: Optional[Dict[str, str]] = None,
      parse_dates: bool = False,
      thousands: str = ",",
      encoding: Optional[str] = None,
      decimal: str = ".",
      converters: Optional[Dict] = None,
      na_values: Optional[Any] = None,
      keep_default_na: bool = True,
      displayed_only: bool = True,
  ) -> List[DataFrame]:
      r"""Read HTML tables into a ``list`` of ``DataFrame`` objects.
  
      Parameters
      ----------
      io : str or file-like
          A URL, a file-like object, or a raw string containing HTML. 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'``.
  
          .. deprecated:: 4.0.0
              Passing html literal strings is deprecated.
              Wrap literal string/bytes input in io.StringIO/io.BytesIO instead.
  
      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 or None, container of strings
          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 or None, optional
          The row (or list of rows for a :class:`~ps.MultiIndex`) to use to
          make the columns headers.
  
      index_col : int or list-like or None, optional
          The column (or list of columns) to use to create the index.
  
      skiprows : int or list-like or slice or None, optional
          0-based. Number of rows to skip after parsing the column integer. 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 or None, 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
          <http://www.w3.org/TR/html-markup/global-attributes.html>`__. ::
  
              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
          <http://www.w3.org/TR/html-markup/table.html>`__. It contains the
          latest information on table attributes for the modern web.
  
      parse_dates : bool, optional
          See :func:`~ps.read_csv` for more details.
  
      thousands : str, optional
          Separator to use to parse thousands. Defaults to ``','``.
  
      encoding : str or None, 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 (example: 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
  
      Returns
      -------
      dfs : list of DataFrames
  
      See Also
      --------
      read_csv
      DataFrame.to_html
      """
      pdfs = pd.read_html(
          io=io,
          match=match,
          flavor=flavor,
          header=header,
          index_col=index_col,
          skiprows=skiprows,
          attrs=attrs,
          parse_dates=parse_dates,
          thousands=thousands,
          encoding=encoding,
          decimal=decimal,
          converters=converters,
          na_values=na_values,
          keep_default_na=keep_default_na,
          displayed_only=displayed_only,
      )
      return cast(List[DataFrame], [from_pandas(pdf) for pdf in pdfs])
  
imports: from typing import Any, Callable, Dict, List, Optional, Set, Sized, Tuple, Type, Union, cast, no_type_check
  from collections.abc import Iterable
  from datetime import tzinfo
  from functools import reduce
  from io import BytesIO
  import json
  import warnings
  import numpy
  import pandas
  from pandas.api.types import is_datetime64_dtype, is_list_like
  from pandas.tseries.offsets import DateOffset
  import pyarrow
  import pyarrow.parquet
  from pyspark.sql import functions, Column
  from pyspark.sql.functions import pandas_udf
  from pyspark.sql.types import ByteType, ShortType, IntegerType, LongType, FloatType, DoubleType, BooleanType, TimestampType, TimestampNTZType, DecimalType, StringType, DateType, StructType, DataType
  from pyspark.sql.dataframe import DataFrame
  from pyspark import pandas
  from pyspark.pandas._typing import Axis, Dtype, Label, Name
  from pyspark.pandas.base import IndexOpsMixin
  from pyspark.pandas.utils import align_diff_frames, default_session, is_name_like_tuple, is_name_like_value, name_like_string, same_anchor, scol_for, validate_axis, log_advice
  from pyspark.pandas.frame import DataFrame, _reduce_spark_multi
  from pyspark.pandas.internal import InternalFrame, DEFAULT_SERIES_NAME, HIDDEN_COLUMNS, SPARK_INDEX_NAME_FORMAT
  from pyspark.pandas.series import Series, first_series
  from pyspark.pandas.spark.utils import as_nullable_spark_type, force_decimal_precision_scale
  from pyspark.pandas.indexes import Index, DatetimeIndex, TimedeltaIndex
  from pyspark.pandas.indexes.multi import MultiIndex
  from pyspark.sql.utils import get_column_class
label_desc: Use image node_id 11 for calling a global function with example usage: read_html(io, match, flavor, header, index_col, skiprows, attrs, parse_dates, thousands, encoding, decimal, converters, na_values, keep_default_na, displayed_only) and returns: cast