

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.
lowercase_								=     {"""LayoutLMv2Config""", """LayoutLMv3Config"""}
@is_pipeline_test
class 				_snake_case			(					unittest.TestCase):
				UpperCamelCase__				:					Dict     		=MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
				UpperCamelCase__				:					int     		=TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

				if model_mapping is not None:
								UpperCamelCase__				:					Optional[int]     		={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[Any]     		={
								    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
								}




				def 							A__      (						self					:						Dict,					__lowercase					:						Optional[int],					__lowercase					:						Optional[Any],					__lowercase					:						Dict						):
							lowercase__					  =				ZeroShotClassificationPipeline(
							    model=__snake_case,					tokenizer=__snake_case,					candidate_labels=["polics", "health"]						)
							return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]




				def 							A__      (						self					:						int,					__lowercase					:						str,					__lowercase					:						List[Any]						):
							lowercase__					  =				classifier("Who are you voting for in 2020?",					candidate_labels="politics"						)
							self.assertEqual(__snake_case,					{"sequence": ANY(__snake_case						), "labels": [ANY(__snake_case						)], "scores": [ANY(__snake_case						)]}						)

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

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

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

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

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

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

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

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

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

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

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

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

							self.run_entailment_id(__snake_case						)




				def 							A__      (						self					:						Dict,					__lowercase					:						Pipeline						):
							lowercase__					  =				zero_shot_classifier.model.config
							lowercase__					  =				config.labelaid
							lowercase__					  =				zero_shot_classifier.entailment_id

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

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

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

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

							lowercase__					  =				original_labelaid
							self.assertEqual(__snake_case,					zero_shot_classifier.entailment_id						)




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

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




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

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




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

							self.assertEqual(
							    nested_simplify(__snake_case						),					{
							        "sequence": "Who are you voting for in 2020?",
							        "labels": ["politics", "public health", "science"],
							        "scores": [0.976, 0.015, 0.009],
							    },					)
							lowercase__					  =				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=__snake_case,					)
							self.assertEqual(
							    nested_simplify(__snake_case						),					{
							        "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 							A__      (						self					:						Tuple						):
							lowercase__					  =				pipeline("zero-shot-classification",					model="roberta-large-mnli",					framework="tf"						)
							lowercase__					  =				zero_shot_classifier(
							    "Who are you voting for in 2020?",					candidate_labels=["politics", "public health", "science"]						)

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









from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase_								=     {
    """configuration_timesformer""": ["""TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """TimesformerConfig"""],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase_								=     [
							    """TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """TimesformerModel""",
							    """TimesformerForVideoClassification""",
							    """TimesformerPreTrainedModel""",
							]

if TYPE_CHECKING:
							from .configuration_timesformer import TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimesformerConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_timesformer import (
														    TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TimesformerForVideoClassification,
														    TimesformerModel,
														    TimesformerPreTrainedModel,
														)

else:
							import sys

							lowercase_								=     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




