
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							:							List[str]     ,						_A							:							Any     ,						):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	List[Any]					=		parent
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		13
       __SCREAMING_SNAKE_CASE      :	List[str]					=		7
       __SCREAMING_SNAKE_CASE      :	Dict					=		True
       __SCREAMING_SNAKE_CASE      :	List[str]					=		True
       __SCREAMING_SNAKE_CASE      :	str					=		True
       __SCREAMING_SNAKE_CASE      :	str					=		True
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		True
       __SCREAMING_SNAKE_CASE      :	List[str]					=		False
       __SCREAMING_SNAKE_CASE      :	str					=		False
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		False
       __SCREAMING_SNAKE_CASE      :	Dict					=		2
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		99
       __SCREAMING_SNAKE_CASE      :	Tuple					=		0
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		32
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		2
       __SCREAMING_SNAKE_CASE      :	List[str]					=		4
       __SCREAMING_SNAKE_CASE      :	List[str]					=		0.1
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		0.1
       __SCREAMING_SNAKE_CASE      :	str					=		512
       __SCREAMING_SNAKE_CASE      :	Any					=		16
       __SCREAMING_SNAKE_CASE      :	Tuple					=		2
       __SCREAMING_SNAKE_CASE      :	str					=		0.02
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		3
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		4
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		'''last'''
       __SCREAMING_SNAKE_CASE      :	Dict					=		True
       __SCREAMING_SNAKE_CASE      :	int					=		None
       __SCREAMING_SNAKE_CASE      :	Tuple					=		0



     def  UpperCAmelCase__							(				self							:							int ):







       """simple docstring"""




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

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

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

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

       __SCREAMING_SNAKE_CASE      :	List[Any]					=		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  UpperCAmelCase__							(				self							:							Dict     ,						_A							:							int     ,						_A							:							Dict     ,						_A							:							List[Any]     ,						_A							:							Dict     ,						_A							:							Dict     ,						_A							:							List[Any]     ,						_A							:							str     ,						_A							:							Tuple     ,						_A							:							List[Any]     ,						):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	List[str]					=		TFFlaubertModel(config=_A )
       __SCREAMING_SNAKE_CASE      :	Any					=		{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		model(_A )

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



     def  UpperCAmelCase__							(				self							:							Tuple     ,						_A							:							List[str]     ,						_A							:							Optional[int]     ,						_A							:							List[Any]     ,						_A							:							Dict     ,						_A							:							int     ,						_A							:							Tuple     ,						_A							:							Optional[int]     ,						_A							:							Optional[int]     ,						_A							:							List[str]     ,						):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	List[Any]					=		TFFlaubertWithLMHeadModel(_A )

       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
       __SCREAMING_SNAKE_CASE      :	Any					=		model(_A )

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



     def  UpperCAmelCase__							(				self							:							List[str]     ,						_A							:							Any     ,						_A							:							Any     ,						_A							:							List[Any]     ,						_A							:							List[str]     ,						_A							:							Tuple     ,						_A							:							Any     ,						_A							:							Optional[Any]     ,						_A							:							Optional[int]     ,						_A							:							str     ,						):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	int					=		TFFlaubertForQuestionAnsweringSimple(_A )

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

       __SCREAMING_SNAKE_CASE      :	str					=		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							:							Tuple     ,						_A							:							Any     ,						_A							:							Any     ,						_A							:							Optional[Any]     ,						_A							:							Any     ,						_A							:							str     ,						_A							:							Optional[Any]     ,						_A							:							Optional[int]     ,						_A							:							Optional[Any]     ,						_A							:							List[str]     ,						):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Tuple					=		TFFlaubertForSequenceClassification(_A )

       __SCREAMING_SNAKE_CASE      :	List[Any]					=		{'''input_ids''': input_ids, '''lengths''': input_lengths}

       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		model(_A )

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



     def  UpperCAmelCase__							(				self							:							Dict     ,						_A							:							Dict     ,						_A							:							Any     ,						_A							:							Tuple     ,						_A							:							Optional[Any]     ,						_A							:							Optional[int]     ,						_A							:							List[str]     ,						_A							:							int     ,						_A							:							Dict     ,						_A							:							Optional[int]     ,						):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	int					=		self.num_labels
       __SCREAMING_SNAKE_CASE      :	int					=		TFFlaubertForTokenClassification(config=_A )
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		model(_A )
       self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.seq_length, self.num_labels) )



     def  UpperCAmelCase__							(				self							:							Any     ,						_A							:							str     ,						_A							:							List[str]     ,						_A							:							Union[str, Any]     ,						_A							:							Any     ,						_A							:							Tuple     ,						_A							:							str     ,						_A							:							List[Any]     ,						_A							:							Optional[Any]     ,						_A							:							Dict     ,						):







       """simple docstring"""




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




     def  UpperCAmelCase__							(				self							:							List[str] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Tuple					=		self.prepare_config_and_inputs()
       (
           (
           __SCREAMING_SNAKE_CASE
       ),		(
           __SCREAMING_SNAKE_CASE
       ),		(
           __SCREAMING_SNAKE_CASE
       ),		(
           __SCREAMING_SNAKE_CASE
       ),		(
           __SCREAMING_SNAKE_CASE
       ),		(
           __SCREAMING_SNAKE_CASE
       ),		(
           __SCREAMING_SNAKE_CASE
       ),		(
           __SCREAMING_SNAKE_CASE
       ),		(
           __SCREAMING_SNAKE_CASE
       ),		
       )      :	Optional[Any]					=		config_and_inputs
       __SCREAMING_SNAKE_CASE      :	Tuple					=		{
           '''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 (							lowerCAmelCase__ ,						lowerCAmelCase__ ,						unittest.TestCase       ):






     """simple docstring"""







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



     def  UpperCAmelCase__							(				self							:							List[str]     ,						_A							:							str     ,						_A							:							Any     ,						_A							:							List[Any]     ,						_A							:							str     ,						_A							:							str ):







       """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[Any] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		TFFlaubertModelTester(self )
       __SCREAMING_SNAKE_CASE      :	Dict					=		ConfigTester(self     ,						config_class=_A     ,						emb_dim=37 )



     def  UpperCAmelCase__							(				self							:							List[Any] ):







       """simple docstring"""




       self.config_tester.run_common_tests()



     def  UpperCAmelCase__							(				self							:							List[Any] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	List[str]					=		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_model(*_A )



     def  UpperCAmelCase__							(				self							:							List[Any] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	int					=		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_lm_head(*_A )



     def  UpperCAmelCase__							(				self							:							int ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Dict					=		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_qa(*_A )



     def  UpperCAmelCase__							(				self							:							Union[str, Any] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	List[str]					=		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_sequence_classif(*_A )



     def  UpperCAmelCase__							(				self							:							Optional[int] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Dict					=		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_for_token_classification(*_A )



     def  UpperCAmelCase__							(				self							:							List[Any] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	int					=		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_for_multiple_choice(*_A )




     @slow
     def  UpperCAmelCase__							(				self							:							Union[str, Any] ):







       """simple docstring"""




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






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






     """simple docstring"""







     @slow
     def  UpperCAmelCase__							(				self							:							str ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	List[Any]					=		TFFlaubertModel.from_pretrained('''jplu/tf-flaubert-small-cased''' )

       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		tf.convert_to_tensor(
           [[0, 158, 735, 2592, 1424, 6727, 82, 1]]     ,						dtype=tf.intaa     ,						)  # "J'aime flaubert !"

       __SCREAMING_SNAKE_CASE      :	List[str]					=		model(_A )[0]
       __SCREAMING_SNAKE_CASE      :	Tuple					=		tf.TensorShape((1, 8, 512) )
       self.assertEqual(output.shape     ,						_A )
       # compare the actual values for a slice.
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		tf.convert_to_tensor(
           [
               [
                   [-1.8_76_87_73, -1.56_65_55, 0.27_07_24_18],
                   [-1.6_92_00_38, -0.5_87_35_05, 1.9_32_95_99],
                   [-2.9_56_39_85, -1.6_99_38_35, 1.7_97_20_52],
               ]
           ]     ,						dtype=tf.floataa     ,						)

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


'''simple docstring'''




def 						lowerCAmelCase_							(  snake_case__		):




    '''simple docstring'''



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

    A			:  int   =		[]

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

        generate(k - 1						,							snake_case__		)

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

    generate(len(snake_case__		)						,							snake_case__		)
    return res


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




