




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





@is_pipeline_test
class     lowercase_	(					unittest.TestCase							):



 '''simple docstring'''
 UpperCAmelCase   :					Tuple				  =     MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
 UpperCAmelCase   :					Optional[int]				  =     TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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

 def       lowerCAmelCase_							(			self	:	List[Any]   ,							_UpperCAmelCase	:	int   ,							_UpperCAmelCase	:	Dict   ,							_UpperCAmelCase	:	str		):
       _A        =       ZeroShotClassificationPipeline(
           model=_UpperCAmelCase   ,							tokenizer=_UpperCAmelCase   ,							candidate_labels=['polics', 'health']		)
       return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]

 def       lowerCAmelCase_							(			self	:	Dict   ,							_UpperCAmelCase	:	Any   ,							_UpperCAmelCase	:	Optional[int]		):
       _A        =       classifier('Who are you voting for in 2020?'   ,							candidate_labels='politics'		)
       self.assertEqual(_UpperCAmelCase   ,							{'sequence': ANY(_UpperCAmelCase		), 'labels': [ANY(_UpperCAmelCase		)], 'scores': [ANY(_UpperCAmelCase		)]}		)

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

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

       _A        =       classifier('Who are you voting for in 2020?'   ,							candidate_labels='politics, public health'		)
       self.assertEqual(
           _UpperCAmelCase   ,							{'sequence': ANY(_UpperCAmelCase		), 'labels': [ANY(_UpperCAmelCase		), ANY(_UpperCAmelCase		)], 'scores': [ANY(_UpperCAmelCase		), ANY(_UpperCAmelCase		)]}		)
       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(
           _UpperCAmelCase   ,							{'sequence': ANY(_UpperCAmelCase		), 'labels': [ANY(_UpperCAmelCase		), ANY(_UpperCAmelCase		)], 'scores': [ANY(_UpperCAmelCase		), ANY(_UpperCAmelCase		)]}		)
       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(_UpperCAmelCase   ,							{'sequence': ANY(_UpperCAmelCase		), 'labels': [ANY(_UpperCAmelCase		)], 'scores': [ANY(_UpperCAmelCase		)]}		)

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

       with self.assertRaises(_UpperCAmelCase		):
             classifier(''   ,							candidate_labels='politics'		)

       with self.assertRaises(_UpperCAmelCase		):
             classifier(_UpperCAmelCase   ,							candidate_labels='politics'		)

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

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

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

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

       self.run_entailment_id(_UpperCAmelCase		)

 def       lowerCAmelCase_							(			self	:	Optional[Any]   ,							_UpperCAmelCase	:	Pipeline		):
       _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(_UpperCAmelCase   ,							zero_shot_classifier.entailment_id		)

 @require_torch
 def       lowerCAmelCase_							(			self	:	Optional[Any]		):
       _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       lowerCAmelCase_							(			self	:	Any		):
       _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(_UpperCAmelCase		)   ,							{
               'sequence': 'Who are you voting for in 2020?',
               'labels': ['science', 'public health', 'politics'],
               'scores': [0.333, 0.333, 0.333],
           }   ,							)

 @require_tf
 def       lowerCAmelCase_							(			self	:	Dict		):
       _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(_UpperCAmelCase		)   ,							{
               'sequence': 'Who are you voting for in 2020?',
               'labels': ['science', 'public health', 'politics'],
               'scores': [0.333, 0.333, 0.333],
           }   ,							)

 @slow
 @require_torch
 def       lowerCAmelCase_							(			self	:	List[str]		):
       _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(_UpperCAmelCase		)   ,							{
               'sequence': 'Who are you voting for in 2020?',
               'labels': ['politics', 'public health', 'science'],
               'scores': [0.976, 0.015, 0.009],
           }   ,							)
       _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=_UpperCAmelCase   ,							)
       self.assertEqual(
           nested_simplify(_UpperCAmelCase		)   ,							{
               '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       lowerCAmelCase_							(			self	:	List[Any]		):
       _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(_UpperCAmelCase		)   ,							{
               'sequence': 'Who are you voting for in 2020?',
               'labels': ['politics', 'public health', 'science'],
               'scores': [0.976, 0.015, 0.009],
           }   ,							)
       _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=_UpperCAmelCase   ,							)
       self.assertEqual(
           nested_simplify(_UpperCAmelCase		)   ,							{
               '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"""

import enum
import os
from hashlib import shaaaa
from typing import Optional

from .. import config
from .logging import get_logger


a         =      get_logger(__name__)





class     lowercase_	(					enum.Enum							):



 '''simple docstring'''
 UpperCAmelCase   :					Optional[int]				  =     '''all_checks'''
 UpperCAmelCase   :					List[Any]				  =     '''basic_checks'''
 UpperCAmelCase   :					Any				  =     '''no_checks'''





class     lowercase_	(					__lowerCAmelCase							):



 '''simple docstring'''





class     lowercase_	(					__lowerCAmelCase							):



 '''simple docstring'''





class     lowercase_	(					__lowerCAmelCase							):



 '''simple docstring'''





class     lowercase_	(					__lowerCAmelCase							):



 '''simple docstring'''






def 						_snake_case					( _snake_case							: Optional[dict]    ,  _snake_case							: dict    ,  _snake_case							: Dict=None							)   -> Dict:






      '''simple docstring'''


      if expected_checksums is None:
            logger.info('Unable to verify checksums.'							)
            return
      if len(set(_snake_case							) - set(_snake_case							)							) > 0:
            raise ExpectedMoreDownloadedFiles(str(set(_snake_case							) - set(_snake_case							)							)							)
      if len(set(_snake_case							) - set(_snake_case							)							) > 0:
            raise UnexpectedDownloadedFile(str(set(_snake_case							) - set(_snake_case							)							)							)
      _A        =       [url for url in expected_checksums if expected_checksums[url] != recorded_checksums[url]]
      _A        =       ' for ' + verification_name if verification_name is not None else ''
      if len(_snake_case							) > 0:
            raise NonMatchingChecksumError(
                F'''Checksums didn\'t match{for_verification_name}:\n'''
                F'''{bad_urls}\n'''
                'Set `verification_mode=\'no_checks\'` to skip checksums verification and ignore this error'							)
      logger.info('All the checksums matched successfully' + for_verification_name							)





class     lowercase_	(					__lowerCAmelCase							):



 '''simple docstring'''





class     lowercase_	(					__lowerCAmelCase							):



 '''simple docstring'''





class     lowercase_	(					__lowerCAmelCase							):



 '''simple docstring'''





class     lowercase_	(					__lowerCAmelCase							):



 '''simple docstring'''






def 						_snake_case					( _snake_case							: Optional[dict]    ,  _snake_case							: dict							)   -> List[str]:






      '''simple docstring'''


      if expected_splits is None:
            logger.info('Unable to verify splits sizes.'							)
            return
      if len(set(_snake_case							) - set(_snake_case							)							) > 0:
            raise ExpectedMoreSplits(str(set(_snake_case							) - set(_snake_case							)							)							)
      if len(set(_snake_case							) - set(_snake_case							)							) > 0:
            raise UnexpectedSplits(str(set(_snake_case							) - set(_snake_case							)							)							)
      _A        =       [
          {'expected': expected_splits[name], 'recorded': recorded_splits[name]}
          for name in expected_splits
          if expected_splits[name].num_examples != recorded_splits[name].num_examples
      ]
      if len(_snake_case							) > 0:
            raise NonMatchingSplitsSizesError(str(_snake_case							)							)
      logger.info('All the splits matched successfully.'							)






def 						_snake_case					( _snake_case							: str    ,  _snake_case							: bool = True							)   -> dict:






      '''simple docstring'''


      if record_checksum:
            _A        =       shaaaa()
            with open(_snake_case    ,  'rb'							) as f:
                  for chunk in iter(lambda: f.read(1 << 20							)    ,  B''							):
                        m.update(_snake_case							)
                  _A        =       m.hexdigest()
      else:
            _A        =       None
      return {"num_bytes": os.path.getsize(_snake_case							), "checksum": checksum}







def 						_snake_case					( _snake_case							: int							)   -> int:






      '''simple docstring'''


      if dataset_size and config.IN_MEMORY_MAX_SIZE:
            return dataset_size < config.IN_MEMORY_MAX_SIZE
      else:
            return False

