

'''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   :			Optional[int]         = {"LayoutLMv2Config", "LayoutLMv3Config"}







@is_pipeline_test
class   UpperCamelCase__    (   unittest.TestCase   ):


		"""simple docstring"""

		SCREAMING_SNAKE_CASE__  :	Optional[Any]   =							MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
		SCREAMING_SNAKE_CASE__  :	str   =							TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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







		def       A_       ( self    ,			snake_case    ,			snake_case    ,			snake_case			):


							'''simple docstring'''

							UpperCAmelCase		:							List[str]   					=   ZeroShotClassificationPipeline(
							    model=lowercase_    ,			tokenizer=lowercase_    ,			candidate_labels=["polics", "health"]			)
							return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]







		def       A_       ( self    ,			snake_case    ,			snake_case			):


							'''simple docstring'''

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

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

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

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

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

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

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

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

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

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

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

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

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

							self.run_entailment_id(lowercase_			)







		def       A_       ( self    ,			snake_case			):


							'''simple docstring'''

							UpperCAmelCase		:							Tuple   					=   zero_shot_classifier.model.config
							UpperCAmelCase		:							Optional[Any]   					=   config.labelaid
							UpperCAmelCase		:							Optional[Any]   					=   zero_shot_classifier.entailment_id

							UpperCAmelCase		:							Union[str, Any]   					=   {"LABEL_0": 0, "LABEL_1": 1, "LABEL_2": 2}
							self.assertEqual(zero_shot_classifier.entailment_id    ,			-1			)

							UpperCAmelCase		:							Union[str, Any]   					=   {"entailment": 0, "neutral": 1, "contradiction": 2}
							self.assertEqual(zero_shot_classifier.entailment_id    ,			0			)

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

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

							UpperCAmelCase		:							Optional[int]   					=   original_labelaid
							self.assertEqual(lowercase_    ,			zero_shot_classifier.entailment_id			)







		@require_torch
		def       A_       ( self			):


							'''simple docstring'''

							UpperCAmelCase		:							Any   					=   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       A_       ( self			):


							'''simple docstring'''

							UpperCAmelCase		:							List[Any]   					=   pipeline(
							    "zero-shot-classification"    ,			model="sshleifer/tiny-distilbert-base-cased-distilled-squad"    ,			framework="pt"    ,			)
							UpperCAmelCase		:							Union[str, Any]   					=   zero_shot_classifier(
							    "Who are you voting for in 2020?"    ,			candidate_labels=["politics", "public health", "science"]			)

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







		@require_tf
		def       A_       ( self			):


							'''simple docstring'''

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

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







		@slow
		@require_torch
		def       A_       ( self			):


							'''simple docstring'''

							UpperCAmelCase		:							List[str]   					=   pipeline("zero-shot-classification"    ,			model="roberta-large-mnli"    ,			framework="pt"			)
							UpperCAmelCase		:							str   					=   zero_shot_classifier(
							    "Who are you voting for in 2020?"    ,			candidate_labels=["politics", "public health", "science"]			)

							self.assertEqual(
							    nested_simplify(lowercase_			)    ,			{
							        "sequence": "Who are you voting for in 2020?",
							        "labels": ["politics", "public health", "science"],
							        "scores": [0.976, 0.015, 0.009],
							    }    ,			)
							UpperCAmelCase		:							Tuple   					=   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=lowercase_    ,			)
							self.assertEqual(
							    nested_simplify(lowercase_			)    ,			{
							        "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       A_       ( self			):


							'''simple docstring'''

							UpperCAmelCase		:							Any   					=   pipeline("zero-shot-classification"    ,			model="roberta-large-mnli"    ,			framework="tf"			)
							UpperCAmelCase		:							Union[str, Any]   					=   zero_shot_classifier(
							    "Who are you voting for in 2020?"    ,			candidate_labels=["politics", "public health", "science"]			)

							self.assertEqual(
							    nested_simplify(lowercase_			)    ,			{
							        "sequence": "Who are you voting for in 2020?",
							        "labels": ["politics", "public health", "science"],
							        "scores": [0.976, 0.015, 0.009],
							    }    ,			)
							UpperCAmelCase		:							Dict   					=   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=lowercase_    ,			)
							self.assertEqual(
							    nested_simplify(lowercase_			)    ,			{
							        "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],
							    }    ,			)



import argparse
import hashlib  # hashlib is only used inside the Test class
import struct







class 						__magic_name__			:

   '''simple docstring'''




   def __init__(				self,    lowercase_       )							->    List[str]:






     """simple docstring"""






     a__  =data
     a__  =[0X67452301, 0Xefcdab89, 0X98badcfe, 0X10325476, 0Xc3d2e1f0]



   @staticmethod
   def  _UpperCAmelCase (				lowercase_,    lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     return ((n << b) | (n >> (32 - b))) & 0Xffffffff



   def  _UpperCAmelCase (				self       )							->    Optional[int]:






     """simple docstring"""






     a__  =b'''\x80''' + b'''\x00''' * (63 - (len(self.data       ) + 8) % 64)
     a__  =self.data + padding + struct.pack('''>Q''',    8 * len(self.data       )       )
     return padded_data



   def  _UpperCAmelCase (				self       )							->    Any:






     """simple docstring"""






     return [
         self.padded_data[i : i + 64] for i in range(0,    len(self.padded_data       ),    64       )
     ]



   def  _UpperCAmelCase (				self,    lowercase_       )							->    List[Any]:






     """simple docstring"""






     a__  =list(struct.unpack('''>16L''',    lowercase_       )       ) + [0] * 64
     for i in range(16,    80       ):
       a__  =self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]),    1       )
     return w



   def  _UpperCAmelCase (				self       )							->    Any:






     """simple docstring"""






     a__  =self.padding()
     a__  =self.split_blocks()
     for block in self.blocks:
       a__  =self.expand_block(lowercase_       )
       a__,      a__,      a__,      a__,      a__  =self.h
       for i in range(0,    80       ):
         if 0 <= i < 20:
           a__  =(b & c) | ((~b) & d)
           a__  =0X5a827999
         elif 20 <= i < 40:
           a__  =b ^ c ^ d
           a__  =0X6ed9eba1
         elif 40 <= i < 60:
           a__  =(b & c) | (b & d) | (c & d)
           a__  =0X8f1bbcdc
         elif 60 <= i < 80:
           a__  =b ^ c ^ d
           a__  =0Xca62c1d6
         a__,      a__,      a__,      a__,      a__  =(
             self.rotate(lowercase_,    5       ) + f + e + k + expanded_block[i] & 0Xffffffff,
             a,
             self.rotate(lowercase_,    30       ),
             c,
             d,
         )
       a__  =(
           self.h[0] + a & 0Xffffffff,
           self.h[1] + b & 0Xffffffff,
           self.h[2] + c & 0Xffffffff,
           self.h[3] + d & 0Xffffffff,
           self.h[4] + e & 0Xffffffff,
       )
     return ("{:08x}" * 5).format(*self.h       )





def 			UpperCAmelCase__				(			):





  '''simple docstring'''







  a__  =b'''Test String'''
  assert SHAaHash(_A							).final_hash() == hashlib.shaa(_A							).hexdigest()  # noqa: S324




def 			UpperCAmelCase__				(			):





  '''simple docstring'''







  a__  =argparse.ArgumentParser(description='''Process some strings or files'''							)
  parser.add_argument(
      '''--string'''	,      dest='''input_string'''	,      default='''Hello World!! Welcome to Cryptography'''	,      help='''Hash the string'''	,      )
  parser.add_argument('''--file'''	,      dest='''input_file'''	,      help='''Hash contents of a file'''							)
  a__  =parser.parse_args()
  a__  =args.input_string
  # In any case hash input should be a bytestring
  if args.input_file:
    with open(args.input_file	,      '''rb'''							) as f:
      a__  =f.read()
  else:
    a__  =bytes(_A	,      '''utf-8'''							)
  print(SHAaHash(_A							).final_hash()							)


if __name__ == "__main__":
       main()
       import doctest

       doctest.testmod()
