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					:   Union[str, Any]							=		{'''LayoutLMv2Config''', '''LayoutLMv3Config'''}


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

							if model_mapping is not None:
														lowercase__						:       List[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__						:       List[str]								=							{
														    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
														}




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



												'''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   :					int	,							_UpperCamelCase   :					Optional[Any]	,							_UpperCamelCase   :					Optional[int]      )					->				Dict:



												'''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   :					int	,							_UpperCamelCase   :					Pipeline      )					->				List[Any]:



												'''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   :					Any      )					->				str:



												'''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   :					Optional[Any]      )					->				int:



												'''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   :					Optional[Any]      )					->				Optional[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      )					->				Union[str, Any]:



												'''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[Any]      )					->				Tuple:



												'''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__     :							list[int]  ):
					if not numbers:
										return 0

					if not isinstance(UpperCAmelCase__      , (list, tuple)  ) or not all(
					    isinstance(UpperCAmelCase__      , UpperCAmelCase__  ) for number in numbers  ):
										raise ValueError("numbers must be an iterable of integers"  )

					SCREAMING_SNAKE_CASE    			=       SCREAMING_SNAKE_CASE    			=       SCREAMING_SNAKE_CASE    			=       numbers[0]

					for i in range(1      , len(UpperCAmelCase__  )  ):
										# update the maximum and minimum subarray products
										SCREAMING_SNAKE_CASE    			=       numbers[i]
										if number < 0:
															SCREAMING_SNAKE_CASE			,   SCREAMING_SNAKE_CASE    			=       min_till_now, max_till_now
										SCREAMING_SNAKE_CASE    			=       max(UpperCAmelCase__      , max_till_now * number  )
										SCREAMING_SNAKE_CASE    			=       min(UpperCAmelCase__      , min_till_now * number  )

										# update the maximum product found till now
										SCREAMING_SNAKE_CASE    			=       max(UpperCAmelCase__      , UpperCAmelCase__  )

					return max_prod




