





"""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.
lowerCAmelCase__     			=			{'''LayoutLMv2Config''', '''LayoutLMv3Config'''}





@is_pipeline_test
class        _lowerCamelCase      (       unittest.TestCase ):
						UpperCAmelCase_ =			MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
						UpperCAmelCase_ =			TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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


						def     snake_case_   (self   ,							__a   ,							__a   ,							__a		) ->   int:
								UpperCamelCase   =	ZeroShotClassificationPipeline(
								    model=__a   ,							tokenizer=__a   ,							candidate_labels=["polics", "health"]		)
								return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]


						def     snake_case_   (self   ,							__a   ,							__a		) ->   Union[str, Any]:
								UpperCamelCase   =	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
								UpperCamelCase   =	classifier("Who are you voting for in 2020?"   ,							["politics"]		)
								self.assertEqual(__a   ,							{"sequence": ANY(__a		), "labels": [ANY(__a		)], "scores": [ANY(__a		)]}		)

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

								UpperCamelCase   =	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		)

								UpperCamelCase   =	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		)

								UpperCamelCase   =	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
								UpperCamelCase   =	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		)
								    ]   ,							)
								UpperCamelCase   =	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     snake_case_   (self   ,							__a		) ->   Optional[Any]:
								UpperCamelCase   =	zero_shot_classifier.model.config
								UpperCamelCase   =	config.labelaid
								UpperCamelCase   =	zero_shot_classifier.entailment_id

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

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

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

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

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


						@require_torch
						def     snake_case_   (self		) ->   List[str]:
								UpperCamelCase   =	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     snake_case_   (self		) ->   List[str]:
								UpperCamelCase   =	pipeline(
								    "zero-shot-classification"   ,							model="sshleifer/tiny-distilbert-base-cased-distilled-squad"   ,							framework="pt"   ,							)
								UpperCamelCase   =	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.333, 0.333, 0.333],
								    }   ,							)


						@require_tf
						def     snake_case_   (self		) ->   List[Any]:
								UpperCamelCase   =	pipeline(
								    "zero-shot-classification"   ,							model="sshleifer/tiny-distilbert-base-cased-distilled-squad"   ,							framework="tf"   ,							)
								UpperCamelCase   =	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.333, 0.333, 0.333],
								    }   ,							)


						@slow
						@require_torch
						def     snake_case_   (self		) ->   Dict:
								UpperCamelCase   =	pipeline("zero-shot-classification"   ,							model="roberta-large-mnli"   ,							framework="pt"		)
								UpperCamelCase   =	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.976, 0.015, 0.009],
								    }   ,							)
								UpperCamelCase   =	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.817, 0.713, 0.018, 0.018],
								    }   ,							)




						@slow
						@require_tf
						def     snake_case_   (self		) ->   List[str]:
								UpperCamelCase   =	pipeline("zero-shot-classification"   ,							model="roberta-large-mnli"   ,							framework="tf"		)
								UpperCamelCase   =	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.976, 0.015, 0.009],
								    }   ,							)
								UpperCamelCase   =	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.817, 0.713, 0.018, 0.018],
								    }   ,							)













"""simple docstring"""





from typing import List

from .keymap import KEYMAP, get_character


def       a__					(					_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		def decorator(_SCREAMING_SNAKE_CASE    ):
				UpperCamelCase   =	getattr(_SCREAMING_SNAKE_CASE  ,	"handle_key"  ,	[]    )
				handle += [key]
				setattr(_SCREAMING_SNAKE_CASE  ,	"handle_key"  ,	_SCREAMING_SNAKE_CASE    )
				return func

		return decorator


def       a__					(					*_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		def decorator(_SCREAMING_SNAKE_CASE    ):
				UpperCamelCase   =	getattr(_SCREAMING_SNAKE_CASE  ,	"handle_key"  ,	[]    )
				handle += keys
				setattr(_SCREAMING_SNAKE_CASE  ,	"handle_key"  ,	_SCREAMING_SNAKE_CASE    )
				return func

		return decorator





class        _lowerCamelCase      (       _lowercase ):


						def __new__(cls   ,							__a   ,							__a   ,							__a		) ->   Any:
								UpperCamelCase   =	super().__new__(cls   ,							__a   ,							__a   ,							__a		)
								if not hasattr(__a   ,							"key_handler"		):
										setattr(__a   ,							"key_handler"   ,							{}		)
								setattr(__a   ,							"handle_input"   ,							KeyHandler.handle_input		)

								for value in attrs.values():
										UpperCamelCase   =	getattr(__a   ,							"handle_key"   ,							[]		)
										for key in handled_keys:
												UpperCamelCase   =	value
								return new_cls




						@staticmethod
						def     snake_case_   (cls		) ->   Optional[Any]:
								UpperCamelCase   =	get_character()
								if char != KEYMAP["undefined"]:
										UpperCamelCase   =	ord(__a		)
								UpperCamelCase   =	cls.key_handler.get(__a		)
								if handler:
										UpperCamelCase   =	char
										return handler(cls		)
								else:
										return None



def       a__					(					cls    ):




		"""simple docstring"""


		return KeyHandler(cls.__name__  ,	cls.__bases__  ,	cls.__dict__.copy()    )






