





from __future__ import annotations

import unittest
import warnings

from transformers import AutoTokenizer, MarianConfig, MarianTokenizer, TranslationPipeline, is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
			import tensorflow as tf

			from transformers import TFAutoModelForSeqaSeqLM, TFMarianModel, TFMarianMTModel



@require_tf
class       __lowerCAmelCase :
			lowerCamelCase_  :  List[Any]     =   MarianConfig
			lowerCamelCase_  :  str     =   {}
			lowerCamelCase_  :  str     =   '''gelu'''






			def __init__(self      ,							__magic_name__      ,							__magic_name__=13      ,							__magic_name__=7      ,							__magic_name__=True      ,							__magic_name__=False      ,							__magic_name__=99      ,							__magic_name__=32      ,							__magic_name__=2      ,							__magic_name__=4      ,							__magic_name__=37      ,							__magic_name__=0.1      ,							__magic_name__=0.1      ,							__magic_name__=20      ,							__magic_name__=2      ,							__magic_name__=1      ,							__magic_name__=0      ,							)  ->     Optional[Any]:


							'''simple docstring'''



							snake_case_		:					Any			    =						parent
							snake_case_		:					int			    =						batch_size
							snake_case_		:					int			    =						seq_length
							snake_case_		:					Dict			    =						is_training
							snake_case_		:					Optional[Any]			    =						use_labels
							snake_case_		:					Any			    =						vocab_size
							snake_case_		:					Optional[int]			    =						hidden_size
							snake_case_		:					Union[str, Any]			    =						num_hidden_layers
							snake_case_		:					Dict			    =						num_attention_heads
							snake_case_		:					List[Any]			    =						intermediate_size

							snake_case_		:					List[str]			    =						hidden_dropout_prob
							snake_case_		:					Optional[Any]			    =						attention_probs_dropout_prob
							snake_case_		:					Any			    =						max_position_embeddings
							snake_case_		:					int			    =						eos_token_id
							snake_case_		:					Optional[Any]			    =						pad_token_id
							snake_case_		:					str			    =						bos_token_id






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


							'''simple docstring'''



							snake_case_		:					Union[str, Any]			    =						ids_tensor([self.batch_size, self.seq_length - 1]      ,							self.vocab_size					)
							snake_case_		:					Dict			    =						tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size					)      ,							1					)
							snake_case_		:					Optional[int]			    =						tf.concat([input_ids, eos_tensor]      ,							axis=1					)

							snake_case_		:					Dict			    =						ids_tensor([self.batch_size, self.seq_length]      ,							self.vocab_size					)

							snake_case_		:					int			    =						self.config_cls(
							    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_ids=[2]      ,							bos_token_id=self.bos_token_id      ,							pad_token_id=self.pad_token_id      ,							decoder_start_token_id=self.pad_token_id      ,							**self.config_updates      ,							)
							snake_case_		:					Tuple			    =						prepare_marian_inputs_dict(__magic_name__      ,							__magic_name__      ,							__magic_name__					)
							return config, inputs_dict






			def     lowerCamelCase						(self      ,							__magic_name__      ,							__magic_name__					)  ->     List[str]:


							'''simple docstring'''



							snake_case_		:					Optional[int]			    =						TFMarianModel(config=__magic_name__					).get_decoder()
							snake_case_		:					List[Any]			    =						inputs_dict['''input_ids''']

							snake_case_		:					Dict			    =						input_ids[:1, :]
							snake_case_		:					Optional[Any]			    =						inputs_dict['''attention_mask'''][:1, :]
							snake_case_		:					List[Any]			    =						inputs_dict['''head_mask''']
							snake_case_		:					List[str]			    =						1

							# first forward pass
							snake_case_		:					int			    =						model(__magic_name__      ,							attention_mask=__magic_name__      ,							head_mask=__magic_name__      ,							use_cache=__magic_name__					)

							snake_case_		:					Optional[Any]			    =						outputs.to_tuple()

							# create hypothetical next token and extent to next_input_ids
							snake_case_		:					List[str]			    =						ids_tensor((self.batch_size, 3)      ,							config.vocab_size					)
							snake_case_		:					Optional[Any]			    =						tf.cast(ids_tensor((self.batch_size, 3)      ,							2					)      ,							tf.inta					)

							# append to next input_ids and
							snake_case_		:					Dict			    =						tf.concat([input_ids, next_tokens]      ,							axis=-1					)
							snake_case_		:					List[Any]			    =						tf.concat([attention_mask, next_attn_mask]      ,							axis=-1					)

							snake_case_		:					Dict			    =						model(__magic_name__      ,							attention_mask=__magic_name__					)[0]
							snake_case_		:					Dict			    =						model(__magic_name__      ,							attention_mask=__magic_name__      ,							past_key_values=__magic_name__					)[0]

							self.parent.assertEqual(next_tokens.shape[1]      ,							output_from_past.shape[1]					)

							# select random slice
							snake_case_		:					Any			    =						int(ids_tensor((1,)      ,							output_from_past.shape[-1]					)					)
							snake_case_		:					Optional[Any]			    =						output_from_no_past[:, -3:, random_slice_idx]
							snake_case_		:					Tuple			    =						output_from_past[:, :, random_slice_idx]

							# test that outputs are equal for slice
							tf.debugging.assert_near(__magic_name__      ,							__magic_name__      ,							rtol=1e-3					)






def   lowerCamelCase_		(       _UpperCamelCase				,       _UpperCamelCase				,       _UpperCamelCase				,       _UpperCamelCase=None				,       _UpperCamelCase=None				,       _UpperCamelCase=None				,       _UpperCamelCase=None				,       _UpperCamelCase=None				,       )	->		str:






				"""simple docstring"""


				if attention_mask is None:
								snake_case_		:					str			    =						tf.cast(tf.math.not_equal(_UpperCamelCase				,       config.pad_token_id				)				,       tf.inta				)
				if decoder_attention_mask is None:
								snake_case_		:					Optional[Any]			    =						tf.concat(
								    [
								        tf.ones(decoder_input_ids[:, :1].shape				,       dtype=tf.inta				),
								        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]				,       config.pad_token_id				)				,       tf.inta				),
								    ]				,       axis=-1				,       )
				if head_mask is None:
								snake_case_		:					str			    =						tf.ones((config.encoder_layers, config.encoder_attention_heads)				)
				if decoder_head_mask is None:
								snake_case_		:					Dict			    =						tf.ones((config.decoder_layers, config.decoder_attention_heads)				)
				if cross_attn_head_mask is None:
								snake_case_		:					List[Any]			    =						tf.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,
				    "head_mask": head_mask,
				    "decoder_head_mask": decoder_head_mask,
				    "cross_attn_head_mask": cross_attn_head_mask,
				}



@require_tf
class       __lowerCAmelCase (    _a,  _a,  unittest.TestCase  ):
			lowerCamelCase_  :  int     =   (TFMarianMTModel, TFMarianModel) if is_tf_available() else ()
			lowerCamelCase_  :  List[Any]     =   (TFMarianMTModel,) if is_tf_available() else ()
			lowerCamelCase_  :  Union[str, Any]     =   (
			    {
			        '''conversational''': TFMarianMTModel,
			        '''feature-extraction''': TFMarianModel,
			        '''summarization''': TFMarianMTModel,
			        '''text2text-generation''': TFMarianMTModel,
			        '''translation''': TFMarianMTModel,
			    }
			    if is_tf_available()
			    else {}
			)
			lowerCamelCase_  :  Optional[Any]     =   True
			lowerCamelCase_  :  Union[str, Any]     =   False
			lowerCamelCase_  :  List[Any]     =   False






			def     lowerCamelCase						(self					)  ->     str:


							'''simple docstring'''



							snake_case_		:					Dict			    =						TFMarianModelTester(self					)
							snake_case_		:					Tuple			    =						ConfigTester(self      ,							config_class=__magic_name__					)






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


							'''simple docstring'''



							self.config_tester.run_common_tests()






			def     lowerCamelCase						(self					)  ->     List[Any]:


							'''simple docstring'''



							snake_case_		:					Optional[int]			    =						self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.check_decoder_model_past_large_inputs(*__magic_name__					)




@require_tf
class       __lowerCAmelCase (    unittest.TestCase  ):
			lowerCamelCase_  :  List[Any]     =   1_000  # show more chars for failing integration tests






			@classmethod
			def     lowerCamelCase						(cls					)  ->     None:


							'''simple docstring'''



							snake_case_		:					Union[str, Any]			    =						F'''Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}'''
							return cls






			@cached_property
			def     lowerCamelCase						(self					)  ->     MarianTokenizer:


							'''simple docstring'''



							return AutoTokenizer.from_pretrained(self.model_name					)






			@property
			def     lowerCamelCase						(self					)  ->     int:


							'''simple docstring'''



							return self.tokenizer.eos_token_id






			@cached_property
			def     lowerCamelCase						(self					)  ->     str:


							'''simple docstring'''



							warnings.simplefilter('''error'''					)
							snake_case_		:					TFMarianMTModel			    =						TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name					)
							assert isinstance(__magic_name__      ,							__magic_name__					)
							snake_case_		:					Union[str, Any]			    =						model.config
							self.assertListEqual(c.bad_words_ids      ,							[[c.pad_token_id]]					)
							self.assertEqual(c.max_length      ,							512					)
							self.assertEqual(c.decoder_start_token_id      ,							c.pad_token_id					)
							return model






			def     lowerCamelCase						(self      ,							**__magic_name__					)  ->     Dict:


							'''simple docstring'''



							snake_case_		:					Any			    =						self.translate_src_text(**__magic_name__					)
							self.assertListEqual(self.expected_text      ,							__magic_name__					)






			def     lowerCamelCase						(self      ,							**__magic_name__					)  ->     str:


							'''simple docstring'''



							snake_case_		:					Optional[int]			    =						self.tokenizer(self.src_text      ,							**__magic_name__      ,							padding=__magic_name__      ,							return_tensors='''tf'''					)
							snake_case_		:					Dict			    =						self.model.generate(
							    model_inputs.input_ids      ,							attention_mask=model_inputs.attention_mask      ,							num_beams=2      ,							max_length=128					)
							snake_case_		:					Tuple			    =						self.tokenizer.batch_decode(generated_ids.numpy()      ,							skip_special_tokens=__magic_name__					)
							return generated_words




@require_sentencepiece
@require_tokenizers
@require_tf
class       __lowerCAmelCase (    _a  ):
			lowerCamelCase_  :  Union[str, Any]     =   '''mt'''
			lowerCamelCase_  :  Union[str, Any]     =   '''en'''
			lowerCamelCase_  :  Tuple     =   ['''Billi messu b\'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem.''']
			lowerCamelCase_  :  Dict     =   ['''Touching gently, Jesus healed a man who was affected by the sad disease of leprosy.''']






			@unittest.skip('''Skipping until #12647 is resolved.'''					)
			@slow
			def     lowerCamelCase						(self					)  ->     Optional[int]:


							'''simple docstring'''



							self._assert_generated_batch_equal_expected()




@require_sentencepiece
@require_tokenizers
@require_tf
class       __lowerCAmelCase (    _a  ):
			lowerCamelCase_  :  Tuple     =   '''en'''
			lowerCamelCase_  :  int     =   '''zh'''
			lowerCamelCase_  :  List[Any]     =   ['''My name is Wolfgang and I live in Berlin''']
			lowerCamelCase_  :  Any     =   ['''我叫沃尔夫冈 我住在柏林''']






			@unittest.skip('''Skipping until #12647 is resolved.'''					)
			@slow
			def     lowerCamelCase						(self					)  ->     Tuple:


							'''simple docstring'''



							self._assert_generated_batch_equal_expected()




@require_sentencepiece
@require_tokenizers
@require_tf
class       __lowerCAmelCase (    _a  ):
			lowerCamelCase_  :  Any     =   '''en'''
			lowerCamelCase_  :  Tuple     =   '''ROMANCE'''
			lowerCamelCase_  :  List[Any]     =   [
			    '''>>fr<< Don\'t spend so much time watching TV.''',
			    '''>>pt<< Your message has been sent.''',
			    '''>>es<< He\'s two years older than me.''',
			]
			lowerCamelCase_  :  Any     =   [
			    '''Ne passez pas autant de temps à regarder la télé.''',
			    '''A sua mensagem foi enviada.''',
			    '''Es dos años más viejo que yo.''',
			]






			@unittest.skip('''Skipping until #12647 is resolved.'''					)
			@slow
			def     lowerCamelCase						(self					)  ->     Optional[Any]:


							'''simple docstring'''



							self._assert_generated_batch_equal_expected()






			@unittest.skip('''Skipping until #12647 is resolved.'''					)
			@slow
			def     lowerCamelCase						(self					)  ->     Tuple:


							'''simple docstring'''



							snake_case_		:					Tuple			    =						TranslationPipeline(self.model      ,							self.tokenizer      ,							framework='''tf'''					)
							snake_case_		:					Tuple			    =						pipeline(self.src_text					)
							self.assertEqual(self.expected_text      ,							[x['''translation_text'''] for x in output]					)







from math import radians as angle_to_radians
from math import sin

# Acceleration Constant on Earth (unit m/s^2)
lowerCAmelCase_												=       9.80_665






def   lowerCamelCase_		(       _UpperCamelCase				,       _UpperCamelCase				)	->		None:






				"""simple docstring"""


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

				if not isinstance(_UpperCamelCase				,       (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   lowerCamelCase_		(       _UpperCamelCase				,       _UpperCamelCase				)	->		float:






				"""simple docstring"""


				check_args(_UpperCamelCase				,       _UpperCamelCase				)
				snake_case_		:					List[str]			    =						angle_to_radians(2 * angle				)
				return round(init_velocity**2 * sin(_UpperCamelCase				) / g				,       2				)






def   lowerCamelCase_		(       _UpperCamelCase				,       _UpperCamelCase				)	->		float:






				"""simple docstring"""


				check_args(_UpperCamelCase				,       _UpperCamelCase				)
				snake_case_		:					Tuple			    =						angle_to_radians(_UpperCamelCase				)
				return round(init_velocity**2 * sin(_UpperCamelCase				) ** 2 / (2 * g)				,       2				)






def   lowerCamelCase_		(       _UpperCamelCase				,       _UpperCamelCase				)	->		float:






				"""simple docstring"""


				check_args(_UpperCamelCase				,       _UpperCamelCase				)
				snake_case_		:					Optional[Any]			    =						angle_to_radians(_UpperCamelCase				)
				return round(2 * init_velocity * sin(_UpperCamelCase				) / g				,       2				)






def   lowerCamelCase_		(       )	->		None:






				"""simple docstring"""


				snake_case_    ,							snake_case_		:					Dict			    =						25, 20
				assert horizontal_distance(_UpperCamelCase				,       _UpperCamelCase				) == 40.97
				assert max_height(_UpperCamelCase				,       _UpperCamelCase				) == 3.73
				assert total_time(_UpperCamelCase				,       _UpperCamelCase				) == 1.74


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

	testmod()

	# Get input from user
	lowerCAmelCase_												=       float(input('''Initial Velocity: ''').strip())

	# Get input from user
	lowerCAmelCase_												=       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]''')
