

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


@is_pipeline_test
class 		_A       (			unittest.TestCase					):
      __a								=	MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
      __a								=	TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					List[Any]:
         lowerCamelCase__						=			ZeroShotClassificationPipeline(
             model=SCREAMING_SNAKE_CASE__    ,						tokenizer=SCREAMING_SNAKE_CASE__    ,						candidate_labels=["polics", "health"]		)
         return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					List[Any]:
         lowerCamelCase__						=			classifier("Who are you voting for in 2020?"    ,						candidate_labels="politics"		)
         self.assertEqual(SCREAMING_SNAKE_CASE__    ,						{"sequence": ANY(SCREAMING_SNAKE_CASE__		), "labels": [ANY(SCREAMING_SNAKE_CASE__		)], "scores": [ANY(SCREAMING_SNAKE_CASE__		)]}		)

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

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

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

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

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

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

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

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

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

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

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

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

         self.run_entailment_id(SCREAMING_SNAKE_CASE__		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__		)   ->					List[str]:
         lowerCamelCase__						=			zero_shot_classifier.model.config
         lowerCamelCase__						=			config.labelaid
         lowerCamelCase__						=			zero_shot_classifier.entailment_id

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

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

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

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

         lowerCamelCase__						=			original_labelaid
         self.assertEqual(SCREAMING_SNAKE_CASE__    ,						zero_shot_classifier.entailment_id		)





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

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





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

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





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

         self.assertEqual(
             nested_simplify(SCREAMING_SNAKE_CASE__		)    ,						{
                 "sequence": "Who are you voting for in 2020?",
                 "labels": ["politics", "public health", "science"],
                 "scores": [0.9_76, 0.0_15, 0.0_09],
             }    ,						)
         lowerCamelCase__						=			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=SCREAMING_SNAKE_CASE__    ,						)
         self.assertEqual(
             nested_simplify(SCREAMING_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.8_17, 0.7_13, 0.0_18, 0.0_18],
             }    ,						)





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

         self.assertEqual(
             nested_simplify(SCREAMING_SNAKE_CASE__		)    ,						{
                 "sequence": "Who are you voting for in 2020?",
                 "labels": ["politics", "public health", "science"],
                 "scores": [0.9_76, 0.0_15, 0.0_09],
             }    ,						)
         lowerCamelCase__						=			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=SCREAMING_SNAKE_CASE__    ,						)
         self.assertEqual(
             nested_simplify(SCREAMING_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.8_17, 0.7_13, 0.0_18, 0.0_18],
             }    ,						)







"""simple docstring"""




# Algorithm for the pigeonhole sorting





def 	UpperCAmelCase__   (				A__   )      ->      Dict:




   """simple docstring"""
   lowerCamelCase__						=			min(A__   )  # min() finds the minimum value
   lowerCamelCase__						=			max(A__   )  # max() finds the maximum value

   lowerCamelCase__						=			max_val - min_val + 1  # size is difference of max and min values plus one

   # list of pigeonholes of size equal to the variable size
   lowerCamelCase__						=			[0] * size

   # Populate the pigeonholes.
   for x in a:
      assert isinstance(A__	,    A__   ), "integers only please"
      holes[x - min_val] += 1

   # Putting the elements back into the array in an order.
   lowerCamelCase__						=			0
   for count in range(A__   ):
      while holes[count] > 0:
         holes[count] -= 1
         lowerCamelCase__						=			count + min_val
         i += 1



def 	UpperCAmelCase__   (				)      ->      Optional[int]:




   """simple docstring"""
   lowerCamelCase__						=			[8, 3, 2, 7, 4, 6, 8]
   pigeonhole_sort(A__   )
   print("Sorted order is:"	,    " ".join(A__   )   )


if __name__ == "__main__":
     main()




