




'''simple docstring'''


import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    Pipeline,
    ZeroShotClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
_snake_case : Any  				=						{'LayoutLMv2Config', 'LayoutLMv3Config'}

@is_pipeline_test
class      A       (						unittest.TestCase       ):
							lowercase_							     =							MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
							lowercase_							     =							TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

							if model_mapping is not None:
														lowercase_							     =							{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
							if tf_model_mapping is not None:
														lowercase_							     =							{
														    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
														}







							def   __lowerCAmelCase     (    self			:    Dict				,     lowerCAmelCase_			:    Optional[int]				,     lowerCAmelCase_			:    int				,     lowerCAmelCase_			:    Optional[int]   )     ->				str:


														"""simple docstring"""


														_a      	=							ZeroShotClassificationPipeline(
														    model=__a				,     tokenizer=__a				,     candidate_labels=['''polics''', '''health''']   )
														return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]







							def   __lowerCAmelCase     (    self			:    Optional[int]				,     lowerCAmelCase_			:    Optional[int]				,     lowerCAmelCase_			:    List[str]   )     ->				Optional[int]:


														"""simple docstring"""


														_a      	=							classifier('''Who are you voting for in 2020?'''				,     candidate_labels='''politics'''   )
														self.assertEqual(__a				,     {'''sequence''': ANY(__a   ), '''labels''': [ANY(__a   )], '''scores''': [ANY(__a   )]}   )

														# No kwarg
														_a      	=							classifier('''Who are you voting for in 2020?'''				,     ['''politics''']   )
														self.assertEqual(__a				,     {'''sequence''': ANY(__a   ), '''labels''': [ANY(__a   )], '''scores''': [ANY(__a   )]}   )

														_a      	=							classifier('''Who are you voting for in 2020?'''				,     candidate_labels=['''politics''']   )
														self.assertEqual(__a				,     {'''sequence''': ANY(__a   ), '''labels''': [ANY(__a   )], '''scores''': [ANY(__a   )]}   )

														_a      	=							classifier('''Who are you voting for in 2020?'''				,     candidate_labels='''politics, public health'''   )
														self.assertEqual(
														    __a				,     {'''sequence''': ANY(__a   ), '''labels''': [ANY(__a   ), ANY(__a   )], '''scores''': [ANY(__a   ), ANY(__a   )]}   )
														self.assertAlmostEqual(sum(nested_simplify(outputs['''scores''']   )   )				,     1.0   )

														_a      	=							classifier('''Who are you voting for in 2020?'''				,     candidate_labels=['''politics''', '''public health''']   )
														self.assertEqual(
														    __a				,     {'''sequence''': ANY(__a   ), '''labels''': [ANY(__a   ), ANY(__a   )], '''scores''': [ANY(__a   ), ANY(__a   )]}   )
														self.assertAlmostEqual(sum(nested_simplify(outputs['''scores''']   )   )				,     1.0   )

														_a      	=							classifier(
														    '''Who are you voting for in 2020?'''				,     candidate_labels='''politics'''				,     hypothesis_template='''This text is about {}'''   )
														self.assertEqual(__a				,     {'''sequence''': ANY(__a   ), '''labels''': [ANY(__a   )], '''scores''': [ANY(__a   )]}   )

														# https://github.com/huggingface/transformers/issues/13846
														_a      	=							classifier(['''I am happy''']				,     ['''positive''', '''negative''']   )
														self.assertEqual(
														    __a				,     [
														        {'''sequence''': ANY(__a   ), '''labels''': [ANY(__a   ), ANY(__a   )], '''scores''': [ANY(__a   ), ANY(__a   )]}
														        for i in range(1   )
														    ]				,     )
														_a      	=							classifier(['''I am happy''', '''I am sad''']				,     ['''positive''', '''negative''']   )
														self.assertEqual(
														    __a				,     [
														        {'''sequence''': ANY(__a   ), '''labels''': [ANY(__a   ), ANY(__a   )], '''scores''': [ANY(__a   ), ANY(__a   )]}
														        for i in range(2   )
														    ]				,     )

														with self.assertRaises(__a   ):
																					classifier(''''''				,     candidate_labels='''politics'''   )

														with self.assertRaises(__a   ):
																					classifier(__a				,     candidate_labels='''politics'''   )

														with self.assertRaises(__a   ):
																					classifier('''Who are you voting for in 2020?'''				,     candidate_labels=''''''   )

														with self.assertRaises(__a   ):
																					classifier('''Who are you voting for in 2020?'''				,     candidate_labels=__a   )

														with self.assertRaises(__a   ):
																					classifier(
																					    '''Who are you voting for in 2020?'''				,     candidate_labels='''politics'''				,     hypothesis_template='''Not formatting template'''				,     )

														with self.assertRaises(__a   ):
																					classifier(
																					    '''Who are you voting for in 2020?'''				,     candidate_labels='''politics'''				,     hypothesis_template=__a				,     )

														self.run_entailment_id(__a   )







							def   __lowerCAmelCase     (    self			:    Any				,     lowerCAmelCase_			:    int   )     ->				List[Any]:


														"""simple docstring"""


														_a      	=							zero_shot_classifier.model.config
														_a      	=							config.labelaid
														_a      	=							zero_shot_classifier.entailment_id

														_a      	=							{'''LABEL_0''': 0, '''LABEL_1''': 1, '''LABEL_2''': 2}
														self.assertEqual(zero_shot_classifier.entailment_id				,     -1   )

														_a      	=							{'''entailment''': 0, '''neutral''': 1, '''contradiction''': 2}
														self.assertEqual(zero_shot_classifier.entailment_id				,     0   )

														_a      	=							{'''ENTAIL''': 0, '''NON-ENTAIL''': 1}
														self.assertEqual(zero_shot_classifier.entailment_id				,     0   )

														_a      	=							{'''ENTAIL''': 2, '''NEUTRAL''': 1, '''CONTR''': 0}
														self.assertEqual(zero_shot_classifier.entailment_id				,     2   )

														_a      	=							original_labelaid
														self.assertEqual(__a				,     zero_shot_classifier.entailment_id   )







							@require_torch
							def   __lowerCAmelCase     (    self			:    Dict   )     ->				Optional[int]:


														"""simple docstring"""


														_a      	=							pipeline(
														    '''zero-shot-classification'''				,     model='''sshleifer/tiny-distilbert-base-cased-distilled-squad'''				,     framework='''pt'''				,     )
														# There was a regression in 4.10 for this
														# Adding a test so we don't make the mistake again.
														# https://github.com/huggingface/transformers/issues/13381#issuecomment-912343499
														zero_shot_classifier(
														    '''Who are you voting for in 2020?''' * 1_00				,     candidate_labels=['''politics''', '''public health''', '''science''']   )







							@require_torch
							def   __lowerCAmelCase     (    self			:    Any   )     ->				str:


														"""simple docstring"""


														_a      	=							pipeline(
														    '''zero-shot-classification'''				,     model='''sshleifer/tiny-distilbert-base-cased-distilled-squad'''				,     framework='''pt'''				,     )
														_a      	=							zero_shot_classifier(
														    '''Who are you voting for in 2020?'''				,     candidate_labels=['''politics''', '''public health''', '''science''']   )

														self.assertEqual(
														    nested_simplify(__a   )				,     {
														        '''sequence''': '''Who are you voting for in 2020?''',
														        '''labels''': ['''science''', '''public health''', '''politics'''],
														        '''scores''': [0.3_3_3, 0.3_3_3, 0.3_3_3],
														    }				,     )







							@require_tf
							def   __lowerCAmelCase     (    self			:    str   )     ->				Dict:


														"""simple docstring"""


														_a      	=							pipeline(
														    '''zero-shot-classification'''				,     model='''sshleifer/tiny-distilbert-base-cased-distilled-squad'''				,     framework='''tf'''				,     )
														_a      	=							zero_shot_classifier(
														    '''Who are you voting for in 2020?'''				,     candidate_labels=['''politics''', '''public health''', '''science''']   )

														self.assertEqual(
														    nested_simplify(__a   )				,     {
														        '''sequence''': '''Who are you voting for in 2020?''',
														        '''labels''': ['''science''', '''public health''', '''politics'''],
														        '''scores''': [0.3_3_3, 0.3_3_3, 0.3_3_3],
														    }				,     )







							@slow
							@require_torch
							def   __lowerCAmelCase     (    self			:    Tuple   )     ->				Any:


														"""simple docstring"""


														_a      	=							pipeline('''zero-shot-classification'''				,     model='''roberta-large-mnli'''				,     framework='''pt'''   )
														_a      	=							zero_shot_classifier(
														    '''Who are you voting for in 2020?'''				,     candidate_labels=['''politics''', '''public health''', '''science''']   )

														self.assertEqual(
														    nested_simplify(__a   )				,     {
														        '''sequence''': '''Who are you voting for in 2020?''',
														        '''labels''': ['''politics''', '''public health''', '''science'''],
														        '''scores''': [0.9_7_6, 0.0_1_5, 0.0_0_9],
														    }				,     )
														_a      	=							zero_shot_classifier(
														    '''The dominant sequence transduction models are based on complex recurrent or convolutional neural networks'''
														    ''' in an encoder-decoder configuration. The best performing models also connect the encoder and decoder'''
														    ''' through an attention mechanism. We propose a new simple network architecture, the Transformer, based'''
														    ''' solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two'''
														    ''' machine translation tasks show these models to be superior in quality while being more parallelizable'''
														    ''' and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014'''
														    ''' English-to-German translation task, improving over the existing best results, including ensembles by'''
														    ''' over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new'''
														    ''' single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small'''
														    ''' fraction of the training costs of the best models from the literature. We show that the Transformer'''
														    ''' generalizes well to other tasks by applying it successfully to English constituency parsing both with'''
														    ''' large and limited training data.'''				,     candidate_labels=['''machine learning''', '''statistics''', '''translation''', '''vision''']				,     multi_label=__a				,     )
														self.assertEqual(
														    nested_simplify(__a   )				,     {
														        '''sequence''': (
														            '''The dominant sequence transduction models are based on complex recurrent or convolutional neural'''
														            ''' networks in an encoder-decoder configuration. The best performing models also connect the'''
														            ''' encoder and decoder through an attention mechanism. We propose a new simple network'''
														            ''' architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence'''
														            ''' and convolutions entirely. Experiments on two machine translation tasks show these models to be'''
														            ''' superior in quality while being more parallelizable and requiring significantly less time to'''
														            ''' train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,'''
														            ''' improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014'''
														            ''' English-to-French translation task, our model establishes a new single-model state-of-the-art'''
														            ''' BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training'''
														            ''' costs of the best models from the literature. We show that the Transformer generalizes well to'''
														            ''' other tasks by applying it successfully to English constituency parsing both with large and'''
														            ''' limited training data.'''
														        ),
														        '''labels''': ['''translation''', '''machine learning''', '''vision''', '''statistics'''],
														        '''scores''': [0.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
														    }				,     )







							@slow
							@require_tf
							def   __lowerCAmelCase     (    self			:    Tuple   )     ->				Optional[Any]:


														"""simple docstring"""


														_a      	=							pipeline('''zero-shot-classification'''				,     model='''roberta-large-mnli'''				,     framework='''tf'''   )
														_a      	=							zero_shot_classifier(
														    '''Who are you voting for in 2020?'''				,     candidate_labels=['''politics''', '''public health''', '''science''']   )

														self.assertEqual(
														    nested_simplify(__a   )				,     {
														        '''sequence''': '''Who are you voting for in 2020?''',
														        '''labels''': ['''politics''', '''public health''', '''science'''],
														        '''scores''': [0.9_7_6, 0.0_1_5, 0.0_0_9],
														    }				,     )
														_a      	=							zero_shot_classifier(
														    '''The dominant sequence transduction models are based on complex recurrent or convolutional neural networks'''
														    ''' in an encoder-decoder configuration. The best performing models also connect the encoder and decoder'''
														    ''' through an attention mechanism. We propose a new simple network architecture, the Transformer, based'''
														    ''' solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two'''
														    ''' machine translation tasks show these models to be superior in quality while being more parallelizable'''
														    ''' and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014'''
														    ''' English-to-German translation task, improving over the existing best results, including ensembles by'''
														    ''' over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new'''
														    ''' single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small'''
														    ''' fraction of the training costs of the best models from the literature. We show that the Transformer'''
														    ''' generalizes well to other tasks by applying it successfully to English constituency parsing both with'''
														    ''' large and limited training data.'''				,     candidate_labels=['''machine learning''', '''statistics''', '''translation''', '''vision''']				,     multi_label=__a				,     )
														self.assertEqual(
														    nested_simplify(__a   )				,     {
														        '''sequence''': (
														            '''The dominant sequence transduction models are based on complex recurrent or convolutional neural'''
														            ''' networks in an encoder-decoder configuration. The best performing models also connect the'''
														            ''' encoder and decoder through an attention mechanism. We propose a new simple network'''
														            ''' architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence'''
														            ''' and convolutions entirely. Experiments on two machine translation tasks show these models to be'''
														            ''' superior in quality while being more parallelizable and requiring significantly less time to'''
														            ''' train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,'''
														            ''' improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014'''
														            ''' English-to-French translation task, our model establishes a new single-model state-of-the-art'''
														            ''' BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training'''
														            ''' costs of the best models from the literature. We show that the Transformer generalizes well to'''
														            ''' other tasks by applying it successfully to English constituency parsing both with large and'''
														            ''' limited training data.'''
														        ),
														        '''labels''': ['''translation''', '''machine learning''', '''vision''', '''statistics'''],
														        '''scores''': [0.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
														    }				,     )



"""simple docstring"""





from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching



def  lowerCamelCase__						(     )				->						List[str]:


					"""simple docstring"""





					import os as original_os
					from os import path as original_path
					from os import rename as original_rename
					from os.path import dirname as original_dirname
					from os.path import join as original_join

					assert _test_patching.os is original_os
					assert _test_patching.path is original_path
					assert _test_patching.join is original_join

					assert _test_patching.renamed_os is original_os
					assert _test_patching.renamed_path is original_path
					assert _test_patching.renamed_join is original_join

					_UpperCamelCase									=    '''__test_patch_submodule_mock__'''
					with patch_submodule(_test_patching,	'''os.path.join''',	__snake_case      ):
										# Every way to access os.path.join must be patched, and the rest must stay untouched

										# check os.path.join
										assert isinstance(_test_patching.os,	_PatchedModuleObj      )
										assert isinstance(_test_patching.os.path,	_PatchedModuleObj      )
										assert _test_patching.os.path.join is mock

										# check path.join
										assert isinstance(_test_patching.path,	_PatchedModuleObj      )
										assert _test_patching.path.join is mock

										# check join
										assert _test_patching.join is mock

										# check that the other attributes are untouched
										assert _test_patching.os.rename is original_rename
										assert _test_patching.path.dirname is original_dirname
										assert _test_patching.os.path.dirname is original_dirname

										# Even renamed modules or objects must be patched

										# check renamed_os.path.join
										assert isinstance(_test_patching.renamed_os,	_PatchedModuleObj      )
										assert isinstance(_test_patching.renamed_os.path,	_PatchedModuleObj      )
										assert _test_patching.renamed_os.path.join is mock

										# check renamed_path.join
										assert isinstance(_test_patching.renamed_path,	_PatchedModuleObj      )
										assert _test_patching.renamed_path.join is mock

										# check renamed_join
										assert _test_patching.renamed_join is mock

										# check that the other attributes are untouched
										assert _test_patching.renamed_os.rename is original_rename
										assert _test_patching.renamed_path.dirname is original_dirname
										assert _test_patching.renamed_os.path.dirname is original_dirname

					# check that everthing is back to normal when the patch is over

					assert _test_patching.os is original_os
					assert _test_patching.path is original_path
					assert _test_patching.join is original_join

					assert _test_patching.renamed_os is original_os
					assert _test_patching.renamed_path is original_path
					assert _test_patching.renamed_join is original_join



def  lowerCamelCase__						(     )				->						List[str]:


					"""simple docstring"""





					assert _test_patching.open is open

					_UpperCamelCase									=    '''__test_patch_submodule_builtin_mock__'''
					# _test_patching has "open" in its globals
					assert _test_patching.open is open
					with patch_submodule(_test_patching,	'''open''',	__snake_case      ):
										assert _test_patching.open is mock

					# check that everthing is back to normal when the patch is over

					assert _test_patching.open is open



def  lowerCamelCase__						(     )				->						Union[str, Any]:


					"""simple docstring"""





					_UpperCamelCase									=    '''__test_patch_submodule_missing_mock__'''
					with patch_submodule(_test_patching,	'''pandas.read_csv''',	__snake_case      ):
										pass



def  lowerCamelCase__						(     )				->						Dict:


					"""simple docstring"""





					_UpperCamelCase									=    '''__test_patch_submodule_missing_builtin_mock__'''
					# _test_patching doesn't have "len" in its globals
					assert getattr(_test_patching,	'''len''',	__snake_case      ) is None
					with patch_submodule(_test_patching,	'''len''',	__snake_case      ):
										assert _test_patching.len is mock
					assert _test_patching.len is len



def  lowerCamelCase__						(     )				->						Tuple:


					"""simple docstring"""





					_UpperCamelCase									=    '''__test_patch_submodule_start_and_stop_mock__'''
					_UpperCamelCase									=    patch_submodule(_test_patching,	'''open''',	__snake_case      )
					assert _test_patching.open is open
					patch.start()
					assert _test_patching.open is mock
					patch.stop()
					assert _test_patching.open is open



def  lowerCamelCase__						(     )				->						Optional[int]:


					"""simple docstring"""





					from os import rename as original_rename
					from os.path import dirname as original_dirname
					from os.path import join as original_join

					_UpperCamelCase									=    '''__test_patch_submodule_successive_join__'''
					_UpperCamelCase									=    '''__test_patch_submodule_successive_dirname__'''
					_UpperCamelCase									=    '''__test_patch_submodule_successive_rename__'''
					assert _test_patching.os.path.join is original_join
					assert _test_patching.os.path.dirname is original_dirname
					assert _test_patching.os.rename is original_rename

					with patch_submodule(_test_patching,	'''os.path.join''',	__snake_case      ):
										with patch_submodule(_test_patching,	'''os.rename''',	__snake_case      ):
															with patch_submodule(_test_patching,	'''os.path.dirname''',	__snake_case      ):
																				assert _test_patching.os.path.join is mock_join
																				assert _test_patching.os.path.dirname is mock_dirname
																				assert _test_patching.os.rename is mock_rename

    # try another order
					with patch_submodule(_test_patching,	'''os.rename''',	__snake_case      ):
										with patch_submodule(_test_patching,	'''os.path.join''',	__snake_case      ):
															with patch_submodule(_test_patching,	'''os.path.dirname''',	__snake_case      ):
																				assert _test_patching.os.path.join is mock_join
																				assert _test_patching.os.path.dirname is mock_dirname
																				assert _test_patching.os.rename is mock_rename

					assert _test_patching.os.path.join is original_join
					assert _test_patching.os.path.dirname is original_dirname
					assert _test_patching.os.rename is original_rename



def  lowerCamelCase__						(     )				->						str:


					"""simple docstring"""





					_UpperCamelCase									=    '''__test_patch_submodule_doesnt_exist_mock__'''
					with patch_submodule(_test_patching,	'''__module_that_doesn_exist__.__attribute_that_doesn_exist__''',	__snake_case      ):
										pass
					with patch_submodule(_test_patching,	'''os.__attribute_that_doesn_exist__''',	__snake_case      ):
										pass






