


'''simple docstring'''


import itertools
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa

import datasets
from datasets.table import table_cast


_UpperCamelCase          =     datasets.utils.logging.get_logger(__name__)







@dataclass
class        __magic_name__  (					datasets.BuilderConfig   ):

     """simple docstring"""






     lowerCamelCase__						=							None







class        __magic_name__  (					datasets.ArrowBasedBuilder   ):

     """simple docstring"""






     lowerCamelCase__						=							ArrowConfig


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          return datasets.DatasetInfo(features=self.config.features		)


     def lowerCAmelCase__     (      self ,    lowerCamelCase		):


          '''simple docstring'''





          if not self.config.data_files:
               raise ValueError(f"At least one data file must be specified, but got data_files={self.config.data_files}"		)
          __A  :					Union[str, Any]						     =       dl_manager.download_and_extract(self.config.data_files		)
          if isinstance(lowerCamelCase ,    (str, list, tuple)		):
               __A  :					List[str]						     =       data_files
               if isinstance(lowerCamelCase ,    lowerCamelCase		):
                    __A  :					Dict						     =       [files]
               # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
               __A  :					List[Any]						     =       [dl_manager.iter_files(lowerCamelCase		) for file in files]
               return [datasets.SplitGenerator(name=datasets.Split.TRAIN ,    gen_kwargs={"files": files}		)]
          __A  :					Optional[Any]						     =       []
          for split_name, files in data_files.items():
               if isinstance(lowerCamelCase ,    lowerCamelCase		):
                    __A  :					Optional[Any]						     =       [files]
               # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
               __A  :					List[str]						     =       [dl_manager.iter_files(lowerCamelCase		) for file in files]
               # Infer features is they are stoed in the arrow schema
               if self.info.features is None:
                    for file in itertools.chain.from_iterable(lowerCamelCase		):
                         with open(lowerCamelCase ,    "rb"		) as f:
                              __A  :					List[Any]						     =       datasets.Features.from_arrow_schema(pa.ipc.open_stream(lowerCamelCase		).schema		)
                         break
               splits.append(datasets.SplitGenerator(name=lowerCamelCase ,    gen_kwargs={"files": files}		)		)
          return splits


     def lowerCAmelCase__     (      self ,    lowerCamelCase		):


          '''simple docstring'''





          if self.info.features is not None:
               # more expensive cast to support nested features with keys in a different order
               # allows str <-> int/float or str to Audio for example
               __A  :					List[Any]						     =       table_cast(lowerCamelCase ,    self.info.features.arrow_schema		)
          return pa_table


     def lowerCAmelCase__     (      self ,    lowerCamelCase		):


          '''simple docstring'''





          for file_idx, file in enumerate(itertools.chain.from_iterable(lowerCamelCase		)		):
               with open(lowerCamelCase ,    "rb"		) as f:
                    try:
                         for batch_idx, record_batch in enumerate(pa.ipc.open_stream(lowerCamelCase		)		):
                              __A  :					Any						     =       pa.Table.from_batches([record_batch]		)
                              # Uncomment for debugging (will print the Arrow table size and elements)
                              # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
                              # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
                              yield f"{file_idx}_{batch_idx}", self._cast_table(lowerCamelCase		)
                    except ValueError as e:
                         logger.error(f"Failed to read file '{file}' with error {type(lowerCamelCase		)}: {e}"		)
                         raise





'''simple docstring'''


from sklearn.metrics import accuracy_score

import datasets


_UpperCamelCase          =     """
Accuracy is the proportion of correct predictions among the total number of cases processed. It can be computed with:
Accuracy = (TP + TN) / (TP + TN + FP + FN)
 Where:
TP: True positive
TN: True negative
FP: False positive
FN: False negative
"""


_UpperCamelCase          =     """
Args:
    predictions (`list` of `int`): Predicted labels.
    references (`list` of `int`): Ground truth labels.
    normalize (`boolean`): If set to False, returns the number of correctly classified samples. Otherwise, returns the fraction of correctly classified samples. Defaults to True.
    sample_weight (`list` of `float`): Sample weights Defaults to None.

Returns:
    accuracy (`float` or `int`): Accuracy score. Minimum possible value is 0. Maximum possible value is 1.0, or the number of examples input, if `normalize` is set to `True`.. A higher score means higher accuracy.

Examples:

    Example 1-A simple example
        >>> accuracy_metric = datasets.load_metric(\"accuracy\")
        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0])
        >>> print(results)
        {'accuracy': 0.5}

    Example 2-The same as Example 1, except with `normalize` set to `False`.
        >>> accuracy_metric = datasets.load_metric(\"accuracy\")
        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], normalize=False)
        >>> print(results)
        {'accuracy': 3.0}

    Example 3-The same as Example 1, except with `sample_weight` set.
        >>> accuracy_metric = datasets.load_metric(\"accuracy\")
        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], sample_weight=[0.5, 2, 0.7, 0.5, 9, 0.4])
        >>> print(results)
        {'accuracy': 0.8778625954198473}
"""


_UpperCamelCase          =     """
@article{scikit-learn,
  title={Scikit-learn: Machine Learning in {P}ython},
  author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
  journal={Journal of Machine Learning Research},
  volume={12},
  pages={2825--2830},
  year={2011}
}
"""







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,		_KWARGS_DESCRIPTION   )
class        __magic_name__  (					datasets.Metric   ):

     """simple docstring"""






     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          return datasets.MetricInfo(
              description=_DESCRIPTION ,    citation=_CITATION ,    inputs_description=_KWARGS_DESCRIPTION ,    features=datasets.Features(
                  {
                      "predictions": datasets.Sequence(datasets.Value("int32"		)		),
                      "references": datasets.Sequence(datasets.Value("int32"		)		),
                  }
                  if self.config_name == "multilabel"
                  else {
                      "predictions": datasets.Value("int32"		),
                      "references": datasets.Value("int32"		),
                  }		) ,    reference_urls=["https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html"] ,    )


     def lowerCAmelCase__     (      self ,    lowerCamelCase ,    lowerCamelCase ,    lowerCamelCase=True ,    lowerCamelCase=None		):


          '''simple docstring'''





          return {
              "accuracy": float(
                  accuracy_score(lowerCamelCase ,    lowerCamelCase ,    normalize=lowerCamelCase ,    sample_weight=lowerCamelCase		)		)
          }

