



from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, 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 numpy as np
			import tensorflow as tf

			from transformers import (
			    TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
			    FlaubertConfig,
			    TFFlaubertForMultipleChoice,
			    TFFlaubertForQuestionAnsweringSimple,
			    TFFlaubertForSequenceClassification,
			    TFFlaubertForTokenClassification,
			    TFFlaubertModel,
			    TFFlaubertWithLMHeadModel,
			)

class    UpperCAmelCase_  :

						'''simple docstring'''




						def __init__(    self      ,							_A      ,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					parent
													__SCREAMING_SNAKE_CASE									=					13
													__SCREAMING_SNAKE_CASE									=					7
													__SCREAMING_SNAKE_CASE									=					True
													__SCREAMING_SNAKE_CASE									=					True
													__SCREAMING_SNAKE_CASE									=					True
													__SCREAMING_SNAKE_CASE									=					True
													__SCREAMING_SNAKE_CASE									=					True
													__SCREAMING_SNAKE_CASE									=					False
													__SCREAMING_SNAKE_CASE									=					False
													__SCREAMING_SNAKE_CASE									=					False
													__SCREAMING_SNAKE_CASE									=					2
													__SCREAMING_SNAKE_CASE									=					99
													__SCREAMING_SNAKE_CASE									=					0
													__SCREAMING_SNAKE_CASE									=					32
													__SCREAMING_SNAKE_CASE									=					2
													__SCREAMING_SNAKE_CASE									=					4
													__SCREAMING_SNAKE_CASE									=					0.1
													__SCREAMING_SNAKE_CASE									=					0.1
													__SCREAMING_SNAKE_CASE									=					512
													__SCREAMING_SNAKE_CASE									=					16
													__SCREAMING_SNAKE_CASE									=					2
													__SCREAMING_SNAKE_CASE									=					0.0_2
													__SCREAMING_SNAKE_CASE									=					3
													__SCREAMING_SNAKE_CASE									=					4
													__SCREAMING_SNAKE_CASE									=					"""last"""
													__SCREAMING_SNAKE_CASE									=					True
													__SCREAMING_SNAKE_CASE									=					None
													__SCREAMING_SNAKE_CASE									=					0






						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					ids_tensor([self.batch_size, self.seq_length]      ,							self.vocab_size		)
													__SCREAMING_SNAKE_CASE									=					random_attention_mask([self.batch_size, self.seq_length]      ,							dtype=tf.floataa		)

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

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

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

													__SCREAMING_SNAKE_CASE									=					FlaubertConfig(
													    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        _A	(    self      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					TFFlaubertModel(config=__a		)
													__SCREAMING_SNAKE_CASE									=					{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
													__SCREAMING_SNAKE_CASE									=					model(__a		)

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






						def        _A	(    self      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					TFFlaubertWithLMHeadModel(__a		)

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

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






						def        _A	(    self      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					TFFlaubertForQuestionAnsweringSimple(__a		)

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

													__SCREAMING_SNAKE_CASE									=					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        _A	(    self      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					TFFlaubertForSequenceClassification(__a		)

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

													__SCREAMING_SNAKE_CASE									=					model(__a		)

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






						def        _A	(    self      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.num_labels
													__SCREAMING_SNAKE_CASE									=					TFFlaubertForTokenClassification(config=__a		)
													__SCREAMING_SNAKE_CASE									=					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
													__SCREAMING_SNAKE_CASE									=					model(__a		)
													self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.seq_length, self.num_labels)		)






						def        _A	(    self      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.num_choices
													__SCREAMING_SNAKE_CASE									=					TFFlaubertForMultipleChoice(config=__a		)
													__SCREAMING_SNAKE_CASE									=					tf.tile(tf.expand_dims(__a      ,							1		)      ,							(1, self.num_choices, 1)		)
													__SCREAMING_SNAKE_CASE									=					tf.tile(tf.expand_dims(__a      ,							1		)      ,							(1, self.num_choices, 1)		)
													__SCREAMING_SNAKE_CASE									=					tf.tile(tf.expand_dims(__a      ,							1		)      ,							(1, self.num_choices, 1)		)
													__SCREAMING_SNAKE_CASE									=					{
													    """input_ids""": multiple_choice_inputs_ids,
													    """attention_mask""": multiple_choice_input_mask,
													    """token_type_ids""": multiple_choice_token_type_ids,
													}
													__SCREAMING_SNAKE_CASE									=					model(__a		)
													self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.num_choices)		)






						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.prepare_config_and_inputs()
													(
													    __SCREAMING_SNAKE_CASE	
													)									=					config_and_inputs
													__SCREAMING_SNAKE_CASE									=					{
													    """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_  (   __a    ,    __a    ,    unittest.TestCase       ):

						'''simple docstring'''




						UpperCamelCase__			: str				  =  (
						    (
						        TFFlaubertModel,
						        TFFlaubertWithLMHeadModel,
						        TFFlaubertForSequenceClassification,
						        TFFlaubertForQuestionAnsweringSimple,
						        TFFlaubertForTokenClassification,
						        TFFlaubertForMultipleChoice,
						    )
						    if is_tf_available()
						    else ()
						)
						UpperCamelCase__			: List[Any]				  =  (
						    (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
						)  # TODO (PVP): Check other models whether language generation is also applicable
						UpperCamelCase__			: List[str]				  =  (
						    {
						        '''feature-extraction''': TFFlaubertModel,
						        '''fill-mask''': TFFlaubertWithLMHeadModel,
						        '''question-answering''': TFFlaubertForQuestionAnsweringSimple,
						        '''text-classification''': TFFlaubertForSequenceClassification,
						        '''token-classification''': TFFlaubertForTokenClassification,
						        '''zero-shot''': TFFlaubertForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						UpperCamelCase__			: Union[str, Any]				  =  False
						UpperCamelCase__			: int				  =  False






						def        _A	(    self      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A		):







													'''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        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					TFFlaubertModelTester(self		)
													__SCREAMING_SNAKE_CASE									=					ConfigTester(self      ,							config_class=__a      ,							emb_dim=37		)






						def        _A	(    self		):







													'''simple docstring'''

													self.config_tester.run_common_tests()






						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_flaubert_model(*__a		)






						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_flaubert_lm_head(*__a		)






						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_flaubert_qa(*__a		)






						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_flaubert_sequence_classif(*__a		)






						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_flaubert_for_token_classification(*__a		)






						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_flaubert_for_multiple_choice(*__a		)






						@slow
						def        _A	(    self		):







													'''simple docstring'''

													for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				__SCREAMING_SNAKE_CASE									=					TFFlaubertModel.from_pretrained(__a		)
																				self.assertIsNotNone(__a		)







@require_tf
@require_sentencepiece
@require_tokenizers
class    UpperCAmelCase_  (   unittest.TestCase       ):

						'''simple docstring'''




						@slow
						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					TFFlaubertModel.from_pretrained('jplu/tf-flaubert-small-cased'		)

													__SCREAMING_SNAKE_CASE									=					tf.convert_to_tensor(
													    [[0, 158, 735, 2_592, 1_424, 6_727, 82, 1]]      ,							dtype=tf.intaa      ,							)  # "J'aime flaubert !"

													__SCREAMING_SNAKE_CASE									=					model(__a		)[0]
													__SCREAMING_SNAKE_CASE									=					tf.TensorShape((1, 8, 512)		)
													self.assertEqual(output.shape      ,							__a		)
													# compare the actual values for a slice.
													__SCREAMING_SNAKE_CASE									=					tf.convert_to_tensor(
													    [
													        [
													            [-1.8_7_6_8_7_7_3, -1.5_6_6_5_5_5, 0.2_7_0_7_2_4_1_8],
													            [-1.6_9_2_0_0_3_8, -0.5_8_7_3_5_0_5, 1.9_3_2_9_5_9_9],
													            [-2.9_5_6_3_9_8_5, -1.6_9_9_3_8_3_5, 1.7_9_7_2_0_5_2],
													        ]
													    ]      ,							dtype=tf.floataa      ,							)

													self.assertTrue(np.allclose(output[:, :3, :3].numpy()      ,							expected_slice.numpy()      ,							atol=1e-4		)		)














def 					snake_case_						(   lowerCAmelCase_				:  list					):

							if len(lowerCAmelCase_					) <= 1:
														return [tuple(lowerCAmelCase_					)]

							__lowercase					:							Any			=   []

							def generate(lowerCAmelCase_				:  int				,				lowerCAmelCase_				:  list					):
														if k == 1:
																					res.append(tuple(arr[:]					)					)
																					return

														generate(k - 1				,				lowerCAmelCase_					)

														for i in range(k - 1					):
																					if k % 2 == 0:  # k is even
																												__lowercase	,	__lowercase					:							List[str]			=   arr[k - 1], arr[i]
																					else:  # k is odd
																												__lowercase	,	__lowercase					:							Any			=   arr[k - 1], arr[0]
																					generate(k - 1				,				lowerCAmelCase_					)

							generate(len(lowerCAmelCase_					)				,				lowerCAmelCase_					)
							return res


if __name__ == "__main__":
	lowerCamelCase       :       Union[str, Any]        =				input('''Enter numbers separated by a comma:\n''').strip()
	lowerCamelCase       :       Optional[Any]        =				[int(item) for item in user_input.split(''',''')]
	print(heaps(arr))