





'''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
      A__       :     Any          ='''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      UpperCamelCase__   (	lowerCAmelCase							,			lowerCAmelCase							,			lowerCAmelCase=None							,			lowerCAmelCase=None							,			lowerCAmelCase=None							,			lowerCAmelCase=None							,			lowerCAmelCase=None							,			lowerCAmelCase=None							,			):





      """simple docstring"""


      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 				UpperCAmelCase  (    unittest.TestCase     ):




      def __init__(    self    :				Dict    ,    __snake_case    :				Dict    ,    __snake_case    :				Dict=13    ,    __snake_case    :				Any=7    ,    __snake_case    :				Any=True    ,    __snake_case    :				int=False    ,    __snake_case    :				List[Any]=99    ,    __snake_case    :				Union[str, Any]=16    ,    __snake_case    :				Dict=2    ,    __snake_case    :				Union[str, Any]=4    ,    __snake_case    :				List[Any]=4    ,    __snake_case    :				List[str]="gelu"    ,    __snake_case    :				Any=0.1    ,    __snake_case    :				Optional[int]=0.1    ,    __snake_case    :				Any=32    ,    __snake_case    :				Union[str, Any]=2    ,    __snake_case    :				Optional[int]=1    ,    __snake_case    :				Any=0    ,    __snake_case    :				str=2    ,    __snake_case    :				int=0.02    ,    )       ->   int:
            _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        lowercase__					(    self    :				Optional[int]						)       ->   Dict:
            _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(__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=__snake_case    ,    )
            _lowerCAmelCase							  =							prepare_mbart_inputs_dict(__snake_case    ,    __snake_case    ,    __snake_case						)
            return config, inputs_dict




      def        lowercase__					(    self    :				Dict						)       ->   Any:
            _lowerCAmelCase  ,							_lowerCAmelCase							  =							self.prepare_config_and_inputs()
            return config, inputs_dict




      def        lowercase__					(    self    :				Tuple    ,    __snake_case    :				List[str]    ,    __snake_case    :				List[Any]    ,    __snake_case    :				Union[str, Any]						)       ->   Dict:
            _lowerCAmelCase							  =							20
            _lowerCAmelCase							  =							model_class_name(__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]    ,    __snake_case    ,    __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]    ,    __snake_case    ,    decoder_attention_mask=__snake_case    ,    past_key_values=__snake_case    ,    decoder_position_ids=__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:]    ,    __snake_case    ,    decoder_attention_mask=__snake_case    ,    past_key_values=outputs_cache.past_key_values    ,    decoder_position_ids=__snake_case    ,    )

            _lowerCAmelCase							  =							model.decode(__snake_case    ,    __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        lowercase__					(    self    :				Optional[int]    ,    __snake_case    :				Optional[int]    ,    __snake_case    :				Tuple    ,    __snake_case    :				Optional[int]						)       ->   Tuple:
            _lowerCAmelCase							  =							20
            _lowerCAmelCase							  =							model_class_name(__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]    ,    __snake_case    ,    __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]    ,    __snake_case    ,    decoder_attention_mask=__snake_case    ,    past_key_values=__snake_case    ,    decoder_position_ids=__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:]    ,    __snake_case    ,    past_key_values=outputs_cache.past_key_values    ,    decoder_attention_mask=__snake_case    ,    decoder_position_ids=__snake_case    ,    )

            _lowerCAmelCase							  =							model.decode(__snake_case    ,    __snake_case    ,    decoder_attention_mask=__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 				UpperCAmelCase  (    unittest.TestCase     ):
      _lowercase:    Optional[Any]		  =     99




      def        lowercase__					(    self    :				str						)       ->   Dict:
            _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        lowercase__					(    self    :				Any						)       ->   Tuple:
            _lowerCAmelCase  ,							_lowerCAmelCase  ,							_lowerCAmelCase							  =							self._get_config_and_data()
            _lowerCAmelCase							  =							FlaxMBartForSequenceClassification(__snake_case						)
            _lowerCAmelCase							  =							model(input_ids=__snake_case    ,    decoder_input_ids=__snake_case						)
            _lowerCAmelCase							  =							(batch_size, config.num_labels)
            self.assertEqual(outputs["""logits"""].shape    ,    __snake_case						)




      def        lowercase__					(    self    :				Optional[Any]						)       ->   Optional[int]:
            _lowerCAmelCase  ,							_lowerCAmelCase  ,							_lowerCAmelCase							  =							self._get_config_and_data()
            _lowerCAmelCase							  =							FlaxMBartForQuestionAnswering(__snake_case						)
            _lowerCAmelCase							  =							model(input_ids=__snake_case						)

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




      def        lowercase__					(    self    :				Union[str, Any]						)       ->   Dict:
            _lowerCAmelCase  ,							_lowerCAmelCase  ,							_lowerCAmelCase							  =							self._get_config_and_data()
            _lowerCAmelCase							  =							FlaxMBartForConditionalGeneration(__snake_case						)
            _lowerCAmelCase							  =							lm_model(input_ids=__snake_case						)
            _lowerCAmelCase							  =							(batch_size, input_ids.shape[1], config.vocab_size)
            self.assertEqual(outputs["""logits"""].shape    ,    __snake_case						)




      def        lowercase__					(    self    :				Optional[Any]						)       ->   str:
            _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(__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=__snake_case    ,    decoder_input_ids=__snake_case						)
            _lowerCAmelCase							  =							(*summary.shape, config.vocab_size)
            self.assertEqual(outputs["""logits"""].shape    ,    __snake_case						)




      def        lowercase__					(    self    :				Optional[int]						)       ->   Optional[Any]:
            _lowerCAmelCase							  =							np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]    ,    dtype=np.intaa						)
            _lowerCAmelCase							  =							shift_tokens_right(__snake_case    ,    1						)
            _lowerCAmelCase							  =							np.equal(__snake_case    ,    1						).astype(np.floataa						).sum()
            _lowerCAmelCase							  =							np.equal(__snake_case    ,    1						).astype(np.floataa						).sum()
            self.assertEqual(shifted.shape    ,    input_ids.shape						)
            self.assertEqual(__snake_case    ,    n_pad_before - 1						)
            self.assertTrue(np.equal(shifted[:, 0]    ,    2						).all()						)




@require_flax
class 				UpperCAmelCase  (    snake_case_							,	unittest.TestCase							,	snake_case_     ):
      _lowercase:    Union[str, Any]		  =     True
      _lowercase:    Dict		  =     (
          (
              FlaxMBartModel,
              FlaxMBartForConditionalGeneration,
              FlaxMBartForSequenceClassification,
              FlaxMBartForQuestionAnswering,
          )
          if is_flax_available()
          else ()
      )
      _lowercase:    Dict		  =     (FlaxMBartForConditionalGeneration,) if is_flax_available() else ()




      def        lowercase__					(    self    :				Optional[Any]						)       ->   Union[str, Any]:
            _lowerCAmelCase							  =							FlaxMBartModelTester(self						)




      def        lowercase__					(    self    :				str						)       ->   List[str]:
            _lowerCAmelCase  ,							_lowerCAmelCase							  =							self.model_tester.prepare_config_and_inputs()
            for model_class in self.all_model_classes:
                  self.model_tester.check_use_cache_forward(__snake_case    ,    __snake_case    ,    __snake_case						)




      def        lowercase__					(    self    :				List[str]						)       ->   List[str]:
            _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(__snake_case    ,    __snake_case    ,    __snake_case						)




      def        lowercase__					(    self    :				Union[str, Any]						)       ->   List[str]:
            _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(__snake_case    ,    __snake_case						)
                        _lowerCAmelCase							  =							model_class(__snake_case						)

                        @jax.jit
                        def encode_jitted(__snake_case    :				Union[str, Any]    ,    __snake_case    :				Dict=None    ,    **__snake_case    :				Optional[Any]						):
                              return model.encode(input_ids=__snake_case    ,    attention_mask=__snake_case						)

                        with self.subTest("""JIT Enabled"""						):
                              _lowerCAmelCase							  =							encode_jitted(**__snake_case						).to_tuple()

                        with self.subTest("""JIT Disabled"""						):
                              with jax.disable_jit():
                                    _lowerCAmelCase							  =							encode_jitted(**__snake_case						).to_tuple()

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




      def        lowercase__					(    self    :				str						)       ->   int:
            _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(__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(__snake_case    :				List[Any]    ,    __snake_case    :				Optional[Any]    ,    __snake_case    :				List[Any]						):
                              return model.decode(
                                  decoder_input_ids=__snake_case    ,    decoder_attention_mask=__snake_case    ,    encoder_outputs=__snake_case    ,    )

                        with self.subTest("""JIT Enabled"""						):
                              _lowerCAmelCase							  =							decode_jitted(**__snake_case						).to_tuple()

                        with self.subTest("""JIT Disabled"""						):
                              with jax.disable_jit():
                                    _lowerCAmelCase							  =							decode_jitted(**__snake_case						).to_tuple()

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




      @slow
      def        lowercase__					(    self    :				Dict						)       ->   int:
            for model_class_name in self.all_model_classes:
                  _lowerCAmelCase							  =							model_class_name.from_pretrained("""facebook/mbart-large-cc25"""    ,    from_pt=__snake_case						)
                  # FlaxMBartForSequenceClassification expects eos token in input_ids
                  _lowerCAmelCase							  =							np.ones((1, 1)						) * model.config.eos_token_id
                  _lowerCAmelCase							  =							model(__snake_case						)
                  self.assertIsNotNone(__snake_case						)




@require_flax
@require_sentencepiece
@require_tokenizers
class 				UpperCAmelCase  (    unittest.TestCase     ):
      _lowercase:    List[str]		  =     [
          ''' UN Chief Says There Is No Military Solution in Syria''',
      ]
      _lowercase:    Optional[Any]		  =     [
          '''Şeful ONU declară că nu există o soluţie militară în Siria''',
      ]
      _lowercase:    Union[str, Any]		  =     '''facebook/mbart-large-en-ro'''




      @cached_property
      def        lowercase__					(    self    :				List[str]						)       ->   Union[str, Any]:
            return AutoTokenizer.from_pretrained(self.model_name						)




      @cached_property
      def        lowercase__					(    self    :				Any						)       ->   str:
            _lowerCAmelCase							  =							FlaxMBartForConditionalGeneration.from_pretrained(self.model_name    ,    from_pt=__snake_case						)
            return model




      def        lowercase__					(    self    :				Union[str, Any]    ,    **__snake_case    :				Optional[Any]						)       ->   Any:
            _lowerCAmelCase							  =							self.translate_src_text(**__snake_case						)
            self.assertListEqual(self.expected_text    ,    __snake_case						)




      def        lowercase__					(    self    :				Tuple    ,    **__snake_case    :				Any						)       ->   str:
            _lowerCAmelCase							  =							self.tokenizer(self.src_text    ,    **__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=__snake_case    ,    num_beams=2    ,    ).sequences
            _lowerCAmelCase							  =							self.tokenizer.batch_decode(__snake_case    ,    skip_special_tokens=__snake_case						)
            return generated_words




      @slow
      def        lowercase__					(    self    :				Tuple						)       ->   str:
            self._assert_generated_batch_equal_expected()













'''simple docstring'''






class 				UpperCAmelCase  :




      def __init__(    self    :				Optional[Any]						)       ->   List[str]:
            _lowerCAmelCase							  =							[0]
            _lowerCAmelCase							  =							0




      def        lowercase__					(    self    :				str    ,    __snake_case    :				int						)       ->   None:
            _lowerCAmelCase							  =							self.__heap[i]
            while i // 2 > 0:
                  if self.__heap[i] > self.__heap[i // 2]:
                        _lowerCAmelCase							  =							self.__heap[i // 2]
                        _lowerCAmelCase							  =							temporary
                  i //= 2




      def        lowercase__					(    self    :				Optional[Any]    ,    __snake_case    :				int						)       ->   None:
            self.__heap.append(__snake_case						)
            self.__size += 1
            self.__swap_up(self.__size						)




      def        lowercase__					(    self    :				str    ,    __snake_case    :				int						)       ->   None:
            while self.__size >= 2 * i:
                  if 2 * i + 1 > self.__size:
                        _lowerCAmelCase							  =							2 * i
                  else:
                        if self.__heap[2 * i] > self.__heap[2 * i + 1]:
                              _lowerCAmelCase							  =							2 * i
                        else:
                              _lowerCAmelCase							  =							2 * i + 1
                  _lowerCAmelCase							  =							self.__heap[i]
                  if self.__heap[i] < self.__heap[bigger_child]:
                        _lowerCAmelCase							  =							self.__heap[bigger_child]
                        _lowerCAmelCase							  =							temporary
                  _lowerCAmelCase							  =							bigger_child




      def        lowercase__					(    self    :				Tuple						)       ->   int:
            _lowerCAmelCase							  =							self.__heap[1]
            _lowerCAmelCase							  =							self.__heap[self.__size]
            self.__size -= 1
            self.__heap.pop()
            self.__swap_down(1						)
            return max_value




      @property
      def        lowercase__					(    self    :				List[Any]						)       ->   str:
            return self.__heap[1:]




      def __len__(    self    :				Optional[Any]						)       ->   str:
            return self.__size


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      # create an instance of BinaryHeap
      A__       :     Tuple          =BinaryHeap()
      binary_heap.insert(6)
      binary_heap.insert(10)
      binary_heap.insert(15)
      binary_heap.insert(12)
      # pop root(max-values because it is max heap)
      print(binary_heap.pop())  # 15
      print(binary_heap.pop())  # 12
      # get the list and size after operations
      print(binary_heap.get_list)
      print(len(binary_heap))






