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.
_lowerCamelCase   :				Tuple     			=						{'''LayoutLMv2Config''', '''LayoutLMv3Config'''}


@is_pipeline_test
class   lowercase      (       unittest.TestCase       ):
							lowercase__  :    Any									=							MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
							lowercase__  :    Optional[int]									=							TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

							if model_mapping is not None:
														lowercase__  :    Union[str, Any]									=							{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
							if tf_model_mapping is not None:
														lowercase__  :    Any									=							{
														    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
														}




							def 		__snake_case(  self				:   Tuple		,							_UpperCamelCase				:   Dict		,							_UpperCamelCase				:   Dict		,							_UpperCamelCase				:   str )   ->			Optional[Any]:



												'''simple docstring'''

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




							def 		__snake_case(  self				:   List[str]		,							_UpperCamelCase				:   Dict		,							_UpperCamelCase				:   int )   ->			List[str]:



												'''simple docstring'''

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

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

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

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

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

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

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

												with self.assertRaises(_UpperCamelCase ):
																	classifier(""		,							candidate_labels="politics" )

												with self.assertRaises(_UpperCamelCase ):
																	classifier(_UpperCamelCase		,							candidate_labels="politics" )

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

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

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

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

												self.run_entailment_id(_UpperCamelCase )




							def 		__snake_case(  self				:   List[str]		,							_UpperCamelCase				:   Pipeline )   ->			Optional[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    zero_shot_classifier.model.config
												SCREAMING_SNAKE_CASE           =    config.labelaid
												SCREAMING_SNAKE_CASE           =    zero_shot_classifier.entailment_id

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

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

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

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

												SCREAMING_SNAKE_CASE           =    original_labelaid
												self.assertEqual(_UpperCamelCase		,							zero_shot_classifier.entailment_id )




							@require_torch
							def 		__snake_case(  self				:   Optional[Any] )   ->			Any:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    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?" * 100		,							candidate_labels=["politics", "public health", "science"] )




							@require_torch
							def 		__snake_case(  self				:   Tuple )   ->			str:



												'''simple docstring'''

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

												self.assertEqual(
												    nested_simplify(_UpperCamelCase )		,							{
												        "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 		__snake_case(  self				:   str )   ->			Any:



												'''simple docstring'''

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

												self.assertEqual(
												    nested_simplify(_UpperCamelCase )		,							{
												        "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 		__snake_case(  self				:   Tuple )   ->			str:



												'''simple docstring'''

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

												self.assertEqual(
												    nested_simplify(_UpperCamelCase )		,							{
												        "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],
												    }		,							)
												SCREAMING_SNAKE_CASE           =    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=_UpperCamelCase		,							)
												self.assertEqual(
												    nested_simplify(_UpperCamelCase )		,							{
												        "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 		__snake_case(  self				:   Optional[int] )   ->			Dict:



												'''simple docstring'''

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

												self.assertEqual(
												    nested_simplify(_UpperCamelCase )		,							{
												        "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],
												    }		,							)
												SCREAMING_SNAKE_CASE           =    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=_UpperCamelCase		,							)
												self.assertEqual(
												    nested_simplify(_UpperCamelCase )		,							{
												        "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],
												    }		,							)





def 		__lowerCamelCase							(UpperCAmelCase__       :							int ,	UpperCAmelCase__       :							int					):
					while b:
										SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE           =    b, a % b
					return a





def 		__lowerCamelCase							(UpperCAmelCase__       :							int ,	UpperCAmelCase__       :							int					):
					return a if b == 0 else euclidean_gcd_recursive(UpperCAmelCase__ ,	a % b					)





def 		__lowerCamelCase							():
					print(F"euclidean_gcd(3, 5) = {euclidean_gcd(3 ,	5					)}"					)
					print(F"euclidean_gcd(5, 3) = {euclidean_gcd(5 ,	3					)}"					)
					print(F"euclidean_gcd(1, 3) = {euclidean_gcd(1 ,	3					)}"					)
					print(F"euclidean_gcd(3, 6) = {euclidean_gcd(3 ,	6					)}"					)
					print(F"euclidean_gcd(6, 3) = {euclidean_gcd(6 ,	3					)}"					)

					print(F"euclidean_gcd_recursive(3, 5) = {euclidean_gcd_recursive(3 ,	5					)}"					)
					print(F"euclidean_gcd_recursive(5, 3) = {euclidean_gcd_recursive(5 ,	3					)}"					)
					print(F"euclidean_gcd_recursive(1, 3) = {euclidean_gcd_recursive(1 ,	3					)}"					)
					print(F"euclidean_gcd_recursive(3, 6) = {euclidean_gcd_recursive(3 ,	6					)}"					)
					print(F"euclidean_gcd_recursive(6, 3) = {euclidean_gcd_recursive(6 ,	3					)}"					)


if __name__ == "__main__":
							main()




