


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.
A_		:     List[str]        =     {'''LayoutLMv2Config''', '''LayoutLMv3Config'''}



@is_pipeline_test
class 		_lowercase		(       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 		A							(      self			:       str							,   __lowerCAmelCase			:       Dict							,   __lowerCAmelCase			:       int							,   __lowerCAmelCase			:       Tuple							)       ->				Any:


    """simple docstring"""






    a						=		ZeroShotClassificationPipeline(
        model=__lowerCAmelCase							,   tokenizer=__lowerCAmelCase							,   candidate_labels=["polics", "health"]							)
    return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]

   def 		A							(      self			:       List[Any]							,   __lowerCAmelCase			:       Any							,   __lowerCAmelCase			:       Any							)       ->				Tuple:


    """simple docstring"""






    a						=		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
    a						=		classifier("Who are you voting for in 2020?"							,   ["politics"]							)
    self.assertEqual(__lowerCAmelCase							,   {"sequence": ANY(__lowerCAmelCase							), "labels": [ANY(__lowerCAmelCase							)], "scores": [ANY(__lowerCAmelCase							)]}							)

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

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

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

    a						=		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
    a						=		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							)
        ]							,   )
    a						=		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 		A							(      self			:       List[str]							,   __lowerCAmelCase			:       Pipeline							)       ->				Dict:


    """simple docstring"""






    a						=		zero_shot_classifier.model.config
    a						=		config.labelaid
    a						=		zero_shot_classifier.entailment_id

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

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

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

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

    a						=		original_labelaid
    self.assertEqual(__lowerCAmelCase							,   zero_shot_classifier.entailment_id							)

   @require_torch
   def 		A							(      self			:       Tuple							)       ->				Optional[Any]:


    """simple docstring"""






    a						=		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[int]							)       ->				Union[str, Any]:


    """simple docstring"""






    a						=		pipeline(
        "zero-shot-classification"							,   model="sshleifer/tiny-distilbert-base-cased-distilled-squad"							,   framework="pt"							,   )
    a						=		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.3_3_3, 0.3_3_3, 0.3_3_3],
        }							,   )

   @require_tf
   def 		A							(      self			:       int							)       ->				Union[str, Any]:


    """simple docstring"""






    a						=		pipeline(
        "zero-shot-classification"							,   model="sshleifer/tiny-distilbert-base-cased-distilled-squad"							,   framework="tf"							,   )
    a						=		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.3_3_3, 0.3_3_3, 0.3_3_3],
        }							,   )

   @slow
   @require_torch
   def 		A							(      self			:       Optional[Any]							)       ->				Any:


    """simple docstring"""






    a						=		pipeline("zero-shot-classification"							,   model="roberta-large-mnli"							,   framework="pt"							)
    a						=		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.9_7_6, 0.0_1_5, 0.0_0_9],
        }							,   )
    a						=		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.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
        }							,   )




   @slow
   @require_tf
   def 		A							(      self			:       Optional[Any]							)       ->				Optional[Any]:


    """simple docstring"""






    a						=		pipeline("zero-shot-classification"							,   model="roberta-large-mnli"							,   framework="tf"							)
    a						=		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.9_7_6, 0.0_1_5, 0.0_0_9],
        }							,   )
    a						=		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.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
        }							,   )






from __future__ import annotations


def 	UpperCAmelCase__      (      UpperCAmelCase__ :int					):






 '''simple docstring'''

 a						=		str(UpperCAmelCase__					)
 return len(UpperCAmelCase__					) == 9 and set(UpperCAmelCase__					) == set("123456789"					)


def 	UpperCAmelCase__      (      ):






 '''simple docstring'''

 for base_num in range(99_99 ,					49_99 ,					-1					):
  a						=		10_00_02 * base_num
  if is_9_pandigital(UpperCAmelCase__					):
   return candidate

 for base_num in range(3_33 ,					99 ,					-1					):
  a						=		1_00_20_03 * base_num
  if is_9_pandigital(UpperCAmelCase__					):
   return candidate

 return None


if __name__ == "__main__":
     print(F"""{solution() = }""")

