


'''simple docstring'''







from __future__ import annotations

import unittest

from transformers import MPNetConfig, 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.models.mpnet.modeling_tf_mpnet import (
			    TFMPNetForMaskedLM,
			    TFMPNetForMultipleChoice,
			    TFMPNetForQuestionAnswering,
			    TFMPNetForSequenceClassification,
			    TFMPNetForTokenClassification,
			    TFMPNetModel,
			)







class A__	:






						def __init__(			self      :Optional[Any]					,						SCREAMING_SNAKE_CASE      :List[str]					,						SCREAMING_SNAKE_CASE      :str=1_3					,						SCREAMING_SNAKE_CASE      :str=7					,						SCREAMING_SNAKE_CASE      :List[str]=True					,						SCREAMING_SNAKE_CASE      :List[str]=True					,						SCREAMING_SNAKE_CASE      :str=False					,						SCREAMING_SNAKE_CASE      :Dict=True					,						SCREAMING_SNAKE_CASE      :Dict=9_9					,						SCREAMING_SNAKE_CASE      :Optional[Any]=6_4					,						SCREAMING_SNAKE_CASE      :int=2					,						SCREAMING_SNAKE_CASE      :List[str]=4					,						SCREAMING_SNAKE_CASE      :List[Any]=6_4					,						SCREAMING_SNAKE_CASE      :Optional[int]="gelu"					,						SCREAMING_SNAKE_CASE      :int=0.1					,						SCREAMING_SNAKE_CASE      :Dict=0.1					,						SCREAMING_SNAKE_CASE      :Tuple=5_1_2					,						SCREAMING_SNAKE_CASE      :Any=1_6					,						SCREAMING_SNAKE_CASE      :Optional[Any]=2					,						SCREAMING_SNAKE_CASE      :Union[str, Any]=0.02					,						SCREAMING_SNAKE_CASE      :List[Any]=3					,						SCREAMING_SNAKE_CASE      :Dict=4					,						SCREAMING_SNAKE_CASE      :str=None					,						)	-> Dict:




													'''simple docstring'''
													_a   :			Tuple					 =parent
													_a   :			Dict					 =batch_size
													_a   :			Optional[int]					 =seq_length
													_a   :			Optional[Any]					 =is_training
													_a   :			Tuple					 =use_input_mask
													_a   :			str					 =use_token_type_ids
													_a   :			Tuple					 =use_labels
													_a   :			Dict					 =vocab_size
													_a   :			Optional[int]					 =hidden_size
													_a   :			Optional[Any]					 =num_hidden_layers
													_a   :			Union[str, Any]					 =num_attention_heads
													_a   :			Union[str, Any]					 =intermediate_size
													_a   :			List[str]					 =hidden_act
													_a   :			int					 =hidden_dropout_prob
													_a   :			Tuple					 =attention_probs_dropout_prob
													_a   :			Tuple					 =max_position_embeddings
													_a   :			Dict					 =type_vocab_size
													_a   :			Any					 =type_sequence_label_size
													_a   :			List[Any]					 =initializer_range
													_a   :			Optional[Any]					 =num_labels
													_a   :			Dict					 =num_choices
													_a   :			List[str]					 =scope






						def __UpperCAmelCase	(			self      :int     )	-> List[str]:




													'''simple docstring'''
													_a   :			Union[str, Any]					 =ids_tensor([self.batch_size, self.seq_length]					,						self.vocab_size     )

													_a   :			Any					 =None
													if self.use_input_mask:
																				_a   :			Optional[int]					 =random_attention_mask([self.batch_size, self.seq_length]     )

													_a   :			str					 =None
													_a   :			Optional[int]					 =None
													_a   :			Union[str, Any]					 =None
													if self.use_labels:
																				_a   :			Tuple					 =ids_tensor([self.batch_size]					,						self.type_sequence_label_size     )
																				_a   :			Union[str, Any]					 =ids_tensor([self.batch_size, self.seq_length]					,						self.num_labels     )
																				_a   :			str					 =ids_tensor([self.batch_size]					,						self.num_choices     )

													_a   :			Optional[Any]					 =MPNetConfig(
													    vocab_size=self.vocab_size					,						hidden_size=self.hidden_size					,						num_hidden_layers=self.num_hidden_layers					,						num_attention_heads=self.num_attention_heads					,						intermediate_size=self.intermediate_size					,						hidden_act=self.hidden_act					,						hidden_dropout_prob=self.hidden_dropout_prob					,						attention_probs_dropout_prob=self.attention_probs_dropout_prob					,						max_position_embeddings=self.max_position_embeddings					,						initializer_range=self.initializer_range					,						)
													return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels






						def __UpperCAmelCase	(			self      :Tuple					,						SCREAMING_SNAKE_CASE      :str					,						SCREAMING_SNAKE_CASE      :List[Any]					,						SCREAMING_SNAKE_CASE      :Optional[Any]					,						SCREAMING_SNAKE_CASE      :int					,						SCREAMING_SNAKE_CASE      :Union[str, Any]					,						SCREAMING_SNAKE_CASE      :int     )	-> Tuple:




													'''simple docstring'''
													_a   :			List[Any]					 =TFMPNetModel(config=SCREAMING_SNAKE_CASE     )
													_a   :			Optional[Any]					 ={"""input_ids""": input_ids, """attention_mask""": input_mask}
													_a   :			Union[str, Any]					 =model(SCREAMING_SNAKE_CASE     )
													_a   :			Any					 =[input_ids, input_mask]
													_a   :			int					 =model(SCREAMING_SNAKE_CASE     )
													self.parent.assertEqual(result.last_hidden_state.shape					,						(self.batch_size, self.seq_length, self.hidden_size)     )






						def __UpperCAmelCase	(			self      :Union[str, Any]					,						SCREAMING_SNAKE_CASE      :Dict					,						SCREAMING_SNAKE_CASE      :int					,						SCREAMING_SNAKE_CASE      :Any					,						SCREAMING_SNAKE_CASE      :Optional[int]					,						SCREAMING_SNAKE_CASE      :List[str]					,						SCREAMING_SNAKE_CASE      :int     )	-> Any:




													'''simple docstring'''
													_a   :			Tuple					 =TFMPNetForMaskedLM(config=SCREAMING_SNAKE_CASE     )
													_a   :			List[Any]					 ={"""input_ids""": input_ids, """attention_mask""": input_mask}
													_a   :			List[str]					 =model(SCREAMING_SNAKE_CASE     )
													self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.seq_length, self.vocab_size)     )






						def __UpperCAmelCase	(			self      :Any					,						SCREAMING_SNAKE_CASE      :List[str]					,						SCREAMING_SNAKE_CASE      :str					,						SCREAMING_SNAKE_CASE      :List[Any]					,						SCREAMING_SNAKE_CASE      :str					,						SCREAMING_SNAKE_CASE      :Optional[int]					,						SCREAMING_SNAKE_CASE      :Dict     )	-> List[Any]:




													'''simple docstring'''
													_a   :			Optional[Any]					 =TFMPNetForQuestionAnswering(config=SCREAMING_SNAKE_CASE     )
													_a   :			int					 ={
													    """input_ids""": input_ids,
													    """attention_mask""": input_mask,
													}
													_a   :			List[Any]					 =model(SCREAMING_SNAKE_CASE     )
													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      :int					,						SCREAMING_SNAKE_CASE      :int					,						SCREAMING_SNAKE_CASE      :Optional[Any]					,						SCREAMING_SNAKE_CASE      :Dict					,						SCREAMING_SNAKE_CASE      :Any					,						SCREAMING_SNAKE_CASE      :List[Any]					,						SCREAMING_SNAKE_CASE      :Optional[int]     )	-> Dict:




													'''simple docstring'''
													_a   :			Dict					 =self.num_labels
													_a   :			int					 =TFMPNetForSequenceClassification(SCREAMING_SNAKE_CASE     )
													_a   :			Dict					 ={"""input_ids""": input_ids, """attention_mask""": input_mask}
													_a   :			int					 =model(SCREAMING_SNAKE_CASE     )
													self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.num_labels)     )






						def __UpperCAmelCase	(			self      :Optional[int]					,						SCREAMING_SNAKE_CASE      :Tuple					,						SCREAMING_SNAKE_CASE      :List[str]					,						SCREAMING_SNAKE_CASE      :Tuple					,						SCREAMING_SNAKE_CASE      :List[Any]					,						SCREAMING_SNAKE_CASE      :Tuple					,						SCREAMING_SNAKE_CASE      :Union[str, Any]     )	-> List[str]:




													'''simple docstring'''
													_a   :			str					 =self.num_choices
													_a   :			Any					 =TFMPNetForMultipleChoice(SCREAMING_SNAKE_CASE     )
													_a   :			int					 =tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE					,						1     )					,						(1, self.num_choices, 1)     )
													_a   :			int					 =tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE					,						1     )					,						(1, self.num_choices, 1)     )
													_a   :			Dict					 ={
													    """input_ids""": multiple_choice_inputs_ids,
													    """attention_mask""": multiple_choice_input_mask,
													}
													_a   :			Dict					 =model(SCREAMING_SNAKE_CASE     )
													self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.num_choices)     )






						def __UpperCAmelCase	(			self      :Optional[Any]					,						SCREAMING_SNAKE_CASE      :Optional[Any]					,						SCREAMING_SNAKE_CASE      :List[str]					,						SCREAMING_SNAKE_CASE      :str					,						SCREAMING_SNAKE_CASE      :List[str]					,						SCREAMING_SNAKE_CASE      :Tuple					,						SCREAMING_SNAKE_CASE      :Dict     )	-> str:




													'''simple docstring'''
													_a   :			str					 =self.num_labels
													_a   :			Any					 =TFMPNetForTokenClassification(SCREAMING_SNAKE_CASE     )
													_a   :			Optional[Any]					 ={"""input_ids""": input_ids, """attention_mask""": input_mask}
													_a   :			Optional[int]					 =model(SCREAMING_SNAKE_CASE     )
													self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.seq_length, self.num_labels)     )






						def __UpperCAmelCase	(			self      :Tuple     )	-> str:




													'''simple docstring'''
													_a   :			Union[str, Any]					 =self.prepare_config_and_inputs()
													(_a)   :			Optional[int]					 =config_and_inputs
													_a   :			List[str]					 ={"""input_ids""": input_ids, """attention_mask""": input_mask}
													return config, inputs_dict







@require_tf
class A__	(						UpperCAmelCase__			,					UpperCAmelCase__			,					unittest.TestCase				):
						__UpperCamelCase	:  Tuple     	=							(
						    (
						        TFMPNetForMaskedLM,
						        TFMPNetForMultipleChoice,
						        TFMPNetForQuestionAnswering,
						        TFMPNetForSequenceClassification,
						        TFMPNetForTokenClassification,
						        TFMPNetModel,
						    )
						    if is_tf_available()
						    else ()
						)
						__UpperCamelCase	:  Optional[int]     	=							(
						    {
						        "feature-extraction": TFMPNetModel,
						        "fill-mask": TFMPNetForMaskedLM,
						        "question-answering": TFMPNetForQuestionAnswering,
						        "text-classification": TFMPNetForSequenceClassification,
						        "token-classification": TFMPNetForTokenClassification,
						        "zero-shot": TFMPNetForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						__UpperCamelCase	:  Optional[int]     	=							False
						__UpperCamelCase	:  Any     	=							False






						def __UpperCAmelCase	(			self      :Optional[int]     )	-> List[str]:




													'''simple docstring'''
													_a   :			Optional[Any]					 =TFMPNetModelTester(self     )
													_a   :			Optional[int]					 =ConfigTester(self					,						config_class=SCREAMING_SNAKE_CASE					,						hidden_size=3_7     )






						def __UpperCAmelCase	(			self      :Optional[Any]     )	-> Optional[Any]:




													'''simple docstring'''
													self.config_tester.run_common_tests()






						def __UpperCAmelCase	(			self      :List[Any]     )	-> Optional[int]:




													'''simple docstring'''
													_a   :			Tuple					 =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_mpnet_model(*SCREAMING_SNAKE_CASE     )






						def __UpperCAmelCase	(			self      :Optional[Any]     )	-> List[str]:




													'''simple docstring'''
													_a   :			Any					 =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_mpnet_for_masked_lm(*SCREAMING_SNAKE_CASE     )






						def __UpperCAmelCase	(			self      :Any     )	-> int:




													'''simple docstring'''
													_a   :			int					 =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_mpnet_for_question_answering(*SCREAMING_SNAKE_CASE     )






						def __UpperCAmelCase	(			self      :Optional[int]     )	-> str:




													'''simple docstring'''
													_a   :			Optional[int]					 =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_mpnet_for_sequence_classification(*SCREAMING_SNAKE_CASE     )






						def __UpperCAmelCase	(			self      :Optional[int]     )	-> int:




													'''simple docstring'''
													_a   :			Optional[int]					 =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_mpnet_for_multiple_choice(*SCREAMING_SNAKE_CASE     )






						def __UpperCAmelCase	(			self      :str     )	-> str:




													'''simple docstring'''
													_a   :			str					 =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_mpnet_for_token_classification(*SCREAMING_SNAKE_CASE     )






						@slow
						def __UpperCAmelCase	(			self      :Union[str, Any]     )	-> Optional[Any]:




													'''simple docstring'''
													for model_name in ["microsoft/mpnet-base"]:
																				_a   :			Tuple					 =TFMPNetModel.from_pretrained(SCREAMING_SNAKE_CASE     )
																				self.assertIsNotNone(SCREAMING_SNAKE_CASE     )







@require_tf
class A__	(						unittest.TestCase				):






						@slow
						def __UpperCAmelCase	(			self      :Dict     )	-> Union[str, Any]:




													'''simple docstring'''
													_a   :			Union[str, Any]					 =TFMPNetModel.from_pretrained("""microsoft/mpnet-base"""     )
													_a   :			Union[str, Any]					 =tf.constant([[0, 1, 2, 3, 4, 5]]     )
													_a   :			Optional[Any]					 =model(SCREAMING_SNAKE_CASE     )[0]

													_a   :			Optional[Any]					 =[1, 6, 7_6_8]
													self.assertEqual(output.shape					,						SCREAMING_SNAKE_CASE     )

													_a   :			List[str]					 =tf.constant(
													    [
													        [
													            [-0.1_067_172, 0.08_216_473, 0.0_024_543],
													            [-0.03_465_879, 0.8_354_118, -0.03_252_288],
													            [-0.06_569_476, -0.12_424_111, -0.0_494_436],
													        ]
													    ]     )
													tf.debugging.assert_near(output[:, :3, :3]					,						SCREAMING_SNAKE_CASE					,						atol=1e-4     )






'''simple docstring'''







def      SCREAMING_SNAKE_CASE_ (  _UpperCAmelCase     :     Union[str, Any]  )  ->      int:
       _a   :			List[str]					 =[701, 301, 132, 57, 23, 10, 4, 1]
       for gap in gaps:
              for i in range(_UpperCAmelCase   ,len(_UpperCAmelCase  )  ):
                     _a   :			Tuple					 =collection[i]
                     _a   :			Optional[Any]					 =i
                     while j >= gap and collection[j - gap] > insert_value:
                            _a   :			Union[str, Any]					 =collection[j - gap]
                            j -= gap
                     if j != i:
                            _a   :			Union[str, Any]					 =insert_value
       return collection


if __name__ == "__main__":
   from doctest import testmod

   testmod()
   A__:   int    =	input('''Enter numbers separated by a comma:\n''').strip()
   A__:   Optional[Any]    =	[int(item) for item in user_input.split(''',''')]
   print(shell_sort(unsorted))


