
"""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
       lowercase_						    =					'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						, lowercase						, lowercase=None						, lowercase=None						, lowercase=None						, lowercase=None						, lowercase=None						, lowercase=None						, )     ->							str:


     """simple docstring"""







     if attention_mask is None:
          UpperCAmelCase_						:    Optional[Any]    					=  np.where(input_ids != config.pad_token_id						, 1						, 0      )
     if decoder_attention_mask is None:
          UpperCAmelCase_						:    Any    					=  np.where(decoder_input_ids != config.pad_token_id						, 1						, 0      )
     if head_mask is None:
          UpperCAmelCase_						:    Optional[int]    					=  np.ones((config.encoder_layers, config.encoder_attention_heads)      )
     if decoder_head_mask is None:
          UpperCAmelCase_						:    int    					=  np.ones((config.decoder_layers, config.decoder_attention_heads)      )
     if cross_attn_head_mask is None:
          UpperCAmelCase_						:    Optional[Any]    					=  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						):
       """simple docstring"""




       def __init__( self       : str     ,   a_       : Union[str, Any]     ,   a_       : Any=13     ,   a_       : int=7     ,   a_       : Union[str, Any]=True     ,   a_       : str=False     ,   a_       : int=99     ,   a_       : Dict=16     ,   a_       : List[str]=2     ,   a_       : Tuple=4     ,   a_       : int=4     ,   a_       : List[Any]="gelu"     ,   a_       : Tuple=0.1     ,   a_       : Tuple=0.1     ,   a_       : Tuple=32     ,   a_       : str=2     ,   a_       : Tuple=1     ,   a_       : str=0     ,   a_       : str=2     ,   a_       : Union[str, Any]=0.02     ,   )->					Any:



            """simple docstring"""

            UpperCAmelCase_						:    Dict    					=  parent
            UpperCAmelCase_						:    str    					=  batch_size
            UpperCAmelCase_						:    Union[str, Any]    					=  seq_length
            UpperCAmelCase_						:    Optional[Any]    					=  is_training
            UpperCAmelCase_						:    Optional[int]    					=  use_labels
            UpperCAmelCase_						:    List[Any]    					=  vocab_size
            UpperCAmelCase_						:    Optional[int]    					=  hidden_size
            UpperCAmelCase_						:    Tuple    					=  num_hidden_layers
            UpperCAmelCase_						:    str    					=  num_attention_heads
            UpperCAmelCase_						:    Optional[int]    					=  intermediate_size
            UpperCAmelCase_						:    Union[str, Any]    					=  hidden_act
            UpperCAmelCase_						:    str    					=  hidden_dropout_prob
            UpperCAmelCase_						:    Union[str, Any]    					=  attention_probs_dropout_prob
            UpperCAmelCase_						:    Union[str, Any]    					=  max_position_embeddings
            UpperCAmelCase_						:    Optional[Any]    					=  eos_token_id
            UpperCAmelCase_						:    Optional[int]    					=  pad_token_id
            UpperCAmelCase_						:    Tuple    					=  bos_token_id
            UpperCAmelCase_						:    Optional[int]    					=  decoder_start_token_id
            UpperCAmelCase_						:    Optional[int]    					=  initializer_range




       def   a      ( self       : Optional[Any] )->					Dict:



            """simple docstring"""

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

            UpperCAmelCase_						:    int    					=  shift_tokens_right(__UpperCamelCase     ,   1 )

            UpperCAmelCase_						:    str    					=  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=__UpperCamelCase     ,   )
            UpperCAmelCase_						:    Optional[Any]    					=  prepare_mbart_inputs_dict(__UpperCamelCase     ,   __UpperCamelCase     ,   __UpperCamelCase )
            return config, inputs_dict




       def   a      ( self       : Dict )->					Union[str, Any]:



            """simple docstring"""

            UpperCAmelCase_					,UpperCAmelCase_						:    Union[str, Any]    					=  self.prepare_config_and_inputs()
            return config, inputs_dict




       def   a      ( self       : Tuple     ,   a_       : Union[str, Any]     ,   a_       : Dict     ,   a_       : Optional[Any] )->					Dict:



            """simple docstring"""

            UpperCAmelCase_						:    Tuple    					=  20
            UpperCAmelCase_						:    List[Any]    					=  model_class_name(__UpperCamelCase )

            UpperCAmelCase_						:    Union[str, Any]    					=  model.encode(inputs_dict["""input_ids"""] )

            UpperCAmelCase_					,UpperCAmelCase_						:    Dict    					=  (
                inputs_dict["""decoder_input_ids"""],
                inputs_dict["""decoder_attention_mask"""],
            )

            UpperCAmelCase_						:    Optional[int]    					=  model.init_cache(decoder_input_ids.shape[0]     ,   __UpperCamelCase     ,   __UpperCamelCase )
            UpperCAmelCase_						:    int    					=  jnp.ones((decoder_input_ids.shape[0], max_decoder_length)     ,   dtype="""i4""" )

            UpperCAmelCase_						:    int    					=  jnp.broadcast_to(
                jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :]     ,   (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)     ,   )
            UpperCAmelCase_						:    str    					=  model.decode(
                decoder_input_ids[:, :-1]     ,   __UpperCamelCase     ,   decoder_attention_mask=__UpperCamelCase     ,   past_key_values=__UpperCamelCase     ,   decoder_position_ids=__UpperCamelCase     ,   )

            UpperCAmelCase_						:    Tuple    					=  jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]     ,   dtype="""i4""" )
            UpperCAmelCase_						:    int    					=  model.decode(
                decoder_input_ids[:, -1:]     ,   __UpperCamelCase     ,   decoder_attention_mask=__UpperCamelCase     ,   past_key_values=outputs_cache.past_key_values     ,   decoder_position_ids=__UpperCamelCase     ,   )

            UpperCAmelCase_						:    int    					=  model.decode(__UpperCamelCase     ,   __UpperCamelCase )

            UpperCAmelCase_						:    str    					=  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       : Optional[int]     ,   a_       : List[Any]     ,   a_       : int     ,   a_       : List[str] )->					int:



            """simple docstring"""

            UpperCAmelCase_						:    Union[str, Any]    					=  20
            UpperCAmelCase_						:    List[str]    					=  model_class_name(__UpperCamelCase )

            UpperCAmelCase_						:    str    					=  model.encode(inputs_dict["""input_ids"""] )

            UpperCAmelCase_					,UpperCAmelCase_						:    Any    					=  (
                inputs_dict["""decoder_input_ids"""],
                inputs_dict["""decoder_attention_mask"""],
            )

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

            UpperCAmelCase_						:    Optional[int]    					=  model.init_cache(decoder_input_ids.shape[0]     ,   __UpperCamelCase     ,   __UpperCamelCase )
            UpperCAmelCase_						:    List[Any]    					=  jnp.broadcast_to(
                jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :]     ,   (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)     ,   )

            UpperCAmelCase_						:    Union[str, Any]    					=  model.decode(
                decoder_input_ids[:, :-1]     ,   __UpperCamelCase     ,   decoder_attention_mask=__UpperCamelCase     ,   past_key_values=__UpperCamelCase     ,   decoder_position_ids=__UpperCamelCase     ,   )
            UpperCAmelCase_						:    List[str]    					=  jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]     ,   dtype="""i4""" )
            UpperCAmelCase_						:    Any    					=  model.decode(
                decoder_input_ids[:, -1:]     ,   __UpperCamelCase     ,   past_key_values=outputs_cache.past_key_values     ,   decoder_attention_mask=__UpperCamelCase     ,   decoder_position_ids=__UpperCamelCase     ,   )

            UpperCAmelCase_						:    Union[str, Any]    					=  model.decode(__UpperCamelCase     ,   __UpperCamelCase     ,   decoder_attention_mask=__UpperCamelCase )

            UpperCAmelCase_						:    str    					=  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						):
       """simple docstring"""




       UpperCamelCase_						:     Tuple				   =    99




       def   a      ( self       : Tuple )->					Optional[int]:



            """simple docstring"""

            UpperCAmelCase_						:    Any    					=  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     ,   )

            UpperCAmelCase_						:    List[Any]    					=  input_ids.shape[0]
            UpperCAmelCase_						:    Optional[Any]    					=  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       : Union[str, Any] )->					int:



            """simple docstring"""

            UpperCAmelCase_					,UpperCAmelCase_					,UpperCAmelCase_						:    Any    					=  self._get_config_and_data()
            UpperCAmelCase_						:    List[Any]    					=  FlaxMBartForSequenceClassification(__UpperCamelCase )
            UpperCAmelCase_						:    int    					=  model(input_ids=__UpperCamelCase     ,   decoder_input_ids=__UpperCamelCase )
            UpperCAmelCase_						:    Optional[int]    					=  (batch_size, config.num_labels)
            self.assertEqual(outputs["""logits"""].shape     ,   __UpperCamelCase )




       def   a      ( self       : Dict )->					Union[str, Any]:



            """simple docstring"""

            UpperCAmelCase_					,UpperCAmelCase_					,UpperCAmelCase_						:    Dict    					=  self._get_config_and_data()
            UpperCAmelCase_						:    Optional[Any]    					=  FlaxMBartForQuestionAnswering(__UpperCamelCase )
            UpperCAmelCase_						:    List[str]    					=  model(input_ids=__UpperCamelCase )

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




       def   a      ( self       : Dict )->					List[str]:



            """simple docstring"""

            UpperCAmelCase_					,UpperCAmelCase_					,UpperCAmelCase_						:    List[Any]    					=  self._get_config_and_data()
            UpperCAmelCase_						:    List[Any]    					=  FlaxMBartForConditionalGeneration(__UpperCamelCase )
            UpperCAmelCase_						:    Optional[Any]    					=  lm_model(input_ids=__UpperCamelCase )
            UpperCAmelCase_						:    Optional[int]    					=  (batch_size, input_ids.shape[1], config.vocab_size)
            self.assertEqual(outputs["""logits"""].shape     ,   __UpperCamelCase )




       def   a      ( self       : Optional[Any] )->					Dict:



            """simple docstring"""

            UpperCAmelCase_						:    Optional[Any]    					=  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     ,   )
            UpperCAmelCase_						:    Optional[int]    					=  FlaxMBartForConditionalGeneration(__UpperCamelCase )
            UpperCAmelCase_						:    Optional[int]    					=  np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]     ,   dtype=np.intaa )
            UpperCAmelCase_						:    List[str]    					=  np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]     ,   dtype=np.intaa )
            UpperCAmelCase_						:    Optional[Any]    					=  lm_model(input_ids=__UpperCamelCase     ,   decoder_input_ids=__UpperCamelCase )
            UpperCAmelCase_						:    Dict    					=  (*summary.shape, config.vocab_size)
            self.assertEqual(outputs["""logits"""].shape     ,   __UpperCamelCase )






       def   a      ( self       : Tuple )->					Union[str, Any]:



            """simple docstring"""

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



@require_flax
class 		UpperCAmelCase_	(UpperCAmelCase_  , unittest.TestCase  , UpperCAmelCase_						):
       """simple docstring"""




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




       def   a      ( self       : str )->					Any:



            """simple docstring"""

            UpperCAmelCase_						:    Tuple    					=  FlaxMBartModelTester(self )




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



            """simple docstring"""

            UpperCAmelCase_					,UpperCAmelCase_						:    Any    					=  self.model_tester.prepare_config_and_inputs()
            for model_class in self.all_model_classes:
                 self.model_tester.check_use_cache_forward(__UpperCamelCase     ,   __UpperCamelCase     ,   __UpperCamelCase )




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



            """simple docstring"""

            UpperCAmelCase_					,UpperCAmelCase_						:    str    					=  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(__UpperCamelCase     ,   __UpperCamelCase     ,   __UpperCamelCase )




       def   a      ( self       : str )->					List[str]:



            """simple docstring"""

            UpperCAmelCase_					,UpperCAmelCase_						:    Tuple    					=  self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 with self.subTest(model_class.__name__ ):
                      UpperCAmelCase_						:    Any    					=  self._prepare_for_class(__UpperCamelCase     ,   __UpperCamelCase )
                      UpperCAmelCase_						:    Dict    					=  model_class(__UpperCamelCase )

                      @jax.jit
                      def encode_jitted(a_       : Optional[Any]     ,   a_       : Any=None     ,   **a_       : Optional[Any] ):
                           return model.encode(input_ids=__UpperCamelCase     ,   attention_mask=__UpperCamelCase )

                      with self.subTest("""JIT Enabled""" ):
                           UpperCAmelCase_						:    List[str]    					=  encode_jitted(**__UpperCamelCase ).to_tuple()

                      with self.subTest("""JIT Disabled""" ):
                           with jax.disable_jit():
                                UpperCAmelCase_						:    Optional[Any]    					=  encode_jitted(**__UpperCamelCase ).to_tuple()

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




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



            """simple docstring"""

            UpperCAmelCase_					,UpperCAmelCase_						:    List[Any]    					=  self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 with self.subTest(model_class.__name__ ):
                      UpperCAmelCase_						:    Dict    					=  model_class(__UpperCamelCase )
                      UpperCAmelCase_						:    str    					=  model.encode(inputs_dict["""input_ids"""]     ,   inputs_dict["""attention_mask"""] )

                      UpperCAmelCase_						:    Tuple    					=  {
                          """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(a_       : Tuple     ,   a_       : List[str]     ,   a_       : Union[str, Any] ):
                           return model.decode(
                               decoder_input_ids=__UpperCamelCase     ,   decoder_attention_mask=__UpperCamelCase     ,   encoder_outputs=__UpperCamelCase     ,   )

                      with self.subTest("""JIT Enabled""" ):
                           UpperCAmelCase_						:    str    					=  decode_jitted(**__UpperCamelCase ).to_tuple()

                      with self.subTest("""JIT Disabled""" ):
                           with jax.disable_jit():
                                UpperCAmelCase_						:    str    					=  decode_jitted(**__UpperCamelCase ).to_tuple()

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






       @slow
       def   a      ( self       : Tuple )->					Dict:



            """simple docstring"""

            for model_class_name in self.all_model_classes:
                 UpperCAmelCase_						:    Dict    					=  model_class_name.from_pretrained("""facebook/mbart-large-cc25"""     ,   from_pt=__UpperCamelCase )
                 # FlaxMBartForSequenceClassification expects eos token in input_ids
                 UpperCAmelCase_						:    List[Any]    					=  np.ones((1, 1) ) * model.config.eos_token_id
                 UpperCAmelCase_						:    Union[str, Any]    					=  model(__UpperCamelCase )
                 self.assertIsNotNone(__UpperCamelCase )



@require_flax
@require_sentencepiece
@require_tokenizers
class 		UpperCAmelCase_	(unittest.TestCase						):
       """simple docstring"""




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




       @cached_property
       def   a      ( self       : Dict )->					List[str]:



            """simple docstring"""

            return AutoTokenizer.from_pretrained(self.model_name )




       @cached_property
       def   a      ( self       : Tuple )->					List[Any]:



            """simple docstring"""

            UpperCAmelCase_						:    Optional[int]    					=  FlaxMBartForConditionalGeneration.from_pretrained(self.model_name     ,   from_pt=__UpperCamelCase )
            return model




       def   a      ( self       : Union[str, Any]     ,   **a_       : Optional[int] )->					List[Any]:



            """simple docstring"""

            UpperCAmelCase_						:    List[str]    					=  self.translate_src_text(**__UpperCamelCase )
            self.assertListEqual(self.expected_text     ,   __UpperCamelCase )




       def   a      ( self       : Optional[int]     ,   **a_       : Dict )->					Union[str, Any]:



            """simple docstring"""

            UpperCAmelCase_						:    Optional[int]    					=  self.tokenizer(self.src_text     ,   **__UpperCamelCase     ,   return_tensors="""np""" )
            UpperCAmelCase_						:    List[Any]    					=  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=__UpperCamelCase     ,   num_beams=2     ,   ).sequences
            UpperCAmelCase_						:    Dict    					=  self.tokenizer.batch_decode(__UpperCamelCase     ,   skip_special_tokens=__UpperCamelCase )
            return generated_words






       @slow
       def   a      ( self       : List[Any] )->					List[Any]:



            """simple docstring"""

            self._assert_generated_batch_equal_expected()



"""simple docstring"""







from math import radians as angle_to_radians
from math import sin

# Acceleration Constant on Earth (unit m/s^2)
lowercase_						    =					9.8_0665




def 			A_			(					lowercase						, lowercase      )     ->							None:


     """simple docstring"""







     if not isinstance(lowercase						, (int, float)      ):
          raise TypeError("""Invalid velocity. Should be a positive number."""      )

     if not isinstance(lowercase						, (int, float)      ):
          raise TypeError("""Invalid angle. Range is 1-90 degrees."""      )

     # Ensure valid angle
     if angle > 90 or angle < 1:
          raise ValueError("""Invalid angle. Range is 1-90 degrees."""      )

     # Ensure valid velocity
     if init_velocity < 0:
          raise ValueError("""Invalid velocity. Should be a positive number."""      )




def 			A_			(					lowercase						, lowercase      )     ->							float:


     """simple docstring"""







     check_args(lowercase						, lowercase      )
     UpperCAmelCase_						:    Any    					=  angle_to_radians(2 * angle      )
     return round(init_velocity**2 * sin(lowercase      ) / g						, 2      )




def 			A_			(					lowercase						, lowercase      )     ->							float:


     """simple docstring"""







     check_args(lowercase						, lowercase      )
     UpperCAmelCase_						:    Union[str, Any]    					=  angle_to_radians(lowercase      )
     return round(init_velocity**2 * sin(lowercase      ) ** 2 / (2 * g)						, 2      )




def 			A_			(					lowercase						, lowercase      )     ->							float:


     """simple docstring"""







     check_args(lowercase						, lowercase      )
     UpperCAmelCase_						:    Optional[int]    					=  angle_to_radians(lowercase      )
     return round(2 * init_velocity * sin(lowercase      ) / g						, 2      )




def 			A_			(					)     ->							None:


     """simple docstring"""







     UpperCAmelCase_					,UpperCAmelCase_						:    Optional[int]    					=  25, 20
     assert horizontal_distance(lowercase						, lowercase      ) == 40.97
     assert max_height(lowercase						, lowercase      ) == 3.73
     assert total_time(lowercase						, lowercase      ) == 1.74


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

       testmod()

       # Get input from user
       lowercase_						    =					float(input("Initial Velocity: ").strip())

       # Get input from user
       lowercase_						    =					float(input("angle: ").strip())

       # Print results
       print()
       print("Results: ")
       print(f"""Horizontal Distance: {horizontal_distance(init_vel, angle)!s} [m]""")
       print(f"""Maximum Height: {max_height(init_vel, angle)!s} [m]""")
       print(f"""Total Time: {total_time(init_vel, angle)!s} [s]""")

