"""simple docstring"""







import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import MBartConfig, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
     import os

     # The slow tests are often failing with OOM error on GPU
     # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
     # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
     _SCREAMING_SNAKE_CASE	:		Dict   =   '''platform'''

     import jax
     import jax.numpy as jnp

     from transformers import AutoTokenizer
     from transformers.models.mbart.modeling_flax_mbart import (
         FlaxMBartForConditionalGeneration,
         FlaxMBartForQuestionAnswering,
         FlaxMBartForSequenceClassification,
         FlaxMBartModel,
         shift_tokens_right,
     )



def       A__    (	lowercase_     :	List[str]      , lowercase_     :	Tuple      , lowercase_     :	Dict=None      , lowercase_     :	str=None      , lowercase_     :	List[Any]=None      , lowercase_     :	Any=None      , lowercase_     :	Optional[Any]=None      , lowercase_     :	Any=None      , )  ->							Optional[Any]:
   if attention_mask is None:
      __lowerCamelCase    		=					np.where(input_ids != config.pad_token_id      , 1      , 0						)
   if decoder_attention_mask is None:
      __lowerCamelCase    		=					np.where(decoder_input_ids != config.pad_token_id      , 1      , 0						)
   if head_mask is None:
      __lowerCamelCase    		=					np.ones((config.encoder_layers, config.encoder_attention_heads)						)
   if decoder_head_mask is None:
      __lowerCamelCase    		=					np.ones((config.decoder_layers, config.decoder_attention_heads)						)
   if cross_attn_head_mask is None:
      __lowerCamelCase    		=					np.ones((config.decoder_layers, config.decoder_attention_heads)						)
   return {
       "input_ids": input_ids,
       "decoder_input_ids": decoder_input_ids,
       "attention_mask": attention_mask,
       "decoder_attention_mask": decoder_attention_mask,
   }






class      _SCREAMING_SNAKE_CASE							(			unittest.TestCase				):



   '''simple docstring'''



   def __init__(	self ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE=13 ,				_SCREAMING_SNAKE_CASE=7 ,				_SCREAMING_SNAKE_CASE=True ,				_SCREAMING_SNAKE_CASE=False ,				_SCREAMING_SNAKE_CASE=99 ,				_SCREAMING_SNAKE_CASE=16 ,				_SCREAMING_SNAKE_CASE=2 ,				_SCREAMING_SNAKE_CASE=4 ,				_SCREAMING_SNAKE_CASE=4 ,				_SCREAMING_SNAKE_CASE="gelu" ,				_SCREAMING_SNAKE_CASE=0.1 ,				_SCREAMING_SNAKE_CASE=0.1 ,				_SCREAMING_SNAKE_CASE=32 ,				_SCREAMING_SNAKE_CASE=2 ,				_SCREAMING_SNAKE_CASE=1 ,				_SCREAMING_SNAKE_CASE=0 ,				_SCREAMING_SNAKE_CASE=2 ,				_SCREAMING_SNAKE_CASE=0.02 ,				):


      '''simple docstring'''

      __lowerCamelCase    		=					parent
      __lowerCamelCase    		=					batch_size
      __lowerCamelCase    		=					seq_length
      __lowerCamelCase    		=					is_training
      __lowerCamelCase    		=					use_labels
      __lowerCamelCase    		=					vocab_size
      __lowerCamelCase    		=					hidden_size
      __lowerCamelCase    		=					num_hidden_layers
      __lowerCamelCase    		=					num_attention_heads
      __lowerCamelCase    		=					intermediate_size
      __lowerCamelCase    		=					hidden_act
      __lowerCamelCase    		=					hidden_dropout_prob
      __lowerCamelCase    		=					attention_probs_dropout_prob
      __lowerCamelCase    		=					max_position_embeddings
      __lowerCamelCase    		=					eos_token_id
      __lowerCamelCase    		=					pad_token_id
      __lowerCamelCase    		=					bos_token_id
      __lowerCamelCase    		=					decoder_start_token_id
      __lowerCamelCase    		=					initializer_range







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					np.clip(ids_tensor([self.batch_size, self.seq_length - 1] ,				self.vocab_size	) ,				3 ,				self.vocab_size	)
      __lowerCamelCase    		=					np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1) ,				dtype=np.intaa	)) ,				-1	)

      __lowerCamelCase    		=					shift_tokens_right(_SCREAMING_SNAKE_CASE ,				1	)

      __lowerCamelCase    		=					MBartConfig(
          vocab_size=self.vocab_size ,				d_model=self.hidden_size ,				encoder_layers=self.num_hidden_layers ,				decoder_layers=self.num_hidden_layers ,				encoder_attention_heads=self.num_attention_heads ,				decoder_attention_heads=self.num_attention_heads ,				encoder_ffn_dim=self.intermediate_size ,				decoder_ffn_dim=self.intermediate_size ,				dropout=self.hidden_dropout_prob ,				attention_dropout=self.attention_probs_dropout_prob ,				max_position_embeddings=self.max_position_embeddings ,				eos_token_id=self.eos_token_id ,				bos_token_id=self.bos_token_id ,				pad_token_id=self.pad_token_id ,				decoder_start_token_id=self.decoder_start_token_id ,				initializer_range=self.initializer_range ,				use_cache=_SCREAMING_SNAKE_CASE ,				)
      __lowerCamelCase    		=					prepare_mbart_inputs_dict(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)
      return config, inputs_dict







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					self.prepare_config_and_inputs()
      return config, inputs_dict







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


      '''simple docstring'''

      __lowerCamelCase    		=					20
      __lowerCamelCase    		=					model_class_name(_SCREAMING_SNAKE_CASE	)

      __lowerCamelCase    		=					model.encode(inputs_dict['input_ids']	)

      __lowerCamelCase		,__lowerCamelCase    		=					(
          inputs_dict['decoder_input_ids'],
          inputs_dict['decoder_attention_mask'],
      )

      __lowerCamelCase    		=					model.init_cache(decoder_input_ids.shape[0] ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					jnp.ones((decoder_input_ids.shape[0], max_decoder_length) ,				dtype='i4'	)

      __lowerCamelCase    		=					jnp.broadcast_to(
          jnp.arange(decoder_input_ids.shape[-1] - 1	)[None, :] ,				(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) ,				)
      __lowerCamelCase    		=					model.decode(
          decoder_input_ids[:, :-1] ,				_SCREAMING_SNAKE_CASE ,				decoder_attention_mask=_SCREAMING_SNAKE_CASE ,				past_key_values=_SCREAMING_SNAKE_CASE ,				decoder_position_ids=_SCREAMING_SNAKE_CASE ,				)

      __lowerCamelCase    		=					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] ,				dtype='i4'	)
      __lowerCamelCase    		=					model.decode(
          decoder_input_ids[:, -1:] ,				_SCREAMING_SNAKE_CASE ,				decoder_attention_mask=_SCREAMING_SNAKE_CASE ,				past_key_values=outputs_cache.past_key_values ,				decoder_position_ids=_SCREAMING_SNAKE_CASE ,				)

      __lowerCamelCase    		=					model.decode(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)

      __lowerCamelCase    		=					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])	)	)
      self.parent.assertTrue(diff < 1E-3 ,				msg=F'''Max diff is {diff}'''	)







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


      '''simple docstring'''

      __lowerCamelCase    		=					20
      __lowerCamelCase    		=					model_class_name(_SCREAMING_SNAKE_CASE	)

      __lowerCamelCase    		=					model.encode(inputs_dict['input_ids']	)

      __lowerCamelCase		,__lowerCamelCase    		=					(
          inputs_dict['decoder_input_ids'],
          inputs_dict['decoder_attention_mask'],
      )

      __lowerCamelCase    		=					jnp.concatenate(
          [
              decoder_attention_mask,
              jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])	),
          ] ,				axis=-1 ,				)

      __lowerCamelCase    		=					model.init_cache(decoder_input_ids.shape[0] ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					jnp.broadcast_to(
          jnp.arange(decoder_input_ids.shape[-1] - 1	)[None, :] ,				(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) ,				)

      __lowerCamelCase    		=					model.decode(
          decoder_input_ids[:, :-1] ,				_SCREAMING_SNAKE_CASE ,				decoder_attention_mask=_SCREAMING_SNAKE_CASE ,				past_key_values=_SCREAMING_SNAKE_CASE ,				decoder_position_ids=_SCREAMING_SNAKE_CASE ,				)
      __lowerCamelCase    		=					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] ,				dtype='i4'	)
      __lowerCamelCase    		=					model.decode(
          decoder_input_ids[:, -1:] ,				_SCREAMING_SNAKE_CASE ,				past_key_values=outputs_cache.past_key_values ,				decoder_attention_mask=_SCREAMING_SNAKE_CASE ,				decoder_position_ids=_SCREAMING_SNAKE_CASE ,				)

      __lowerCamelCase    		=					model.decode(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				decoder_attention_mask=_SCREAMING_SNAKE_CASE	)

      __lowerCamelCase    		=					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])	)	)
      self.parent.assertTrue(diff < 1E-3 ,				msg=F'''Max diff is {diff}'''	)






@require_flax
class      _SCREAMING_SNAKE_CASE							(			unittest.TestCase				):



   '''simple docstring'''



   __UpperCAmelCase	:							Union[str, Any]    =    99







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					np.array(
          [
              [71, 82, 18, 33, 46, 91, 2],
              [68, 34, 26, 58, 30, 82, 2],
              [5, 97, 17, 39, 94, 40, 2],
              [76, 83, 94, 25, 70, 78, 2],
              [87, 59, 41, 35, 48, 66, 2],
              [55, 13, 16, 58, 5, 2, 1],  # note padding
              [64, 27, 31, 51, 12, 75, 2],
              [52, 64, 86, 17, 83, 39, 2],
              [48, 61, 9, 24, 71, 82, 2],
              [26, 1, 60, 48, 22, 13, 2],
              [21, 5, 62, 28, 14, 76, 2],
              [45, 98, 37, 86, 59, 48, 2],
              [70, 70, 50, 9, 28, 0, 2],
          ] ,				dtype=np.intaa ,				)

      __lowerCamelCase    		=					input_ids.shape[0]
      __lowerCamelCase    		=					MBartConfig(
          vocab_size=self.vocab_size ,				d_model=24 ,				encoder_layers=2 ,				decoder_layers=2 ,				encoder_attention_heads=2 ,				decoder_attention_heads=2 ,				encoder_ffn_dim=32 ,				decoder_ffn_dim=32 ,				max_position_embeddings=48 ,				eos_token_id=2 ,				pad_token_id=1 ,				bos_token_id=0 ,				)
      return config, input_ids, batch_size







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase		,__lowerCamelCase    		=					self._get_config_and_data()
      __lowerCamelCase    		=					FlaxMBartForSequenceClassification(_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					model(input_ids=_SCREAMING_SNAKE_CASE ,				decoder_input_ids=_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					(batch_size, config.num_labels)
      self.assertEqual(outputs['logits'].shape ,				_SCREAMING_SNAKE_CASE	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase		,__lowerCamelCase    		=					self._get_config_and_data()
      __lowerCamelCase    		=					FlaxMBartForQuestionAnswering(_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					model(input_ids=_SCREAMING_SNAKE_CASE	)

      self.assertEqual(outputs['start_logits'].shape ,				input_ids.shape	)
      self.assertEqual(outputs['end_logits'].shape ,				input_ids.shape	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase		,__lowerCamelCase    		=					self._get_config_and_data()
      __lowerCamelCase    		=					FlaxMBartForConditionalGeneration(_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					lm_model(input_ids=_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					(batch_size, input_ids.shape[1], config.vocab_size)
      self.assertEqual(outputs['logits'].shape ,				_SCREAMING_SNAKE_CASE	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					MBartConfig(
          vocab_size=self.vocab_size ,				d_model=14 ,				encoder_layers=2 ,				decoder_layers=2 ,				encoder_attention_heads=2 ,				decoder_attention_heads=2 ,				encoder_ffn_dim=8 ,				decoder_ffn_dim=8 ,				max_position_embeddings=48 ,				)
      __lowerCamelCase    		=					FlaxMBartForConditionalGeneration(_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]] ,				dtype=np.intaa	)
      __lowerCamelCase    		=					np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]] ,				dtype=np.intaa	)
      __lowerCamelCase    		=					lm_model(input_ids=_SCREAMING_SNAKE_CASE ,				decoder_input_ids=_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					(*summary.shape, config.vocab_size)
      self.assertEqual(outputs['logits'].shape ,				_SCREAMING_SNAKE_CASE	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]] ,				dtype=np.intaa	)
      __lowerCamelCase    		=					shift_tokens_right(_SCREAMING_SNAKE_CASE ,				1	)
      __lowerCamelCase    		=					np.equal(_SCREAMING_SNAKE_CASE ,				1	).astype(np.floataa	).sum()
      __lowerCamelCase    		=					np.equal(_SCREAMING_SNAKE_CASE ,				1	).astype(np.floataa	).sum()
      self.assertEqual(shifted.shape ,				input_ids.shape	)
      self.assertEqual(_SCREAMING_SNAKE_CASE ,				n_pad_before - 1	)
      self.assertTrue(np.equal(shifted[:, 0] ,				2	).all()	)






@require_flax
class      _SCREAMING_SNAKE_CASE							(			UpperCAmelCase    ,				unittest.TestCase    ,				UpperCAmelCase				):



   '''simple docstring'''



   __UpperCAmelCase	:							Optional[Any]    =    True
   __UpperCAmelCase	:							Any    =    (
       (
           FlaxMBartModel,
           FlaxMBartForConditionalGeneration,
           FlaxMBartForSequenceClassification,
           FlaxMBartForQuestionAnswering,
       )
       if is_flax_available()
       else ()
   )
   __UpperCAmelCase	:							List[Any]    =    (FlaxMBartForConditionalGeneration,) if is_flax_available() else ()







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					FlaxMBartModelTester(self	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs()
      for model_class in self.all_model_classes:
         self.model_tester.check_use_cache_forward(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs()
      for model_class in self.all_model_classes:
         self.model_tester.check_use_cache_forward_with_attn_mask(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         with self.subTest(model_class.__name__	):
            __lowerCamelCase    		=					self._prepare_for_class(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)
            __lowerCamelCase    		=					model_class(_SCREAMING_SNAKE_CASE	)

            @jax.jit
            def encode_jitted(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE=None ,				**_SCREAMING_SNAKE_CASE	):
               return model.encode(input_ids=_SCREAMING_SNAKE_CASE ,				attention_mask=_SCREAMING_SNAKE_CASE	)

            with self.subTest('JIT Enabled'	):
               __lowerCamelCase    		=					encode_jitted(**_SCREAMING_SNAKE_CASE	).to_tuple()

            with self.subTest('JIT Disabled'	):
               with jax.disable_jit():
                  __lowerCamelCase    		=					encode_jitted(**_SCREAMING_SNAKE_CASE	).to_tuple()

            self.assertEqual(len(_SCREAMING_SNAKE_CASE	) ,				len(_SCREAMING_SNAKE_CASE	)	)
            for jitted_output, output in zip(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	):
               self.assertEqual(jitted_output.shape ,				output.shape	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         with self.subTest(model_class.__name__	):
            __lowerCamelCase    		=					model_class(_SCREAMING_SNAKE_CASE	)
            __lowerCamelCase    		=					model.encode(inputs_dict['input_ids'] ,				inputs_dict['attention_mask']	)

            __lowerCamelCase    		=					{
                'decoder_input_ids': inputs_dict['decoder_input_ids'],
                'decoder_attention_mask': inputs_dict['decoder_attention_mask'],
                'encoder_outputs': encoder_outputs,
            }

            @jax.jit
            def decode_jitted(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	):
               return model.decode(
                   decoder_input_ids=_SCREAMING_SNAKE_CASE ,				decoder_attention_mask=_SCREAMING_SNAKE_CASE ,				encoder_outputs=_SCREAMING_SNAKE_CASE ,				)

            with self.subTest('JIT Enabled'	):
               __lowerCamelCase    		=					decode_jitted(**_SCREAMING_SNAKE_CASE	).to_tuple()

            with self.subTest('JIT Disabled'	):
               with jax.disable_jit():
                  __lowerCamelCase    		=					decode_jitted(**_SCREAMING_SNAKE_CASE	).to_tuple()

            self.assertEqual(len(_SCREAMING_SNAKE_CASE	) ,				len(_SCREAMING_SNAKE_CASE	)	)
            for jitted_output, output in zip(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	):
               self.assertEqual(jitted_output.shape ,				output.shape	)







   @slow
   def    _A				(	self	):


      '''simple docstring'''

      for model_class_name in self.all_model_classes:
         __lowerCamelCase    		=					model_class_name.from_pretrained('facebook/mbart-large-cc25' ,				from_pt=_SCREAMING_SNAKE_CASE	)
         # FlaxMBartForSequenceClassification expects eos token in input_ids
         __lowerCamelCase    		=					np.ones((1, 1)	) * model.config.eos_token_id
         __lowerCamelCase    		=					model(_SCREAMING_SNAKE_CASE	)
         self.assertIsNotNone(_SCREAMING_SNAKE_CASE	)






@require_flax
@require_sentencepiece
@require_tokenizers
class      _SCREAMING_SNAKE_CASE							(			unittest.TestCase				):



   '''simple docstring'''



   __UpperCAmelCase	:							Optional[Any]    =    [
       " UN Chief Says There Is No Military Solution in Syria",
   ]
   __UpperCAmelCase	:							Optional[int]    =    [
       "Şeful ONU declară că nu există o soluţie militară în Siria",
   ]
   __UpperCAmelCase	:							Optional[int]    =    "facebook/mbart-large-en-ro"







   @cached_property
   def    _A				(	self	):


      '''simple docstring'''

      return AutoTokenizer.from_pretrained(self.model_name	)







   @cached_property
   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					FlaxMBartForConditionalGeneration.from_pretrained(self.model_name ,				from_pt=_SCREAMING_SNAKE_CASE	)
      return model







   def    _A				(	self ,				**_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase    		=					self.translate_src_text(**_SCREAMING_SNAKE_CASE	)
      self.assertListEqual(self.expected_text ,				_SCREAMING_SNAKE_CASE	)







   def    _A				(	self ,				**_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase    		=					self.tokenizer(self.src_text ,				**_SCREAMING_SNAKE_CASE ,				return_tensors='np'	)
      __lowerCamelCase    		=					self.model.generate(
          model_inputs.input_ids ,				attention_mask=model_inputs.attention_mask ,				decoder_start_token_id=self.tokenizer.lang_code_to_id['ro_RO'] ,				early_stopping=_SCREAMING_SNAKE_CASE ,				num_beams=2 ,				).sequences
      __lowerCamelCase    		=					self.tokenizer.batch_decode(_SCREAMING_SNAKE_CASE ,				skip_special_tokens=_SCREAMING_SNAKE_CASE	)
      return generated_words







   @slow
   def    _A				(	self	):


      '''simple docstring'''

      self._assert_generated_batch_equal_expected()







"""simple docstring"""







def       A__    (	lowercase_     :	list						)  ->							list:

   for insert_index, insert_value in enumerate(collection[1:]						):
      __lowerCamelCase    		=					insert_index
      while insert_index >= 0 and insert_value < collection[insert_index]:
         __lowerCamelCase    		=					collection[insert_index]
         insert_index -= 1
      if insert_index != temp_index:
         __lowerCamelCase    		=					insert_value
   return collection


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

     testmod()

     _SCREAMING_SNAKE_CASE	:		List[str]   =   input('''Enter numbers separated by a comma:\n''').strip()
     _SCREAMING_SNAKE_CASE	:		Optional[int]   =   [int(item) for item in user_input.split(''',''')]
     print(F"{insertion_sort(unsorted) = }")






