
"""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.
UpperCamelCase			:       int									=				{"LayoutLMv2Config", "LayoutLMv3Config"}

@is_pipeline_test
class __lowerCAmelCase	(   unittest.TestCase    ):
     lowercase		     =		MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
     lowercase		     =		TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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





     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

      '''simple docstring'''




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





     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

      '''simple docstring'''




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

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

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

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

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

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

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

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

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

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

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

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

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

      self.run_entailment_id(__snake_case   )





     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase   ):

      '''simple docstring'''




      __UpperCamelCase       						= zero_shot_classifier.model.config
      __UpperCamelCase       						= config.labelaid
      __UpperCamelCase       						= zero_shot_classifier.entailment_id

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

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

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

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

      __UpperCamelCase       						= original_labelaid
      self.assertEqual(__snake_case			,  zero_shot_classifier.entailment_id   )





     @require_torch
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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

      '''simple docstring'''




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

      self.assertEqual(
          nested_simplify(__snake_case   )			,  {
              '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 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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

      self.assertEqual(
          nested_simplify(__snake_case   )			,  {
              '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 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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

      self.assertEqual(
          nested_simplify(__snake_case   )			,  {
              '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],
          }			,  )
      __UpperCamelCase       						= 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=__snake_case			,  )
      self.assertEqual(
          nested_simplify(__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_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
          }			,  )







     @slow
     @require_tf
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= pipeline('zero-shot-classification'			,  model='roberta-large-mnli'			,  framework='tf'   )
      __UpperCamelCase       						= zero_shot_classifier(
          'Who are you voting for in 2020?'			,  candidate_labels=['politics', 'public health', 'science']   )

      self.assertEqual(
          nested_simplify(__snake_case   )			,  {
              '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],
          }			,  )
      __UpperCamelCase       						= 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=__snake_case			,  )
      self.assertEqual(
          nested_simplify(__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_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
          }			,  )





"""simple docstring"""

import numpy as np
import qiskit






def 							A		(       snake_case   :int = 8       ,      snake_case   :int | None = None	)   ->			str:
 __UpperCamelCase       						= np.random.default_rng(seed=snake_case	)

 # Roughly 25% of the qubits will contribute to the key.
 # So we take more than we need.
 __UpperCamelCase       						= 6 * key_len
 # Measurement basis for Alice's qubits.
 __UpperCamelCase       						= rng.integers(2       ,      size=snake_case	)
 # The set of states Alice will prepare.
 __UpperCamelCase       						= rng.integers(2       ,      size=snake_case	)
 # Measurement basis for Bob's qubits.
 __UpperCamelCase       						= rng.integers(2       ,      size=snake_case	)

 # Quantum Circuit to simulate BB84
 __UpperCamelCase       						= qiskit.QuantumCircuit(snake_case       ,      name='BB84'	)

 # Alice prepares her qubits according to rules above.
 for index, _ in enumerate(snake_case	):
  if alice_state[index] == 1:
   bbaa_circ.x(snake_case	)
  if alice_basis[index] == 1:
   bbaa_circ.h(snake_case	)
 bbaa_circ.barrier()

 # Bob measures the received qubits according to rules above.
 for index, _ in enumerate(snake_case	):
  if bob_basis[index] == 1:
   bbaa_circ.h(snake_case	)

 bbaa_circ.barrier()
 bbaa_circ.measure_all()

 # Simulate the quantum circuit.
 __UpperCamelCase       						= qiskit.Aer.get_backend('aer_simulator'	)
 # We only need to run one shot because the key is unique.
 # Multiple shots will produce the same key.
 __UpperCamelCase       						= qiskit.execute(snake_case       ,      snake_case       ,      shots=1       ,      seed_simulator=snake_case	)
 # Returns the result of measurement.
 __UpperCamelCase       						= job.result().get_counts(snake_case	).most_frequent()

 # Extracting the generated key from the simulation results.
 # Only keep measurement results where Alice and Bob chose the same basis.
 __UpperCamelCase       						= ''.join(
     [
         result_bit
         for alice_basis_bit, bob_basis_bit, result_bit in zip(
             snake_case       ,      snake_case       ,      snake_case	)
         if alice_basis_bit == bob_basis_bit
     ]	)

 # Get final key. Pad with 0 if too short, otherwise truncate.
 __UpperCamelCase       						= gen_key[:key_len] if len(snake_case	) >= key_len else gen_key.ljust(snake_case       ,      '0'	)
 return key


if __name__ == "__main__":
      print(f'''The generated key is : {bbaa(8, seed=0)}''')
      from doctest import testmod

      testmod()



