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



		def __init__(					self							, A_							, )    ->   Union[str, Any]:
				"""simple docstring"""
				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            =	512
				UpperCamelCase            =	16
				UpperCamelCase            =	2
				UpperCamelCase            =	0.02
				UpperCamelCase            =	3
				UpperCamelCase            =	4
				UpperCamelCase            =	'last'
				UpperCamelCase            =	True
				UpperCamelCase            =	None
				UpperCamelCase            =	0



		def __UpperCamelCase					(					self			)    ->   List[str]:
				"""simple docstring"""
				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 __UpperCamelCase					(					self							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, )    ->   Any:
				"""simple docstring"""
				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 __UpperCamelCase					(					self							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, )    ->   List[Any]:
				"""simple docstring"""
				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 __UpperCamelCase					(					self							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, )    ->   List[Any]:
				"""simple docstring"""
				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 __UpperCamelCase					(					self							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, )    ->   str:
				"""simple docstring"""
				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 __UpperCamelCase					(					self							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, )    ->   Dict:
				"""simple docstring"""
				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 __UpperCamelCase					(					self							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, )    ->   List[Any]:
				"""simple docstring"""
				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 __UpperCamelCase					(					self			)    ->   str:
				"""simple docstring"""
				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 							lowercase   (						_SCREAMING_SNAKE_CASE    ,  _SCREAMING_SNAKE_CASE    ,  unittest.TestCase  ):
		__lowercase			:			Any      	=							(
		    (
		        TFXLMModel,
		        TFXLMWithLMHeadModel,
		        TFXLMForSequenceClassification,
		        TFXLMForQuestionAnsweringSimple,
		        TFXLMForTokenClassification,
		        TFXLMForMultipleChoice,
		    )
		    if is_tf_available()
		    else ()
		)
		__lowercase			:			Optional[Any]      	=							(
		    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
		)  # TODO (PVP): Check other models whether language generation is also applicable
		__lowercase			:			int      	=							(
		    {
		        "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 {}
		)
		__lowercase			:			List[str]      	=							False
		__lowercase			:			Optional[int]      	=							False



		def __UpperCamelCase					(					self							, A_							, A_							, A_							, A_							, A_			)    ->   List[Any]:
				"""simple docstring"""
				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 __UpperCamelCase					(					self			)    ->   List[str]:
				"""simple docstring"""
				UpperCamelCase            =	TFXLMModelTester(self			)
				UpperCamelCase            =	ConfigTester(self							, config_class=A_							, emb_dim=37			)



		def __UpperCamelCase					(					self			)    ->   List[Any]:
				"""simple docstring"""
				self.config_tester.run_common_tests()



		def __UpperCamelCase					(					self			)    ->   str:
				"""simple docstring"""
				UpperCamelCase            =	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_xlm_model(*A_			)



		def __UpperCamelCase					(					self			)    ->   Tuple:
				"""simple docstring"""
				UpperCamelCase            =	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_xlm_lm_head(*A_			)



		def __UpperCamelCase					(					self			)    ->   Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase            =	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_xlm_qa(*A_			)



		def __UpperCamelCase					(					self			)    ->   Dict:
				"""simple docstring"""
				UpperCamelCase            =	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_xlm_sequence_classif(*A_			)



		def __UpperCamelCase					(					self			)    ->   Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase            =	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_xlm_for_token_classification(*A_			)



		def __UpperCamelCase					(					self			)    ->   List[str]:
				"""simple docstring"""
				UpperCamelCase            =	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_xlm_for_multiple_choice(*A_			)



		@slow
		def __UpperCamelCase					(					self			)    ->   List[Any]:
				"""simple docstring"""
				for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						UpperCamelCase            =	TFXLMModel.from_pretrained(A_			)
						self.assertIsNotNone(A_			)






@require_tf
class 							lowercase   (						unittest.TestCase  ):



		@slow
		def __UpperCamelCase					(					self			)    ->   List[str]:
				"""simple docstring"""
				UpperCamelCase            =	TFXLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'			)
				UpperCamelCase            =	tf.convert_to_tensor([[14, 447]]							, dtype=tf.intaa			)  # the president
				UpperCamelCase            =	[
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				]  # 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_			)


from __future__ import annotations


def  A			(   lowercase       ,			lowercase					)  ->    int:
		'''simple docstring'''

		UpperCamelCase      ,    UpperCamelCase            =	0, len(lowercase					) - 1
		while start_ind <= end_ind:
				if array[start_ind] == search_item:
						return start_ind
				elif array[end_ind] == search_item:
						return end_ind
				else:
						start_ind += 1
						end_ind -= 1
    # returns -1 if search_item is not found in array
		return -1


if __name__ == "__main__":
					print(double_linear_search(list(range(100)), 40))
