



"""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    UpperCamelCase     :




	"""simple docstring"""






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






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      int			=					ids_tensor([self.batch_size, self.seq_length]							,self.vocab_size					)
			_lowercase							:      Tuple			=					random_attention_mask([self.batch_size, self.seq_length]							,dtype=tf.floataa					)

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

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

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

			_lowercase							:      List[str]			=					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 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,):
			_lowercase							:      Optional[Any]			=					TFXLMModel(config=UpperCAmelCase_					)
			_lowercase							:      List[Any]			=					{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
			_lowercase							:      List[str]			=					model(UpperCAmelCase_					)

			_lowercase							:      Any			=					[input_ids, input_mask]
			_lowercase							:      str			=					model(UpperCAmelCase_					)
			self.parent.assertEqual(result.last_hidden_state.shape							,(self.batch_size, self.seq_length, self.hidden_size)					)






	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,):
			_lowercase							:      List[Any]			=					TFXLMWithLMHeadModel(UpperCAmelCase_					)

			_lowercase							:      Union[str, Any]			=					{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
			_lowercase							:      Dict			=					model(UpperCAmelCase_					)

			_lowercase							:      List[Any]			=					outputs

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






	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,):
			_lowercase							:      Union[str, Any]			=					TFXLMForQuestionAnsweringSimple(UpperCAmelCase_					)

			_lowercase							:      Optional[int]			=					{"""input_ids""": input_ids, """lengths""": input_lengths}

			_lowercase							:      List[str]			=					model(UpperCAmelCase_					)

			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 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,):
			_lowercase							:      Any			=					TFXLMForSequenceClassification(UpperCAmelCase_					)

			_lowercase							:      Optional[int]			=					{"""input_ids""": input_ids, """lengths""": input_lengths}

			_lowercase							:      Optional[int]			=					model(UpperCAmelCase_					)

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






	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,):
			_lowercase							:      Dict			=					self.num_labels
			_lowercase							:      int			=					TFXLMForTokenClassification(config=UpperCAmelCase_					)
			_lowercase							:      Optional[Any]			=					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
			_lowercase							:      Any			=					model(UpperCAmelCase_					)
			self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.seq_length, self.num_labels)					)






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






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      Any			=					self.prepare_config_and_inputs()
			(
			    (
			    _lowercase
			)			,   (
			    _lowercase
			)			,   (
			    _lowercase
			)			,   (
			    _lowercase
			)			,   (
			    _lowercase
			)			,   (
			    _lowercase
			)			,   (
			    _lowercase
			)			,   (
			    _lowercase
			)			,   (
			    _lowercase
			)			,   
			)							:      Optional[int]			=					config_and_inputs
			_lowercase							:      Union[str, Any]			=					{
			    """input_ids""": input_ids,
			    """token_type_ids""": token_type_ids,
			    """langs""": token_type_ids,
			    """lengths""": input_lengths,
			}
			return config, inputs_dict







@require_tf
class    UpperCamelCase     (			snake_case ,					snake_case ,					unittest.TestCase    ):




	"""simple docstring"""
	SCREAMING_SNAKE_CASE_				:    Optional[Any]		    =   (
	    (
	        TFXLMModel,
	        TFXLMWithLMHeadModel,
	        TFXLMForSequenceClassification,
	        TFXLMForQuestionAnsweringSimple,
	        TFXLMForTokenClassification,
	        TFXLMForMultipleChoice,
	    )
	    if is_tf_available()
	    else ()
	)
	SCREAMING_SNAKE_CASE_				:    List[str]		    =   (
	    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
	)  # TODO (PVP): Check other models whether language generation is also applicable
	SCREAMING_SNAKE_CASE_				:    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 {}
	)
	SCREAMING_SNAKE_CASE_				:    Tuple		    =   False
	SCREAMING_SNAKE_CASE_				:    str		    =   False






	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_					):
			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 					lowerCamelCase__ (			self					):
			_lowercase							:      Any			=					TFXLMModelTester(self					)
			_lowercase							:      Union[str, Any]			=					ConfigTester(self							,config_class=UpperCAmelCase_							,emb_dim=37					)






	def 					lowerCamelCase__ (			self					):
			self.config_tester.run_common_tests()






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      str			=					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_model(*UpperCAmelCase_					)






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      List[Any]			=					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_lm_head(*UpperCAmelCase_					)






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      Union[str, Any]			=					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_qa(*UpperCAmelCase_					)






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      Union[str, Any]			=					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_sequence_classif(*UpperCAmelCase_					)






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      Tuple			=					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_for_token_classification(*UpperCAmelCase_					)






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      Optional[int]			=					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCAmelCase_					)






	@slow
	def 					lowerCamelCase__ (			self					):
			for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					_lowercase							:      Dict			=					TFXLMModel.from_pretrained(UpperCAmelCase_					)
					self.assertIsNotNone(UpperCAmelCase_					)







@require_tf
class    UpperCamelCase     (			unittest.TestCase    ):




	"""simple docstring"""






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








"""simple docstring"""







from itertools import combinations_with_replacement


def       __SCREAMING_SNAKE_CASE      (   __UpperCAmelCase = 100	):
		_lowercase							:      list[int]			=					[*list(range(1					,							21	)	), 25]
		_lowercase							:      list[int]			=					[2 * x for x in range(1					,							21	)] + [50]
		_lowercase							:      list[int]			=					[3 * x for x in range(1					,							21	)]
		_lowercase							:      list[int]			=					singles + doubles + triples + [0]

		_lowercase							:      int			=					0
		_lowercase							:      int
		_lowercase							:      int
		_lowercase							:      int
		_lowercase							:      int

		for double in doubles:
				for throwa, throwa in combinations_with_replacement(__UpperCAmelCase					,							2	):
						_lowercase							:      Union[str, Any]			=					double + throwa + throwa
						if checkout_total < limit:
								num_checkouts += 1

		return num_checkouts


if __name__ == "__main__":
		print(F'{solution() = }')



