


'''simple docstring'''






# flake8: noqa
# Lint as: python3

from typing import Dict, List, Optional, Type

from .. import config
from ..utils import logging
from .formatting import (
    ArrowFormatter,
    CustomFormatter,
    Formatter,
    PandasFormatter,
    PythonFormatter,
    TensorFormatter,
    format_table,
    query_table,
)
from .np_formatter import NumpyFormatter


a_					:    Optional[Any]          =    logging.get_logger(__name__)

a_					:    Dict[Optional[str], Type[Formatter]]          =    {}
a_					:    Dict[Optional[str], str]          =    {}
a_					:    Dict[Optional[str], Exception]          =    {}






def 	_A				(lowerCAmelCase__  :type				,						lowerCAmelCase__  :Optional[str]				,						lowerCAmelCase__  :Optional[List[str]] = None				,						)   ->  Any:




     '''simple docstring'''



     _a			      =							aliases if aliases is not None else []
     if format_type in _FORMAT_TYPES:
          logger.warning(
              f'Overwriting format type \'{format_type}\' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})'		)
     _a			      =							formatter_cls
     for alias in set(aliases + [format_type]		):
          if alias in _FORMAT_TYPES_ALIASES:
               logger.warning(
                   f'Overwriting format type alias \'{alias}\' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})'		)
          _a			      =							format_type






def 	_A				(lowerCAmelCase__  :Exception				,						lowerCAmelCase__  :Optional[str]				,						lowerCAmelCase__  :Optional[List[str]] = None		)   ->  Union[str, Any]:




     '''simple docstring'''



     _a			      =							aliases if aliases is not None else []
     for alias in set(aliases + [format_type]		):
          _a			      =							unavailable_error


# Here we define all the available formatting functions that can be used by `Dataset.set_format`
_register_formatter(PythonFormatter, None, aliases=["python"])
_register_formatter(ArrowFormatter, "arrow", aliases=["pa", "pyarrow"])
_register_formatter(NumpyFormatter, "numpy", aliases=["np"])
_register_formatter(PandasFormatter, "pandas", aliases=["pd"])
_register_formatter(CustomFormatter, "custom")

if config.TORCH_AVAILABLE:
 from .torch_formatter import TorchFormatter

 _register_formatter(TorchFormatter, "torch", aliases=["pt", "pytorch"])
else:
 a_					:    Dict          =    ValueError("PyTorch needs to be installed to be able to return PyTorch tensors.")
 _register_unavailable_formatter(_torch_error, "torch", aliases=["pt", "pytorch"])

if config.TF_AVAILABLE:
 from .tf_formatter import TFFormatter

 _register_formatter(TFFormatter, "tensorflow", aliases=["tf"])
else:
 a_					:    Union[str, Any]          =    ValueError("Tensorflow needs to be installed to be able to return Tensorflow tensors.")
 _register_unavailable_formatter(_tf_error, "tensorflow", aliases=["tf"])

if config.JAX_AVAILABLE:
 from .jax_formatter import JaxFormatter

 _register_formatter(JaxFormatter, "jax", aliases=[])
else:
 a_					:    Any          =    ValueError("JAX needs to be installed to be able to return JAX arrays.")
 _register_unavailable_formatter(_jax_error, "jax", aliases=[])






def 	_A				(lowerCAmelCase__  :Optional[str]		)   ->  Optional[str]:




     '''simple docstring'''



     if format_type in _FORMAT_TYPES_ALIASES:
          return _FORMAT_TYPES_ALIASES[format_type]
     else:
          return format_type






def 	_A				(lowerCAmelCase__  :Optional[str]				,						**lowerCAmelCase__  :int		)   ->  Formatter:




     '''simple docstring'''



     _a			      =							get_format_type_from_alias(lowerCAmelCase__		)
     if format_type in _FORMAT_TYPES:
          return _FORMAT_TYPES[format_type](**lowerCAmelCase__		)
     if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE:
          raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type]
     else:
          raise ValueError(
              f'Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None		)}, but got \'{format_type}\''		)





'''simple docstring'''






import datasets


a_					:    List[Any]          =    "\\n@InProceedings{conneau2018xnli,\n  author = \"Conneau, Alexis\n                 and Rinott, Ruty\n                 and Lample, Guillaume\n                 and Williams, Adina\n                 and Bowman, Samuel R.\n                 and Schwenk, Holger\n                 and Stoyanov, Veselin\",\n  title = \"XNLI: Evaluating Cross-lingual Sentence Representations\",\n  booktitle = \"Proceedings of the 2018 Conference on Empirical Methods\n               in Natural Language Processing\",\n  year = \"2018\",\n  publisher = \"Association for Computational Linguistics\",\n  location = \"Brussels, Belgium\",\n}\n"

a_					:    Optional[Any]          =    "\\nXNLI is a subset of a few thousand examples from MNLI which has been translated\ninto a 14 different languages (some low-ish resource). As with MNLI, the goal is\nto predict textual entailment (does sentence A imply/contradict/neither sentence\nB) and is a classification task (given two sentences, predict one of three\nlabels).\n"

a_					:    Optional[Any]          =    "\nComputes XNLI score which is just simple accuracy.\nArgs:\n    predictions: Predicted labels.\n    references: Ground truth labels.\nReturns:\n    'accuracy': accuracy\nExamples:\n\n    >>> predictions = [0, 1]\n    >>> references = [0, 1]\n    >>> xnli_metric = datasets.load_metric(\"xnli\")\n    >>> results = xnli_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0}\n"






def 	_A				(lowerCAmelCase__  :List[Any]				,						lowerCAmelCase__  :Tuple		)   ->  Dict:




     '''simple docstring'''



     return (preds == labels).mean()






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION  ,				_KWARGS_DESCRIPTION       )
class  a     (     datasets.Metric       ):
 def 							__UpperCAmelCase		( self						)					->							Dict:
      return datasets.MetricInfo(
          description=_DESCRIPTION      ,				citation=_CITATION      ,				inputs_description=_KWARGS_DESCRIPTION      ,				features=datasets.Features(
              {
                  'predictions': datasets.Value('int64' if self.config_name != 'sts-b' else 'float32'						),
                  'references': datasets.Value('int64' if self.config_name != 'sts-b' else 'float32'						),
              }						)      ,				codebase_urls=[]      ,				reference_urls=[]      ,				format='numpy'      ,				)




 def 							__UpperCAmelCase		( self      ,				__magic_name__      ,				__magic_name__						)					->							Dict:
      return {"accuracy": simple_accuracy(__magic_name__      ,				__magic_name__						)}

