from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import (
         TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
         TFXLMForMultipleChoice,
         TFXLMForQuestionAnsweringSimple,
         TFXLMForSequenceClassification,
         TFXLMForTokenClassification,
         TFXLMModel,
         TFXLMWithLMHeadModel,
         XLMConfig,
     )







class 			SCREAMING_SNAKE_CASE__ :

       def __init__(				self :			Dict       ,       _lowerCAmelCase :			str       ,       ):
           __snake_case    :							List[str]             =  parent
           __snake_case    :							List[Any]             =  13
           __snake_case    :							List[Any]             =  7
           __snake_case    :							List[Any]             =  True
           __snake_case    :							Union[str, Any]             =  True
           __snake_case    :							Any             =  True
           __snake_case    :							int             =  True
           __snake_case    :							Tuple             =  True
           __snake_case    :							List[str]             =  False
           __snake_case    :							Tuple             =  False
           __snake_case    :							str             =  False
           __snake_case    :							Union[str, Any]             =  2
           __snake_case    :							List[str]             =  99
           __snake_case    :							Optional[Any]             =  0
           __snake_case    :							str             =  32
           __snake_case    :							Optional[Any]             =  2
           __snake_case    :							Union[str, Any]             =  4
           __snake_case    :							Tuple             =  0.1
           __snake_case    :							Optional[int]             =  0.1
           __snake_case    :							Dict             =  5_12
           __snake_case    :							Optional[int]             =  16
           __snake_case    :							Tuple             =  2
           __snake_case    :							Optional[int]             =  0.02
           __snake_case    :							Any             =  3
           __snake_case    :							Dict             =  4
           __snake_case    :							Tuple             =  'last'
           __snake_case    :							Dict             =  True
           __snake_case    :							Optional[int]             =  None
           __snake_case    :							Dict             =  0

       def        snake_case__  (				self :			Optional[Any]       ):
           __snake_case    :							Optional[Any]             =  ids_tensor([self.batch_size, self.seq_length]       ,       self.vocab_size       )
           __snake_case    :							Union[str, Any]             =  random_attention_mask([self.batch_size, self.seq_length]       ,       dtype=tf.floataa       )

           __snake_case    :							str             =  None
           if self.use_input_lengths:
               __snake_case    :							Optional[int]             =  (
                   ids_tensor([self.batch_size]       ,       vocab_size=2       ) + self.seq_length - 2
               )  # small variation of seq_length

           __snake_case    :							str             =  None
           if self.use_token_type_ids:
               __snake_case    :							str             =  ids_tensor([self.batch_size, self.seq_length]       ,       self.n_langs       )

           __snake_case    :							Union[str, Any]             =  None
           __snake_case    :							Tuple             =  None
           __snake_case    :							str             =  None
           if self.use_labels:
               __snake_case    :							List[Any]             =  ids_tensor([self.batch_size]       ,       self.type_sequence_label_size       )
               __snake_case    :							Optional[int]             =  ids_tensor([self.batch_size, self.seq_length]       ,       self.num_labels       )
               __snake_case    :							Any             =  ids_tensor([self.batch_size]       ,       2       ,       dtype=tf.floataa       )
               __snake_case    :							List[Any]             =  ids_tensor([self.batch_size]       ,       self.num_choices       )

           __snake_case    :							Union[str, Any]             =  XLMConfig(
               vocab_size=self.vocab_size       ,       n_special=self.n_special       ,       emb_dim=self.hidden_size       ,       n_layers=self.num_hidden_layers       ,       n_heads=self.num_attention_heads       ,       dropout=self.hidden_dropout_prob       ,       attention_dropout=self.attention_probs_dropout_prob       ,       gelu_activation=self.gelu_activation       ,       sinusoidal_embeddings=self.sinusoidal_embeddings       ,       asm=self.asm       ,       causal=self.causal       ,       n_langs=self.n_langs       ,       max_position_embeddings=self.max_position_embeddings       ,       initializer_range=self.initializer_range       ,       summary_type=self.summary_type       ,       use_proj=self.use_proj       ,       bos_token_id=self.bos_token_id       ,       )

           return (
               config,
               input_ids,
               token_type_ids,
               input_lengths,
               sequence_labels,
               token_labels,
               is_impossible_labels,
               choice_labels,
               input_mask,
           )

       def        snake_case__  (				self :			int       ,       _lowerCAmelCase :			Union[str, Any]       ,       _lowerCAmelCase :			Optional[int]       ,       _lowerCAmelCase :			List[str]       ,       _lowerCAmelCase :			Dict       ,       _lowerCAmelCase :			Optional[Any]       ,       _lowerCAmelCase :			Any       ,       _lowerCAmelCase :			int       ,       _lowerCAmelCase :			str       ,       _lowerCAmelCase :			Union[str, Any]       ,       ):
           __snake_case    :							int             =  TFXLMModel(config=_lowerCAmelCase       )
           __snake_case    :							Union[str, Any]             =  {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
           __snake_case    :							str             =  model(_lowerCAmelCase       )

           __snake_case    :							List[str]             =  [input_ids, input_mask]
           __snake_case    :							List[str]             =  model(_lowerCAmelCase       )
           self.parent.assertEqual(result.last_hidden_state.shape       ,       (self.batch_size, self.seq_length, self.hidden_size)       )

       def        snake_case__  (				self :			List[str]       ,       _lowerCAmelCase :			Union[str, Any]       ,       _lowerCAmelCase :			Dict       ,       _lowerCAmelCase :			Union[str, Any]       ,       _lowerCAmelCase :			Optional[Any]       ,       _lowerCAmelCase :			Union[str, Any]       ,       _lowerCAmelCase :			Optional[int]       ,       _lowerCAmelCase :			Any       ,       _lowerCAmelCase :			Union[str, Any]       ,       _lowerCAmelCase :			Any       ,       ):
           __snake_case    :							Optional[Any]             =  TFXLMWithLMHeadModel(_lowerCAmelCase       )

           __snake_case    :							int             =  {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
           __snake_case    :							Dict             =  model(_lowerCAmelCase       )

           __snake_case    :							Union[str, Any]             =  outputs

           self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, self.seq_length, self.vocab_size)       )

       def        snake_case__  (				self :			Dict       ,       _lowerCAmelCase :			List[str]       ,       _lowerCAmelCase :			Any       ,       _lowerCAmelCase :			Optional[int]       ,       _lowerCAmelCase :			str       ,       _lowerCAmelCase :			str       ,       _lowerCAmelCase :			str       ,       _lowerCAmelCase :			Dict       ,       _lowerCAmelCase :			str       ,       _lowerCAmelCase :			Union[str, Any]       ,       ):
           __snake_case    :							Any             =  TFXLMForQuestionAnsweringSimple(_lowerCAmelCase       )

           __snake_case    :							Union[str, Any]             =  {'input_ids': input_ids, 'lengths': input_lengths}

           __snake_case    :							Optional[Any]             =  model(_lowerCAmelCase       )

           self.parent.assertEqual(result.start_logits.shape       ,       (self.batch_size, self.seq_length)       )
           self.parent.assertEqual(result.end_logits.shape       ,       (self.batch_size, self.seq_length)       )

       def        snake_case__  (				self :			str       ,       _lowerCAmelCase :			str       ,       _lowerCAmelCase :			Union[str, Any]       ,       _lowerCAmelCase :			Dict       ,       _lowerCAmelCase :			str       ,       _lowerCAmelCase :			List[str]       ,       _lowerCAmelCase :			Tuple       ,       _lowerCAmelCase :			List[str]       ,       _lowerCAmelCase :			List[str]       ,       _lowerCAmelCase :			Optional[Any]       ,       ):
           __snake_case    :							str             =  TFXLMForSequenceClassification(_lowerCAmelCase       )

           __snake_case    :							List[str]             =  {'input_ids': input_ids, 'lengths': input_lengths}

           __snake_case    :							List[str]             =  model(_lowerCAmelCase       )

           self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, self.type_sequence_label_size)       )

       def        snake_case__  (				self :			str       ,       _lowerCAmelCase :			Tuple       ,       _lowerCAmelCase :			Union[str, Any]       ,       _lowerCAmelCase :			Dict       ,       _lowerCAmelCase :			str       ,       _lowerCAmelCase :			str       ,       _lowerCAmelCase :			Tuple       ,       _lowerCAmelCase :			Union[str, Any]       ,       _lowerCAmelCase :			List[Any]       ,       _lowerCAmelCase :			Union[str, Any]       ,       ):
           __snake_case    :							str             =  self.num_labels
           __snake_case    :							Dict             =  TFXLMForTokenClassification(config=_lowerCAmelCase       )
           __snake_case    :							str             =  {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
           __snake_case    :							Optional[int]             =  model(_lowerCAmelCase       )
           self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, self.seq_length, self.num_labels)       )

       def        snake_case__  (				self :			Optional[int]       ,       _lowerCAmelCase :			int       ,       _lowerCAmelCase :			Optional[Any]       ,       _lowerCAmelCase :			str       ,       _lowerCAmelCase :			Tuple       ,       _lowerCAmelCase :			Optional[int]       ,       _lowerCAmelCase :			Dict       ,       _lowerCAmelCase :			str       ,       _lowerCAmelCase :			Union[str, Any]       ,       _lowerCAmelCase :			Dict       ,       ):
           __snake_case    :							Union[str, Any]             =  self.num_choices
           __snake_case    :							Union[str, Any]             =  TFXLMForMultipleChoice(config=_lowerCAmelCase       )
           __snake_case    :							Union[str, Any]             =  tf.tile(tf.expand_dims(_lowerCAmelCase       ,       1       )       ,       (1, self.num_choices, 1)       )
           __snake_case    :							List[Any]             =  tf.tile(tf.expand_dims(_lowerCAmelCase       ,       1       )       ,       (1, self.num_choices, 1)       )
           __snake_case    :							str             =  tf.tile(tf.expand_dims(_lowerCAmelCase       ,       1       )       ,       (1, self.num_choices, 1)       )
           __snake_case    :							Optional[int]             =  {
               'input_ids': multiple_choice_inputs_ids,
               'attention_mask': multiple_choice_input_mask,
               'token_type_ids': multiple_choice_token_type_ids,
           }
           __snake_case    :							Optional[Any]             =  model(_lowerCAmelCase       )
           self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, self.num_choices)       )





       def        snake_case__  (				self :			int       ):
           __snake_case    :							List[Any]             =  self.prepare_config_and_inputs()
           (
               __snake_case     
           )    :							Optional[Any]             =  config_and_inputs
           __snake_case    :							int             =  {
               'input_ids': input_ids,
               'token_type_ids': token_type_ids,
               'langs': token_type_ids,
               'lengths': input_lengths,
           }
           return config, inputs_dict







@require_tf
class 			SCREAMING_SNAKE_CASE__ (   __UpperCamelCase					,				__UpperCamelCase					,				unittest.TestCase  ):
       A				:     Optional[int]					    =     (
           (
               TFXLMModel,
               TFXLMWithLMHeadModel,
               TFXLMForSequenceClassification,
               TFXLMForQuestionAnsweringSimple,
               TFXLMForTokenClassification,
               TFXLMForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       A				:     Tuple					    =     (
           (TFXLMWithLMHeadModel,) if is_tf_available() else ()
       )  # TODO (PVP): Check other models whether language generation is also applicable
       A				:     Tuple					    =     (
           {
               "feature-extraction": TFXLMModel,
               "fill-mask": TFXLMWithLMHeadModel,
               "question-answering": TFXLMForQuestionAnsweringSimple,
               "text-classification": TFXLMForSequenceClassification,
               "text-generation": TFXLMWithLMHeadModel,
               "token-classification": TFXLMForTokenClassification,
               "zero-shot": TFXLMForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       A				:     Tuple					    =     False
       A				:     Optional[int]					    =     False

       def        snake_case__  (				self :			Dict       ,       _lowerCAmelCase :			Dict       ,       _lowerCAmelCase :			Optional[int]       ,       _lowerCAmelCase :			List[Any]       ,       _lowerCAmelCase :			int       ,       _lowerCAmelCase :			Union[str, Any]       ):
           if (
               pipeline_test_casse_name == "QAPipelineTests"
               and tokenizer_name is not None
               and not tokenizer_name.endswith("""Fast"""       )
           ):
               # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
               # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
               # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
               return True

           return False

       def        snake_case__  (				self :			List[Any]       ):
           __snake_case    :							int             =  TFXLMModelTester(self       )
           __snake_case    :							Dict             =  ConfigTester(self       ,       config_class=_lowerCAmelCase       ,       emb_dim=37       )

       def        snake_case__  (				self :			Dict       ):
           self.config_tester.run_common_tests()

       def        snake_case__  (				self :			List[Any]       ):
           __snake_case    :							List[Any]             =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_model(*_lowerCAmelCase       )

       def        snake_case__  (				self :			str       ):
           __snake_case    :							str             =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_lm_head(*_lowerCAmelCase       )

       def        snake_case__  (				self :			int       ):
           __snake_case    :							Tuple             =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_qa(*_lowerCAmelCase       )

       def        snake_case__  (				self :			List[Any]       ):
           __snake_case    :							str             =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_sequence_classif(*_lowerCAmelCase       )

       def        snake_case__  (				self :			Any       ):
           __snake_case    :							Dict             =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_for_token_classification(*_lowerCAmelCase       )

       def        snake_case__  (				self :			List[Any]       ):
           __snake_case    :							Any             =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_for_multiple_choice(*_lowerCAmelCase       )





       @slow
       def        snake_case__  (				self :			Optional[Any]       ):
           for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __snake_case    :							str             =  TFXLMModel.from_pretrained(_lowerCAmelCase       )
               self.assertIsNotNone(_lowerCAmelCase       )







@require_tf
class 			SCREAMING_SNAKE_CASE__ (   unittest.TestCase  ):

       @slow
       def        snake_case__  (				self :			List[Any]       ):
           __snake_case    :							Union[str, Any]             =  TFXLMWithLMHeadModel.from_pretrained("""xlm-mlm-en-2048"""       )
           __snake_case    :							Dict             =  tf.convert_to_tensor([[14, 4_47]]       ,       dtype=tf.intaa       )  # the president
           __snake_case    :							Optional[int]             =  [
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
               14,
               4_47,
           ]  # the president the president the president the president the president the president the president the president the president the president
           # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
           __snake_case    :							Union[str, Any]             =  model.generate(_lowerCAmelCase       ,       do_sample=_lowerCAmelCase       )
           self.assertListEqual(output_ids[0].numpy().tolist()       ,       _lowerCAmelCase       )







import doctest

import projectq
from projectq.ops import H, Measure
def       UpperCamelCase__     (  SCREAMING_SNAKE_CASE__						):
 __lowerCamelCase		:							int							=						quantum_engine.allocate_qubit()
 H | qubit
 Measure | qubit
 return int(SCREAMING_SNAKE_CASE__						)


if __name__ == "__main__":
       doctest.testmod()

       # initialises a new quantum backend
       lowercase_           =	projectq.MainEngine()

       # Generate a list of 10 random numbers
       lowercase_           =	[get_random_number(quantum_engine) for _ in range(1_0)]

       # Flushes the quantum engine from memory
       quantum_engine.flush()

       print('Random numbers', random_numbers_list)

