Add files using upload-large-folder tool

ckpts/universal/global_step40/zero/23.attention.dense.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa9f765aa7814461dbecc370b8515288885948e8afbbbbe4b565514bee1d1481
+size 16778396

ckpts/universal/global_step40/zero/23.mlp.dense_4h_to_h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41075e102137caa1e8745c571f82083723c462bf9ff1249ca75595f67f475897
+size 33555612

ckpts/universal/global_step40/zero/23.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48f20aad6c18db2d99498dd71e920c8bb03025779589319272f087c6248d2453
+size 33555627

ckpts/universal/global_step40/zero/23.mlp.dense_4h_to_h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e31ca62821543e3cbbac929cd9187fa3c82f07a9a41942a3f2dd8698ddc209eb
+size 33555533

ckpts/universal/global_step40/zero/24.mlp.dense_h_to_4h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4534d085bc382985eb6cd40e84a61a5079e049be0ea2c05e40cd890f0eda71cd
+size 33555612

ckpts/universal/global_step40/zero/24.mlp.dense_h_to_4h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef8be073710cc5ec015a0dcd6891e7ed954253af39e802e1844bae546db26dc6
+size 33555627

ckpts/universal/global_step40/zero/24.mlp.dense_h_to_4h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c82ab44226b2005a8b55040ac6cac7a56f4cbb9344f4a332697041b457d67478
+size 33555533

ckpts/universal/global_step40/zero/25.input_layernorm.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8543fd9fe7fff423557d08ddedc20c96ddda4fd6e4db89e9f4848bf7342e1898
+size 9387

ckpts/universal/global_step40/zero/25.mlp.dense_4h_to_h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8621b78afe936756a9952fa31d3ce1f3f0cc64ac84d1e0b4f3ac2ba23f89fee6
+size 33555612

ckpts/universal/global_step40/zero/25.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3db1a383ebabc03297f2d5f8d907b1185c656124131e1fd7fdb34465d6decddc
+size 33555627

ckpts/universal/global_step40/zero/25.mlp.dense_4h_to_h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c0a3307676c70e489cc33ee5db5e70a3ea50c1c3be1e49668a31a330c32f1811
+size 33555533

ckpts/universal/global_step40/zero/4.attention.dense.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b77231c886bbd3f915b506fcb52525d543f3bbf983ec097d70106ecc3cb270a3
+size 16778396

ckpts/universal/global_step40/zero/4.attention.dense.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13ce3d24964147d1243e591e91c30aa056e0015a6b6d43de7a5678538af3a9fa
+size 16778411

ckpts/universal/global_step40/zero/4.attention.dense.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:212a1c16128c00a974a895b7ce9ac104655436f387808b79dfe1154da1d5ed19
+size 16778317

venv/lib/python3.10/site-packages/sklearn/datasets/_arff_parser.py

@@ -0,0 +1,542 @@
+"""Implementation of ARFF parsers: via LIAC-ARFF and pandas."""
+import itertools
+import re
+from collections import OrderedDict
+from collections.abc import Generator
+from typing import List
+
+import numpy as np
+import scipy as sp
+
+from ..externals import _arff
+from ..externals._arff import ArffSparseDataType
+from ..utils import (
+    _chunk_generator,
+    check_pandas_support,
+    get_chunk_n_rows,
+)
+from ..utils.fixes import pd_fillna
+
+
+def _split_sparse_columns(
+    arff_data: ArffSparseDataType, include_columns: List
+) -> ArffSparseDataType:
+    """Obtains several columns from sparse ARFF representation. Additionally,
+    the column indices are re-labelled, given the columns that are not
+    included. (e.g., when including [1, 2, 3], the columns will be relabelled
+    to [0, 1, 2]).
+
+    Parameters
+    ----------
+    arff_data : tuple
+        A tuple of three lists of equal size; first list indicating the value,
+        second the x coordinate and the third the y coordinate.
+
+    include_columns : list
+        A list of columns to include.
+
+    Returns
+    -------
+    arff_data_new : tuple
+        Subset of arff data with only the include columns indicated by the
+        include_columns argument.
+    """
+    arff_data_new: ArffSparseDataType = (list(), list(), list())
+    reindexed_columns = {
+        column_idx: array_idx for array_idx, column_idx in enumerate(include_columns)
+    }
+    for val, row_idx, col_idx in zip(arff_data[0], arff_data[1], arff_data[2]):
+        if col_idx in include_columns:
+            arff_data_new[0].append(val)
+            arff_data_new[1].append(row_idx)
+            arff_data_new[2].append(reindexed_columns[col_idx])
+    return arff_data_new
+
+
+def _sparse_data_to_array(
+    arff_data: ArffSparseDataType, include_columns: List
+) -> np.ndarray:
+    # turns the sparse data back into an array (can't use toarray() function,
+    # as this does only work on numeric data)
+    num_obs = max(arff_data[1]) + 1
+    y_shape = (num_obs, len(include_columns))
+    reindexed_columns = {
+        column_idx: array_idx for array_idx, column_idx in enumerate(include_columns)
+    }
+    # TODO: improve for efficiency
+    y = np.empty(y_shape, dtype=np.float64)
+    for val, row_idx, col_idx in zip(arff_data[0], arff_data[1], arff_data[2]):
+        if col_idx in include_columns:
+            y[row_idx, reindexed_columns[col_idx]] = val
+    return y
+
+
+def _post_process_frame(frame, feature_names, target_names):
+    """Post process a dataframe to select the desired columns in `X` and `y`.
+
+    Parameters
+    ----------
+    frame : dataframe
+        The dataframe to split into `X` and `y`.
+
+    feature_names : list of str
+        The list of feature names to populate `X`.
+
+    target_names : list of str
+        The list of target names to populate `y`.
+
+    Returns
+    -------
+    X : dataframe
+        The dataframe containing the features.
+
+    y : {series, dataframe} or None
+        The series or dataframe containing the target.
+    """
+    X = frame[feature_names]
+    if len(target_names) >= 2:
+        y = frame[target_names]
+    elif len(target_names) == 1:
+        y = frame[target_names[0]]
+    else:
+        y = None
+    return X, y
+
+
+def _liac_arff_parser(
+    gzip_file,
+    output_arrays_type,
+    openml_columns_info,
+    feature_names_to_select,
+    target_names_to_select,
+    shape=None,
+):
+    """ARFF parser using the LIAC-ARFF library coded purely in Python.
+
+    This parser is quite slow but consumes a generator. Currently it is needed
+    to parse sparse datasets. For dense datasets, it is recommended to instead
+    use the pandas-based parser, although it does not always handles the
+    dtypes exactly the same.
+
+    Parameters
+    ----------
+    gzip_file : GzipFile instance
+        The file compressed to be read.
+
+    output_arrays_type : {"numpy", "sparse", "pandas"}
+        The type of the arrays that will be returned. The possibilities ara:
+
+        - `"numpy"`: both `X` and `y` will be NumPy arrays;
+        - `"sparse"`: `X` will be sparse matrix and `y` will be a NumPy array;
+        - `"pandas"`: `X` will be a pandas DataFrame and `y` will be either a
+          pandas Series or DataFrame.
+
+    columns_info : dict
+        The information provided by OpenML regarding the columns of the ARFF
+        file.
+
+    feature_names_to_select : list of str
+        A list of the feature names to be selected.
+
+    target_names_to_select : list of str
+        A list of the target names to be selected.
+
+    Returns
+    -------
+    X : {ndarray, sparse matrix, dataframe}
+        The data matrix.
+
+    y : {ndarray, dataframe, series}
+        The target.
+
+    frame : dataframe or None
+        A dataframe containing both `X` and `y`. `None` if
+        `output_array_type != "pandas"`.
+
+    categories : list of str or None
+        The names of the features that are categorical. `None` if
+        `output_array_type == "pandas"`.
+    """
+
+    def _io_to_generator(gzip_file):
+        for line in gzip_file:
+            yield line.decode("utf-8")
+
+    stream = _io_to_generator(gzip_file)
+
+    # find which type (dense or sparse) ARFF type we will have to deal with
+    return_type = _arff.COO if output_arrays_type == "sparse" else _arff.DENSE_GEN
+    # we should not let LIAC-ARFF to encode the nominal attributes with NumPy
+    # arrays to have only numerical values.
+    encode_nominal = not (output_arrays_type == "pandas")
+    arff_container = _arff.load(
+        stream, return_type=return_type, encode_nominal=encode_nominal
+    )
+    columns_to_select = feature_names_to_select + target_names_to_select
+
+    categories = {
+        name: cat
+        for name, cat in arff_container["attributes"]
+        if isinstance(cat, list) and name in columns_to_select
+    }
+    if output_arrays_type == "pandas":
+        pd = check_pandas_support("fetch_openml with as_frame=True")
+
+        columns_info = OrderedDict(arff_container["attributes"])
+        columns_names = list(columns_info.keys())
+
+        # calculate chunksize
+        first_row = next(arff_container["data"])
+        first_df = pd.DataFrame([first_row], columns=columns_names, copy=False)
+
+        row_bytes = first_df.memory_usage(deep=True).sum()
+        chunksize = get_chunk_n_rows(row_bytes)
+
+        # read arff data with chunks
+        columns_to_keep = [col for col in columns_names if col in columns_to_select]
+        dfs = [first_df[columns_to_keep]]
+        for data in _chunk_generator(arff_container["data"], chunksize):
+            dfs.append(
+                pd.DataFrame(data, columns=columns_names, copy=False)[columns_to_keep]
+            )
+        # dfs[0] contains only one row, which may not have enough data to infer to
+        # column's dtype. Here we use `dfs[1]` to configure the dtype in dfs[0]
+        if len(dfs) >= 2:
+            dfs[0] = dfs[0].astype(dfs[1].dtypes)
+
+        # liac-arff parser does not depend on NumPy and uses None to represent
+        # missing values. To be consistent with the pandas parser, we replace
+        # None with np.nan.
+        frame = pd.concat(dfs, ignore_index=True)
+        frame = pd_fillna(pd, frame)
+        del dfs, first_df
+
+        # cast the columns frame
+        dtypes = {}
+        for name in frame.columns:
+            column_dtype = openml_columns_info[name]["data_type"]
+            if column_dtype.lower() == "integer":
+                # Use a pandas extension array instead of np.int64 to be able
+                # to support missing values.
+                dtypes[name] = "Int64"
+            elif column_dtype.lower() == "nominal":
+                dtypes[name] = "category"
+            else:
+                dtypes[name] = frame.dtypes[name]
+        frame = frame.astype(dtypes)
+
+        X, y = _post_process_frame(
+            frame, feature_names_to_select, target_names_to_select
+        )
+    else:
+        arff_data = arff_container["data"]
+
+        feature_indices_to_select = [
+            int(openml_columns_info[col_name]["index"])
+            for col_name in feature_names_to_select
+        ]
+        target_indices_to_select = [
+            int(openml_columns_info[col_name]["index"])
+            for col_name in target_names_to_select
+        ]
+
+        if isinstance(arff_data, Generator):
+            if shape is None:
+                raise ValueError(
+                    "shape must be provided when arr['data'] is a Generator"
+                )
+            if shape[0] == -1:
+                count = -1
+            else:
+                count = shape[0] * shape[1]
+            data = np.fromiter(
+                itertools.chain.from_iterable(arff_data),
+                dtype="float64",
+                count=count,
+            )
+            data = data.reshape(*shape)
+            X = data[:, feature_indices_to_select]
+            y = data[:, target_indices_to_select]
+        elif isinstance(arff_data, tuple):
+            arff_data_X = _split_sparse_columns(arff_data, feature_indices_to_select)
+            num_obs = max(arff_data[1]) + 1
+            X_shape = (num_obs, len(feature_indices_to_select))
+            X = sp.sparse.coo_matrix(
+                (arff_data_X[0], (arff_data_X[1], arff_data_X[2])),
+                shape=X_shape,
+                dtype=np.float64,
+            )
+            X = X.tocsr()
+            y = _sparse_data_to_array(arff_data, target_indices_to_select)
+        else:
+            # This should never happen
+            raise ValueError(
+                f"Unexpected type for data obtained from arff: {type(arff_data)}"
+            )
+
+        is_classification = {
+            col_name in categories for col_name in target_names_to_select
+        }
+        if not is_classification:
+            # No target
+            pass
+        elif all(is_classification):
+            y = np.hstack(
+                [
+                    np.take(
+                        np.asarray(categories.pop(col_name), dtype="O"),
+                        y[:, i : i + 1].astype(int, copy=False),
+                    )
+                    for i, col_name in enumerate(target_names_to_select)
+                ]
+            )
+        elif any(is_classification):
+            raise ValueError(
+                "Mix of nominal and non-nominal targets is not currently supported"
+            )
+
+        # reshape y back to 1-D array, if there is only 1 target column;
+        # back to None if there are not target columns
+        if y.shape[1] == 1:
+            y = y.reshape((-1,))
+        elif y.shape[1] == 0:
+            y = None
+
+    if output_arrays_type == "pandas":
+        return X, y, frame, None
+    return X, y, None, categories
+
+
+def _pandas_arff_parser(
+    gzip_file,
+    output_arrays_type,
+    openml_columns_info,
+    feature_names_to_select,
+    target_names_to_select,
+    read_csv_kwargs=None,
+):
+    """ARFF parser using `pandas.read_csv`.
+
+    This parser uses the metadata fetched directly from OpenML and skips the metadata
+    headers of ARFF file itself. The data is loaded as a CSV file.
+
+    Parameters
+    ----------
+    gzip_file : GzipFile instance
+        The GZip compressed file with the ARFF formatted payload.
+
+    output_arrays_type : {"numpy", "sparse", "pandas"}
+        The type of the arrays that will be returned. The possibilities are:
+
+        - `"numpy"`: both `X` and `y` will be NumPy arrays;
+        - `"sparse"`: `X` will be sparse matrix and `y` will be a NumPy array;
+        - `"pandas"`: `X` will be a pandas DataFrame and `y` will be either a
+          pandas Series or DataFrame.
+
+    openml_columns_info : dict
+        The information provided by OpenML regarding the columns of the ARFF
+        file.
+
+    feature_names_to_select : list of str
+        A list of the feature names to be selected to build `X`.
+
+    target_names_to_select : list of str
+        A list of the target names to be selected to build `y`.
+
+    read_csv_kwargs : dict, default=None
+        Keyword arguments to pass to `pandas.read_csv`. It allows to overwrite
+        the default options.
+
+    Returns
+    -------
+    X : {ndarray, sparse matrix, dataframe}
+        The data matrix.
+
+    y : {ndarray, dataframe, series}
+        The target.
+
+    frame : dataframe or None
+        A dataframe containing both `X` and `y`. `None` if
+        `output_array_type != "pandas"`.
+
+    categories : list of str or None
+        The names of the features that are categorical. `None` if
+        `output_array_type == "pandas"`.
+    """
+    import pandas as pd
+
+    # read the file until the data section to skip the ARFF metadata headers
+    for line in gzip_file:
+        if line.decode("utf-8").lower().startswith("@data"):
+            break
+
+    dtypes = {}
+    for name in openml_columns_info:
+        column_dtype = openml_columns_info[name]["data_type"]
+        if column_dtype.lower() == "integer":
+            # Use Int64 to infer missing values from data
+            # XXX: this line is not covered by our tests. Is this really needed?
+            dtypes[name] = "Int64"
+        elif column_dtype.lower() == "nominal":
+            dtypes[name] = "category"
+    # since we will not pass `names` when reading the ARFF file, we need to translate
+    # `dtypes` from column names to column indices to pass to `pandas.read_csv`
+    dtypes_positional = {
+        col_idx: dtypes[name]
+        for col_idx, name in enumerate(openml_columns_info)
+        if name in dtypes
+    }
+
+    default_read_csv_kwargs = {
+        "header": None,
+        "index_col": False,  # always force pandas to not use the first column as index
+        "na_values": ["?"],  # missing values are represented by `?`
+        "keep_default_na": False,  # only `?` is a missing value given the ARFF specs
+        "comment": "%",  # skip line starting by `%` since they are comments
+        "quotechar": '"',  # delimiter to use for quoted strings
+        "skipinitialspace": True,  # skip spaces after delimiter to follow ARFF specs
+        "escapechar": "\\",
+        "dtype": dtypes_positional,
+    }
+    read_csv_kwargs = {**default_read_csv_kwargs, **(read_csv_kwargs or {})}
+    frame = pd.read_csv(gzip_file, **read_csv_kwargs)
+    try:
+        # Setting the columns while reading the file will select the N first columns
+        # and not raise a ParserError. Instead, we set the columns after reading the
+        # file and raise a ParserError if the number of columns does not match the
+        # number of columns in the metadata given by OpenML.
+        frame.columns = [name for name in openml_columns_info]
+    except ValueError as exc:
+        raise pd.errors.ParserError(
+            "The number of columns provided by OpenML does not match the number of "
+            "columns inferred by pandas when reading the file."
+        ) from exc
+
+    columns_to_select = feature_names_to_select + target_names_to_select
+    columns_to_keep = [col for col in frame.columns if col in columns_to_select]
+    frame = frame[columns_to_keep]
+
+    # `pd.read_csv` automatically handles double quotes for quoting non-numeric
+    # CSV cell values. Contrary to LIAC-ARFF, `pd.read_csv` cannot be configured to
+    # consider either single quotes and double quotes as valid quoting chars at
+    # the same time since this case does not occur in regular (non-ARFF) CSV files.
+    # To mimic the behavior of LIAC-ARFF parser, we manually strip single quotes
+    # on categories as a post-processing steps if needed.
+    #
+    # Note however that we intentionally do not attempt to do this kind of manual
+    # post-processing of (non-categorical) string-typed columns because we cannot
+    # resolve the ambiguity of the case of CSV cell with nesting quoting such as
+    # `"'some string value'"` with pandas.
+    single_quote_pattern = re.compile(r"^'(?P<contents>.*)'$")
+
+    def strip_single_quotes(input_string):
+        match = re.search(single_quote_pattern, input_string)
+        if match is None:
+            return input_string
+
+        return match.group("contents")
+
+    categorical_columns = [
+        name
+        for name, dtype in frame.dtypes.items()
+        if isinstance(dtype, pd.CategoricalDtype)
+    ]
+    for col in categorical_columns:
+        frame[col] = frame[col].cat.rename_categories(strip_single_quotes)
+
+    X, y = _post_process_frame(frame, feature_names_to_select, target_names_to_select)
+
+    if output_arrays_type == "pandas":
+        return X, y, frame, None
+    else:
+        X, y = X.to_numpy(), y.to_numpy()
+
+    categories = {
+        name: dtype.categories.tolist()
+        for name, dtype in frame.dtypes.items()
+        if isinstance(dtype, pd.CategoricalDtype)
+    }
+    return X, y, None, categories
+
+
+def load_arff_from_gzip_file(
+    gzip_file,
+    parser,
+    output_type,
+    openml_columns_info,
+    feature_names_to_select,
+    target_names_to_select,
+    shape=None,
+    read_csv_kwargs=None,
+):
+    """Load a compressed ARFF file using a given parser.
+
+    Parameters
+    ----------
+    gzip_file : GzipFile instance
+        The file compressed to be read.
+
+    parser : {"pandas", "liac-arff"}
+        The parser used to parse the ARFF file. "pandas" is recommended
+        but only supports loading dense datasets.
+
+    output_type : {"numpy", "sparse", "pandas"}
+        The type of the arrays that will be returned. The possibilities ara:
+
+        - `"numpy"`: both `X` and `y` will be NumPy arrays;
+        - `"sparse"`: `X` will be sparse matrix and `y` will be a NumPy array;
+        - `"pandas"`: `X` will be a pandas DataFrame and `y` will be either a
+          pandas Series or DataFrame.
+
+    openml_columns_info : dict
+        The information provided by OpenML regarding the columns of the ARFF
+        file.
+
+    feature_names_to_select : list of str
+        A list of the feature names to be selected.
+
+    target_names_to_select : list of str
+        A list of the target names to be selected.
+
+    read_csv_kwargs : dict, default=None
+        Keyword arguments to pass to `pandas.read_csv`. It allows to overwrite
+        the default options.
+
+    Returns
+    -------
+    X : {ndarray, sparse matrix, dataframe}
+        The data matrix.
+
+    y : {ndarray, dataframe, series}
+        The target.
+
+    frame : dataframe or None
+        A dataframe containing both `X` and `y`. `None` if
+        `output_array_type != "pandas"`.
+
+    categories : list of str or None
+        The names of the features that are categorical. `None` if
+        `output_array_type == "pandas"`.
+    """
+    if parser == "liac-arff":
+        return _liac_arff_parser(
+            gzip_file,
+            output_type,
+            openml_columns_info,
+            feature_names_to_select,
+            target_names_to_select,
+            shape,
+        )
+    elif parser == "pandas":
+        return _pandas_arff_parser(
+            gzip_file,
+            output_type,
+            openml_columns_info,
+            feature_names_to_select,
+            target_names_to_select,
+            read_csv_kwargs,
+        )
+    else:
+        raise ValueError(
+            f"Unknown parser: '{parser}'. Should be 'liac-arff' or 'pandas'."
+        )

venv/lib/python3.10/site-packages/sklearn/datasets/_base.py

@@ -0,0 +1,1441 @@
+"""
+Base IO code for all datasets
+"""
+
+# Copyright (c) 2007 David Cournapeau <[email protected]>
+#               2010 Fabian Pedregosa <[email protected]>
+#               2010 Olivier Grisel <[email protected]>
+# License: BSD 3 clause
+import csv
+import gzip
+import hashlib
+import os
+import shutil
+from collections import namedtuple
+from importlib import resources
+from numbers import Integral
+from os import environ, listdir, makedirs
+from os.path import expanduser, isdir, join, splitext
+from pathlib import Path
+from urllib.request import urlretrieve
+
+import numpy as np
+
+from ..preprocessing import scale
+from ..utils import Bunch, check_pandas_support, check_random_state
+from ..utils._param_validation import Interval, StrOptions, validate_params
+
+DATA_MODULE = "sklearn.datasets.data"
+DESCR_MODULE = "sklearn.datasets.descr"
+IMAGES_MODULE = "sklearn.datasets.images"
+
+RemoteFileMetadata = namedtuple("RemoteFileMetadata", ["filename", "url", "checksum"])
+
+
+@validate_params(
+    {
+        "data_home": [str, os.PathLike, None],
+    },
+    prefer_skip_nested_validation=True,
+)
+def get_data_home(data_home=None) -> str:
+    """Return the path of the scikit-learn data directory.
+
+    This folder is used by some large dataset loaders to avoid downloading the
+    data several times.
+
+    By default the data directory is set to a folder named 'scikit_learn_data' in the
+    user home folder.
+
+    Alternatively, it can be set by the 'SCIKIT_LEARN_DATA' environment
+    variable or programmatically by giving an explicit folder path. The '~'
+    symbol is expanded to the user home folder.
+
+    If the folder does not already exist, it is automatically created.
+
+    Parameters
+    ----------
+    data_home : str or path-like, default=None
+        The path to scikit-learn data directory. If `None`, the default path
+        is `~/scikit_learn_data`.
+
+    Returns
+    -------
+    data_home: str
+        The path to scikit-learn data directory.
+    """
+    if data_home is None:
+        data_home = environ.get("SCIKIT_LEARN_DATA", join("~", "scikit_learn_data"))
+    data_home = expanduser(data_home)
+    makedirs(data_home, exist_ok=True)
+    return data_home
+
+
+@validate_params(
+    {
+        "data_home": [str, os.PathLike, None],
+    },
+    prefer_skip_nested_validation=True,
+)
+def clear_data_home(data_home=None):
+    """Delete all the content of the data home cache.
+
+    Parameters
+    ----------
+    data_home : str or path-like, default=None
+        The path to scikit-learn data directory. If `None`, the default path
+        is `~/scikit_learn_data`.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import clear_data_home
+    >>> clear_data_home()  # doctest: +SKIP
+    """
+    data_home = get_data_home(data_home)
+    shutil.rmtree(data_home)
+
+
+def _convert_data_dataframe(
+    caller_name, data, target, feature_names, target_names, sparse_data=False
+):
+    pd = check_pandas_support("{} with as_frame=True".format(caller_name))
+    if not sparse_data:
+        data_df = pd.DataFrame(data, columns=feature_names, copy=False)
+    else:
+        data_df = pd.DataFrame.sparse.from_spmatrix(data, columns=feature_names)
+
+    target_df = pd.DataFrame(target, columns=target_names)
+    combined_df = pd.concat([data_df, target_df], axis=1)
+    X = combined_df[feature_names]
+    y = combined_df[target_names]
+    if y.shape[1] == 1:
+        y = y.iloc[:, 0]
+    return combined_df, X, y
+
+
+@validate_params(
+    {
+        "container_path": [str, os.PathLike],
+        "description": [str, None],
+        "categories": [list, None],
+        "load_content": ["boolean"],
+        "shuffle": ["boolean"],
+        "encoding": [str, None],
+        "decode_error": [StrOptions({"strict", "ignore", "replace"})],
+        "random_state": ["random_state"],
+        "allowed_extensions": [list, None],
+    },
+    prefer_skip_nested_validation=True,
+)
+def load_files(
+    container_path,
+    *,
+    description=None,
+    categories=None,
+    load_content=True,
+    shuffle=True,
+    encoding=None,
+    decode_error="strict",
+    random_state=0,
+    allowed_extensions=None,
+):
+    """Load text files with categories as subfolder names.
+
+    Individual samples are assumed to be files stored a two levels folder
+    structure such as the following:
+
+        container_folder/
+            category_1_folder/
+                file_1.txt
+                file_2.txt
+                ...
+                file_42.txt
+            category_2_folder/
+                file_43.txt
+                file_44.txt
+                ...
+
+    The folder names are used as supervised signal label names. The individual
+    file names are not important.
+
+    This function does not try to extract features into a numpy array or scipy
+    sparse matrix. In addition, if load_content is false it does not try to
+    load the files in memory.
+
+    To use text files in a scikit-learn classification or clustering algorithm,
+    you will need to use the :mod:`~sklearn.feature_extraction.text` module to
+    build a feature extraction transformer that suits your problem.
+
+    If you set load_content=True, you should also specify the encoding of the
+    text using the 'encoding' parameter. For many modern text files, 'utf-8'
+    will be the correct encoding. If you leave encoding equal to None, then the
+    content will be made of bytes instead of Unicode, and you will not be able
+    to use most functions in :mod:`~sklearn.feature_extraction.text`.
+
+    Similar feature extractors should be built for other kind of unstructured
+    data input such as images, audio, video, ...
+
+    If you want files with a specific file extension (e.g. `.txt`) then you
+    can pass a list of those file extensions to `allowed_extensions`.
+
+    Read more in the :ref:`User Guide <datasets>`.
+
+    Parameters
+    ----------
+    container_path : str
+        Path to the main folder holding one subfolder per category.
+
+    description : str, default=None
+        A paragraph describing the characteristic of the dataset: its source,
+        reference, etc.
+
+    categories : list of str, default=None
+        If None (default), load all the categories. If not None, list of
+        category names to load (other categories ignored).
+
+    load_content : bool, default=True
+        Whether to load or not the content of the different files. If true a
+        'data' attribute containing the text information is present in the data
+        structure returned. If not, a filenames attribute gives the path to the
+        files.
+
+    shuffle : bool, default=True
+        Whether or not to shuffle the data: might be important for models that
+        make the assumption that the samples are independent and identically
+        distributed (i.i.d.), such as stochastic gradient descent.
+
+    encoding : str, default=None
+        If None, do not try to decode the content of the files (e.g. for images
+        or other non-text content). If not None, encoding to use to decode text
+        files to Unicode if load_content is True.
+
+    decode_error : {'strict', 'ignore', 'replace'}, default='strict'
+        Instruction on what to do if a byte sequence is given to analyze that
+        contains characters not of the given `encoding`. Passed as keyword
+        argument 'errors' to bytes.decode.
+
+    random_state : int, RandomState instance or None, default=0
+        Determines random number generation for dataset shuffling. Pass an int
+        for reproducible output across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    allowed_extensions : list of str, default=None
+        List of desired file extensions to filter the files to be loaded.
+
+    Returns
+    -------
+    data : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        data : list of str
+            Only present when `load_content=True`.
+            The raw text data to learn.
+        target : ndarray
+            The target labels (integer index).
+        target_names : list
+            The names of target classes.
+        DESCR : str
+            The full description of the dataset.
+        filenames: ndarray
+            The filenames holding the dataset.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_files
+    >>> container_path = "./"
+    >>> load_files(container_path)  # doctest: +SKIP
+    """
+
+    target = []
+    target_names = []
+    filenames = []
+
+    folders = [
+        f for f in sorted(listdir(container_path)) if isdir(join(container_path, f))
+    ]
+
+    if categories is not None:
+        folders = [f for f in folders if f in categories]
+
+    if allowed_extensions is not None:
+        allowed_extensions = frozenset(allowed_extensions)
+
+    for label, folder in enumerate(folders):
+        target_names.append(folder)
+        folder_path = join(container_path, folder)
+        files = sorted(listdir(folder_path))
+        if allowed_extensions is not None:
+            documents = [
+                join(folder_path, file)
+                for file in files
+                if os.path.splitext(file)[1] in allowed_extensions
+            ]
+        else:
+            documents = [join(folder_path, file) for file in files]
+        target.extend(len(documents) * [label])
+        filenames.extend(documents)
+
+    # convert to array for fancy indexing
+    filenames = np.array(filenames)
+    target = np.array(target)
+
+    if shuffle:
+        random_state = check_random_state(random_state)
+        indices = np.arange(filenames.shape[0])
+        random_state.shuffle(indices)
+        filenames = filenames[indices]
+        target = target[indices]
+
+    if load_content:
+        data = []
+        for filename in filenames:
+            data.append(Path(filename).read_bytes())
+        if encoding is not None:
+            data = [d.decode(encoding, decode_error) for d in data]
+        return Bunch(
+            data=data,
+            filenames=filenames,
+            target_names=target_names,
+            target=target,
+            DESCR=description,
+        )
+
+    return Bunch(
+        filenames=filenames, target_names=target_names, target=target, DESCR=description
+    )
+
+
+def load_csv_data(
+    data_file_name,
+    *,
+    data_module=DATA_MODULE,
+    descr_file_name=None,
+    descr_module=DESCR_MODULE,
+    encoding="utf-8",
+):
+    """Loads `data_file_name` from `data_module with `importlib.resources`.
+
+    Parameters
+    ----------
+    data_file_name : str
+        Name of csv file to be loaded from `data_module/data_file_name`.
+        For example `'wine_data.csv'`.
+
+    data_module : str or module, default='sklearn.datasets.data'
+        Module where data lives. The default is `'sklearn.datasets.data'`.
+
+    descr_file_name : str, default=None
+        Name of rst file to be loaded from `descr_module/descr_file_name`.
+        For example `'wine_data.rst'`. See also :func:`load_descr`.
+        If not None, also returns the corresponding description of
+        the dataset.
+
+    descr_module : str or module, default='sklearn.datasets.descr'
+        Module where `descr_file_name` lives. See also :func:`load_descr`.
+        The default is `'sklearn.datasets.descr'`.
+
+    Returns
+    -------
+    data : ndarray of shape (n_samples, n_features)
+        A 2D array with each row representing one sample and each column
+        representing the features of a given sample.
+
+    target : ndarry of shape (n_samples,)
+        A 1D array holding target variables for all the samples in `data`.
+        For example target[0] is the target variable for data[0].
+
+    target_names : ndarry of shape (n_samples,)
+        A 1D array containing the names of the classifications. For example
+        target_names[0] is the name of the target[0] class.
+
+    descr : str, optional
+        Description of the dataset (the content of `descr_file_name`).
+        Only returned if `descr_file_name` is not None.
+
+    encoding : str, optional
+        Text encoding of the CSV file.
+
+        .. versionadded:: 1.4
+    """
+    data_path = resources.files(data_module) / data_file_name
+    with data_path.open("r", encoding="utf-8") as csv_file:
+        data_file = csv.reader(csv_file)
+        temp = next(data_file)
+        n_samples = int(temp[0])
+        n_features = int(temp[1])
+        target_names = np.array(temp[2:])
+        data = np.empty((n_samples, n_features))
+        target = np.empty((n_samples,), dtype=int)
+
+        for i, ir in enumerate(data_file):
+            data[i] = np.asarray(ir[:-1], dtype=np.float64)
+            target[i] = np.asarray(ir[-1], dtype=int)
+
+    if descr_file_name is None:
+        return data, target, target_names
+    else:
+        assert descr_module is not None
+        descr = load_descr(descr_module=descr_module, descr_file_name=descr_file_name)
+        return data, target, target_names, descr
+
+
+def load_gzip_compressed_csv_data(
+    data_file_name,
+    *,
+    data_module=DATA_MODULE,
+    descr_file_name=None,
+    descr_module=DESCR_MODULE,
+    encoding="utf-8",
+    **kwargs,
+):
+    """Loads gzip-compressed with `importlib.resources`.
+
+    1) Open resource file with `importlib.resources.open_binary`
+    2) Decompress file obj with `gzip.open`
+    3) Load decompressed data with `np.loadtxt`
+
+    Parameters
+    ----------
+    data_file_name : str
+        Name of gzip-compressed csv file  (`'*.csv.gz'`) to be loaded from
+        `data_module/data_file_name`. For example `'diabetes_data.csv.gz'`.
+
+    data_module : str or module, default='sklearn.datasets.data'
+        Module where data lives. The default is `'sklearn.datasets.data'`.
+
+    descr_file_name : str, default=None
+        Name of rst file to be loaded from `descr_module/descr_file_name`.
+        For example `'wine_data.rst'`. See also :func:`load_descr`.
+        If not None, also returns the corresponding description of
+        the dataset.
+
+    descr_module : str or module, default='sklearn.datasets.descr'
+        Module where `descr_file_name` lives. See also :func:`load_descr`.
+        The default  is `'sklearn.datasets.descr'`.
+
+    encoding : str, default="utf-8"
+        Name of the encoding that the gzip-decompressed file will be
+        decoded with. The default is 'utf-8'.
+
+    **kwargs : dict, optional
+        Keyword arguments to be passed to `np.loadtxt`;
+        e.g. delimiter=','.
+
+    Returns
+    -------
+    data : ndarray of shape (n_samples, n_features)
+        A 2D array with each row representing one sample and each column
+        representing the features and/or target of a given sample.
+
+    descr : str, optional
+        Description of the dataset (the content of `descr_file_name`).
+        Only returned if `descr_file_name` is not None.
+    """
+    data_path = resources.files(data_module) / data_file_name
+    with data_path.open("rb") as compressed_file:
+        compressed_file = gzip.open(compressed_file, mode="rt", encoding=encoding)
+        data = np.loadtxt(compressed_file, **kwargs)
+
+    if descr_file_name is None:
+        return data
+    else:
+        assert descr_module is not None
+        descr = load_descr(descr_module=descr_module, descr_file_name=descr_file_name)
+        return data, descr
+
+
+def load_descr(descr_file_name, *, descr_module=DESCR_MODULE, encoding="utf-8"):
+    """Load `descr_file_name` from `descr_module` with `importlib.resources`.
+
+    Parameters
+    ----------
+    descr_file_name : str, default=None
+        Name of rst file to be loaded from `descr_module/descr_file_name`.
+        For example `'wine_data.rst'`. See also :func:`load_descr`.
+        If not None, also returns the corresponding description of
+        the dataset.
+
+    descr_module : str or module, default='sklearn.datasets.descr'
+        Module where `descr_file_name` lives. See also :func:`load_descr`.
+        The default  is `'sklearn.datasets.descr'`.
+
+    encoding : str, default="utf-8"
+        Name of the encoding that `descr_file_name` will be decoded with.
+        The default is 'utf-8'.
+
+        .. versionadded:: 1.4
+
+    Returns
+    -------
+    fdescr : str
+        Content of `descr_file_name`.
+    """
+    path = resources.files(descr_module) / descr_file_name
+    return path.read_text(encoding=encoding)
+
+
+@validate_params(
+    {
+        "return_X_y": ["boolean"],
+        "as_frame": ["boolean"],
+    },
+    prefer_skip_nested_validation=True,
+)
+def load_wine(*, return_X_y=False, as_frame=False):
+    """Load and return the wine dataset (classification).
+
+    .. versionadded:: 0.18
+
+    The wine dataset is a classic and very easy multi-class classification
+    dataset.
+
+    =================   ==============
+    Classes                          3
+    Samples per class        [59,71,48]
+    Samples total                  178
+    Dimensionality                  13
+    Features            real, positive
+    =================   ==============
+
+    The copy of UCI ML Wine Data Set dataset is downloaded and modified to fit
+    standard format from:
+    https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data
+
+    Read more in the :ref:`User Guide <wine_dataset>`.
+
+    Parameters
+    ----------
+    return_X_y : bool, default=False
+        If True, returns ``(data, target)`` instead of a Bunch object.
+        See below for more information about the `data` and `target` object.
+
+    as_frame : bool, default=False
+        If True, the data is a pandas DataFrame including columns with
+        appropriate dtypes (numeric). The target is
+        a pandas DataFrame or Series depending on the number of target columns.
+        If `return_X_y` is True, then (`data`, `target`) will be pandas
+        DataFrames or Series as described below.
+
+        .. versionadded:: 0.23
+
+    Returns
+    -------
+    data : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        data : {ndarray, dataframe} of shape (178, 13)
+            The data matrix. If `as_frame=True`, `data` will be a pandas
+            DataFrame.
+        target: {ndarray, Series} of shape (178,)
+            The classification target. If `as_frame=True`, `target` will be
+            a pandas Series.
+        feature_names: list
+            The names of the dataset columns.
+        target_names: list
+            The names of target classes.
+        frame: DataFrame of shape (178, 14)
+            Only present when `as_frame=True`. DataFrame with `data` and
+            `target`.
+
+            .. versionadded:: 0.23
+        DESCR: str
+            The full description of the dataset.
+
+    (data, target) : tuple if ``return_X_y`` is True
+        A tuple of two ndarrays by default. The first contains a 2D array of shape
+        (178, 13) with each row representing one sample and each column representing
+        the features. The second array of shape (178,) contains the target samples.
+
+    Examples
+    --------
+    Let's say you are interested in the samples 10, 80, and 140, and want to
+    know their class name.
+
+    >>> from sklearn.datasets import load_wine
+    >>> data = load_wine()
+    >>> data.target[[10, 80, 140]]
+    array([0, 1, 2])
+    >>> list(data.target_names)
+    ['class_0', 'class_1', 'class_2']
+    """
+
+    data, target, target_names, fdescr = load_csv_data(
+        data_file_name="wine_data.csv", descr_file_name="wine_data.rst"
+    )
+
+    feature_names = [
+        "alcohol",
+        "malic_acid",
+        "ash",
+        "alcalinity_of_ash",
+        "magnesium",
+        "total_phenols",
+        "flavanoids",
+        "nonflavanoid_phenols",
+        "proanthocyanins",
+        "color_intensity",
+        "hue",
+        "od280/od315_of_diluted_wines",
+        "proline",
+    ]
+
+    frame = None
+    target_columns = [
+        "target",
+    ]
+    if as_frame:
+        frame, data, target = _convert_data_dataframe(
+            "load_wine", data, target, feature_names, target_columns
+        )
+
+    if return_X_y:
+        return data, target
+
+    return Bunch(
+        data=data,
+        target=target,
+        frame=frame,
+        target_names=target_names,
+        DESCR=fdescr,
+        feature_names=feature_names,
+    )
+
+
+@validate_params(
+    {"return_X_y": ["boolean"], "as_frame": ["boolean"]},
+    prefer_skip_nested_validation=True,
+)
+def load_iris(*, return_X_y=False, as_frame=False):
+    """Load and return the iris dataset (classification).
+
+    The iris dataset is a classic and very easy multi-class classification
+    dataset.
+
+    =================   ==============
+    Classes                          3
+    Samples per class               50
+    Samples total                  150
+    Dimensionality                   4
+    Features            real, positive
+    =================   ==============
+
+    Read more in the :ref:`User Guide <iris_dataset>`.
+
+    Parameters
+    ----------
+    return_X_y : bool, default=False
+        If True, returns ``(data, target)`` instead of a Bunch object. See
+        below for more information about the `data` and `target` object.
+
+        .. versionadded:: 0.18
+
+    as_frame : bool, default=False
+        If True, the data is a pandas DataFrame including columns with
+        appropriate dtypes (numeric). The target is
+        a pandas DataFrame or Series depending on the number of target columns.
+        If `return_X_y` is True, then (`data`, `target`) will be pandas
+        DataFrames or Series as described below.
+
+        .. versionadded:: 0.23
+
+    Returns
+    -------
+    data : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        data : {ndarray, dataframe} of shape (150, 4)
+            The data matrix. If `as_frame=True`, `data` will be a pandas
+            DataFrame.
+        target: {ndarray, Series} of shape (150,)
+            The classification target. If `as_frame=True`, `target` will be
+            a pandas Series.
+        feature_names: list
+            The names of the dataset columns.
+        target_names: list
+            The names of target classes.
+        frame: DataFrame of shape (150, 5)
+            Only present when `as_frame=True`. DataFrame with `data` and
+            `target`.
+
+            .. versionadded:: 0.23
+        DESCR: str
+            The full description of the dataset.
+        filename: str
+            The path to the location of the data.
+
+            .. versionadded:: 0.20
+
+    (data, target) : tuple if ``return_X_y`` is True
+        A tuple of two ndarray. The first containing a 2D array of shape
+        (n_samples, n_features) with each row representing one sample and
+        each column representing the features. The second ndarray of shape
+        (n_samples,) containing the target samples.
+
+        .. versionadded:: 0.18
+
+    Notes
+    -----
+        .. versionchanged:: 0.20
+            Fixed two wrong data points according to Fisher's paper.
+            The new version is the same as in R, but not as in the UCI
+            Machine Learning Repository.
+
+    Examples
+    --------
+    Let's say you are interested in the samples 10, 25, and 50, and want to
+    know their class name.
+
+    >>> from sklearn.datasets import load_iris
+    >>> data = load_iris()
+    >>> data.target[[10, 25, 50]]
+    array([0, 0, 1])
+    >>> list(data.target_names)
+    ['setosa', 'versicolor', 'virginica']
+
+    See :ref:`sphx_glr_auto_examples_datasets_plot_iris_dataset.py` for a more
+    detailed example of how to work with the iris dataset.
+    """
+    data_file_name = "iris.csv"
+    data, target, target_names, fdescr = load_csv_data(
+        data_file_name=data_file_name, descr_file_name="iris.rst"
+    )
+
+    feature_names = [
+        "sepal length (cm)",
+        "sepal width (cm)",
+        "petal length (cm)",
+        "petal width (cm)",
+    ]
+
+    frame = None
+    target_columns = [
+        "target",
+    ]
+    if as_frame:
+        frame, data, target = _convert_data_dataframe(
+            "load_iris", data, target, feature_names, target_columns
+        )
+
+    if return_X_y:
+        return data, target
+
+    return Bunch(
+        data=data,
+        target=target,
+        frame=frame,
+        target_names=target_names,
+        DESCR=fdescr,
+        feature_names=feature_names,
+        filename=data_file_name,
+        data_module=DATA_MODULE,
+    )
+
+
+@validate_params(
+    {"return_X_y": ["boolean"], "as_frame": ["boolean"]},
+    prefer_skip_nested_validation=True,
+)
+def load_breast_cancer(*, return_X_y=False, as_frame=False):
+    """Load and return the breast cancer wisconsin dataset (classification).
+
+    The breast cancer dataset is a classic and very easy binary classification
+    dataset.
+
+    =================   ==============
+    Classes                          2
+    Samples per class    212(M),357(B)
+    Samples total                  569
+    Dimensionality                  30
+    Features            real, positive
+    =================   ==============
+
+    The copy of UCI ML Breast Cancer Wisconsin (Diagnostic) dataset is
+    downloaded from:
+    https://archive.ics.uci.edu/dataset/17/breast+cancer+wisconsin+diagnostic
+
+    Read more in the :ref:`User Guide <breast_cancer_dataset>`.
+
+    Parameters
+    ----------
+    return_X_y : bool, default=False
+        If True, returns ``(data, target)`` instead of a Bunch object.
+        See below for more information about the `data` and `target` object.
+
+        .. versionadded:: 0.18
+
+    as_frame : bool, default=False
+        If True, the data is a pandas DataFrame including columns with
+        appropriate dtypes (numeric). The target is
+        a pandas DataFrame or Series depending on the number of target columns.
+        If `return_X_y` is True, then (`data`, `target`) will be pandas
+        DataFrames or Series as described below.
+
+        .. versionadded:: 0.23
+
+    Returns
+    -------
+    data : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        data : {ndarray, dataframe} of shape (569, 30)
+            The data matrix. If `as_frame=True`, `data` will be a pandas
+            DataFrame.
+        target : {ndarray, Series} of shape (569,)
+            The classification target. If `as_frame=True`, `target` will be
+            a pandas Series.
+        feature_names : ndarray of shape (30,)
+            The names of the dataset columns.
+        target_names : ndarray of shape (2,)
+            The names of target classes.
+        frame : DataFrame of shape (569, 31)
+            Only present when `as_frame=True`. DataFrame with `data` and
+            `target`.
+
+            .. versionadded:: 0.23
+        DESCR : str
+            The full description of the dataset.
+        filename : str
+            The path to the location of the data.
+
+            .. versionadded:: 0.20
+
+    (data, target) : tuple if ``return_X_y`` is True
+        A tuple of two ndarrays by default. The first contains a 2D ndarray of
+        shape (569, 30) with each row representing one sample and each column
+        representing the features. The second ndarray of shape (569,) contains
+        the target samples.  If `as_frame=True`, both arrays are pandas objects,
+        i.e. `X` a dataframe and `y` a series.
+
+        .. versionadded:: 0.18
+
+    Examples
+    --------
+    Let's say you are interested in the samples 10, 50, and 85, and want to
+    know their class name.
+
+    >>> from sklearn.datasets import load_breast_cancer
+    >>> data = load_breast_cancer()
+    >>> data.target[[10, 50, 85]]
+    array([0, 1, 0])
+    >>> list(data.target_names)
+    ['malignant', 'benign']
+    """
+    data_file_name = "breast_cancer.csv"
+    data, target, target_names, fdescr = load_csv_data(
+        data_file_name=data_file_name, descr_file_name="breast_cancer.rst"
+    )
+
+    feature_names = np.array(
+        [
+            "mean radius",
+            "mean texture",
+            "mean perimeter",
+            "mean area",
+            "mean smoothness",
+            "mean compactness",
+            "mean concavity",
+            "mean concave points",
+            "mean symmetry",
+            "mean fractal dimension",
+            "radius error",
+            "texture error",
+            "perimeter error",
+            "area error",
+            "smoothness error",
+            "compactness error",
+            "concavity error",
+            "concave points error",
+            "symmetry error",
+            "fractal dimension error",
+            "worst radius",
+            "worst texture",
+            "worst perimeter",
+            "worst area",
+            "worst smoothness",
+            "worst compactness",
+            "worst concavity",
+            "worst concave points",
+            "worst symmetry",
+            "worst fractal dimension",
+        ]
+    )
+
+    frame = None
+    target_columns = [
+        "target",
+    ]
+    if as_frame:
+        frame, data, target = _convert_data_dataframe(
+            "load_breast_cancer", data, target, feature_names, target_columns
+        )
+
+    if return_X_y:
+        return data, target
+
+    return Bunch(
+        data=data,
+        target=target,
+        frame=frame,
+        target_names=target_names,
+        DESCR=fdescr,
+        feature_names=feature_names,
+        filename=data_file_name,
+        data_module=DATA_MODULE,
+    )
+
+
+@validate_params(
+    {
+        "n_class": [Interval(Integral, 1, 10, closed="both")],
+        "return_X_y": ["boolean"],
+        "as_frame": ["boolean"],
+    },
+    prefer_skip_nested_validation=True,
+)
+def load_digits(*, n_class=10, return_X_y=False, as_frame=False):
+    """Load and return the digits dataset (classification).
+
+    Each datapoint is a 8x8 image of a digit.
+
+    =================   ==============
+    Classes                         10
+    Samples per class             ~180
+    Samples total                 1797
+    Dimensionality                  64
+    Features             integers 0-16
+    =================   ==============
+
+    This is a copy of the test set of the UCI ML hand-written digits datasets
+    https://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits
+
+    Read more in the :ref:`User Guide <digits_dataset>`.
+
+    Parameters
+    ----------
+    n_class : int, default=10
+        The number of classes to return. Between 0 and 10.
+
+    return_X_y : bool, default=False
+        If True, returns ``(data, target)`` instead of a Bunch object.
+        See below for more information about the `data` and `target` object.
+
+        .. versionadded:: 0.18
+
+    as_frame : bool, default=False
+        If True, the data is a pandas DataFrame including columns with
+        appropriate dtypes (numeric). The target is
+        a pandas DataFrame or Series depending on the number of target columns.
+        If `return_X_y` is True, then (`data`, `target`) will be pandas
+        DataFrames or Series as described below.
+
+        .. versionadded:: 0.23
+
+    Returns
+    -------
+    data : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        data : {ndarray, dataframe} of shape (1797, 64)
+            The flattened data matrix. If `as_frame=True`, `data` will be
+            a pandas DataFrame.
+        target: {ndarray, Series} of shape (1797,)
+            The classification target. If `as_frame=True`, `target` will be
+            a pandas Series.
+        feature_names: list
+            The names of the dataset columns.
+        target_names: list
+            The names of target classes.
+
+            .. versionadded:: 0.20
+
+        frame: DataFrame of shape (1797, 65)
+            Only present when `as_frame=True`. DataFrame with `data` and
+            `target`.
+
+            .. versionadded:: 0.23
+        images: {ndarray} of shape (1797, 8, 8)
+            The raw image data.
+        DESCR: str
+            The full description of the dataset.
+
+    (data, target) : tuple if ``return_X_y`` is True
+        A tuple of two ndarrays by default. The first contains a 2D ndarray of
+        shape (1797, 64) with each row representing one sample and each column
+        representing the features. The second ndarray of shape (1797) contains
+        the target samples.  If `as_frame=True`, both arrays are pandas objects,
+        i.e. `X` a dataframe and `y` a series.
+
+        .. versionadded:: 0.18
+
+    Examples
+    --------
+    To load the data and visualize the images::
+
+        >>> from sklearn.datasets import load_digits
+        >>> digits = load_digits()
+        >>> print(digits.data.shape)
+        (1797, 64)
+        >>> import matplotlib.pyplot as plt
+        >>> plt.gray()
+        >>> plt.matshow(digits.images[0])
+        <...>
+        >>> plt.show()
+    """
+
+    data, fdescr = load_gzip_compressed_csv_data(
+        data_file_name="digits.csv.gz", descr_file_name="digits.rst", delimiter=","
+    )
+
+    target = data[:, -1].astype(int, copy=False)
+    flat_data = data[:, :-1]
+    images = flat_data.view()
+    images.shape = (-1, 8, 8)
+
+    if n_class < 10:
+        idx = target < n_class
+        flat_data, target = flat_data[idx], target[idx]
+        images = images[idx]
+
+    feature_names = [
+        "pixel_{}_{}".format(row_idx, col_idx)
+        for row_idx in range(8)
+        for col_idx in range(8)
+    ]
+
+    frame = None
+    target_columns = [
+        "target",
+    ]
+    if as_frame:
+        frame, flat_data, target = _convert_data_dataframe(
+            "load_digits", flat_data, target, feature_names, target_columns
+        )
+
+    if return_X_y:
+        return flat_data, target
+
+    return Bunch(
+        data=flat_data,
+        target=target,
+        frame=frame,
+        feature_names=feature_names,
+        target_names=np.arange(10),
+        images=images,
+        DESCR=fdescr,
+    )
+
+
+@validate_params(
+    {"return_X_y": ["boolean"], "as_frame": ["boolean"], "scaled": ["boolean"]},
+    prefer_skip_nested_validation=True,
+)
+def load_diabetes(*, return_X_y=False, as_frame=False, scaled=True):
+    """Load and return the diabetes dataset (regression).
+
+    ==============   ==================
+    Samples total    442
+    Dimensionality   10
+    Features         real, -.2 < x < .2
+    Targets          integer 25 - 346
+    ==============   ==================
+
+    .. note::
+       The meaning of each feature (i.e. `feature_names`) might be unclear
+       (especially for `ltg`) as the documentation of the original dataset is
+       not explicit. We provide information that seems correct in regard with
+       the scientific literature in this field of research.
+
+    Read more in the :ref:`User Guide <diabetes_dataset>`.
+
+    Parameters
+    ----------
+    return_X_y : bool, default=False
+        If True, returns ``(data, target)`` instead of a Bunch object.
+        See below for more information about the `data` and `target` object.
+
+        .. versionadded:: 0.18
+
+    as_frame : bool, default=False
+        If True, the data is a pandas DataFrame including columns with
+        appropriate dtypes (numeric). The target is
+        a pandas DataFrame or Series depending on the number of target columns.
+        If `return_X_y` is True, then (`data`, `target`) will be pandas
+        DataFrames or Series as described below.
+
+        .. versionadded:: 0.23
+
+    scaled : bool, default=True
+        If True, the feature variables are mean centered and scaled by the
+        standard deviation times the square root of `n_samples`.
+        If False, raw data is returned for the feature variables.
+
+        .. versionadded:: 1.1
+
+    Returns
+    -------
+    data : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        data : {ndarray, dataframe} of shape (442, 10)
+            The data matrix. If `as_frame=True`, `data` will be a pandas
+            DataFrame.
+        target: {ndarray, Series} of shape (442,)
+            The regression target. If `as_frame=True`, `target` will be
+            a pandas Series.
+        feature_names: list
+            The names of the dataset columns.
+        frame: DataFrame of shape (442, 11)
+            Only present when `as_frame=True`. DataFrame with `data` and
+            `target`.
+
+            .. versionadded:: 0.23
+        DESCR: str
+            The full description of the dataset.
+        data_filename: str
+            The path to the location of the data.
+        target_filename: str
+            The path to the location of the target.
+
+    (data, target) : tuple if ``return_X_y`` is True
+        Returns a tuple of two ndarray of shape (n_samples, n_features)
+        A 2D array with each row representing one sample and each column
+        representing the features and/or target of a given sample.
+
+        .. versionadded:: 0.18
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_diabetes
+    >>> diabetes = load_diabetes()
+    >>> diabetes.target[:3]
+    array([151.,  75., 141.])
+    >>> diabetes.data.shape
+    (442, 10)
+    """
+    data_filename = "diabetes_data_raw.csv.gz"
+    target_filename = "diabetes_target.csv.gz"
+    data = load_gzip_compressed_csv_data(data_filename)
+    target = load_gzip_compressed_csv_data(target_filename)
+
+    if scaled:
+        data = scale(data, copy=False)
+        data /= data.shape[0] ** 0.5
+
+    fdescr = load_descr("diabetes.rst")
+
+    feature_names = ["age", "sex", "bmi", "bp", "s1", "s2", "s3", "s4", "s5", "s6"]
+
+    frame = None
+    target_columns = [
+        "target",
+    ]
+    if as_frame:
+        frame, data, target = _convert_data_dataframe(
+            "load_diabetes", data, target, feature_names, target_columns
+        )
+
+    if return_X_y:
+        return data, target
+
+    return Bunch(
+        data=data,
+        target=target,
+        frame=frame,
+        DESCR=fdescr,
+        feature_names=feature_names,
+        data_filename=data_filename,
+        target_filename=target_filename,
+        data_module=DATA_MODULE,
+    )
+
+
+@validate_params(
+    {
+        "return_X_y": ["boolean"],
+        "as_frame": ["boolean"],
+    },
+    prefer_skip_nested_validation=True,
+)
+def load_linnerud(*, return_X_y=False, as_frame=False):
+    """Load and return the physical exercise Linnerud dataset.
+
+    This dataset is suitable for multi-output regression tasks.
+
+    ==============   ============================
+    Samples total    20
+    Dimensionality   3 (for both data and target)
+    Features         integer
+    Targets          integer
+    ==============   ============================
+
+    Read more in the :ref:`User Guide <linnerrud_dataset>`.
+
+    Parameters
+    ----------
+    return_X_y : bool, default=False
+        If True, returns ``(data, target)`` instead of a Bunch object.
+        See below for more information about the `data` and `target` object.
+
+        .. versionadded:: 0.18
+
+    as_frame : bool, default=False
+        If True, the data is a pandas DataFrame including columns with
+        appropriate dtypes (numeric, string or categorical). The target is
+        a pandas DataFrame or Series depending on the number of target columns.
+        If `return_X_y` is True, then (`data`, `target`) will be pandas
+        DataFrames or Series as described below.
+
+        .. versionadded:: 0.23
+
+    Returns
+    -------
+    data : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        data : {ndarray, dataframe} of shape (20, 3)
+            The data matrix. If `as_frame=True`, `data` will be a pandas
+            DataFrame.
+        target: {ndarray, dataframe} of shape (20, 3)
+            The regression targets. If `as_frame=True`, `target` will be
+            a pandas DataFrame.
+        feature_names: list
+            The names of the dataset columns.
+        target_names: list
+            The names of the target columns.
+        frame: DataFrame of shape (20, 6)
+            Only present when `as_frame=True`. DataFrame with `data` and
+            `target`.
+
+            .. versionadded:: 0.23
+        DESCR: str
+            The full description of the dataset.
+        data_filename: str
+            The path to the location of the data.
+        target_filename: str
+            The path to the location of the target.
+
+            .. versionadded:: 0.20
+
+    (data, target) : tuple if ``return_X_y`` is True
+        Returns a tuple of two ndarrays or dataframe of shape
+        `(20, 3)`. Each row represents one sample and each column represents the
+        features in `X` and a target in `y` of a given sample.
+
+        .. versionadded:: 0.18
+    """
+    data_filename = "linnerud_exercise.csv"
+    target_filename = "linnerud_physiological.csv"
+
+    data_module_path = resources.files(DATA_MODULE)
+    # Read header and data
+    data_path = data_module_path / data_filename
+    with data_path.open("r", encoding="utf-8") as f:
+        header_exercise = f.readline().split()
+        f.seek(0)  # reset file obj
+        data_exercise = np.loadtxt(f, skiprows=1)
+
+    target_path = data_module_path / target_filename
+    with target_path.open("r", encoding="utf-8") as f:
+        header_physiological = f.readline().split()
+        f.seek(0)  # reset file obj
+        data_physiological = np.loadtxt(f, skiprows=1)
+
+    fdescr = load_descr("linnerud.rst")
+
+    frame = None
+    if as_frame:
+        (frame, data_exercise, data_physiological) = _convert_data_dataframe(
+            "load_linnerud",
+            data_exercise,
+            data_physiological,
+            header_exercise,
+            header_physiological,
+        )
+    if return_X_y:
+        return data_exercise, data_physiological
+
+    return Bunch(
+        data=data_exercise,
+        feature_names=header_exercise,
+        target=data_physiological,
+        target_names=header_physiological,
+        frame=frame,
+        DESCR=fdescr,
+        data_filename=data_filename,
+        target_filename=target_filename,
+        data_module=DATA_MODULE,
+    )
+
+
+def load_sample_images():
+    """Load sample images for image manipulation.
+
+    Loads both, ``china`` and ``flower``.
+
+    Read more in the :ref:`User Guide <sample_images>`.
+
+    Returns
+    -------
+    data : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        images : list of ndarray of shape (427, 640, 3)
+            The two sample image.
+        filenames : list
+            The filenames for the images.
+        DESCR : str
+            The full description of the dataset.
+
+    Examples
+    --------
+    To load the data and visualize the images:
+
+    >>> from sklearn.datasets import load_sample_images
+    >>> dataset = load_sample_images()     #doctest: +SKIP
+    >>> len(dataset.images)                #doctest: +SKIP
+    2
+    >>> first_img_data = dataset.images[0] #doctest: +SKIP
+    >>> first_img_data.shape               #doctest: +SKIP
+    (427, 640, 3)
+    >>> first_img_data.dtype               #doctest: +SKIP
+    dtype('uint8')
+    """
+    try:
+        from PIL import Image
+    except ImportError:
+        raise ImportError(
+            "The Python Imaging Library (PIL) is required to load data "
+            "from jpeg files. Please refer to "
+            "https://pillow.readthedocs.io/en/stable/installation.html "
+            "for installing PIL."
+        )
+
+    descr = load_descr("README.txt", descr_module=IMAGES_MODULE)
+
+    filenames, images = [], []
+
+    jpg_paths = sorted(
+        resource
+        for resource in resources.files(IMAGES_MODULE).iterdir()
+        if resource.is_file() and resource.match("*.jpg")
+    )
+
+    for path in jpg_paths:
+        filenames.append(str(path))
+        with path.open("rb") as image_file:
+            pil_image = Image.open(image_file)
+            image = np.asarray(pil_image)
+        images.append(image)
+
+    return Bunch(images=images, filenames=filenames, DESCR=descr)
+
+
+@validate_params(
+    {
+        "image_name": [StrOptions({"china.jpg", "flower.jpg"})],
+    },
+    prefer_skip_nested_validation=True,
+)
+def load_sample_image(image_name):
+    """Load the numpy array of a single sample image.
+
+    Read more in the :ref:`User Guide <sample_images>`.
+
+    Parameters
+    ----------
+    image_name : {`china.jpg`, `flower.jpg`}
+        The name of the sample image loaded.
+
+    Returns
+    -------
+    img : 3D array
+        The image as a numpy array: height x width x color.
+
+    Examples
+    --------
+
+    >>> from sklearn.datasets import load_sample_image
+    >>> china = load_sample_image('china.jpg')   # doctest: +SKIP
+    >>> china.dtype                              # doctest: +SKIP
+    dtype('uint8')
+    >>> china.shape                              # doctest: +SKIP
+    (427, 640, 3)
+    >>> flower = load_sample_image('flower.jpg') # doctest: +SKIP
+    >>> flower.dtype                             # doctest: +SKIP
+    dtype('uint8')
+    >>> flower.shape                             # doctest: +SKIP
+    (427, 640, 3)
+    """
+    images = load_sample_images()
+    index = None
+    for i, filename in enumerate(images.filenames):
+        if filename.endswith(image_name):
+            index = i
+            break
+    if index is None:
+        raise AttributeError("Cannot find sample image: %s" % image_name)
+    return images.images[index]
+
+
+def _pkl_filepath(*args, **kwargs):
+    """Return filename for Python 3 pickles
+
+    args[-1] is expected to be the ".pkl" filename. For compatibility with
+    older scikit-learn versions, a suffix is inserted before the extension.
+
+    _pkl_filepath('/path/to/folder', 'filename.pkl') returns
+    '/path/to/folder/filename_py3.pkl'
+
+    """
+    py3_suffix = kwargs.get("py3_suffix", "_py3")
+    basename, ext = splitext(args[-1])
+    basename += py3_suffix
+    new_args = args[:-1] + (basename + ext,)
+    return join(*new_args)
+
+
+def _sha256(path):
+    """Calculate the sha256 hash of the file at path."""
+    sha256hash = hashlib.sha256()
+    chunk_size = 8192
+    with open(path, "rb") as f:
+        while True:
+            buffer = f.read(chunk_size)
+            if not buffer:
+                break
+            sha256hash.update(buffer)
+    return sha256hash.hexdigest()
+
+
+def _fetch_remote(remote, dirname=None):
+    """Helper function to download a remote dataset into path
+
+    Fetch a dataset pointed by remote's url, save into path using remote's
+    filename and ensure its integrity based on the SHA256 Checksum of the
+    downloaded file.
+
+    Parameters
+    ----------
+    remote : RemoteFileMetadata
+        Named tuple containing remote dataset meta information: url, filename
+        and checksum
+
+    dirname : str
+        Directory to save the file to.
+
+    Returns
+    -------
+    file_path: str
+        Full path of the created file.
+    """
+
+    file_path = remote.filename if dirname is None else join(dirname, remote.filename)
+    urlretrieve(remote.url, file_path)
+    checksum = _sha256(file_path)
+    if remote.checksum != checksum:
+        raise OSError(
+            "{} has an SHA256 checksum ({}) "
+            "differing from expected ({}), "
+            "file may be corrupted.".format(file_path, checksum, remote.checksum)
+        )
+    return file_path

venv/lib/python3.10/site-packages/sklearn/datasets/_covtype.py

@@ -0,0 +1,236 @@
+"""Forest covertype dataset.
+
+A classic dataset for classification benchmarks, featuring categorical and
+real-valued features.
+
+The dataset page is available from UCI Machine Learning Repository
+
+    https://archive.ics.uci.edu/ml/datasets/Covertype
+
+Courtesy of Jock A. Blackard and Colorado State University.
+"""
+
+# Author: Lars Buitinck
+#         Peter Prettenhofer <[email protected]>
+# License: BSD 3 clause
+
+import logging
+import os
+from gzip import GzipFile
+from os.path import exists, join
+from tempfile import TemporaryDirectory
+
+import joblib
+import numpy as np
+
+from ..utils import Bunch, check_random_state
+from ..utils._param_validation import validate_params
+from . import get_data_home
+from ._base import (
+    RemoteFileMetadata,
+    _convert_data_dataframe,
+    _fetch_remote,
+    _pkl_filepath,
+    load_descr,
+)
+
+# The original data can be found in:
+# https://archive.ics.uci.edu/ml/machine-learning-databases/covtype/covtype.data.gz
+ARCHIVE = RemoteFileMetadata(
+    filename="covtype.data.gz",
+    url="https://ndownloader.figshare.com/files/5976039",
+    checksum="614360d0257557dd1792834a85a1cdebfadc3c4f30b011d56afee7ffb5b15771",
+)
+
+logger = logging.getLogger(__name__)
+
+# Column names reference:
+# https://archive.ics.uci.edu/ml/machine-learning-databases/covtype/covtype.info
+FEATURE_NAMES = [
+    "Elevation",
+    "Aspect",
+    "Slope",
+    "Horizontal_Distance_To_Hydrology",
+    "Vertical_Distance_To_Hydrology",
+    "Horizontal_Distance_To_Roadways",
+    "Hillshade_9am",
+    "Hillshade_Noon",
+    "Hillshade_3pm",
+    "Horizontal_Distance_To_Fire_Points",
+]
+FEATURE_NAMES += [f"Wilderness_Area_{i}" for i in range(4)]
+FEATURE_NAMES += [f"Soil_Type_{i}" for i in range(40)]
+TARGET_NAMES = ["Cover_Type"]
+
+
+@validate_params(
+    {
+        "data_home": [str, os.PathLike, None],
+        "download_if_missing": ["boolean"],
+        "random_state": ["random_state"],
+        "shuffle": ["boolean"],
+        "return_X_y": ["boolean"],
+        "as_frame": ["boolean"],
+    },
+    prefer_skip_nested_validation=True,
+)
+def fetch_covtype(
+    *,
+    data_home=None,
+    download_if_missing=True,
+    random_state=None,
+    shuffle=False,
+    return_X_y=False,
+    as_frame=False,
+):
+    """Load the covertype dataset (classification).
+
+    Download it if necessary.
+
+    =================   ============
+    Classes                        7
+    Samples total             581012
+    Dimensionality                54
+    Features                     int
+    =================   ============
+
+    Read more in the :ref:`User Guide <covtype_dataset>`.
+
+    Parameters
+    ----------
+    data_home : str or path-like, default=None
+        Specify another download and cache folder for the datasets. By default
+        all scikit-learn data is stored in '~/scikit_learn_data' subfolders.
+
+    download_if_missing : bool, default=True
+        If False, raise an OSError if the data is not locally available
+        instead of trying to download the data from the source site.
+
+    random_state : int, RandomState instance or None, default=None
+        Determines random number generation for dataset shuffling. Pass an int
+        for reproducible output across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    shuffle : bool, default=False
+        Whether to shuffle dataset.
+
+    return_X_y : bool, default=False
+        If True, returns ``(data.data, data.target)`` instead of a Bunch
+        object.
+
+        .. versionadded:: 0.20
+
+    as_frame : bool, default=False
+        If True, the data is a pandas DataFrame including columns with
+        appropriate dtypes (numeric). The target is a pandas DataFrame or
+        Series depending on the number of target columns. If `return_X_y` is
+        True, then (`data`, `target`) will be pandas DataFrames or Series as
+        described below.
+
+        .. versionadded:: 0.24
+
+    Returns
+    -------
+    dataset : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        data : ndarray of shape (581012, 54)
+            Each row corresponds to the 54 features in the dataset.
+        target : ndarray of shape (581012,)
+            Each value corresponds to one of
+            the 7 forest covertypes with values
+            ranging between 1 to 7.
+        frame : dataframe of shape (581012, 55)
+            Only present when `as_frame=True`. Contains `data` and `target`.
+        DESCR : str
+            Description of the forest covertype dataset.
+        feature_names : list
+            The names of the dataset columns.
+        target_names: list
+            The names of the target columns.
+
+    (data, target) : tuple if ``return_X_y`` is True
+        A tuple of two ndarray. The first containing a 2D array of
+        shape (n_samples, n_features) with each row representing one
+        sample and each column representing the features. The second
+        ndarray of shape (n_samples,) containing the target samples.
+
+        .. versionadded:: 0.20
+
+    Examples
+    --------
+    >>> from sklearn.datasets import fetch_covtype
+    >>> cov_type = fetch_covtype()
+    >>> cov_type.data.shape
+    (581012, 54)
+    >>> cov_type.target.shape
+    (581012,)
+    >>> # Let's check the 4 first feature names
+    >>> cov_type.feature_names[:4]
+    ['Elevation', 'Aspect', 'Slope', 'Horizontal_Distance_To_Hydrology']
+    """
+    data_home = get_data_home(data_home=data_home)
+    covtype_dir = join(data_home, "covertype")
+    samples_path = _pkl_filepath(covtype_dir, "samples")
+    targets_path = _pkl_filepath(covtype_dir, "targets")
+    available = exists(samples_path) and exists(targets_path)
+
+    if download_if_missing and not available:
+        os.makedirs(covtype_dir, exist_ok=True)
+
+        # Creating temp_dir as a direct subdirectory of the target directory
+        # guarantees that both reside on the same filesystem, so that we can use
+        # os.rename to atomically move the data files to their target location.
+        with TemporaryDirectory(dir=covtype_dir) as temp_dir:
+            logger.info(f"Downloading {ARCHIVE.url}")
+            archive_path = _fetch_remote(ARCHIVE, dirname=temp_dir)
+            Xy = np.genfromtxt(GzipFile(filename=archive_path), delimiter=",")
+
+            X = Xy[:, :-1]
+            y = Xy[:, -1].astype(np.int32, copy=False)
+
+            samples_tmp_path = _pkl_filepath(temp_dir, "samples")
+            joblib.dump(X, samples_tmp_path, compress=9)
+            os.rename(samples_tmp_path, samples_path)
+
+            targets_tmp_path = _pkl_filepath(temp_dir, "targets")
+            joblib.dump(y, targets_tmp_path, compress=9)
+            os.rename(targets_tmp_path, targets_path)
+
+    elif not available and not download_if_missing:
+        raise OSError("Data not found and `download_if_missing` is False")
+    try:
+        X, y
+    except NameError:
+        X = joblib.load(samples_path)
+        y = joblib.load(targets_path)
+
+    if shuffle:
+        ind = np.arange(X.shape[0])
+        rng = check_random_state(random_state)
+        rng.shuffle(ind)
+        X = X[ind]
+        y = y[ind]
+
+    fdescr = load_descr("covtype.rst")
+
+    frame = None
+    if as_frame:
+        frame, X, y = _convert_data_dataframe(
+            caller_name="fetch_covtype",
+            data=X,
+            target=y,
+            feature_names=FEATURE_NAMES,
+            target_names=TARGET_NAMES,
+        )
+    if return_X_y:
+        return X, y
+
+    return Bunch(
+        data=X,
+        target=y,
+        frame=frame,
+        target_names=TARGET_NAMES,
+        feature_names=FEATURE_NAMES,
+        DESCR=fdescr,
+    )

venv/lib/python3.10/site-packages/sklearn/datasets/_olivetti_faces.py

@@ -0,0 +1,156 @@
+"""Modified Olivetti faces dataset.
+
+The original database was available from (now defunct)
+
+    https://www.cl.cam.ac.uk/research/dtg/attarchive/facedatabase.html
+
+The version retrieved here comes in MATLAB format from the personal
+web page of Sam Roweis:
+
+    https://cs.nyu.edu/~roweis/
+"""
+
+# Copyright (c) 2011 David Warde-Farley <wardefar at iro dot umontreal dot ca>
+# License: BSD 3 clause
+
+from os import PathLike, makedirs, remove
+from os.path import exists
+
+import joblib
+import numpy as np
+from scipy.io import loadmat
+
+from ..utils import Bunch, check_random_state
+from ..utils._param_validation import validate_params
+from . import get_data_home
+from ._base import RemoteFileMetadata, _fetch_remote, _pkl_filepath, load_descr
+
+# The original data can be found at:
+# https://cs.nyu.edu/~roweis/data/olivettifaces.mat
+FACES = RemoteFileMetadata(
+    filename="olivettifaces.mat",
+    url="https://ndownloader.figshare.com/files/5976027",
+    checksum="b612fb967f2dc77c9c62d3e1266e0c73d5fca46a4b8906c18e454d41af987794",
+)
+
+
+@validate_params(
+    {
+        "data_home": [str, PathLike, None],
+        "shuffle": ["boolean"],
+        "random_state": ["random_state"],
+        "download_if_missing": ["boolean"],
+        "return_X_y": ["boolean"],
+    },
+    prefer_skip_nested_validation=True,
+)
+def fetch_olivetti_faces(
+    *,
+    data_home=None,
+    shuffle=False,
+    random_state=0,
+    download_if_missing=True,
+    return_X_y=False,
+):
+    """Load the Olivetti faces data-set from AT&T (classification).
+
+    Download it if necessary.
+
+    =================   =====================
+    Classes                                40
+    Samples total                         400
+    Dimensionality                       4096
+    Features            real, between 0 and 1
+    =================   =====================
+
+    Read more in the :ref:`User Guide <olivetti_faces_dataset>`.
+
+    Parameters
+    ----------
+    data_home : str or path-like, default=None
+        Specify another download and cache folder for the datasets. By default
+        all scikit-learn data is stored in '~/scikit_learn_data' subfolders.
+
+    shuffle : bool, default=False
+        If True the order of the dataset is shuffled to avoid having
+        images of the same person grouped.
+
+    random_state : int, RandomState instance or None, default=0
+        Determines random number generation for dataset shuffling. Pass an int
+        for reproducible output across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    download_if_missing : bool, default=True
+        If False, raise an OSError if the data is not locally available
+        instead of trying to download the data from the source site.
+
+    return_X_y : bool, default=False
+        If True, returns `(data, target)` instead of a `Bunch` object. See
+        below for more information about the `data` and `target` object.
+
+        .. versionadded:: 0.22
+
+    Returns
+    -------
+    data : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        data: ndarray, shape (400, 4096)
+            Each row corresponds to a ravelled
+            face image of original size 64 x 64 pixels.
+        images : ndarray, shape (400, 64, 64)
+            Each row is a face image
+            corresponding to one of the 40 subjects of the dataset.
+        target : ndarray, shape (400,)
+            Labels associated to each face image.
+            Those labels are ranging from 0-39 and correspond to the
+            Subject IDs.
+        DESCR : str
+            Description of the modified Olivetti Faces Dataset.
+
+    (data, target) : tuple if `return_X_y=True`
+        Tuple with the `data` and `target` objects described above.
+
+        .. versionadded:: 0.22
+    """
+    data_home = get_data_home(data_home=data_home)
+    if not exists(data_home):
+        makedirs(data_home)
+    filepath = _pkl_filepath(data_home, "olivetti.pkz")
+    if not exists(filepath):
+        if not download_if_missing:
+            raise OSError("Data not found and `download_if_missing` is False")
+
+        print("downloading Olivetti faces from %s to %s" % (FACES.url, data_home))
+        mat_path = _fetch_remote(FACES, dirname=data_home)
+        mfile = loadmat(file_name=mat_path)
+        # delete raw .mat data
+        remove(mat_path)
+
+        faces = mfile["faces"].T.copy()
+        joblib.dump(faces, filepath, compress=6)
+        del mfile
+    else:
+        faces = joblib.load(filepath)
+
+    # We want floating point data, but float32 is enough (there is only
+    # one byte of precision in the original uint8s anyway)
+    faces = np.float32(faces)
+    faces = faces - faces.min()
+    faces /= faces.max()
+    faces = faces.reshape((400, 64, 64)).transpose(0, 2, 1)
+    # 10 images per class, 400 images total, each class is contiguous.
+    target = np.array([i // 10 for i in range(400)])
+    if shuffle:
+        random_state = check_random_state(random_state)
+        order = random_state.permutation(len(faces))
+        faces = faces[order]
+        target = target[order]
+    faces_vectorized = faces.reshape(len(faces), -1)
+
+    fdescr = load_descr("olivetti_faces.rst")
+
+    if return_X_y:
+        return faces_vectorized, target
+
+    return Bunch(data=faces_vectorized, images=faces, target=target, DESCR=fdescr)

venv/lib/python3.10/site-packages/sklearn/datasets/_openml.py

@@ -0,0 +1,1158 @@
+import gzip
+import hashlib
+import json
+import os
+import shutil
+import time
+from contextlib import closing
+from functools import wraps
+from os.path import join
+from tempfile import TemporaryDirectory
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+from warnings import warn
+
+import numpy as np
+
+from ..utils import (
+    Bunch,
+    check_pandas_support,  # noqa  # noqa
+)
+from ..utils._param_validation import (
+    Integral,
+    Interval,
+    Real,
+    StrOptions,
+    validate_params,
+)
+from . import get_data_home
+from ._arff_parser import load_arff_from_gzip_file
+
+__all__ = ["fetch_openml"]
+
+_OPENML_PREFIX = "https://api.openml.org/"
+_SEARCH_NAME = "api/v1/json/data/list/data_name/{}/limit/2"
+_DATA_INFO = "api/v1/json/data/{}"
+_DATA_FEATURES = "api/v1/json/data/features/{}"
+_DATA_QUALITIES = "api/v1/json/data/qualities/{}"
+_DATA_FILE = "data/v1/download/{}"
+
+OpenmlQualitiesType = List[Dict[str, str]]
+OpenmlFeaturesType = List[Dict[str, str]]
+
+
+def _get_local_path(openml_path: str, data_home: str) -> str:
+    return os.path.join(data_home, "openml.org", openml_path + ".gz")
+
+
+def _retry_with_clean_cache(
+    openml_path: str,
+    data_home: Optional[str],
+    no_retry_exception: Optional[Exception] = None,
+) -> Callable:
+    """If the first call to the decorated function fails, the local cached
+    file is removed, and the function is called again. If ``data_home`` is
+    ``None``, then the function is called once. We can provide a specific
+    exception to not retry on using `no_retry_exception` parameter.
+    """
+
+    def decorator(f):
+        @wraps(f)
+        def wrapper(*args, **kw):
+            if data_home is None:
+                return f(*args, **kw)
+            try:
+                return f(*args, **kw)
+            except URLError:
+                raise
+            except Exception as exc:
+                if no_retry_exception is not None and isinstance(
+                    exc, no_retry_exception
+                ):
+                    raise
+                warn("Invalid cache, redownloading file", RuntimeWarning)
+                local_path = _get_local_path(openml_path, data_home)
+                if os.path.exists(local_path):
+                    os.unlink(local_path)
+                return f(*args, **kw)
+
+        return wrapper
+
+    return decorator
+
+
+def _retry_on_network_error(
+    n_retries: int = 3, delay: float = 1.0, url: str = ""
+) -> Callable:
+    """If the function call results in a network error, call the function again
+    up to ``n_retries`` times with a ``delay`` between each call. If the error
+    has a 412 status code, don't call the function again as this is a specific
+    OpenML error.
+    The url parameter is used to give more information to the user about the
+    error.
+    """
+
+    def decorator(f):
+        @wraps(f)
+        def wrapper(*args, **kwargs):
+            retry_counter = n_retries
+            while True:
+                try:
+                    return f(*args, **kwargs)
+                except (URLError, TimeoutError) as e:
+                    # 412 is a specific OpenML error code.
+                    if isinstance(e, HTTPError) and e.code == 412:
+                        raise
+                    if retry_counter == 0:
+                        raise
+                    warn(
+                        f"A network error occurred while downloading {url}. Retrying..."
+                    )
+                    retry_counter -= 1
+                    time.sleep(delay)
+
+        return wrapper
+
+    return decorator
+
+
+def _open_openml_url(
+    openml_path: str, data_home: Optional[str], n_retries: int = 3, delay: float = 1.0
+):
+    """
+    Returns a resource from OpenML.org. Caches it to data_home if required.
+
+    Parameters
+    ----------
+    openml_path : str
+        OpenML URL that will be accessed. This will be prefixes with
+        _OPENML_PREFIX.
+
+    data_home : str
+        Directory to which the files will be cached. If None, no caching will
+        be applied.
+
+    n_retries : int, default=3
+        Number of retries when HTTP errors are encountered. Error with status
+        code 412 won't be retried as they represent OpenML generic errors.
+
+    delay : float, default=1.0
+        Number of seconds between retries.
+
+    Returns
+    -------
+    result : stream
+        A stream to the OpenML resource.
+    """
+
+    def is_gzip_encoded(_fsrc):
+        return _fsrc.info().get("Content-Encoding", "") == "gzip"
+
+    req = Request(_OPENML_PREFIX + openml_path)
+    req.add_header("Accept-encoding", "gzip")
+
+    if data_home is None:
+        fsrc = _retry_on_network_error(n_retries, delay, req.full_url)(urlopen)(req)
+        if is_gzip_encoded(fsrc):
+            return gzip.GzipFile(fileobj=fsrc, mode="rb")
+        return fsrc
+
+    local_path = _get_local_path(openml_path, data_home)
+    dir_name, file_name = os.path.split(local_path)
+    if not os.path.exists(local_path):
+        os.makedirs(dir_name, exist_ok=True)
+        try:
+            # Create a tmpdir as a subfolder of dir_name where the final file will
+            # be moved to if the download is successful. This guarantees that the
+            # renaming operation to the final location is atomic to ensure the
+            # concurrence safety of the dataset caching mechanism.
+            with TemporaryDirectory(dir=dir_name) as tmpdir:
+                with closing(
+                    _retry_on_network_error(n_retries, delay, req.full_url)(urlopen)(
+                        req
+                    )
+                ) as fsrc:
+                    opener: Callable
+                    if is_gzip_encoded(fsrc):
+                        opener = open
+                    else:
+                        opener = gzip.GzipFile
+                    with opener(os.path.join(tmpdir, file_name), "wb") as fdst:
+                        shutil.copyfileobj(fsrc, fdst)
+                shutil.move(fdst.name, local_path)
+        except Exception:
+            if os.path.exists(local_path):
+                os.unlink(local_path)
+            raise
+
+    # XXX: First time, decompression will not be necessary (by using fsrc), but
+    # it will happen nonetheless
+    return gzip.GzipFile(local_path, "rb")
+
+
+class OpenMLError(ValueError):
+    """HTTP 412 is a specific OpenML error code, indicating a generic error"""
+
+    pass
+
+
+def _get_json_content_from_openml_api(
+    url: str,
+    error_message: Optional[str],
+    data_home: Optional[str],
+    n_retries: int = 3,
+    delay: float = 1.0,
+) -> Dict:
+    """
+    Loads json data from the openml api.
+
+    Parameters
+    ----------
+    url : str
+        The URL to load from. Should be an official OpenML endpoint.
+
+    error_message : str or None
+        The error message to raise if an acceptable OpenML error is thrown
+        (acceptable error is, e.g., data id not found. Other errors, like 404's
+        will throw the native error message).
+
+    data_home : str or None
+        Location to cache the response. None if no cache is required.
+
+    n_retries : int, default=3
+        Number of retries when HTTP errors are encountered. Error with status
+        code 412 won't be retried as they represent OpenML generic errors.
+
+    delay : float, default=1.0
+        Number of seconds between retries.
+
+    Returns
+    -------
+    json_data : json
+        the json result from the OpenML server if the call was successful.
+        An exception otherwise.
+    """
+
+    @_retry_with_clean_cache(url, data_home=data_home)
+    def _load_json():
+        with closing(
+            _open_openml_url(url, data_home, n_retries=n_retries, delay=delay)
+        ) as response:
+            return json.loads(response.read().decode("utf-8"))
+
+    try:
+        return _load_json()
+    except HTTPError as error:
+        # 412 is an OpenML specific error code, indicating a generic error
+        # (e.g., data not found)
+        if error.code != 412:
+            raise error
+
+    # 412 error, not in except for nicer traceback
+    raise OpenMLError(error_message)
+
+
+def _get_data_info_by_name(
+    name: str,
+    version: Union[int, str],
+    data_home: Optional[str],
+    n_retries: int = 3,
+    delay: float = 1.0,
+):
+    """
+    Utilizes the openml dataset listing api to find a dataset by
+    name/version
+    OpenML api function:
+    https://www.openml.org/api_docs#!/data/get_data_list_data_name_data_name
+
+    Parameters
+    ----------
+    name : str
+        name of the dataset
+
+    version : int or str
+        If version is an integer, the exact name/version will be obtained from
+        OpenML. If version is a string (value: "active") it will take the first
+        version from OpenML that is annotated as active. Any other string
+        values except "active" are treated as integer.
+
+    data_home : str or None
+        Location to cache the response. None if no cache is required.
+
+    n_retries : int, default=3
+        Number of retries when HTTP errors are encountered. Error with status
+        code 412 won't be retried as they represent OpenML generic errors.
+
+    delay : float, default=1.0
+        Number of seconds between retries.
+
+    Returns
+    -------
+    first_dataset : json
+        json representation of the first dataset object that adhired to the
+        search criteria
+
+    """
+    if version == "active":
+        # situation in which we return the oldest active version
+        url = _SEARCH_NAME.format(name) + "/status/active/"
+        error_msg = "No active dataset {} found.".format(name)
+        json_data = _get_json_content_from_openml_api(
+            url,
+            error_msg,
+            data_home=data_home,
+            n_retries=n_retries,
+            delay=delay,
+        )
+        res = json_data["data"]["dataset"]
+        if len(res) > 1:
+            first_version = version = res[0]["version"]
+            warning_msg = (
+                "Multiple active versions of the dataset matching the name"
+                f" {name} exist. Versions may be fundamentally different, "
+                f"returning version {first_version}. "
+                "Available versions:\n"
+            )
+            for r in res:
+                warning_msg += f"- version {r['version']}, status: {r['status']}\n"
+                warning_msg += (
+                    f"  url: https://www.openml.org/search?type=data&id={r['did']}\n"
+                )
+            warn(warning_msg)
+        return res[0]
+
+    # an integer version has been provided
+    url = (_SEARCH_NAME + "/data_version/{}").format(name, version)
+    try:
+        json_data = _get_json_content_from_openml_api(
+            url,
+            error_message=None,
+            data_home=data_home,
+            n_retries=n_retries,
+            delay=delay,
+        )
+    except OpenMLError:
+        # we can do this in 1 function call if OpenML does not require the
+        # specification of the dataset status (i.e., return datasets with a
+        # given name / version regardless of active, deactivated, etc. )
+        # TODO: feature request OpenML.
+        url += "/status/deactivated"
+        error_msg = "Dataset {} with version {} not found.".format(name, version)
+        json_data = _get_json_content_from_openml_api(
+            url,
+            error_msg,
+            data_home=data_home,
+            n_retries=n_retries,
+            delay=delay,
+        )
+
+    return json_data["data"]["dataset"][0]
+
+
+def _get_data_description_by_id(
+    data_id: int,
+    data_home: Optional[str],
+    n_retries: int = 3,
+    delay: float = 1.0,
+) -> Dict[str, Any]:
+    # OpenML API function: https://www.openml.org/api_docs#!/data/get_data_id
+    url = _DATA_INFO.format(data_id)
+    error_message = "Dataset with data_id {} not found.".format(data_id)
+    json_data = _get_json_content_from_openml_api(
+        url,
+        error_message,
+        data_home=data_home,
+        n_retries=n_retries,
+        delay=delay,
+    )
+    return json_data["data_set_description"]
+
+
+def _get_data_features(
+    data_id: int,
+    data_home: Optional[str],
+    n_retries: int = 3,
+    delay: float = 1.0,
+) -> OpenmlFeaturesType:
+    # OpenML function:
+    # https://www.openml.org/api_docs#!/data/get_data_features_id
+    url = _DATA_FEATURES.format(data_id)
+    error_message = "Dataset with data_id {} not found.".format(data_id)
+    json_data = _get_json_content_from_openml_api(
+        url,
+        error_message,
+        data_home=data_home,
+        n_retries=n_retries,
+        delay=delay,
+    )
+    return json_data["data_features"]["feature"]
+
+
+def _get_data_qualities(
+    data_id: int,
+    data_home: Optional[str],
+    n_retries: int = 3,
+    delay: float = 1.0,
+) -> OpenmlQualitiesType:
+    # OpenML API function:
+    # https://www.openml.org/api_docs#!/data/get_data_qualities_id
+    url = _DATA_QUALITIES.format(data_id)
+    error_message = "Dataset with data_id {} not found.".format(data_id)
+    json_data = _get_json_content_from_openml_api(
+        url,
+        error_message,
+        data_home=data_home,
+        n_retries=n_retries,
+        delay=delay,
+    )
+    # the qualities might not be available, but we still try to process
+    # the data
+    return json_data.get("data_qualities", {}).get("quality", [])
+
+
+def _get_num_samples(data_qualities: OpenmlQualitiesType) -> int:
+    """Get the number of samples from data qualities.
+
+    Parameters
+    ----------
+    data_qualities : list of dict
+        Used to retrieve the number of instances (samples) in the dataset.
+
+    Returns
+    -------
+    n_samples : int
+        The number of samples in the dataset or -1 if data qualities are
+        unavailable.
+    """
+    # If the data qualities are unavailable, we return -1
+    default_n_samples = -1
+
+    qualities = {d["name"]: d["value"] for d in data_qualities}
+    return int(float(qualities.get("NumberOfInstances", default_n_samples)))
+
+
+def _load_arff_response(
+    url: str,
+    data_home: Optional[str],
+    parser: str,
+    output_type: str,
+    openml_columns_info: dict,
+    feature_names_to_select: List[str],
+    target_names_to_select: List[str],
+    shape: Optional[Tuple[int, int]],
+    md5_checksum: str,
+    n_retries: int = 3,
+    delay: float = 1.0,
+    read_csv_kwargs: Optional[Dict] = None,
+):
+    """Load the ARFF data associated with the OpenML URL.
+
+    In addition of loading the data, this function will also check the
+    integrity of the downloaded file from OpenML using MD5 checksum.
+
+    Parameters
+    ----------
+    url : str
+        The URL of the ARFF file on OpenML.
+
+    data_home : str
+        The location where to cache the data.
+
+    parser : {"liac-arff", "pandas"}
+        The parser used to parse the ARFF file.
+
+    output_type : {"numpy", "pandas", "sparse"}
+        The type of the arrays that will be returned. The possibilities are:
+
+        - `"numpy"`: both `X` and `y` will be NumPy arrays;
+        - `"sparse"`: `X` will be sparse matrix and `y` will be a NumPy array;
+        - `"pandas"`: `X` will be a pandas DataFrame and `y` will be either a
+          pandas Series or DataFrame.
+
+    openml_columns_info : dict
+        The information provided by OpenML regarding the columns of the ARFF
+        file.
+
+    feature_names_to_select : list of str
+        The list of the features to be selected.
+
+    target_names_to_select : list of str
+        The list of the target variables to be selected.
+
+    shape : tuple or None
+        With `parser="liac-arff"`, when using a generator to load the data,
+        one needs to provide the shape of the data beforehand.
+
+    md5_checksum : str
+        The MD5 checksum provided by OpenML to check the data integrity.
+
+    n_retries : int, default=3
+        The number of times to retry downloading the data if it fails.
+
+    delay : float, default=1.0
+        The delay between two consecutive downloads in seconds.
+
+    read_csv_kwargs : dict, default=None
+        Keyword arguments to pass to `pandas.read_csv` when using the pandas parser.
+        It allows to overwrite the default options.
+
+        .. versionadded:: 1.3
+
+    Returns
+    -------
+    X : {ndarray, sparse matrix, dataframe}
+        The data matrix.
+
+    y : {ndarray, dataframe, series}
+        The target.
+
+    frame : dataframe or None
+        A dataframe containing both `X` and `y`. `None` if
+        `output_array_type != "pandas"`.
+
+    categories : list of str or None
+        The names of the features that are categorical. `None` if
+        `output_array_type == "pandas"`.
+    """
+    gzip_file = _open_openml_url(url, data_home, n_retries=n_retries, delay=delay)
+    with closing(gzip_file):
+        md5 = hashlib.md5()
+        for chunk in iter(lambda: gzip_file.read(4096), b""):
+            md5.update(chunk)
+        actual_md5_checksum = md5.hexdigest()
+
+    if actual_md5_checksum != md5_checksum:
+        raise ValueError(
+            f"md5 checksum of local file for {url} does not match description: "
+            f"expected: {md5_checksum} but got {actual_md5_checksum}. "
+            "Downloaded file could have been modified / corrupted, clean cache "
+            "and retry..."
+        )
+
+    def _open_url_and_load_gzip_file(url, data_home, n_retries, delay, arff_params):
+        gzip_file = _open_openml_url(url, data_home, n_retries=n_retries, delay=delay)
+        with closing(gzip_file):
+            return load_arff_from_gzip_file(gzip_file, **arff_params)
+
+    arff_params: Dict = dict(
+        parser=parser,
+        output_type=output_type,
+        openml_columns_info=openml_columns_info,
+        feature_names_to_select=feature_names_to_select,
+        target_names_to_select=target_names_to_select,
+        shape=shape,
+        read_csv_kwargs=read_csv_kwargs or {},
+    )
+    try:
+        X, y, frame, categories = _open_url_and_load_gzip_file(
+            url, data_home, n_retries, delay, arff_params
+        )
+    except Exception as exc:
+        if parser != "pandas":
+            raise
+
+        from pandas.errors import ParserError
+
+        if not isinstance(exc, ParserError):
+            raise
+
+        # A parsing error could come from providing the wrong quotechar
+        # to pandas. By default, we use a double quote. Thus, we retry
+        # with a single quote before to raise the error.
+        arff_params["read_csv_kwargs"].update(quotechar="'")
+        X, y, frame, categories = _open_url_and_load_gzip_file(
+            url, data_home, n_retries, delay, arff_params
+        )
+
+    return X, y, frame, categories
+
+
+def _download_data_to_bunch(
+    url: str,
+    sparse: bool,
+    data_home: Optional[str],
+    *,
+    as_frame: bool,
+    openml_columns_info: List[dict],
+    data_columns: List[str],
+    target_columns: List[str],
+    shape: Optional[Tuple[int, int]],
+    md5_checksum: str,
+    n_retries: int = 3,
+    delay: float = 1.0,
+    parser: str,
+    read_csv_kwargs: Optional[Dict] = None,
+):
+    """Download ARFF data, load it to a specific container and create to Bunch.
+
+    This function has a mechanism to retry/cache/clean the data.
+
+    Parameters
+    ----------
+    url : str
+        The URL of the ARFF file on OpenML.
+
+    sparse : bool
+        Whether the dataset is expected to use the sparse ARFF format.
+
+    data_home : str
+        The location where to cache the data.
+
+    as_frame : bool
+        Whether or not to return the data into a pandas DataFrame.
+
+    openml_columns_info : list of dict
+        The information regarding the columns provided by OpenML for the
+        ARFF dataset. The information is stored as a list of dictionaries.
+
+    data_columns : list of str
+        The list of the features to be selected.
+
+    target_columns : list of str
+        The list of the target variables to be selected.
+
+    shape : tuple or None
+        With `parser="liac-arff"`, when using a generator to load the data,
+        one needs to provide the shape of the data beforehand.
+
+    md5_checksum : str
+        The MD5 checksum provided by OpenML to check the data integrity.
+
+    n_retries : int, default=3
+        Number of retries when HTTP errors are encountered. Error with status
+        code 412 won't be retried as they represent OpenML generic errors.
+
+    delay : float, default=1.0
+        Number of seconds between retries.
+
+    parser : {"liac-arff", "pandas"}
+        The parser used to parse the ARFF file.
+
+    read_csv_kwargs : dict, default=None
+        Keyword arguments to pass to `pandas.read_csv` when using the pandas parser.
+        It allows to overwrite the default options.
+
+        .. versionadded:: 1.3
+
+    Returns
+    -------
+    data : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        X : {ndarray, sparse matrix, dataframe}
+            The data matrix.
+        y : {ndarray, dataframe, series}
+            The target.
+        frame : dataframe or None
+            A dataframe containing both `X` and `y`. `None` if
+            `output_array_type != "pandas"`.
+        categories : list of str or None
+            The names of the features that are categorical. `None` if
+            `output_array_type == "pandas"`.
+    """
+    # Prepare which columns and data types should be returned for the X and y
+    features_dict = {feature["name"]: feature for feature in openml_columns_info}
+
+    if sparse:
+        output_type = "sparse"
+    elif as_frame:
+        output_type = "pandas"
+    else:
+        output_type = "numpy"
+
+    # XXX: target columns should all be categorical or all numeric
+    _verify_target_data_type(features_dict, target_columns)
+    for name in target_columns:
+        column_info = features_dict[name]
+        n_missing_values = int(column_info["number_of_missing_values"])
+        if n_missing_values > 0:
+            raise ValueError(
+                f"Target column '{column_info['name']}' has {n_missing_values} missing "
+                "values. Missing values are not supported for target columns."
+            )
+
+    no_retry_exception = None
+    if parser == "pandas":
+        # If we get a ParserError with pandas, then we don't want to retry and we raise
+        # early.
+        from pandas.errors import ParserError
+
+        no_retry_exception = ParserError
+
+    X, y, frame, categories = _retry_with_clean_cache(
+        url, data_home, no_retry_exception
+    )(_load_arff_response)(
+        url,
+        data_home,
+        parser=parser,
+        output_type=output_type,
+        openml_columns_info=features_dict,
+        feature_names_to_select=data_columns,
+        target_names_to_select=target_columns,
+        shape=shape,
+        md5_checksum=md5_checksum,
+        n_retries=n_retries,
+        delay=delay,
+        read_csv_kwargs=read_csv_kwargs,
+    )
+
+    return Bunch(
+        data=X,
+        target=y,
+        frame=frame,
+        categories=categories,
+        feature_names=data_columns,
+        target_names=target_columns,
+    )
+
+
+def _verify_target_data_type(features_dict, target_columns):
+    # verifies the data type of the y array in case there are multiple targets
+    # (throws an error if these targets do not comply with sklearn support)
+    if not isinstance(target_columns, list):
+        raise ValueError("target_column should be list, got: %s" % type(target_columns))
+    found_types = set()
+    for target_column in target_columns:
+        if target_column not in features_dict:
+            raise KeyError(f"Could not find target_column='{target_column}'")
+        if features_dict[target_column]["data_type"] == "numeric":
+            found_types.add(np.float64)
+        else:
+            found_types.add(object)
+
+        # note: we compare to a string, not boolean
+        if features_dict[target_column]["is_ignore"] == "true":
+            warn(f"target_column='{target_column}' has flag is_ignore.")
+        if features_dict[target_column]["is_row_identifier"] == "true":
+            warn(f"target_column='{target_column}' has flag is_row_identifier.")
+    if len(found_types) > 1:
+        raise ValueError(
+            "Can only handle homogeneous multi-target datasets, "
+            "i.e., all targets are either numeric or "
+            "categorical."
+        )
+
+
+def _valid_data_column_names(features_list, target_columns):
+    # logic for determining on which columns can be learned. Note that from the
+    # OpenML guide follows that columns that have the `is_row_identifier` or
+    # `is_ignore` flag, these can not be learned on. Also target columns are
+    # excluded.
+    valid_data_column_names = []
+    for feature in features_list:
+        if (
+            feature["name"] not in target_columns
+            and feature["is_ignore"] != "true"
+            and feature["is_row_identifier"] != "true"
+        ):
+            valid_data_column_names.append(feature["name"])
+    return valid_data_column_names
+
+
+@validate_params(
+    {
+        "name": [str, None],
+        "version": [Interval(Integral, 1, None, closed="left"), StrOptions({"active"})],
+        "data_id": [Interval(Integral, 1, None, closed="left"), None],
+        "data_home": [str, os.PathLike, None],
+        "target_column": [str, list, None],
+        "cache": [bool],
+        "return_X_y": [bool],
+        "as_frame": [bool, StrOptions({"auto"})],
+        "n_retries": [Interval(Integral, 1, None, closed="left")],
+        "delay": [Interval(Real, 0, None, closed="right")],
+        "parser": [
+            StrOptions({"auto", "pandas", "liac-arff"}),
+        ],
+        "read_csv_kwargs": [dict, None],
+    },
+    prefer_skip_nested_validation=True,
+)
+def fetch_openml(
+    name: Optional[str] = None,
+    *,
+    version: Union[str, int] = "active",
+    data_id: Optional[int] = None,
+    data_home: Optional[Union[str, os.PathLike]] = None,
+    target_column: Optional[Union[str, List]] = "default-target",
+    cache: bool = True,
+    return_X_y: bool = False,
+    as_frame: Union[str, bool] = "auto",
+    n_retries: int = 3,
+    delay: float = 1.0,
+    parser: str = "auto",
+    read_csv_kwargs: Optional[Dict] = None,
+):
+    """Fetch dataset from openml by name or dataset id.
+
+    Datasets are uniquely identified by either an integer ID or by a
+    combination of name and version (i.e. there might be multiple
+    versions of the 'iris' dataset). Please give either name or data_id
+    (not both). In case a name is given, a version can also be
+    provided.
+
+    Read more in the :ref:`User Guide <openml>`.
+
+    .. versionadded:: 0.20
+
+    .. note:: EXPERIMENTAL
+
+        The API is experimental (particularly the return value structure),
+        and might have small backward-incompatible changes without notice
+        or warning in future releases.
+
+    Parameters
+    ----------
+    name : str, default=None
+        String identifier of the dataset. Note that OpenML can have multiple
+        datasets with the same name.
+
+    version : int or 'active', default='active'
+        Version of the dataset. Can only be provided if also ``name`` is given.
+        If 'active' the oldest version that's still active is used. Since
+        there may be more than one active version of a dataset, and those
+        versions may fundamentally be different from one another, setting an
+        exact version is highly recommended.
+
+    data_id : int, default=None
+        OpenML ID of the dataset. The most specific way of retrieving a
+        dataset. If data_id is not given, name (and potential version) are
+        used to obtain a dataset.
+
+    data_home : str or path-like, default=None
+        Specify another download and cache folder for the data sets. By default
+        all scikit-learn data is stored in '~/scikit_learn_data' subfolders.
+
+    target_column : str, list or None, default='default-target'
+        Specify the column name in the data to use as target. If
+        'default-target', the standard target column a stored on the server
+        is used. If ``None``, all columns are returned as data and the
+        target is ``None``. If list (of strings), all columns with these names
+        are returned as multi-target (Note: not all scikit-learn classifiers
+        can handle all types of multi-output combinations).
+
+    cache : bool, default=True
+        Whether to cache the downloaded datasets into `data_home`.
+
+    return_X_y : bool, default=False
+        If True, returns ``(data, target)`` instead of a Bunch object. See
+        below for more information about the `data` and `target` objects.
+
+    as_frame : bool or 'auto', default='auto'
+        If True, the data is a pandas DataFrame including columns with
+        appropriate dtypes (numeric, string or categorical). The target is
+        a pandas DataFrame or Series depending on the number of target_columns.
+        The Bunch will contain a ``frame`` attribute with the target and the
+        data. If ``return_X_y`` is True, then ``(data, target)`` will be pandas
+        DataFrames or Series as describe above.
+
+        If `as_frame` is 'auto', the data and target will be converted to
+        DataFrame or Series as if `as_frame` is set to True, unless the dataset
+        is stored in sparse format.
+
+        If `as_frame` is False, the data and target will be NumPy arrays and
+        the `data` will only contain numerical values when `parser="liac-arff"`
+        where the categories are provided in the attribute `categories` of the
+        `Bunch` instance. When `parser="pandas"`, no ordinal encoding is made.
+
+        .. versionchanged:: 0.24
+           The default value of `as_frame` changed from `False` to `'auto'`
+           in 0.24.
+
+    n_retries : int, default=3
+        Number of retries when HTTP errors or network timeouts are encountered.
+        Error with status code 412 won't be retried as they represent OpenML
+        generic errors.
+
+    delay : float, default=1.0
+        Number of seconds between retries.
+
+    parser : {"auto", "pandas", "liac-arff"}, default="auto"
+        Parser used to load the ARFF file. Two parsers are implemented:
+
+        - `"pandas"`: this is the most efficient parser. However, it requires
+          pandas to be installed and can only open dense datasets.
+        - `"liac-arff"`: this is a pure Python ARFF parser that is much less
+          memory- and CPU-efficient. It deals with sparse ARFF datasets.
+
+        If `"auto"`, the parser is chosen automatically such that `"liac-arff"`
+        is selected for sparse ARFF datasets, otherwise `"pandas"` is selected.
+
+        .. versionadded:: 1.2
+        .. versionchanged:: 1.4
+           The default value of `parser` changes from `"liac-arff"` to
+           `"auto"`.
+
+    read_csv_kwargs : dict, default=None
+        Keyword arguments passed to :func:`pandas.read_csv` when loading the data
+        from a ARFF file and using the pandas parser. It can allow to
+        overwrite some default parameters.
+
+        .. versionadded:: 1.3
+
+    Returns
+    -------
+    data : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        data : np.array, scipy.sparse.csr_matrix of floats, or pandas DataFrame
+            The feature matrix. Categorical features are encoded as ordinals.
+        target : np.array, pandas Series or DataFrame
+            The regression target or classification labels, if applicable.
+            Dtype is float if numeric, and object if categorical. If
+            ``as_frame`` is True, ``target`` is a pandas object.
+        DESCR : str
+            The full description of the dataset.
+        feature_names : list
+            The names of the dataset columns.
+        target_names: list
+            The names of the target columns.
+
+        .. versionadded:: 0.22
+
+        categories : dict or None
+            Maps each categorical feature name to a list of values, such
+            that the value encoded as i is ith in the list. If ``as_frame``
+            is True, this is None.
+        details : dict
+            More metadata from OpenML.
+        frame : pandas DataFrame
+            Only present when `as_frame=True`. DataFrame with ``data`` and
+            ``target``.
+
+    (data, target) : tuple if ``return_X_y`` is True
+
+        .. note:: EXPERIMENTAL
+
+            This interface is **experimental** and subsequent releases may
+            change attributes without notice (although there should only be
+            minor changes to ``data`` and ``target``).
+
+        Missing values in the 'data' are represented as NaN's. Missing values
+        in 'target' are represented as NaN's (numerical target) or None
+        (categorical target).
+
+    Notes
+    -----
+    The `"pandas"` and `"liac-arff"` parsers can lead to different data types
+    in the output. The notable differences are the following:
+
+    - The `"liac-arff"` parser always encodes categorical features as `str` objects.
+      To the contrary, the `"pandas"` parser instead infers the type while
+      reading and numerical categories will be casted into integers whenever
+      possible.
+    - The `"liac-arff"` parser uses float64 to encode numerical features
+      tagged as 'REAL' and 'NUMERICAL' in the metadata. The `"pandas"`
+      parser instead infers if these numerical features corresponds
+      to integers and uses panda's Integer extension dtype.
+    - In particular, classification datasets with integer categories are
+      typically loaded as such `(0, 1, ...)` with the `"pandas"` parser while
+      `"liac-arff"` will force the use of string encoded class labels such as
+      `"0"`, `"1"` and so on.
+    - The `"pandas"` parser will not strip single quotes - i.e. `'` - from
+      string columns. For instance, a string `'my string'` will be kept as is
+      while the `"liac-arff"` parser will strip the single quotes. For
+      categorical columns, the single quotes are stripped from the values.
+
+    In addition, when `as_frame=False` is used, the `"liac-arff"` parser
+    returns ordinally encoded data where the categories are provided in the
+    attribute `categories` of the `Bunch` instance. Instead, `"pandas"` returns
+    a NumPy array were the categories are not encoded.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import fetch_openml
+    >>> adult = fetch_openml("adult", version=2)  # doctest: +SKIP
+    >>> adult.frame.info()  # doctest: +SKIP
+    <class 'pandas.core.frame.DataFrame'>
+    RangeIndex: 48842 entries, 0 to 48841
+    Data columns (total 15 columns):
+     #   Column          Non-Null Count  Dtype
+    ---  ------          --------------  -----
+     0   age             48842 non-null  int64
+     1   workclass       46043 non-null  category
+     2   fnlwgt          48842 non-null  int64
+     3   education       48842 non-null  category
+     4   education-num   48842 non-null  int64
+     5   marital-status  48842 non-null  category
+     6   occupation      46033 non-null  category
+     7   relationship    48842 non-null  category
+     8   race            48842 non-null  category
+     9   sex             48842 non-null  category
+     10  capital-gain    48842 non-null  int64
+     11  capital-loss    48842 non-null  int64
+     12  hours-per-week  48842 non-null  int64
+     13  native-country  47985 non-null  category
+     14  class           48842 non-null  category
+    dtypes: category(9), int64(6)
+    memory usage: 2.7 MB
+    """
+    if cache is False:
+        # no caching will be applied
+        data_home = None
+    else:
+        data_home = get_data_home(data_home=data_home)
+        data_home = join(str(data_home), "openml")
+
+    # check valid function arguments. data_id XOR (name, version) should be
+    # provided
+    if name is not None:
+        # OpenML is case-insensitive, but the caching mechanism is not
+        # convert all data names (str) to lower case
+        name = name.lower()
+        if data_id is not None:
+            raise ValueError(
+                "Dataset data_id={} and name={} passed, but you can only "
+                "specify a numeric data_id or a name, not "
+                "both.".format(data_id, name)
+            )
+        data_info = _get_data_info_by_name(
+            name, version, data_home, n_retries=n_retries, delay=delay
+        )
+        data_id = data_info["did"]
+    elif data_id is not None:
+        # from the previous if statement, it is given that name is None
+        if version != "active":
+            raise ValueError(
+                "Dataset data_id={} and version={} passed, but you can only "
+                "specify a numeric data_id or a version, not "
+                "both.".format(data_id, version)
+            )
+    else:
+        raise ValueError(
+            "Neither name nor data_id are provided. Please provide name or data_id."
+        )
+
+    data_description = _get_data_description_by_id(data_id, data_home)
+    if data_description["status"] != "active":
+        warn(
+            "Version {} of dataset {} is inactive, meaning that issues have "
+            "been found in the dataset. Try using a newer version from "
+            "this URL: {}".format(
+                data_description["version"],
+                data_description["name"],
+                data_description["url"],
+            )
+        )
+    if "error" in data_description:
+        warn(
+            "OpenML registered a problem with the dataset. It might be "
+            "unusable. Error: {}".format(data_description["error"])
+        )
+    if "warning" in data_description:
+        warn(
+            "OpenML raised a warning on the dataset. It might be "
+            "unusable. Warning: {}".format(data_description["warning"])
+        )
+
+    return_sparse = data_description["format"].lower() == "sparse_arff"
+    as_frame = not return_sparse if as_frame == "auto" else as_frame
+    if parser == "auto":
+        parser_ = "liac-arff" if return_sparse else "pandas"
+    else:
+        parser_ = parser
+
+    if parser_ == "pandas":
+        try:
+            check_pandas_support("`fetch_openml`")
+        except ImportError as exc:
+            if as_frame:
+                err_msg = (
+                    "Returning pandas objects requires pandas to be installed. "
+                    "Alternatively, explicitly set `as_frame=False` and "
+                    "`parser='liac-arff'`."
+                )
+            else:
+                err_msg = (
+                    f"Using `parser={parser!r}` wit dense data requires pandas to be "
+                    "installed. Alternatively, explicitly set `parser='liac-arff'`."
+                )
+            raise ImportError(err_msg) from exc
+
+    if return_sparse:
+        if as_frame:
+            raise ValueError(
+                "Sparse ARFF datasets cannot be loaded with as_frame=True. "
+                "Use as_frame=False or as_frame='auto' instead."
+            )
+        if parser_ == "pandas":
+            raise ValueError(
+                f"Sparse ARFF datasets cannot be loaded with parser={parser!r}. "
+                "Use parser='liac-arff' or parser='auto' instead."
+            )
+
+    # download data features, meta-info about column types
+    features_list = _get_data_features(data_id, data_home)
+
+    if not as_frame:
+        for feature in features_list:
+            if "true" in (feature["is_ignore"], feature["is_row_identifier"]):
+                continue
+            if feature["data_type"] == "string":
+                raise ValueError(
+                    "STRING attributes are not supported for "
+                    "array representation. Try as_frame=True"
+                )
+
+    if target_column == "default-target":
+        # determines the default target based on the data feature results
+        # (which is currently more reliable than the data description;
+        # see issue: https://github.com/openml/OpenML/issues/768)
+        target_columns = [
+            feature["name"]
+            for feature in features_list
+            if feature["is_target"] == "true"
+        ]
+    elif isinstance(target_column, str):
+        # for code-simplicity, make target_column by default a list
+        target_columns = [target_column]
+    elif target_column is None:
+        target_columns = []
+    else:
+        # target_column already is of type list
+        target_columns = target_column
+    data_columns = _valid_data_column_names(features_list, target_columns)
+
+    shape: Optional[Tuple[int, int]]
+    # determine arff encoding to return
+    if not return_sparse:
+        # The shape must include the ignored features to keep the right indexes
+        # during the arff data conversion.
+        data_qualities = _get_data_qualities(data_id, data_home)
+        shape = _get_num_samples(data_qualities), len(features_list)
+    else:
+        shape = None
+
+    # obtain the data
+    url = _DATA_FILE.format(data_description["file_id"])
+    bunch = _download_data_to_bunch(
+        url,
+        return_sparse,
+        data_home,
+        as_frame=bool(as_frame),
+        openml_columns_info=features_list,
+        shape=shape,
+        target_columns=target_columns,
+        data_columns=data_columns,
+        md5_checksum=data_description["md5_checksum"],
+        n_retries=n_retries,
+        delay=delay,
+        parser=parser_,
+        read_csv_kwargs=read_csv_kwargs,
+    )
+
+    if return_X_y:
+        return bunch.data, bunch.target
+
+    description = "{}\n\nDownloaded from openml.org.".format(
+        data_description.pop("description")
+    )
+
+    bunch.update(
+        DESCR=description,
+        details=data_description,
+        url="https://www.openml.org/d/{}".format(data_id),
+    )
+
+    return bunch

venv/lib/python3.10/site-packages/sklearn/datasets/_twenty_newsgroups.py

@@ -0,0 +1,561 @@
+"""Caching loader for the 20 newsgroups text classification dataset.
+
+
+The description of the dataset is available on the official website at:
+
+    http://people.csail.mit.edu/jrennie/20Newsgroups/
+
+Quoting the introduction:
+
+    The 20 Newsgroups data set is a collection of approximately 20,000
+    newsgroup documents, partitioned (nearly) evenly across 20 different
+    newsgroups. To the best of my knowledge, it was originally collected
+    by Ken Lang, probably for his Newsweeder: Learning to filter netnews
+    paper, though he does not explicitly mention this collection. The 20
+    newsgroups collection has become a popular data set for experiments
+    in text applications of machine learning techniques, such as text
+    classification and text clustering.
+
+This dataset loader will download the recommended "by date" variant of the
+dataset and which features a point in time split between the train and
+test sets. The compressed dataset size is around 14 Mb compressed. Once
+uncompressed the train set is 52 MB and the test set is 34 MB.
+"""
+# Copyright (c) 2011 Olivier Grisel <[email protected]>
+# License: BSD 3 clause
+
+import codecs
+import logging
+import os
+import pickle
+import re
+import shutil
+import tarfile
+from contextlib import suppress
+
+import joblib
+import numpy as np
+import scipy.sparse as sp
+
+from .. import preprocessing
+from ..feature_extraction.text import CountVectorizer
+from ..utils import Bunch, check_random_state
+from ..utils._param_validation import StrOptions, validate_params
+from . import get_data_home, load_files
+from ._base import (
+    RemoteFileMetadata,
+    _convert_data_dataframe,
+    _fetch_remote,
+    _pkl_filepath,
+    load_descr,
+)
+
+logger = logging.getLogger(__name__)
+
+# The original data can be found at:
+# https://people.csail.mit.edu/jrennie/20Newsgroups/20news-bydate.tar.gz
+ARCHIVE = RemoteFileMetadata(
+    filename="20news-bydate.tar.gz",
+    url="https://ndownloader.figshare.com/files/5975967",
+    checksum="8f1b2514ca22a5ade8fbb9cfa5727df95fa587f4c87b786e15c759fa66d95610",
+)
+
+CACHE_NAME = "20news-bydate.pkz"
+TRAIN_FOLDER = "20news-bydate-train"
+TEST_FOLDER = "20news-bydate-test"
+
+
+def _download_20newsgroups(target_dir, cache_path):
+    """Download the 20 newsgroups data and stored it as a zipped pickle."""
+    train_path = os.path.join(target_dir, TRAIN_FOLDER)
+    test_path = os.path.join(target_dir, TEST_FOLDER)
+
+    os.makedirs(target_dir, exist_ok=True)
+
+    logger.info("Downloading dataset from %s (14 MB)", ARCHIVE.url)
+    archive_path = _fetch_remote(ARCHIVE, dirname=target_dir)
+
+    logger.debug("Decompressing %s", archive_path)
+    tarfile.open(archive_path, "r:gz").extractall(path=target_dir)
+
+    with suppress(FileNotFoundError):
+        os.remove(archive_path)
+
+    # Store a zipped pickle
+    cache = dict(
+        train=load_files(train_path, encoding="latin1"),
+        test=load_files(test_path, encoding="latin1"),
+    )
+    compressed_content = codecs.encode(pickle.dumps(cache), "zlib_codec")
+    with open(cache_path, "wb") as f:
+        f.write(compressed_content)
+
+    shutil.rmtree(target_dir)
+    return cache
+
+
+def strip_newsgroup_header(text):
+    """
+    Given text in "news" format, strip the headers, by removing everything
+    before the first blank line.
+
+    Parameters
+    ----------
+    text : str
+        The text from which to remove the signature block.
+    """
+    _before, _blankline, after = text.partition("\n\n")
+    return after
+
+
+_QUOTE_RE = re.compile(
+    r"(writes in|writes:|wrote:|says:|said:" r"|^In article|^Quoted from|^\||^>)"
+)
+
+
+def strip_newsgroup_quoting(text):
+    """
+    Given text in "news" format, strip lines beginning with the quote
+    characters > or |, plus lines that often introduce a quoted section
+    (for example, because they contain the string 'writes:'.)
+
+    Parameters
+    ----------
+    text : str
+        The text from which to remove the signature block.
+    """
+    good_lines = [line for line in text.split("\n") if not _QUOTE_RE.search(line)]
+    return "\n".join(good_lines)
+
+
+def strip_newsgroup_footer(text):
+    """
+    Given text in "news" format, attempt to remove a signature block.
+
+    As a rough heuristic, we assume that signatures are set apart by either
+    a blank line or a line made of hyphens, and that it is the last such line
+    in the file (disregarding blank lines at the end).
+
+    Parameters
+    ----------
+    text : str
+        The text from which to remove the signature block.
+    """
+    lines = text.strip().split("\n")
+    for line_num in range(len(lines) - 1, -1, -1):
+        line = lines[line_num]
+        if line.strip().strip("-") == "":
+            break
+
+    if line_num > 0:
+        return "\n".join(lines[:line_num])
+    else:
+        return text
+
+
+@validate_params(
+    {
+        "data_home": [str, os.PathLike, None],
+        "subset": [StrOptions({"train", "test", "all"})],
+        "categories": ["array-like", None],
+        "shuffle": ["boolean"],
+        "random_state": ["random_state"],
+        "remove": [tuple],
+        "download_if_missing": ["boolean"],
+        "return_X_y": ["boolean"],
+    },
+    prefer_skip_nested_validation=True,
+)
+def fetch_20newsgroups(
+    *,
+    data_home=None,
+    subset="train",
+    categories=None,
+    shuffle=True,
+    random_state=42,
+    remove=(),
+    download_if_missing=True,
+    return_X_y=False,
+):
+    """Load the filenames and data from the 20 newsgroups dataset \
+(classification).
+
+    Download it if necessary.
+
+    =================   ==========
+    Classes                     20
+    Samples total            18846
+    Dimensionality               1
+    Features                  text
+    =================   ==========
+
+    Read more in the :ref:`User Guide <20newsgroups_dataset>`.
+
+    Parameters
+    ----------
+    data_home : str or path-like, default=None
+        Specify a download and cache folder for the datasets. If None,
+        all scikit-learn data is stored in '~/scikit_learn_data' subfolders.
+
+    subset : {'train', 'test', 'all'}, default='train'
+        Select the dataset to load: 'train' for the training set, 'test'
+        for the test set, 'all' for both, with shuffled ordering.
+
+    categories : array-like, dtype=str, default=None
+        If None (default), load all the categories.
+        If not None, list of category names to load (other categories
+        ignored).
+
+    shuffle : bool, default=True
+        Whether or not to shuffle the data: might be important for models that
+        make the assumption that the samples are independent and identically
+        distributed (i.i.d.), such as stochastic gradient descent.
+
+    random_state : int, RandomState instance or None, default=42
+        Determines random number generation for dataset shuffling. Pass an int
+        for reproducible output across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    remove : tuple, default=()
+        May contain any subset of ('headers', 'footers', 'quotes'). Each of
+        these are kinds of text that will be detected and removed from the
+        newsgroup posts, preventing classifiers from overfitting on
+        metadata.
+
+        'headers' removes newsgroup headers, 'footers' removes blocks at the
+        ends of posts that look like signatures, and 'quotes' removes lines
+        that appear to be quoting another post.
+
+        'headers' follows an exact standard; the other filters are not always
+        correct.
+
+    download_if_missing : bool, default=True
+        If False, raise an OSError if the data is not locally available
+        instead of trying to download the data from the source site.
+
+    return_X_y : bool, default=False
+        If True, returns `(data.data, data.target)` instead of a Bunch
+        object.
+
+        .. versionadded:: 0.22
+
+    Returns
+    -------
+    bunch : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        data : list of shape (n_samples,)
+            The data list to learn.
+        target: ndarray of shape (n_samples,)
+            The target labels.
+        filenames: list of shape (n_samples,)
+            The path to the location of the data.
+        DESCR: str
+            The full description of the dataset.
+        target_names: list of shape (n_classes,)
+            The names of target classes.
+
+    (data, target) : tuple if `return_X_y=True`
+        A tuple of two ndarrays. The first contains a 2D array of shape
+        (n_samples, n_classes) with each row representing one sample and each
+        column representing the features. The second array of shape
+        (n_samples,) contains the target samples.
+
+        .. versionadded:: 0.22
+    """
+
+    data_home = get_data_home(data_home=data_home)
+    cache_path = _pkl_filepath(data_home, CACHE_NAME)
+    twenty_home = os.path.join(data_home, "20news_home")
+    cache = None
+    if os.path.exists(cache_path):
+        try:
+            with open(cache_path, "rb") as f:
+                compressed_content = f.read()
+            uncompressed_content = codecs.decode(compressed_content, "zlib_codec")
+            cache = pickle.loads(uncompressed_content)
+        except Exception as e:
+            print(80 * "_")
+            print("Cache loading failed")
+            print(80 * "_")
+            print(e)
+
+    if cache is None:
+        if download_if_missing:
+            logger.info("Downloading 20news dataset. This may take a few minutes.")
+            cache = _download_20newsgroups(
+                target_dir=twenty_home, cache_path=cache_path
+            )
+        else:
+            raise OSError("20Newsgroups dataset not found")
+
+    if subset in ("train", "test"):
+        data = cache[subset]
+    elif subset == "all":
+        data_lst = list()
+        target = list()
+        filenames = list()
+        for subset in ("train", "test"):
+            data = cache[subset]
+            data_lst.extend(data.data)
+            target.extend(data.target)
+            filenames.extend(data.filenames)
+
+        data.data = data_lst
+        data.target = np.array(target)
+        data.filenames = np.array(filenames)
+
+    fdescr = load_descr("twenty_newsgroups.rst")
+
+    data.DESCR = fdescr
+
+    if "headers" in remove:
+        data.data = [strip_newsgroup_header(text) for text in data.data]
+    if "footers" in remove:
+        data.data = [strip_newsgroup_footer(text) for text in data.data]
+    if "quotes" in remove:
+        data.data = [strip_newsgroup_quoting(text) for text in data.data]
+
+    if categories is not None:
+        labels = [(data.target_names.index(cat), cat) for cat in categories]
+        # Sort the categories to have the ordering of the labels
+        labels.sort()
+        labels, categories = zip(*labels)
+        mask = np.isin(data.target, labels)
+        data.filenames = data.filenames[mask]
+        data.target = data.target[mask]
+        # searchsorted to have continuous labels
+        data.target = np.searchsorted(labels, data.target)
+        data.target_names = list(categories)
+        # Use an object array to shuffle: avoids memory copy
+        data_lst = np.array(data.data, dtype=object)
+        data_lst = data_lst[mask]
+        data.data = data_lst.tolist()
+
+    if shuffle:
+        random_state = check_random_state(random_state)
+        indices = np.arange(data.target.shape[0])
+        random_state.shuffle(indices)
+        data.filenames = data.filenames[indices]
+        data.target = data.target[indices]
+        # Use an object array to shuffle: avoids memory copy
+        data_lst = np.array(data.data, dtype=object)
+        data_lst = data_lst[indices]
+        data.data = data_lst.tolist()
+
+    if return_X_y:
+        return data.data, data.target
+
+    return data
+
+
+@validate_params(
+    {
+        "subset": [StrOptions({"train", "test", "all"})],
+        "remove": [tuple],
+        "data_home": [str, os.PathLike, None],
+        "download_if_missing": ["boolean"],
+        "return_X_y": ["boolean"],
+        "normalize": ["boolean"],
+        "as_frame": ["boolean"],
+    },
+    prefer_skip_nested_validation=True,
+)
+def fetch_20newsgroups_vectorized(
+    *,
+    subset="train",
+    remove=(),
+    data_home=None,
+    download_if_missing=True,
+    return_X_y=False,
+    normalize=True,
+    as_frame=False,
+):
+    """Load and vectorize the 20 newsgroups dataset (classification).
+
+    Download it if necessary.
+
+    This is a convenience function; the transformation is done using the
+    default settings for
+    :class:`~sklearn.feature_extraction.text.CountVectorizer`. For more
+    advanced usage (stopword filtering, n-gram extraction, etc.), combine
+    fetch_20newsgroups with a custom
+    :class:`~sklearn.feature_extraction.text.CountVectorizer`,
+    :class:`~sklearn.feature_extraction.text.HashingVectorizer`,
+    :class:`~sklearn.feature_extraction.text.TfidfTransformer` or
+    :class:`~sklearn.feature_extraction.text.TfidfVectorizer`.
+
+    The resulting counts are normalized using
+    :func:`sklearn.preprocessing.normalize` unless normalize is set to False.
+
+    =================   ==========
+    Classes                     20
+    Samples total            18846
+    Dimensionality          130107
+    Features                  real
+    =================   ==========
+
+    Read more in the :ref:`User Guide <20newsgroups_dataset>`.
+
+    Parameters
+    ----------
+    subset : {'train', 'test', 'all'}, default='train'
+        Select the dataset to load: 'train' for the training set, 'test'
+        for the test set, 'all' for both, with shuffled ordering.
+
+    remove : tuple, default=()
+        May contain any subset of ('headers', 'footers', 'quotes'). Each of
+        these are kinds of text that will be detected and removed from the
+        newsgroup posts, preventing classifiers from overfitting on
+        metadata.
+
+        'headers' removes newsgroup headers, 'footers' removes blocks at the
+        ends of posts that look like signatures, and 'quotes' removes lines
+        that appear to be quoting another post.
+
+    data_home : str or path-like, default=None
+        Specify an download and cache folder for the datasets. If None,
+        all scikit-learn data is stored in '~/scikit_learn_data' subfolders.
+
+    download_if_missing : bool, default=True
+        If False, raise an OSError if the data is not locally available
+        instead of trying to download the data from the source site.
+
+    return_X_y : bool, default=False
+        If True, returns ``(data.data, data.target)`` instead of a Bunch
+        object.
+
+        .. versionadded:: 0.20
+
+    normalize : bool, default=True
+        If True, normalizes each document's feature vector to unit norm using
+        :func:`sklearn.preprocessing.normalize`.
+
+        .. versionadded:: 0.22
+
+    as_frame : bool, default=False
+        If True, the data is a pandas DataFrame including columns with
+        appropriate dtypes (numeric, string, or categorical). The target is
+        a pandas DataFrame or Series depending on the number of
+        `target_columns`.
+
+        .. versionadded:: 0.24
+
+    Returns
+    -------
+    bunch : :class:`~sklearn.utils.Bunch`
+        Dictionary-like object, with the following attributes.
+
+        data: {sparse matrix, dataframe} of shape (n_samples, n_features)
+            The input data matrix. If ``as_frame`` is `True`, ``data`` is
+            a pandas DataFrame with sparse columns.
+        target: {ndarray, series} of shape (n_samples,)
+            The target labels. If ``as_frame`` is `True`, ``target`` is a
+            pandas Series.
+        target_names: list of shape (n_classes,)
+            The names of target classes.
+        DESCR: str
+            The full description of the dataset.
+        frame: dataframe of shape (n_samples, n_features + 1)
+            Only present when `as_frame=True`. Pandas DataFrame with ``data``
+            and ``target``.
+
+            .. versionadded:: 0.24
+
+    (data, target) : tuple if ``return_X_y`` is True
+        `data` and `target` would be of the format defined in the `Bunch`
+        description above.
+
+        .. versionadded:: 0.20
+    """
+    data_home = get_data_home(data_home=data_home)
+    filebase = "20newsgroup_vectorized"
+    if remove:
+        filebase += "remove-" + "-".join(remove)
+    target_file = _pkl_filepath(data_home, filebase + ".pkl")
+
+    # we shuffle but use a fixed seed for the memoization
+    data_train = fetch_20newsgroups(
+        data_home=data_home,
+        subset="train",
+        categories=None,
+        shuffle=True,
+        random_state=12,
+        remove=remove,
+        download_if_missing=download_if_missing,
+    )
+
+    data_test = fetch_20newsgroups(
+        data_home=data_home,
+        subset="test",
+        categories=None,
+        shuffle=True,
+        random_state=12,
+        remove=remove,
+        download_if_missing=download_if_missing,
+    )
+
+    if os.path.exists(target_file):
+        try:
+            X_train, X_test, feature_names = joblib.load(target_file)
+        except ValueError as e:
+            raise ValueError(
+                f"The cached dataset located in {target_file} was fetched "
+                "with an older scikit-learn version and it is not compatible "
+                "with the scikit-learn version imported. You need to "
+                f"manually delete the file: {target_file}."
+            ) from e
+    else:
+        vectorizer = CountVectorizer(dtype=np.int16)
+        X_train = vectorizer.fit_transform(data_train.data).tocsr()
+        X_test = vectorizer.transform(data_test.data).tocsr()
+        feature_names = vectorizer.get_feature_names_out()
+
+        joblib.dump((X_train, X_test, feature_names), target_file, compress=9)
+
+    # the data is stored as int16 for compactness
+    # but normalize needs floats
+    if normalize:
+        X_train = X_train.astype(np.float64)
+        X_test = X_test.astype(np.float64)
+        preprocessing.normalize(X_train, copy=False)
+        preprocessing.normalize(X_test, copy=False)
+
+    target_names = data_train.target_names
+
+    if subset == "train":
+        data = X_train
+        target = data_train.target
+    elif subset == "test":
+        data = X_test
+        target = data_test.target
+    elif subset == "all":
+        data = sp.vstack((X_train, X_test)).tocsr()
+        target = np.concatenate((data_train.target, data_test.target))
+
+    fdescr = load_descr("twenty_newsgroups.rst")
+
+    frame = None
+    target_name = ["category_class"]
+
+    if as_frame:
+        frame, data, target = _convert_data_dataframe(
+            "fetch_20newsgroups_vectorized",
+            data,
+            target,
+            feature_names,
+            target_names=target_name,
+            sparse_data=True,
+        )
+
+    if return_X_y:
+        return data, target
+
+    return Bunch(
+        data=data,
+        target=target,
+        frame=frame,
+        target_names=target_names,
+        feature_names=feature_names,
+        DESCR=fdescr,
+    )

venv/lib/python3.10/site-packages/sklearn/datasets/images/README.txt

@@ -0,0 +1,21 @@
+Image: china.jpg
+Released under a creative commons license. [1]
+Attribution: Some rights reserved by danielbuechele [2]
+Retrieved 21st August, 2011 from [3] by Robert Layton
+
+[1] https://creativecommons.org/licenses/by/2.0/
+[2] https://www.flickr.com/photos/danielbuechele/
+[3] https://www.flickr.com/photos/danielbuechele/6061409035/sizes/z/in/photostream/
+
+
+Image: flower.jpg
+Released under a creative commons license. [1]
+Attribution: Some rights reserved by danielbuechele [2]
+Retrieved 21st August, 2011 from [3] by Robert Layton
+
+[1] https://creativecommons.org/licenses/by/2.0/
+[2] https://www.flickr.com/photos/vultilion/
+[3] https://www.flickr.com/photos/vultilion/6056698931/sizes/z/in/photostream/
+
+
+