





"""simple docstring"""





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 							_lowerCamelCase   :


						def __init__(self ,				__a ,				)			-> List[Any]:
								UpperCamelCase =						parent
								UpperCamelCase =						13
								UpperCamelCase =						7
								UpperCamelCase =						True
								UpperCamelCase =						True
								UpperCamelCase =						True
								UpperCamelCase =						True
								UpperCamelCase =						True
								UpperCamelCase =						False
								UpperCamelCase =						False
								UpperCamelCase =						False
								UpperCamelCase =						2
								UpperCamelCase =						99
								UpperCamelCase =						0
								UpperCamelCase =						32
								UpperCamelCase =						2
								UpperCamelCase =						4
								UpperCamelCase =						0.1
								UpperCamelCase =						0.1
								UpperCamelCase =						5_12
								UpperCamelCase =						16
								UpperCamelCase =						2
								UpperCamelCase =						0.02
								UpperCamelCase =						3
								UpperCamelCase =						4
								UpperCamelCase =						"last"
								UpperCamelCase =						True
								UpperCamelCase =						None
								UpperCamelCase =						0


						def      snake_case_ (self		)			-> Optional[Any]:
								UpperCamelCase =						ids_tensor([self.batch_size, self.seq_length] ,				self.vocab_size		)
								UpperCamelCase =						random_attention_mask([self.batch_size, self.seq_length] ,				dtype=tf.floataa		)

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

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

								UpperCamelCase =						None
								UpperCamelCase =						None
								UpperCamelCase =						None
								if self.use_labels:
										UpperCamelCase =						ids_tensor([self.batch_size] ,				self.type_sequence_label_size		)
										UpperCamelCase =						ids_tensor([self.batch_size, self.seq_length] ,				self.num_labels		)
										UpperCamelCase =						ids_tensor([self.batch_size] ,				2 ,				dtype=tf.floataa		)
										UpperCamelCase =						ids_tensor([self.batch_size] ,				self.num_choices		)

								UpperCamelCase =						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 ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				)			-> Optional[Any]:
								UpperCamelCase =						TFXLMModel(config=__a		)
								UpperCamelCase =						{"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
								UpperCamelCase =						model(__a		)

								UpperCamelCase =						[input_ids, input_mask]
								UpperCamelCase =						model(__a		)
								self.parent.assertEqual(result.last_hidden_state.shape ,				(self.batch_size, self.seq_length, self.hidden_size)		)


						def      snake_case_ (self ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				)			-> Tuple:
								UpperCamelCase =						TFXLMWithLMHeadModel(__a		)

								UpperCamelCase =						{"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
								UpperCamelCase =						model(__a		)

								UpperCamelCase =						outputs

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


						def      snake_case_ (self ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				)			-> Dict:
								UpperCamelCase =						TFXLMForQuestionAnsweringSimple(__a		)

								UpperCamelCase =						{"input_ids": input_ids, "lengths": input_lengths}

								UpperCamelCase =						model(__a		)

								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 ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				)			-> Union[str, Any]:
								UpperCamelCase =						TFXLMForSequenceClassification(__a		)

								UpperCamelCase =						{"input_ids": input_ids, "lengths": input_lengths}

								UpperCamelCase =						model(__a		)

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


						def      snake_case_ (self ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				)			-> Tuple:
								UpperCamelCase =						self.num_labels
								UpperCamelCase =						TFXLMForTokenClassification(config=__a		)
								UpperCamelCase =						{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
								UpperCamelCase =						model(__a		)
								self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length, self.num_labels)		)


						def      snake_case_ (self ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				__a ,				)			-> Union[str, Any]:
								UpperCamelCase =						self.num_choices
								UpperCamelCase =						TFXLMForMultipleChoice(config=__a		)
								UpperCamelCase =						tf.tile(tf.expand_dims(__a ,				1		) ,				(1, self.num_choices, 1)		)
								UpperCamelCase =						tf.tile(tf.expand_dims(__a ,				1		) ,				(1, self.num_choices, 1)		)
								UpperCamelCase =						tf.tile(tf.expand_dims(__a ,				1		) ,				(1, self.num_choices, 1)		)
								UpperCamelCase =						{
								    "input_ids": multiple_choice_inputs_ids,
								    "attention_mask": multiple_choice_input_mask,
								    "token_type_ids": multiple_choice_token_type_ids,
								}
								UpperCamelCase =						model(__a		)
								self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_choices)		)




						def      snake_case_ (self		)			-> Optional[Any]:
								UpperCamelCase =						self.prepare_config_and_inputs()
								(
								    (
								    UpperCamelCase		
								) ,					(
								    UpperCamelCase		
								) ,					(
								    UpperCamelCase		
								) ,					(
								    UpperCamelCase		
								) ,					(
								    UpperCamelCase		
								) ,					(
								    UpperCamelCase		
								) ,					(
								    UpperCamelCase		
								) ,					(
								    UpperCamelCase		
								) ,					(
								    UpperCamelCase		
								) ,							
								) =						config_and_inputs
								UpperCamelCase =						{
								    "input_ids": input_ids,
								    "token_type_ids": token_type_ids,
								    "langs": token_type_ids,
								    "lengths": input_lengths,
								}
								return config, inputs_dict





@require_tf
class 							_lowerCamelCase   (							_a	,      _a	,      unittest.TestCase			):
						UpperCAmelCase_			=      (
						    (
						        TFXLMModel,
						        TFXLMWithLMHeadModel,
						        TFXLMForSequenceClassification,
						        TFXLMForQuestionAnsweringSimple,
						        TFXLMForTokenClassification,
						        TFXLMForMultipleChoice,
						    )
						    if is_tf_available()
						    else ()
						)
						UpperCAmelCase_			=      (
						    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
						)  # TODO (PVP): Check other models whether language generation is also applicable
						UpperCAmelCase_			=      (
						    {
						        "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 {}
						)
						UpperCAmelCase_			=      False
						UpperCAmelCase_			=      False


						def      snake_case_ (self ,				__a ,				__a ,				__a ,				__a ,				__a		)			-> List[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		)			-> Any:
								UpperCamelCase =						TFXLMModelTester(self		)
								UpperCamelCase =						ConfigTester(self ,				config_class=__a ,				emb_dim=37		)


						def      snake_case_ (self		)			-> List[str]:
								self.config_tester.run_common_tests()


						def      snake_case_ (self		)			-> Any:
								UpperCamelCase =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_model(*__a		)


						def      snake_case_ (self		)			-> Any:
								UpperCamelCase =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_lm_head(*__a		)


						def      snake_case_ (self		)			-> List[Any]:
								UpperCamelCase =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_qa(*__a		)


						def      snake_case_ (self		)			-> Any:
								UpperCamelCase =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_sequence_classif(*__a		)


						def      snake_case_ (self		)			-> Tuple:
								UpperCamelCase =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_for_token_classification(*__a		)


						def      snake_case_ (self		)			-> int:
								UpperCamelCase =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_for_multiple_choice(*__a		)




						@slow
						def      snake_case_ (self		)			-> Optional[int]:
								for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										UpperCamelCase =						TFXLMModel.from_pretrained(__a		)
										self.assertIsNotNone(__a		)





@require_tf
class 							_lowerCamelCase   (							unittest.TestCase			):


						@slow
						def      snake_case_ (self		)			-> int:
								UpperCamelCase =						TFXLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"		)
								UpperCamelCase =						tf.convert_to_tensor([[14, 4_47]] ,				dtype=tf.intaa		)  # the president
								UpperCamelCase =						[
								    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
								UpperCamelCase =						model.generate(__a ,				do_sample=__a		)
								self.assertListEqual(output_ids[0].numpy().tolist() ,				__a		)













class 		_lowerCAmelCase:

  """simple docstring"""







  def __init__(   self      )->   None:
     # numbermap keys are the number and its values are lists of indexes sorted
     # in ascending order
     __A    =  {}
     # indexmap keys are an index and it's values are the number at that index
     __A    =  {}

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase      )->   list[int]:
     if isinstance(UpperCAmelCase    ,							(range, str)      ):
        __A    =  list(UpperCAmelCase      )
     elif not isinstance(UpperCAmelCase    ,							UpperCAmelCase      ):
        raise TypeError(
            '''binary_search_delete() only accepts either a list, range or str'''      )

     __A    =  0
     __A    =  len(UpperCAmelCase      ) - 1

     while low <= high:
        __A    =  (low + high) // 2
        if array[mid] == item:
           array.pop(UpperCAmelCase      )
           return array
        elif array[mid] < item:
           __A    =  mid + 1
        else:
           __A    =  mid - 1
     raise ValueError(
         '''Either the item is not in the array or the array was unsorted'''      )

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase      )->   list[int]:
     if isinstance(UpperCAmelCase    ,							(range, str)      ):
        __A    =  list(UpperCAmelCase      )
     elif not isinstance(UpperCAmelCase    ,							UpperCAmelCase      ):
        raise TypeError(
            '''binary_search_insert() only accepts either a list, range or str'''      )

     __A    =  0
     __A    =  len(UpperCAmelCase      ) - 1

     while low <= high:
        __A    =  (low + high) // 2
        if array[mid] == index:
           # If the item already exists in the array,
           # insert it after the existing item
           array.insert(mid + 1    ,							UpperCAmelCase      )
           return array
        elif array[mid] < index:
           __A    =  mid + 1
        else:
           __A    =  mid - 1

        # If the item doesn't exist in the array, insert it at the appropriate position
     array.insert(UpperCAmelCase    ,							UpperCAmelCase      )
     return array

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase      )->   None:
     # Remove previous index
     if index in self.indexmap:
        __A    =  self.indexmap[index]
        if len(self.numbermap[n]      ) == 1:
           del self.numbermap[n]
        else:
           __A    =  self.binary_search_delete(self.numbermap[n]    ,							UpperCAmelCase      )

        # Set new index
     __A    =  number

     # Number not seen before or empty so insert number value
     if number not in self.numbermap:
        __A    =  [index]

     # Here we need to perform a binary search insertion in order to insert
     # The item in the correct place
     else:
        __A    =  self.binary_search_insert(
            self.numbermap[number]    ,							UpperCAmelCase      )





  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase      )->   int:
     return self.numbermap.get(UpperCAmelCase    ,							[-1]      )[0]


if __name__ == "__main__":
    import doctest

    doctest.testmod()

