





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.
_snake_case  :   Optional[Any]						   =  {'LayoutLMv2Config', 'LayoutLMv3Config'}



@is_pipeline_test
class     _UpperCAmelCase   (   unittest.TestCase   ):

  """simple docstring"""


  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     lowercase		(    self			:		str ,  lowerCAmelCase_			:		int ,  lowerCAmelCase_			:		Tuple ,  lowerCAmelCase_			:		Optional[Any]					)							->						str:
     __lowerCAmelCase							     =     ZeroShotClassificationPipeline(
         model=lowerCAmelCase_ ,  tokenizer=lowerCAmelCase_ ,  candidate_labels=['polics', 'health']					)
     return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]






  def     lowercase		(    self			:		Optional[int] ,  lowerCAmelCase_			:		List[Any] ,  lowerCAmelCase_			:		Tuple					)							->						List[str]:
     __lowerCAmelCase							     =     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
     __lowerCAmelCase							     =     classifier('Who are you voting for in 2020?' ,  ['politics']					)
     self.assertEqual(lowerCAmelCase_ ,  {'sequence': ANY(lowerCAmelCase_					), 'labels': [ANY(lowerCAmelCase_					)], 'scores': [ANY(lowerCAmelCase_					)]}					)

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

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

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

     __lowerCAmelCase							     =     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
     __lowerCAmelCase							     =     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					)
         ] ,  )
     __lowerCAmelCase							     =     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     lowercase		(    self			:		Dict ,  lowerCAmelCase_			:		Pipeline					)							->						List[Any]:
     __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(lowerCAmelCase_ ,  zero_shot_classifier.entailment_id					)






  @require_torch
  def     lowercase		(    self			:		Any					)							->						Tuple:
     __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?' * 1_0_0 ,  candidate_labels=['politics', 'public health', 'science']					)






  @require_torch
  def     lowercase		(    self			:		int					)							->						Tuple:
     __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(lowerCAmelCase_					) ,  {
             '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     lowercase		(    self			:		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(lowerCAmelCase_					) ,  {
             '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     lowercase		(    self			:		Any					)							->						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(lowerCAmelCase_					) ,  {
             '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=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_17, 0.7_13, 0.0_18, 0.0_18],
         } ,  )






  @slow
  @require_tf
  def     lowercase		(    self			:		Any					)							->						Union[str, Any]:
     __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(lowerCAmelCase_					) ,  {
             '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=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_17, 0.7_13, 0.0_18, 0.0_18],
         } ,  )








import builtins
import sys

from ...utils.imports import _is_package_available
from . import cursor, input
from .helpers import Direction, clear_line, forceWrite, linebreak, move_cursor, reset_cursor, writeColor
from .keymap import KEYMAP


_snake_case  :   Union[str, Any]						   =  False
try:
     _snake_case  :   Tuple						   =  _is_package_available('google.colab')
except ModuleNotFoundError:
     pass



@input.register
class     _UpperCAmelCase   :

  """simple docstring"""


  def __init__(    self			:		Union[str, Any] ,  lowerCAmelCase_			:		str = None ,  lowerCAmelCase_			:		list = []					)							->						Optional[int]:
     __lowerCAmelCase							     =     0
     __lowerCAmelCase							     =     choices
     __lowerCAmelCase							     =     prompt
     if sys.platform == "win32":
        __lowerCAmelCase							     =     '*'
     else:
        __lowerCAmelCase							     =     '➔ '






  def     lowercase		(    self			:		Dict ,  lowerCAmelCase_			:		Dict ,  lowerCAmelCase_			:		str = ""					)							->						Any:
     if sys.platform != "win32":
        writeColor(self.choices[index] ,  3_2 ,  lowerCAmelCase_					)
     else:
        forceWrite(self.choices[index] ,  lowerCAmelCase_					)






  def     lowercase		(    self			:		List[Any] ,  lowerCAmelCase_			:		int					)							->						List[Any]:
     if index == self.position:
        forceWrite(f""" {self.arrow_char} """					)
        self.write_choice(lowerCAmelCase_					)
     else:
        forceWrite(f"""    {self.choices[index]}"""					)
     reset_cursor()






  def     lowercase		(    self			:		Dict ,  lowerCAmelCase_			:		Direction ,  lowerCAmelCase_			:		int = 1					)							->						Union[str, Any]:
     __lowerCAmelCase							     =     self.position
     if direction == Direction.DOWN:
        if self.position + 1 >= len(self.choices					):
           return
        self.position += num_spaces
     else:
        if self.position - 1 < 0:
           return
        self.position -= num_spaces
     clear_line()
     self.print_choice(lowerCAmelCase_					)
     move_cursor(lowerCAmelCase_ ,  direction.name					)
     self.print_choice(self.position					)






  @input.mark(KEYMAP['up']					)
  def     lowercase		(    self			:		Optional[int]					)							->						Tuple:
     self.move_direction(Direction.UP					)






  @input.mark(KEYMAP['down']					)
  def     lowercase		(    self			:		str					)							->						Optional[Any]:
     self.move_direction(Direction.DOWN					)






  @input.mark(KEYMAP['newline']					)
  def     lowercase		(    self			:		str					)							->						Any:
     move_cursor(len(self.choices					) - self.position ,  'DOWN'					)
     return self.position






  @input.mark(KEYMAP['interrupt']					)
  def     lowercase		(    self			:		Dict					)							->						Optional[Any]:
     move_cursor(len(self.choices					) - self.position ,  'DOWN'					)
     raise KeyboardInterrupt






  @input.mark_multiple(*[KEYMAP[str(lowerCAmelCase_					)] for number in range(1_0					)]					)
  def     lowercase		(    self			:		List[Any]					)							->						Optional[int]:
     __lowerCAmelCase							     =     int(chr(self.current_selection					)					)
     __lowerCAmelCase							     =     index - self.position
     if index == self.position:
        return
     if index < len(self.choices					):
        if self.position > index:
           self.move_direction(Direction.UP ,  -movement					)
        elif self.position < index:
           self.move_direction(Direction.DOWN ,  lowerCAmelCase_					)
        else:
           return
     else:
        return






  def     lowercase		(    self			:		Any ,  lowerCAmelCase_			:		int = 0					)							->						int:
     if self.prompt:
        linebreak()
        forceWrite(self.prompt ,  '\n'					)
        if in_colab:
           forceWrite('Please input a choice index (starting from 0), and press enter' ,  '\n'					)
        else:
           forceWrite('Please select a choice using the arrow or number keys, and selecting with enter' ,  '\n'					)
     __lowerCAmelCase							     =     default_choice
     for i in range(len(self.choices					)					):
        self.print_choice(lowerCAmelCase_					)
        forceWrite('\n'					)
     move_cursor(len(self.choices					) - self.position ,  'UP'					)
     with cursor.hide():
        while True:
           if in_colab:
              try:
                 __lowerCAmelCase							     =     int(builtins.input()					)
              except ValueError:
                 __lowerCAmelCase							     =     default_choice
           else:
              __lowerCAmelCase							     =     self.handle_input()
           if choice is not None:
              reset_cursor()
              for _ in range(len(self.choices					) + 1					):
                 move_cursor(1 ,  'UP'					)
                 clear_line()
              self.write_choice(lowerCAmelCase_ ,  '\n'					)
              return choice

