


import argparse
import json
import re
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    MobileNetVaConfig,
    MobileNetVaForImageClassification,
    MobileNetVaForSemanticSegmentation,
    MobileNetVaImageProcessor,
    load_tf_weights_in_mobilenet_va,
)
from transformers.utils import logging


logging.set_verbosity_info()
lowerCamelCase		=	logging.get_logger(__name__)






def   lowerCamelCase_					( _a ):




		"""simple docstring"""






		lowerCAmelCase__     :    Dict					  =      MobileNetVaConfig(layer_norm_eps=0.0_01 )

		if "quant" in model_name:
				raise ValueError('''Quantized models are not supported.''' )

		lowerCAmelCase__     :    Optional[int]					  =      re.match(R'''^.*mobilenet_v2_([^_]*)_([^_]*)$'''			,     _a )
		if matches:
				lowerCAmelCase__     :    Tuple					  =      float(matches[1] )
				lowerCAmelCase__     :    List[Any]					  =      int(matches[2] )

		if model_name.startswith('''deeplabv3_''' ):
				lowerCAmelCase__     :    int					  =      8
				lowerCAmelCase__     :    str					  =      21
				lowerCAmelCase__     :    str					  =      '''pascal-voc-id2label.json'''
		else:
				# The TensorFlow version of MobileNetV2 predicts 1001 classes instead
				# of the usual 1000. The first class (index 0) is "background".
				lowerCAmelCase__     :    Optional[int]					  =      1_001
				lowerCAmelCase__     :    List[Any]					  =      '''imagenet-1k-id2label.json'''

		lowerCAmelCase__     :    Union[str, Any]					  =      '''huggingface/label-files'''
		lowerCAmelCase__     :    Any					  =      json.load(open(hf_hub_download(_a			,     _a			,     repo_type='''dataset''' )			,     '''r''' ) )

		if config.num_labels == 1_001:
				lowerCAmelCase__     :    Optional[Any]					  =      {int(_a ) + 1: v for k, v in idalabel.items()}
				lowerCAmelCase__     :    str					  =      '''background'''
		else:
				lowerCAmelCase__     :    Dict					  =      {int(_a ): v for k, v in idalabel.items()}

		lowerCAmelCase__     :    Any					  =      idalabel
		lowerCAmelCase__     :    str					  =      {v: k for k, v in idalabel.items()}

		return config






def   lowerCamelCase_					( ):




		"""simple docstring"""






		lowerCAmelCase__     :    List[str]					  =      '''http://images.cocodataset.org/val2017/000000039769.jpg'''
		lowerCAmelCase__     :    int					  =      Image.open(requests.get(_a			,     stream=_a ).raw )
		return im






@torch.no_grad()
def   lowerCamelCase_					( _a			,     _a			,     _a			,     _a=False ):




		"""simple docstring"""






		lowerCAmelCase__     :    int					  =      get_mobilenet_va_config(_a )

		# Load 🤗 model
		if model_name.startswith('''deeplabv3_''' ):
				lowerCAmelCase__     :    List[Any]					  =      MobileNetVaForSemanticSegmentation(_a ).eval()
		else:
				lowerCAmelCase__     :    str					  =      MobileNetVaForImageClassification(_a ).eval()

		# Load weights from TensorFlow checkpoint
		load_tf_weights_in_mobilenet_va(_a			,     _a			,     _a )

		# Check outputs on an image, prepared by MobileNetV2ImageProcessor
		lowerCAmelCase__     :    Optional[Any]					  =      MobileNetVaImageProcessor(
		    crop_size={'''width''': config.image_size, '''height''': config.image_size}			,     size={'''shortest_edge''': config.image_size + 32}			,     )
		lowerCAmelCase__     :    Dict					  =      image_processor(images=prepare_img()			,     return_tensors='''pt''' )
		lowerCAmelCase__     :    Optional[int]					  =      model(**_a )
		lowerCAmelCase__     :    Any					  =      outputs.logits

		if model_name.startswith('''deeplabv3_''' ):
				assert logits.shape == (1, 21, 65, 65)

				if model_name == "deeplabv3_mobilenet_v2_1.0_513":
						lowerCAmelCase__     :    Tuple					  =      torch.tensor(
						    [
						        [[17.57_90, 17.75_81, 18.33_55], [18.32_57, 18.42_30, 18.89_73], [18.61_69, 18.86_50, 19.21_87]],
						        [[-2.15_95, -2.09_77, -2.37_41], [-2.42_26, -2.30_28, -2.68_35], [-2.78_19, -2.59_91, -2.77_06]],
						        [[4.20_58, 4.83_17, 4.76_38], [4.41_36, 5.03_61, 4.93_83], [4.50_28, 4.96_44, 4.87_34]],
						    ] )

				else:
						raise ValueError(f'Unknown model name: {model_name}' )

				assert torch.allclose(logits[0, :3, :3, :3]			,     _a			,     atol=1e-4 )
		else:
				assert logits.shape == (1, 1_001)

				if model_name == "mobilenet_v2_1.4_224":
						lowerCAmelCase__     :    int					  =      torch.tensor([0.01_81, -1.00_15, 0.46_88] )
				elif model_name == "mobilenet_v2_1.0_224":
						lowerCAmelCase__     :    int					  =      torch.tensor([0.24_45, -1.19_93, 0.19_05] )
				elif model_name == "mobilenet_v2_0.75_160":
						lowerCAmelCase__     :    int					  =      torch.tensor([0.24_82, 0.41_36, 0.66_69] )
				elif model_name == "mobilenet_v2_0.35_96":
						lowerCAmelCase__     :    List[Any]					  =      torch.tensor([0.14_51, -0.46_24, 0.71_92] )
				else:
						lowerCAmelCase__     :    Tuple					  =      None

				if expected_logits is not None:
						assert torch.allclose(logits[0, :3]			,     _a			,     atol=1e-4 )

		Path(_a ).mkdir(exist_ok=_a )
		print(f'Saving model {model_name} to {pytorch_dump_folder_path}' )
		model.save_pretrained(_a )
		print(f'Saving image processor to {pytorch_dump_folder_path}' )
		image_processor.save_pretrained(_a )

		if push_to_hub:
				print('''Pushing to the hub...''' )
				lowerCAmelCase__     :    List[Any]					  =      '''google/''' + model_name
				image_processor.push_to_hub(_a )
				model.push_to_hub(_a )


if __name__ == "__main__":
		lowerCamelCase		=	argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '''--model_name''',
		    default='''mobilenet_v2_1.0_224''',
		    type=str,
		    help='''Name of the MobileNetV2 model you\'d like to convert. Should in the form \'mobilenet_v2_<depth>_<size>\'.''',
		)
		parser.add_argument(
		    '''--checkpoint_path''', required=True, type=str, help='''Path to the original TensorFlow checkpoint (.ckpt file).'''
		)
		parser.add_argument(
		    '''--pytorch_dump_folder_path''', required=True, type=str, help='''Path to the output PyTorch model directory.'''
		)
		parser.add_argument(
		    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
		)

		lowerCamelCase		=	parser.parse_args()
		convert_movilevit_checkpoint(
		    args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
		)








from math import radians as angle_to_radians
from math import sin

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






def   lowerCamelCase_					( _a			,     _a ):




		"""simple docstring"""






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

		if not isinstance(_a			,     (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_					( _a			,     _a ):




		"""simple docstring"""






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






def   lowerCamelCase_					( _a			,     _a ):




		"""simple docstring"""






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






def   lowerCamelCase_					( _a			,     _a ):




		"""simple docstring"""






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






def   lowerCamelCase_					( ):




		"""simple docstring"""






		lowerCAmelCase__  ,			lowerCAmelCase__     :    Optional[int]					  =      25, 20
		assert horizontal_distance(_a			,     _a ) == 40.97
		assert max_height(_a			,     _a ) == 3.73
		assert total_time(_a			,     _a ) == 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]''')




