
import argparse

import torch
from flax.training.checkpoints import restore_checkpoint

from transformers import FNetConfig, FNetForPreTraining
from transformers.utils import logging


logging.set_verbosity_info()



def      _a     (   __UpperCamelCase       :  str	,__UpperCamelCase       :  Dict	,__UpperCamelCase       :  int    ):
			# Initialise PyTorch model
			lowerCAmelCase__ :    List[Any]				      =			FNetConfig.from_json_file(__UpperCamelCase    )
			print(f'''Building PyTorch model from configuration: {config}'''    )
			lowerCAmelCase__ :    List[Any]				      =			FNetForPreTraining(__UpperCamelCase    )

			lowerCAmelCase__ :    Optional[Any]				      =			restore_checkpoint(__UpperCamelCase	,__UpperCamelCase    )
			lowerCAmelCase__ :    str				      =			checkpoint_dict['''target''']

			# Embeddings
			# Position IDs
			lowerCAmelCase__ :    int				      =			fnet_pretraining_model.state_dict()

			lowerCAmelCase__ :    List[Any]				      =			state_dict['''fnet.embeddings.position_ids''']
			lowerCAmelCase__ :    Tuple				      =			{'''fnet.embeddings.position_ids''': position_ids}
			# Embedding Layers
			lowerCAmelCase__ :    List[str]				      =			torch.tensor(
			    pretrained_model_params['''encoder''']['''embedder''']['''word''']['''embedding''']    )
			lowerCAmelCase__ :    Any				      =			torch.tensor(
			    pretrained_model_params['''encoder''']['''embedder''']['''position''']['''embedding'''][0]    )
			lowerCAmelCase__ :    Tuple				      =			torch.tensor(
			    pretrained_model_params['''encoder''']['''embedder''']['''type''']['''embedding''']    )
			lowerCAmelCase__ :    Union[str, Any]				      =			torch.tensor(
			    pretrained_model_params['''encoder''']['''embedder''']['''hidden_mapping_in''']['''kernel''']    ).T
			lowerCAmelCase__ :    Optional[Any]				      =			torch.tensor(
			    pretrained_model_params['''encoder''']['''embedder''']['''hidden_mapping_in''']['''bias''']    )
			lowerCAmelCase__ :    Tuple				      =			torch.tensor(
			    pretrained_model_params['''encoder''']['''embedder''']['''layer_norm''']['''scale''']    )
			lowerCAmelCase__ :    Union[str, Any]				      =			torch.tensor(
			    pretrained_model_params['''encoder''']['''embedder''']['''layer_norm''']['''bias''']    )

			# Encoder Layers
			for layer in range(config.num_hidden_layers    ):
						lowerCAmelCase__ :    str				      =			torch.tensor(
						    pretrained_model_params['''encoder'''][f'''encoder_{layer}''']['''mixing_layer_norm''']['''scale''']    )
						lowerCAmelCase__ :    str				      =			torch.tensor(
						    pretrained_model_params['''encoder'''][f'''encoder_{layer}''']['''mixing_layer_norm''']['''bias''']    )

						lowerCAmelCase__ :    Dict				      =			torch.tensor(
						    pretrained_model_params['''encoder'''][f'''feed_forward_{layer}''']['''intermediate''']['''kernel''']    ).T
						lowerCAmelCase__ :    Optional[int]				      =			torch.tensor(
						    pretrained_model_params['''encoder'''][f'''feed_forward_{layer}''']['''intermediate''']['''bias''']    )

						lowerCAmelCase__ :    List[str]				      =			torch.tensor(
						    pretrained_model_params['''encoder'''][f'''feed_forward_{layer}''']['''output''']['''kernel''']    ).T
						lowerCAmelCase__ :    List[str]				      =			torch.tensor(
						    pretrained_model_params['''encoder'''][f'''feed_forward_{layer}''']['''output''']['''bias''']    )

						lowerCAmelCase__ :    Optional[int]				      =			torch.tensor(
						    pretrained_model_params['''encoder'''][f'''encoder_{layer}''']['''output_layer_norm''']['''scale''']    )
						lowerCAmelCase__ :    int				      =			torch.tensor(
						    pretrained_model_params['''encoder'''][f'''encoder_{layer}''']['''output_layer_norm''']['''bias''']    )

			# Pooler Layers
			lowerCAmelCase__ :    Optional[Any]				      =			torch.tensor(pretrained_model_params['''encoder''']['''pooler''']['''kernel''']    ).T
			lowerCAmelCase__ :    Optional[int]				      =			torch.tensor(pretrained_model_params['''encoder''']['''pooler''']['''bias''']    )

			# Masked LM Layers
			lowerCAmelCase__ :    Optional[int]				      =			torch.tensor(
			    pretrained_model_params['''predictions_dense''']['''kernel''']    ).T
			lowerCAmelCase__ :    Optional[Any]				      =			torch.tensor(
			    pretrained_model_params['''predictions_dense''']['''bias''']    )
			lowerCAmelCase__ :    str				      =			torch.tensor(
			    pretrained_model_params['''predictions_layer_norm''']['''scale''']    )
			lowerCAmelCase__ :    Union[str, Any]				      =			torch.tensor(
			    pretrained_model_params['''predictions_layer_norm''']['''bias''']    )
			lowerCAmelCase__ :    str				      =			torch.tensor(
			    pretrained_model_params['''encoder''']['''embedder''']['''word''']['''embedding''']    )
			lowerCAmelCase__ :    int				      =			torch.tensor(
			    pretrained_model_params['''predictions_output''']['''output_bias''']    )
			lowerCAmelCase__ :    Union[str, Any]				      =			torch.tensor(pretrained_model_params['''predictions_output''']['''output_bias''']    )

			# Seq Relationship Layers
			lowerCAmelCase__ :    Union[str, Any]				      =			torch.tensor(
			    pretrained_model_params['''classification''']['''output_kernel''']    )
			lowerCAmelCase__ :    Optional[Any]				      =			torch.tensor(
			    pretrained_model_params['''classification''']['''output_bias''']    )

			# Load State Dict
			fnet_pretraining_model.load_state_dict(__UpperCamelCase    )

			# Save PreTrained
			print(f'''Saving pretrained model to {save_path}'''    )
			fnet_pretraining_model.save_pretrained(__UpperCamelCase    )


if __name__ == "__main__":
							A__       :   Tuple   						=					argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    """--flax_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
							)
							parser.add_argument(
							    """--fnet_config_file""",
							    default=None,
							    type=str,
							    required=True,
							    help=(
							        """The config json file corresponding to the pre-trained FNet model. \n"""
							        """This specifies the model architecture."""
							    ),
							)
							parser.add_argument("""--save_path""", default=None, type=str, required=True, help="""Path to the output model.""")
							A__       :   Dict   						=					parser.parse_args()
							convert_flax_checkpoint_to_pytorch(args.flax_checkpoint_path, args.fnet_config_file, args.save_path)





from math import radians as angle_to_radians
from math import sin

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



def      _a     (   __UpperCamelCase       :  float	,__UpperCamelCase       :  float    ):

			# Ensure valid instance
			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      _a     (   __UpperCamelCase       :  float	,__UpperCamelCase       :  float    ):
			check_args(__UpperCamelCase	,__UpperCamelCase    )
			lowerCAmelCase__ :    Union[str, Any]				      =			angle_to_radians(2 * angle    )
			return round(init_velocity**2 * sin(__UpperCamelCase    ) / g	,2    )



def      _a     (   __UpperCamelCase       :  float	,__UpperCamelCase       :  float    ):
			check_args(__UpperCamelCase	,__UpperCamelCase    )
			lowerCAmelCase__ :    List[str]				      =			angle_to_radians(__UpperCamelCase    )
			return round(init_velocity**2 * sin(__UpperCamelCase    ) ** 2 / (2 * g)	,2    )



def      _a     (   __UpperCamelCase       :  float	,__UpperCamelCase       :  float    ):
			check_args(__UpperCamelCase	,__UpperCamelCase    )
			lowerCAmelCase__ :    Dict				      =			angle_to_radians(__UpperCamelCase    )
			return round(2 * init_velocity * sin(__UpperCamelCase    ) / g	,2    )



def      _a     (   ):
			lowerCAmelCase__      ,				lowerCAmelCase__ :    List[Any]				      =			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
							A__       :   List[Any]   						=					float(input("""Initial Velocity: """).strip())

							# Get input from user
							A__       :   Optional[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]""")



