

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



@is_pipeline_test
class   __lowercase    (			unittest.TestCase     ):




			"""simple docstring"""







			_UpperCAmelCase       :							Union[str, Any]      							=					MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
			_UpperCAmelCase       :							Any      							=					TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

			if model_mapping is not None:
						_UpperCAmelCase       :							Tuple      							=					{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
			if tf_model_mapping is not None:
						_UpperCAmelCase       :							Optional[int]      							=					{
						    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
						}



			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[str]       ,						lowerCAmelCase__  :					int       ,						lowerCAmelCase__  :					List[str]       ,						lowerCAmelCase__  :					Union[str, Any]):
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	ZeroShotClassificationPipeline(
									    model=__lowerCamelCase       ,						tokenizer=__lowerCamelCase       ,						candidate_labels=["polics", "health"])
									return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Tuple       ,						lowerCAmelCase__  :					Tuple       ,						lowerCAmelCase__  :					Any):
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	classifier("Who are you voting for in 2020?"       ,						candidate_labels="politics")
									self.assertEqual(__lowerCamelCase       ,						{"sequence": ANY(__lowerCamelCase), "labels": [ANY(__lowerCamelCase)], "scores": [ANY(__lowerCamelCase)]})

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

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

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

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

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

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

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

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

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

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

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

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

									self.run_entailment_id(__lowerCamelCase)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					str       ,						lowerCAmelCase__  :					int):
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	zero_shot_classifier.model.config
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	config.labelaid
									SCREAMING_SNAKE_CASE_:			List[str]  		=	zero_shot_classifier.entailment_id

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

									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	{"entailment": 0, "neutral": 1, "contradiction": 2}
									self.assertEqual(zero_shot_classifier.entailment_id       ,						0)

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

									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	{"ENTAIL": 2, "NEUTRAL": 1, "CONTR": 0}
									self.assertEqual(zero_shot_classifier.entailment_id       ,						2)

									SCREAMING_SNAKE_CASE_:			str  		=	original_labelaid
									self.assertEqual(__lowerCamelCase       ,						zero_shot_classifier.entailment_id)



			@require_torch
			def 	_SCREAMING_SNAKE_CASE      (			self  :					Tuple):
									SCREAMING_SNAKE_CASE_:			Tuple  		=	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 	_SCREAMING_SNAKE_CASE      (			self  :					str):
									SCREAMING_SNAKE_CASE_:			Any  		=	pipeline(
									    "zero-shot-classification"       ,						model="sshleifer/tiny-distilbert-base-cased-distilled-squad"       ,						framework="pt"       ,						)
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	zero_shot_classifier(
									    "Who are you voting for in 2020?"       ,						candidate_labels=["politics", "public health", "science"])

									self.assertEqual(
									    nested_simplify(__lowerCamelCase)       ,						{
									        "sequence": "Who are you voting for in 2020?",
									        "labels": ["science", "public health", "politics"],
									        "scores": [0.333, 0.333, 0.333],
									    }       ,						)



			@require_tf
			def 	_SCREAMING_SNAKE_CASE      (			self  :					Any):
									SCREAMING_SNAKE_CASE_:			Any  		=	pipeline(
									    "zero-shot-classification"       ,						model="sshleifer/tiny-distilbert-base-cased-distilled-squad"       ,						framework="tf"       ,						)
									SCREAMING_SNAKE_CASE_:			Tuple  		=	zero_shot_classifier(
									    "Who are you voting for in 2020?"       ,						candidate_labels=["politics", "public health", "science"])

									self.assertEqual(
									    nested_simplify(__lowerCamelCase)       ,						{
									        "sequence": "Who are you voting for in 2020?",
									        "labels": ["science", "public health", "politics"],
									        "scores": [0.333, 0.333, 0.333],
									    }       ,						)



			@slow
			@require_torch
			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[Any]):
									SCREAMING_SNAKE_CASE_:			Tuple  		=	pipeline("zero-shot-classification"       ,						model="roberta-large-mnli"       ,						framework="pt")
									SCREAMING_SNAKE_CASE_:			Dict  		=	zero_shot_classifier(
									    "Who are you voting for in 2020?"       ,						candidate_labels=["politics", "public health", "science"])

									self.assertEqual(
									    nested_simplify(__lowerCamelCase)       ,						{
									        "sequence": "Who are you voting for in 2020?",
									        "labels": ["politics", "public health", "science"],
									        "scores": [0.976, 0.015, 0.009],
									    }       ,						)
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	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=__lowerCamelCase       ,						)
									self.assertEqual(
									    nested_simplify(__lowerCamelCase)       ,						{
									        "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.817, 0.713, 0.018, 0.018],
									    }       ,						)




			@slow
			@require_tf
			def 	_SCREAMING_SNAKE_CASE      (			self  :					Optional[int]):
									SCREAMING_SNAKE_CASE_:			List[str]  		=	pipeline("zero-shot-classification"       ,						model="roberta-large-mnli"       ,						framework="tf")
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	zero_shot_classifier(
									    "Who are you voting for in 2020?"       ,						candidate_labels=["politics", "public health", "science"])

									self.assertEqual(
									    nested_simplify(__lowerCamelCase)       ,						{
									        "sequence": "Who are you voting for in 2020?",
									        "labels": ["politics", "public health", "science"],
									        "scores": [0.976, 0.015, 0.009],
									    }       ,						)
									SCREAMING_SNAKE_CASE_:			str  		=	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=__lowerCamelCase       ,						)
									self.assertEqual(
									    nested_simplify(__lowerCamelCase)       ,						{
									        "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.817, 0.713, 0.018, 0.018],
									    }       ,						)









def       A_				(   _UpperCAmelCase    ,     _UpperCAmelCase   ):

						if density <= 0:
												raise ValueError("Impossible fluid density"   )
						if bulk_modulus <= 0:
												raise ValueError("Impossible bulk modulus"   )

						return (bulk_modulus / density) ** 0.5


if __name__ == "__main__":
						import doctest

						doctest.testmod()






