
"""simple docstring"""







import json
import os
import random
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
       from PIL import Image

       from transformers import FlavaImageProcessor, FlavaProcessor
       from transformers.models.flava.image_processing_flava import (
           FLAVA_CODEBOOK_MEAN,
           FLAVA_CODEBOOK_STD,
           FLAVA_IMAGE_MEAN,
           FLAVA_IMAGE_STD,
       )



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




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



            """simple docstring"""

            UpperCAmelCase_						:    Union[str, Any]    					=  tempfile.mkdtemp()

            # fmt: off
            UpperCAmelCase_						:    Union[str, Any]    					=  ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing""", """,""", """low""", """lowest"""]
            # fmt: on
            UpperCAmelCase_						:    List[Any]    					=  os.path.join(self.tmpdirname     ,   VOCAB_FILES_NAMES["""vocab_file"""] )

            with open(self.vocab_file     ,   """w"""     ,   encoding="""utf-8""" ) as fp:
                 fp.write("""""".join([x + """\n""" for x in vocab_tokens] ) )

            UpperCAmelCase_						:    Union[str, Any]    					=  {
                """image_mean""": FLAVA_IMAGE_MEAN,
                """image_std""": FLAVA_IMAGE_STD,
                """do_normalize""": True,
                """do_resize""": True,
                """size""": 2_24,
                """do_center_crop""": True,
                """crop_size""": 2_24,
                """input_size_patches""": 14,
                """total_mask_patches""": 75,
                """mask_group_max_patches""": None,
                """mask_group_min_patches""": 16,
                """mask_group_min_aspect_ratio""": 0.3,
                """mask_group_max_aspect_ratio""": None,
                """codebook_do_resize""": True,
                """codebook_size""": 1_12,
                """codebook_do_center_crop""": True,
                """codebook_crop_size""": 1_12,
                """codebook_do_map_pixels""": True,
                """codebook_do_normalize""": True,
                """codebook_image_mean""": FLAVA_CODEBOOK_MEAN,
                """codebook_image_std""": FLAVA_CODEBOOK_STD,
            }

            UpperCAmelCase_						:    Tuple    					=  os.path.join(self.tmpdirname     ,   a_ )
            with open(self.image_processor_file     ,   """w"""     ,   encoding="""utf-8""" ) as fp:
                 json.dump(a_     ,   a_ )




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



            """simple docstring"""

            return BertTokenizer.from_pretrained(self.tmpdirname     ,   **a_ )




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



            """simple docstring"""

            return BertTokenizerFast.from_pretrained(self.tmpdirname     ,   **a_ )




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



            """simple docstring"""

            return FlavaImageProcessor.from_pretrained(self.tmpdirname     ,   **a_ )




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



            """simple docstring"""

            shutil.rmtree(self.tmpdirname )




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



            """simple docstring"""

            UpperCAmelCase_						:    str    					=  [np.random.randint(2_55     ,   size=(3, 30, 4_00)     ,   dtype=np.uinta )]

            UpperCAmelCase_						:    Tuple    					=  [Image.fromarray(np.moveaxis(a_     ,   0     ,   -1 ) ) for x in image_inputs]

            return image_inputs




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



            """simple docstring"""

            UpperCAmelCase_						:    int    					=  self.get_tokenizer()
            UpperCAmelCase_						:    Union[str, Any]    					=  self.get_rust_tokenizer()
            UpperCAmelCase_						:    Tuple    					=  self.get_image_processor()

            UpperCAmelCase_						:    Any    					=  FlavaProcessor(tokenizer=a_     ,   image_processor=a_ )
            processor_slow.save_pretrained(self.tmpdirname )
            UpperCAmelCase_						:    List[Any]    					=  FlavaProcessor.from_pretrained(self.tmpdirname     ,   use_fast=a_ )

            UpperCAmelCase_						:    List[Any]    					=  FlavaProcessor(tokenizer=a_     ,   image_processor=a_ )
            processor_fast.save_pretrained(self.tmpdirname )
            UpperCAmelCase_						:    Tuple    					=  FlavaProcessor.from_pretrained(self.tmpdirname )

            self.assertEqual(processor_slow.tokenizer.get_vocab()     ,   tokenizer_slow.get_vocab() )
            self.assertEqual(processor_fast.tokenizer.get_vocab()     ,   tokenizer_fast.get_vocab() )
            self.assertEqual(tokenizer_slow.get_vocab()     ,   tokenizer_fast.get_vocab() )
            self.assertIsInstance(processor_slow.tokenizer     ,   a_ )
            self.assertIsInstance(processor_fast.tokenizer     ,   a_ )

            self.assertEqual(processor_slow.image_processor.to_json_string()     ,   image_processor.to_json_string() )
            self.assertEqual(processor_fast.image_processor.to_json_string()     ,   image_processor.to_json_string() )
            self.assertIsInstance(processor_slow.image_processor     ,   a_ )
            self.assertIsInstance(processor_fast.image_processor     ,   a_ )




       def   a      ( self       : int )->					Tuple:



            """simple docstring"""

            UpperCAmelCase_						:    str    					=  FlavaProcessor(tokenizer=self.get_tokenizer()     ,   image_processor=self.get_image_processor() )
            processor.save_pretrained(self.tmpdirname )

            UpperCAmelCase_						:    Any    					=  self.get_tokenizer(bos_token="""(BOS)"""     ,   eos_token="""(EOS)""" )
            UpperCAmelCase_						:    List[Any]    					=  self.get_image_processor(do_normalize=a_     ,   padding_value=1.0 )

            UpperCAmelCase_						:    int    					=  FlavaProcessor.from_pretrained(
                self.tmpdirname     ,   bos_token="""(BOS)"""     ,   eos_token="""(EOS)"""     ,   do_normalize=a_     ,   padding_value=1.0 )

            self.assertEqual(processor.tokenizer.get_vocab()     ,   tokenizer_add_kwargs.get_vocab() )
            self.assertIsInstance(processor.tokenizer     ,   a_ )

            self.assertEqual(processor.image_processor.to_json_string()     ,   image_processor_add_kwargs.to_json_string() )
            self.assertIsInstance(processor.image_processor     ,   a_ )




       def   a      ( self       : Any )->					Any:



            """simple docstring"""

            UpperCAmelCase_						:    int    					=  self.get_image_processor()
            UpperCAmelCase_						:    Tuple    					=  self.get_tokenizer()

            UpperCAmelCase_						:    Optional[Any]    					=  FlavaProcessor(tokenizer=a_     ,   image_processor=a_ )

            UpperCAmelCase_						:    Tuple    					=  self.prepare_image_inputs()

            UpperCAmelCase_						:    Any    					=  image_processor(a_     ,   return_tensors="""np""" )
            UpperCAmelCase_						:    Union[str, Any]    					=  processor(images=a_     ,   return_tensors="""np""" )

            for key in input_feat_extract.keys():
                 self.assertAlmostEqual(input_feat_extract[key].sum()     ,   input_processor[key].sum()     ,   delta=1E-2 )

            # With rest of the args
            random.seed(12_34 )
            UpperCAmelCase_						:    Tuple    					=  image_processor(
                a_     ,   return_image_mask=a_     ,   return_codebook_pixels=a_     ,   return_tensors="""np""" )
            random.seed(12_34 )
            UpperCAmelCase_						:    List[str]    					=  processor(
                images=a_     ,   return_image_mask=a_     ,   return_codebook_pixels=a_     ,   return_tensors="""np""" )

            for key in input_feat_extract.keys():
                 self.assertAlmostEqual(input_feat_extract[key].sum()     ,   input_processor[key].sum()     ,   delta=1E-2 )




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



            """simple docstring"""

            UpperCAmelCase_						:    str    					=  self.get_image_processor()
            UpperCAmelCase_						:    List[str]    					=  self.get_tokenizer()

            UpperCAmelCase_						:    str    					=  FlavaProcessor(tokenizer=a_     ,   image_processor=a_ )

            UpperCAmelCase_						:    Optional[int]    					=  """lower newer"""

            UpperCAmelCase_						:    int    					=  processor(text=a_ )

            UpperCAmelCase_						:    Optional[Any]    					=  tokenizer(a_ )

            for key in encoded_tok.keys():
                 self.assertListEqual(encoded_tok[key]     ,   encoded_processor[key] )




       def   a      ( self       : str )->					str:



            """simple docstring"""

            UpperCAmelCase_						:    List[str]    					=  self.get_image_processor()
            UpperCAmelCase_						:    Optional[Any]    					=  self.get_tokenizer()

            UpperCAmelCase_						:    Union[str, Any]    					=  FlavaProcessor(tokenizer=a_     ,   image_processor=a_ )

            UpperCAmelCase_						:    Union[str, Any]    					=  """lower newer"""
            UpperCAmelCase_						:    List[str]    					=  self.prepare_image_inputs()

            UpperCAmelCase_						:    Dict    					=  processor(text=a_     ,   images=a_ )

            self.assertListEqual(list(inputs.keys() )     ,   ["""input_ids""", """token_type_ids""", """attention_mask""", """pixel_values"""] )

            # add extra args
            UpperCAmelCase_						:    Union[str, Any]    					=  processor(text=a_     ,   images=a_     ,   return_codebook_pixels=a_     ,   return_image_mask=a_ )

            self.assertListEqual(
                list(inputs.keys() )     ,   [
                    """input_ids""",
                    """token_type_ids""",
                    """attention_mask""",
                    """pixel_values""",
                    """codebook_pixel_values""",
                    """bool_masked_pos""",
                ]     ,   )

            # test if it raises when no input is passed
            with pytest.raises(a_ ):
                 processor()




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



            """simple docstring"""

            UpperCAmelCase_						:    str    					=  self.get_image_processor()
            UpperCAmelCase_						:    str    					=  self.get_tokenizer()

            UpperCAmelCase_						:    List[str]    					=  FlavaProcessor(tokenizer=a_     ,   image_processor=a_ )

            UpperCAmelCase_						:    int    					=  [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

            UpperCAmelCase_						:    List[Any]    					=  processor.batch_decode(a_ )
            UpperCAmelCase_						:    Union[str, Any]    					=  tokenizer.batch_decode(a_ )

            self.assertListEqual(a_     ,   a_ )






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



            """simple docstring"""

            UpperCAmelCase_						:    List[str]    					=  self.get_image_processor()
            UpperCAmelCase_						:    Dict    					=  self.get_tokenizer()

            UpperCAmelCase_						:    int    					=  FlavaProcessor(tokenizer=a_     ,   image_processor=a_ )

            UpperCAmelCase_						:    List[Any]    					=  """lower newer"""
            UpperCAmelCase_						:    List[str]    					=  self.prepare_image_inputs()

            UpperCAmelCase_						:    str    					=  processor(text=a_     ,   images=a_ )

            self.assertListEqual(list(inputs.keys() )     ,   processor.model_input_names )



"""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]""")

