


'''simple docstring'''







import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
      from tokenizers import Tokenizer
      from tokenizers.models import WordPiece

class       lowerCamelCase_							(	unittest.TestCase  ):






   '''simple docstring'''

   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase ):
       UpperCamelCase__      =			list(tokenizer_class.max_model_input_sizes.keys() )
       for model_name in sa_models[:1]:
           UpperCamelCase__      =			tokenizer_class.from_pretrained(__UpperCamelCase )
           self.assertIsNotNone(__UpperCamelCase )
           self.assertIsInstance(__UpperCamelCase     ,						__UpperCamelCase )
           self.assertIsInstance(__UpperCamelCase     ,						__UpperCamelCase )

           for special_tok in tokenizer.all_special_tokens:
               self.assertIsInstance(__UpperCamelCase     ,						__UpperCamelCase )
               UpperCamelCase__      =			tokenizer.convert_tokens_to_ids(__UpperCamelCase )
               self.assertIsInstance(__UpperCamelCase     ,						__UpperCamelCase )


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase     ,						__UpperCamelCase = None ):
       UpperCamelCase__      =			pickle.dumps(__UpperCamelCase )
       self.assertIsNotNone(__UpperCamelCase )

       UpperCamelCase__      =			pickle.loads(__UpperCamelCase )

       # Ensure is_fast is correctly restored
       self.assertEqual(be_restored.is_fast     ,						be_original.is_fast )

       # Ensure encodings are potentially correctly restored
       if be_original.is_fast:
           self.assertIsNotNone(be_restored.encodings )
       else:
           self.assertIsNone(be_restored.encodings )

       # Ensure the keys are the same
       for original_v, restored_v in zip(be_original.values()     ,						be_restored.values() ):
           if equal_op:
               self.assertTrue(equal_op(__UpperCamelCase     ,						__UpperCamelCase ) )
           else:
               self.assertEqual(__UpperCamelCase     ,						__UpperCamelCase )


   @slow
   def 	_UpperCamelCase       (  self ):
       self.check_tokenizer_from_pretrained(__UpperCamelCase )


   def 	_UpperCamelCase       (  self ):
       self.assertEqual(TensorType("tf" )     ,						TensorType.TENSORFLOW )
       self.assertEqual(TensorType("pt" )     ,						TensorType.PYTORCH )
       self.assertEqual(TensorType("np" )     ,						TensorType.NUMPY )


   @require_tokenizers
   def 	_UpperCamelCase       (  self ):
       import numpy as np

       UpperCamelCase__      =			BertTokenizer.from_pretrained("bert-base-cased" )
       UpperCamelCase__      =			BertTokenizerFast.from_pretrained("bert-base-cased" )

       # Python no tensor
       with self.subTest("BatchEncoding (Python, return_tensors=None)" ):
           self.assert_dump_and_restore(tokenizer_p("Small example to encode" ) )

       with self.subTest("BatchEncoding (Python, return_tensors=NUMPY)" ):
           self.assert_dump_and_restore(
               tokenizer_p("Small example to encode"     ,						return_tensors=TensorType.NUMPY )     ,						np.array_equal )

       with self.subTest("BatchEncoding (Rust, return_tensors=None)" ):
           self.assert_dump_and_restore(tokenizer_r("Small example to encode" ) )

       with self.subTest("BatchEncoding (Rust, return_tensors=NUMPY)" ):
           self.assert_dump_and_restore(
               tokenizer_r("Small example to encode"     ,						return_tensors=TensorType.NUMPY )     ,						np.array_equal )


   @require_tf
   @require_tokenizers
   def 	_UpperCamelCase       (  self ):
       import tensorflow as tf

       def tf_array_equals(__UpperCamelCase     ,						__UpperCamelCase ):
           return tf.reduce_all(tf.equal(__UpperCamelCase     ,						__UpperCamelCase ) )

       UpperCamelCase__      =			BertTokenizer.from_pretrained("bert-base-cased" )
       UpperCamelCase__      =			BertTokenizerFast.from_pretrained("bert-base-cased" )

       with self.subTest("BatchEncoding (Python, return_tensors=TENSORFLOW)" ):
           self.assert_dump_and_restore(
               tokenizer_p("Small example to encode"     ,						return_tensors=TensorType.TENSORFLOW )     ,						__UpperCamelCase )

       with self.subTest("BatchEncoding (Rust, return_tensors=TENSORFLOW)" ):
           self.assert_dump_and_restore(
               tokenizer_r("Small example to encode"     ,						return_tensors=TensorType.TENSORFLOW )     ,						__UpperCamelCase )


   @require_torch
   @require_tokenizers
   def 	_UpperCamelCase       (  self ):
       import torch

       UpperCamelCase__      =			BertTokenizer.from_pretrained("bert-base-cased" )
       UpperCamelCase__      =			BertTokenizerFast.from_pretrained("bert-base-cased" )

       with self.subTest("BatchEncoding (Python, return_tensors=PYTORCH)" ):
           self.assert_dump_and_restore(
               tokenizer_p("Small example to encode"     ,						return_tensors=TensorType.PYTORCH )     ,						torch.equal )

       with self.subTest("BatchEncoding (Rust, return_tensors=PYTORCH)" ):
           self.assert_dump_and_restore(
               tokenizer_r("Small example to encode"     ,						return_tensors=TensorType.PYTORCH )     ,						torch.equal )


   @require_tokenizers
   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			BertTokenizer.from_pretrained("bert-base-cased" )
       UpperCamelCase__      =			BertTokenizerFast.from_pretrained("bert-base-cased" )

       with self.subTest("Python Tokenizer" ):
           self.assertFalse(tokenizer_p("Small example to_encode" ).is_fast )

       with self.subTest("Rust Tokenizer" ):
           self.assertTrue(tokenizer_r("Small example to_encode" ).is_fast )


   @require_tokenizers
   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			BertTokenizerFast.from_pretrained("bert-base-cased" )
       UpperCamelCase__      =			tokenizer_r(["Test", "\xad", "test"]     ,						is_split_into_words=__UpperCamelCase )

       self.assertEqual(encoded.word_to_tokens(0 )     ,						TokenSpan(start=1     ,						end=2 ) )
       self.assertEqual(encoded.word_to_tokens(1 )     ,						__UpperCamelCase )
       self.assertEqual(encoded.word_to_tokens(2 )     ,						TokenSpan(start=2     ,						end=3 ) )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			BatchEncoding({"inputs": [[1, 2, 3], [4, 5, 6]], "labels": [0, 1]} )
       UpperCamelCase__      =			batch.convert_to_tensors(tensor_type="np" )
       self.assertEqual(tensor_batch["inputs"].shape     ,						(2, 3) )
       self.assertEqual(tensor_batch["labels"].shape     ,						(2,) )
       # test converting the converted
       with CaptureStderr() as cs:
           UpperCamelCase__      =			batch.convert_to_tensors(tensor_type="np" )
       self.assertFalse(len(cs.err )     ,						msg=f'should have no warning, but got {cs.err}' )

       UpperCamelCase__      =			BatchEncoding({"inputs": [1, 2, 3], "labels": 0} )
       UpperCamelCase__      =			batch.convert_to_tensors(tensor_type="np"     ,						prepend_batch_axis=__UpperCamelCase )
       self.assertEqual(tensor_batch["inputs"].shape     ,						(1, 3) )
       self.assertEqual(tensor_batch["labels"].shape     ,						(1,) )


   @require_torch
   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			BatchEncoding({"inputs": [[1, 2, 3], [4, 5, 6]], "labels": [0, 1]} )
       UpperCamelCase__      =			batch.convert_to_tensors(tensor_type="pt" )
       self.assertEqual(tensor_batch["inputs"].shape     ,						(2, 3) )
       self.assertEqual(tensor_batch["labels"].shape     ,						(2,) )
       # test converting the converted
       with CaptureStderr() as cs:
           UpperCamelCase__      =			batch.convert_to_tensors(tensor_type="pt" )
       self.assertFalse(len(cs.err )     ,						msg=f'should have no warning, but got {cs.err}' )

       UpperCamelCase__      =			BatchEncoding({"inputs": [1, 2, 3], "labels": 0} )
       UpperCamelCase__      =			batch.convert_to_tensors(tensor_type="pt"     ,						prepend_batch_axis=__UpperCamelCase )
       self.assertEqual(tensor_batch["inputs"].shape     ,						(1, 3) )
       self.assertEqual(tensor_batch["labels"].shape     ,						(1,) )


   @require_tf
   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			BatchEncoding({"inputs": [[1, 2, 3], [4, 5, 6]], "labels": [0, 1]} )
       UpperCamelCase__      =			batch.convert_to_tensors(tensor_type="tf" )
       self.assertEqual(tensor_batch["inputs"].shape     ,						(2, 3) )
       self.assertEqual(tensor_batch["labels"].shape     ,						(2,) )
       # test converting the converted
       with CaptureStderr() as cs:
           UpperCamelCase__      =			batch.convert_to_tensors(tensor_type="tf" )
       self.assertFalse(len(cs.err )     ,						msg=f'should have no warning, but got {cs.err}' )

       UpperCamelCase__      =			BatchEncoding({"inputs": [1, 2, 3], "labels": 0} )
       UpperCamelCase__      =			batch.convert_to_tensors(tensor_type="tf"     ,						prepend_batch_axis=__UpperCamelCase )
       self.assertEqual(tensor_batch["inputs"].shape     ,						(1, 3) )
       self.assertEqual(tensor_batch["labels"].shape     ,						(1,) )


   @require_flax
   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			BatchEncoding({"inputs": [[1, 2, 3], [4, 5, 6]], "labels": [0, 1]} )
       UpperCamelCase__      =			batch.convert_to_tensors(tensor_type="jax" )
       self.assertEqual(tensor_batch["inputs"].shape     ,						(2, 3) )
       self.assertEqual(tensor_batch["labels"].shape     ,						(2,) )
       # test converting the converted
       with CaptureStderr() as cs:
           UpperCamelCase__      =			batch.convert_to_tensors(tensor_type="jax" )
       self.assertFalse(len(cs.err )     ,						msg=f'should have no warning, but got {cs.err}' )

       UpperCamelCase__      =			BatchEncoding({"inputs": [1, 2, 3], "labels": 0} )
       UpperCamelCase__      =			batch.convert_to_tensors(tensor_type="jax"     ,						prepend_batch_axis=__UpperCamelCase )
       self.assertEqual(tensor_batch["inputs"].shape     ,						(1, 3) )
       self.assertEqual(tensor_batch["labels"].shape     ,						(1,) )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			[{"input_ids": np.array([0, 1, 2] )}, {"input_ids": np.array([0, 1, 2, 3] )}]
       UpperCamelCase__      =			BertTokenizer.from_pretrained("bert-base-cased" )

       UpperCamelCase__      =			tokenizer.pad(__UpperCamelCase     ,						padding=__UpperCamelCase )
       self.assertTrue(isinstance(batch["input_ids"]     ,						np.ndarray ) )
       self.assertEqual(batch["input_ids"].tolist()     ,						[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]] )
       UpperCamelCase__      =			tokenizer.pad(__UpperCamelCase     ,						padding=__UpperCamelCase     ,						return_tensors="np" )
       self.assertTrue(isinstance(batch["input_ids"]     ,						np.ndarray ) )
       self.assertEqual(batch["input_ids"].tolist()     ,						[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]] )


   @require_torch
   def 	_UpperCamelCase       (  self ):
       import torch

       UpperCamelCase__      =			[{"input_ids": torch.tensor([0, 1, 2] )}, {"input_ids": torch.tensor([0, 1, 2, 3] )}]
       UpperCamelCase__      =			BertTokenizer.from_pretrained("bert-base-cased" )

       UpperCamelCase__      =			tokenizer.pad(__UpperCamelCase     ,						padding=__UpperCamelCase )
       self.assertTrue(isinstance(batch["input_ids"]     ,						torch.Tensor ) )
       self.assertEqual(batch["input_ids"].tolist()     ,						[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]] )
       UpperCamelCase__      =			tokenizer.pad(__UpperCamelCase     ,						padding=__UpperCamelCase     ,						return_tensors="pt" )
       self.assertTrue(isinstance(batch["input_ids"]     ,						torch.Tensor ) )
       self.assertEqual(batch["input_ids"].tolist()     ,						[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]] )


   @require_tf
   def 	_UpperCamelCase       (  self ):
       import tensorflow as tf

       UpperCamelCase__      =			[{"input_ids": tf.constant([0, 1, 2] )}, {"input_ids": tf.constant([0, 1, 2, 3] )}]
       UpperCamelCase__      =			BertTokenizer.from_pretrained("bert-base-cased" )

       UpperCamelCase__      =			tokenizer.pad(__UpperCamelCase     ,						padding=__UpperCamelCase )
       self.assertTrue(isinstance(batch["input_ids"]     ,						tf.Tensor ) )
       self.assertEqual(batch["input_ids"].numpy().tolist()     ,						[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]] )
       UpperCamelCase__      =			tokenizer.pad(__UpperCamelCase     ,						padding=__UpperCamelCase     ,						return_tensors="tf" )
       self.assertTrue(isinstance(batch["input_ids"]     ,						tf.Tensor ) )
       self.assertEqual(batch["input_ids"].numpy().tolist()     ,						[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]] )


   @require_tokenizers
   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			Tokenizer(WordPiece(unk_token="[UNK]" ) )
       PreTrainedTokenizerFast(tokenizer_object=__UpperCamelCase )







   @require_tokenizers
   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			Tokenizer(WordPiece(unk_token="[UNK]" ) )
       with tempfile.TemporaryDirectory() as tmpdirname:
           bert_tokenizer.save(os.path.join(__UpperCamelCase     ,						"tokenizer.json" ) )
           PreTrainedTokenizerFast(tokenizer_file=os.path.join(__UpperCamelCase     ,						"tokenizer.json" ) )









'''simple docstring'''







from math import radians as angle_to_radians
from math import sin

# Acceleration Constant on Earth (unit m/s^2)
lowercase__     :  str    					=			9.8_0_6_6_5





def 						snake_case__ (lowerCAmelCase_					,  lowerCAmelCase_	):

    # Ensure valid instance
    if not isinstance(lowerCAmelCase_					,  (int, float)	):
        raise TypeError("Invalid velocity. Should be a positive number."	)

    if not isinstance(lowerCAmelCase_					,  (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 						snake_case__ (lowerCAmelCase_					,  lowerCAmelCase_	):
    check_args(lowerCAmelCase_					,  lowerCAmelCase_	)
    UpperCamelCase__      =			angle_to_radians(2 * angle	)
    return round(init_velocity**2 * sin(lowerCAmelCase_	) / g					,  2	)





def 						snake_case__ (lowerCAmelCase_					,  lowerCAmelCase_	):
    check_args(lowerCAmelCase_					,  lowerCAmelCase_	)
    UpperCamelCase__      =			angle_to_radians(lowerCAmelCase_	)
    return round(init_velocity**2 * sin(lowerCAmelCase_	) ** 2 / (2 * g)					,  2	)





def 						snake_case__ (lowerCAmelCase_					,  lowerCAmelCase_	):
    check_args(lowerCAmelCase_					,  lowerCAmelCase_	)
    UpperCamelCase__      =			angle_to_radians(lowerCAmelCase_	)
    return round(2 * init_velocity * sin(lowerCAmelCase_	) / g					,  2	)





def 						snake_case__ ():
    UpperCamelCase__    ,  UpperCamelCase__      =			25, 20
    assert horizontal_distance(lowerCAmelCase_					,  lowerCAmelCase_	) == 40.97
    assert max_height(lowerCAmelCase_					,  lowerCAmelCase_	) == 3.73
    assert total_time(lowerCAmelCase_					,  lowerCAmelCase_	) == 1.74


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

      testmod()

      # Get input from user
      lowercase__     :  Union[str, Any]    					=			float(input('Initial Velocity: ').strip())

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




