



import time
from dataclasses import dataclass
from multiprocessing import Pool
from unittest import TestCase
from unittest.mock import patch

import multiprocess
import numpy as np
import pytest

from datasets.utils.py_utils import (
    NestedDataStructure,
    asdict,
    iflatmap_unordered,
    map_nested,
    temp_seed,
    temporary_assignment,
    zip_dict,
)

from .utils import require_tf, require_torch


def A    (							__UpperCamelCase       )    ->   List[str]:  # picklable for multiprocessing
			return x.sum()


def A    (							__UpperCamelCase       )    ->   Optional[Any]:  # picklable for multiprocessing
			return i + 1


@dataclass
class   __lowerCAmelCase  :
					"""simple docstring"""






					A__					:		int
					A__					:		str







class   __lowerCAmelCase  (		UpperCAmelCase_   ):
					"""simple docstring"""






					def      _a				(  self       :							List[str]       ):






								"""simple docstring"""


								A__	  =     {}
								A__	  =     []
								A__	  =     1
								A__	  =     [1, 2]
								A__	  =     {'a': 1, 'b': 2}
								A__	  =     {'a': [1, 2], 'b': [3, 4]}
								A__	  =     {'a': {'1': 1}, 'b': 2}
								A__	  =     {'a': 1, 'b': 2, 'c': 3, 'd': 4}
								A__	  =     {}
								A__	  =     []
								A__	  =     2
								A__	  =     [2, 3]
								A__	  =     {'a': 2, 'b': 3}
								A__	  =     {'a': [2, 3], 'b': [4, 5]}
								A__	  =     {'a': {'1': 2}, 'b': 3}
								A__	  =     {'a': 2, 'b': 3, 'c': 4, 'd': 5}
								self.assertEqual(map_nested(_snake_case					,       _snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case       )					,       _snake_case       )

								A__	  =     2
								self.assertEqual(map_nested(_snake_case					,       _snake_case					,       num_proc=_snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case					,       num_proc=_snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case					,       num_proc=_snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case					,       num_proc=_snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case					,       num_proc=_snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case					,       num_proc=_snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case					,       num_proc=_snake_case       )					,       _snake_case       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case					,       num_proc=_snake_case       )					,       _snake_case       )

								A__	  =     {'a': np.eye(2       ), 'b': np.zeros(3       ), 'c': np.ones(2       )}
								A__	  =     {'a': 2, 'b': 0, 'c': 2}
								A__	  =     {
								    'a': np.eye(2       ).astype(_snake_case       ),
								    'b': np.zeros(3       ).astype(_snake_case       ),
								    'c': np.ones(2       ).astype(_snake_case       ),
								}
								self.assertEqual(map_nested(_snake_case					,       _snake_case					,       map_numpy=_snake_case       )					,       _snake_case       )
								self.assertEqual(
								    {k: v.tolist() for k, v in map_nested(_snake_case					,       _snake_case					,       map_numpy=_snake_case       ).items()}					,       {k: v.tolist() for k, v in expected_map_nested_sna_int.items()}					,       )
								self.assertEqual(map_nested(_snake_case					,       _snake_case					,       map_numpy=_snake_case					,       num_proc=_snake_case       )					,       _snake_case       )
								self.assertEqual(
								    {k: v.tolist() for k, v in map_nested(_snake_case					,       _snake_case					,       map_numpy=_snake_case					,       num_proc=_snake_case       ).items()}					,       {k: v.tolist() for k, v in expected_map_nested_sna_int.items()}					,       )
								with self.assertRaises(_snake_case       ):  # can't pickle a local lambda
											map_nested(lambda _snake_case       : x + 1					,       _snake_case					,       num_proc=_snake_case       )



					def      _a				(  self       :							Optional[int]       ):






								"""simple docstring"""


								A__	  =     {'a': 1, 'b': 2}
								A__	  =     {'a': 3, 'b': 4}
								A__	  =     {'a': 5, 'b': 6}
								A__	  =     sorted([('a', (1, 3, 5)), ('b', (2, 4, 6))]       )
								self.assertEqual(sorted(zip_dict(_snake_case					,       _snake_case					,       _snake_case       )       )					,       _snake_case       )



					def      _a				(  self       :							Tuple       ):






								"""simple docstring"""


								class   __lowerCAmelCase  :
													"""simple docstring"""






													A__					:		int      							=     "bar"







								A__	  =     Foo()
								self.assertEqual(foo.my_attr					,       'bar'       )
								with temporary_assignment(_snake_case					,       'my_attr'					,       'BAR'       ):
											self.assertEqual(foo.my_attr					,       'BAR'       )
								self.assertEqual(foo.my_attr					,       'bar'       )







@pytest.mark.parametrize(
    'iterable_length, num_proc, expected_num_proc'			,						[
        (1, None, 1),
        (1, 1, 1),
        (2, None, 1),
        (2, 1, 1),
        (2, 2, 1),
        (2, 3, 1),
        (3, 2, 1),
        (16, 16, 16),
        (16, 17, 16),
        (17, 16, 16),
    ]			,						)
def A    (							__UpperCamelCase			,						__UpperCamelCase			,						__UpperCamelCase       )    ->   List[str]:
			with patch('datasets.utils.py_utils._single_map_nested'       ) as mock_single_map_nested, patch(
			    'datasets.parallel.parallel.Pool'       ) as mock_multiprocessing_pool:
						A__	  =     {f'''{i}''': i for i in range(__UpperCamelCase       )}
						A__	  =     map_nested(lambda __UpperCamelCase       : x + 10			,						__UpperCamelCase			,						num_proc=__UpperCamelCase			,						parallel_min_length=16       )
						if expected_num_proc == 1:
									assert mock_single_map_nested.called
									assert not mock_multiprocessing_pool.called
						else:
									assert not mock_single_map_nested.called
									assert mock_multiprocessing_pool.called
									assert mock_multiprocessing_pool.call_args[0][0] == expected_num_proc


class   __lowerCAmelCase  (		UpperCAmelCase_   ):
					"""simple docstring"""






					@require_tf
					def      _a				(  self       :							Optional[int]       ):






								"""simple docstring"""


								import tensorflow as tf
								from tensorflow.keras import layers

								A__	  =     layers.Dense(2       )

								def gen_random_output():
											A__	  =     tf.random.uniform((1, 3)       )
											return model(_snake_case       ).numpy()

								with temp_seed(42					,       set_tensorflow=_snake_case       ):
											A__	  =     gen_random_output()
								with temp_seed(42					,       set_tensorflow=_snake_case       ):
											A__	  =     gen_random_output()
								A__	  =     gen_random_output()

								np.testing.assert_equal(_snake_case					,       _snake_case       )
								self.assertGreater(np.abs(outa - outa       ).sum()					,       0       )



					@require_torch
					def      _a				(  self       :							Optional[Any]       ):






								"""simple docstring"""


								import torch

								def gen_random_output():
											A__	  =     torch.nn.Linear(3					,       2       )
											A__	  =     torch.rand(1					,       3       )
											return model(_snake_case       ).detach().numpy()

								with temp_seed(42					,       set_pytorch=_snake_case       ):
											A__	  =     gen_random_output()
								with temp_seed(42					,       set_pytorch=_snake_case       ):
											A__	  =     gen_random_output()
								A__	  =     gen_random_output()

								np.testing.assert_equal(_snake_case					,       _snake_case       )
								self.assertGreater(np.abs(outa - outa       ).sum()					,       0       )



					def      _a				(  self       :							List[Any]       ):






								"""simple docstring"""


								def gen_random_output():
											return np.random.rand(1					,       3       )

								with temp_seed(42       ):
											A__	  =     gen_random_output()
								with temp_seed(42       ):
											A__	  =     gen_random_output()
								A__	  =     gen_random_output()

								np.testing.assert_equal(_snake_case					,       _snake_case       )
								self.assertGreater(np.abs(outa - outa       ).sum()					,       0       )







@pytest.mark.parametrize('input_data'			,						[{}]       )
def A    (							__UpperCamelCase       )    ->   List[str]:
			A__	  =     NestedDataStructure(__UpperCamelCase       ).data
			assert output_data == input_data


@pytest.mark.parametrize(
    'data, expected_output'			,						[
        ({}, []),
        ([], []),
        ('foo', ['foo']),
        (['foo', 'bar'], ['foo', 'bar']),
        ([['foo', 'bar']], ['foo', 'bar']),
        ([[['foo'], ['bar']]], ['foo', 'bar']),
        ([[['foo'], 'bar']], ['foo', 'bar']),
        ({'a': 1, 'b': 2}, [1, 2]),
        ({'a': [1, 2], 'b': [3, 4]}, [1, 2, 3, 4]),
        ({'a': [[1, 2]], 'b': [[3, 4]]}, [1, 2, 3, 4]),
        ({'a': [[1, 2]], 'b': [3, 4]}, [1, 2, 3, 4]),
        ({'a': [[[1], [2]]], 'b': [[[3], [4]]]}, [1, 2, 3, 4]),
        ({'a': [[[1], [2]]], 'b': [[3, 4]]}, [1, 2, 3, 4]),
        ({'a': [[[1], [2]]], 'b': [3, 4]}, [1, 2, 3, 4]),
        ({'a': [[[1], [2]]], 'b': [3, [4]]}, [1, 2, 3, 4]),
        ({'a': {'1': 1}, 'b': 2}, [1, 2]),
        ({'a': {'1': [1]}, 'b': 2}, [1, 2]),
        ({'a': {'1': [1]}, 'b': [2]}, [1, 2]),
    ]			,						)
def A    (							__UpperCamelCase			,						__UpperCamelCase       )    ->   str:
			A__	  =     NestedDataStructure(__UpperCamelCase       ).flatten()
			assert output == expected_output


def A    (							)    ->   Tuple:
			A__	  =     A(x=1			,						y='foobar'       )
			A__	  =     {'x': 1, 'y': 'foobar'}
			assert asdict(__UpperCamelCase       ) == expected_output

			A__	  =     {'a': {'b': A(x=10			,						y='foo'       )}, 'c': [A(x=20			,						y='bar'       )]}
			A__	  =     {'a': {'b': {'x': 10, 'y': 'foo'}}, 'c': [{'x': 20, 'y': 'bar'}]}
			assert asdict(__UpperCamelCase       ) == expected_output

			with pytest.raises(__UpperCamelCase       ):
						asdict([1, A(x=10			,						y='foo'       )]       )


def A    (							__UpperCamelCase       )    ->   str:
			return text.split()


def A    (							__UpperCamelCase       )    ->   Tuple:
			yield (time.time(), content)
			time.sleep(2       )
			yield (time.time(), content)






def A    (							)    ->   Any:
			with Pool(2       ) as pool:
						A__	  =     list(iflatmap_unordered(__UpperCamelCase			,						_split_text			,						kwargs_iterable=[{'text': 'hello there'}] * 10       )       )
						assert out.count('hello'       ) == 10
						assert out.count('there'       ) == 10
						assert len(__UpperCamelCase       ) == 20

			# check multiprocess from pathos (uses dill for pickling)
			with multiprocess.Pool(2       ) as pool:
						A__	  =     list(iflatmap_unordered(__UpperCamelCase			,						_split_text			,						kwargs_iterable=[{'text': 'hello there'}] * 10       )       )
						assert out.count('hello'       ) == 10
						assert out.count('there'       ) == 10
						assert len(__UpperCamelCase       ) == 20

			# check that we get items as fast as possible
			with Pool(2       ) as pool:
						A__	  =     []
						for yield_time, content in iflatmap_unordered(
						    __UpperCamelCase			,						_aseconds_generator_of_aitems_with_timing			,						kwargs_iterable=[{'content': 'a'}, {'content': 'b'}]       ):
									assert yield_time < time.time() + 0.1, "we should each item directly after it was yielded"
									out.append(__UpperCamelCase       )
						assert out.count('a'       ) == 2
						assert out.count('b'       ) == 2
						assert len(__UpperCamelCase       ) == 4












'''simple docstring'''



from scipy.stats import pearsonr, spearmanr
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets


__UpperCamelCase   :							Optional[int]         =   """\
@inproceedings{wang2019glue,
  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},
  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},
  note={In the Proceedings of ICLR.},
  year={2019}
}
"""

__UpperCamelCase   :							Tuple         =   """\
GLUE, the General Language Understanding Evaluation benchmark
(https://gluebenchmark.com/) is a collection of resources for training,
evaluating, and analyzing natural language understanding systems.
"""

__UpperCamelCase   :							Optional[int]         =   """
Compute GLUE evaluation metric associated to each GLUE dataset.
Args:
    predictions: list of predictions to score.
        Each translation should be tokenized into a list of tokens.
    references: list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
Returns: depending on the GLUE subset, one or several of:
    \"accuracy\": Accuracy
    \"f1\": F1 score
    \"pearson\": Pearson Correlation
    \"spearmanr\": Spearman Correlation
    \"matthews_correlation\": Matthew Correlation
Examples:

    >>> glue_metric = datasets.load_metric('glue', 'sst2')  # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"]
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'mrpc')  # 'mrpc' or 'qqp'
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0, 'f1': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'stsb')
    >>> references = [0., 1., 2., 3., 4., 5.]
    >>> predictions = [0., 1., 2., 3., 4., 5.]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)})
    {'pearson': 1.0, 'spearmanr': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'cola')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'matthews_correlation': 1.0}
"""



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						Optional[int],       SCREAMING_SNAKE_CASE__:						str     )	->      List[Any]:

   """simple docstring"""
   return float((preds == labels).mean()     )



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						Optional[Any],       SCREAMING_SNAKE_CASE__:						List[str]     )	->      Optional[Any]:

   """simple docstring"""
   __a					  =     simple_accuracy(SCREAMING_SNAKE_CASE__,       SCREAMING_SNAKE_CASE__     )
   __a					  =     float(fa_score(y_true=SCREAMING_SNAKE_CASE__,       y_pred=SCREAMING_SNAKE_CASE__     )     )
   return {
       "accuracy": acc,
       "f1": fa,
   }



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						int,       SCREAMING_SNAKE_CASE__:						Optional[Any]     )	->      int:

   """simple docstring"""
   __a					  =     float(pearsonr(SCREAMING_SNAKE_CASE__,       SCREAMING_SNAKE_CASE__     )[0]     )
   __a					  =     float(spearmanr(SCREAMING_SNAKE_CASE__,       SCREAMING_SNAKE_CASE__     )[0]     )
   return {
       "pearson": pearson_corr,
       "spearmanr": spearman_corr,
   }



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




      def 			__UpperCamelCase				(	self   )				->int:



         '''simple docstring'''
         if self.config_name not in [
             "sst2",
             "mnli",
             "mnli_mismatched",
             "mnli_matched",
             "cola",
             "stsb",
             "mrpc",
             "qqp",
             "qnli",
             "rte",
             "wnli",
             "hans",
         ]:
            raise KeyError(
                'You should supply a configuration name selected in '
                '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
                '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'   )
         return datasets.MetricInfo(
             description=_DESCRIPTION			, citation=_CITATION			, inputs_description=_KWARGS_DESCRIPTION			, features=datasets.Features(
                 {
                     'predictions': datasets.Value('int64' if self.config_name != 'stsb' else 'float32'   ),
                     'references': datasets.Value('int64' if self.config_name != 'stsb' else 'float32'   ),
                 }   )			, codebase_urls=[]			, reference_urls=[]			, format='numpy'			, )






      def 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase   )				->Tuple:



         '''simple docstring'''
         if self.config_name == "cola":
            return {"matthews_correlation": matthews_corrcoef(lowerCamelCase			, lowerCamelCase   )}
         elif self.config_name == "stsb":
            return pearson_and_spearman(lowerCamelCase			, lowerCamelCase   )
         elif self.config_name in ["mrpc", "qqp"]:
            return acc_and_fa(lowerCamelCase			, lowerCamelCase   )
         elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
            return {"accuracy": simple_accuracy(lowerCamelCase			, lowerCamelCase   )}
         else:
            raise KeyError(
                'You should supply a configuration name selected in '
                '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
                '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'   )