



import logging
import os
from dataclasses import dataclass, field
from typing import Dict, List, Optional

import numpy as np
import torch
from utils_hans import HansDataset, InputFeatures, hans_processors, hans_tasks_num_labels

import transformers
from transformers import (
    AutoConfig,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    default_data_collator,
    set_seed,
)
from transformers.trainer_utils import is_main_process


A__  :  Optional[Any]       = logging.getLogger(__name__)



@dataclass
class     __snake_case						:






							"""simple docstring"""




							_a      				=			field(
							    metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''}						)
							_a      				=			field(
							    default=UpperCamelCase_						,metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''}						)
							_a      				=			field(
							    default=UpperCamelCase_						,metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''}						)
							_a      				=			field(
							    default=UpperCamelCase_						,metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''}						,)





@dataclass
class     __snake_case						:






							"""simple docstring"""




							_a      				=			field(
							    metadata={'''help''': '''The name of the task to train selected in the list: ''' + ''', '''.join(hans_processors.keys()						)}						)
							_a      				=			field(
							    metadata={'''help''': '''The input data dir. Should contain the .tsv files (or other data files) for the task.'''}						)
							_a      				=			field(
							    default=128						,metadata={
							        '''help''': (
							            '''The maximum total input sequence length after tokenization. Sequences longer '''
							            '''than this will be truncated, sequences shorter will be padded.'''
							        )
							    }						,)
							_a      				=			field(
							    default=UpperCamelCase_						,metadata={'''help''': '''Overwrite the cached training and evaluation sets'''}						)





def       UpperCamelCase(  __UpperCamelCase							:		List[InputFeatures]			):
		lowerCAmelCase_      :					List[Any]     =			default_data_collator(__UpperCamelCase			)
		lowerCAmelCase_      :					Dict     =			batch.pop('''pairID'''					,__UpperCamelCase			)
		return batch


def       UpperCamelCase(  ):
		# See all possible arguments in src/transformers/training_args.py
		# or by passing the --help flag to this script.
		# We now keep distinct sets of args, for a cleaner separation of concerns.

		lowerCAmelCase_      :					str     =			HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)			)
		lowerCAmelCase_      :					str     =			parser.parse_args_into_dataclasses()

		if (
		    os.path.exists(training_args.output_dir			)
		    and os.listdir(training_args.output_dir			)
		    and training_args.do_train
		    and not training_args.overwrite_output_dir
		):
				raise ValueError(
				    f"""Output directory ({training_args.output_dir}) already exists and is not empty. Use"""
				    ''' --overwrite_output_dir to overcome.'''			)

		# Setup logging
		logging.basicConfig(
		    format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s'''					,datefmt='''%m/%d/%Y %H:%M:%S'''					,level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN					,)
		logger.warning(
		    '''Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s'''					,training_args.local_rank					,training_args.device					,training_args.n_gpu					,bool(training_args.local_rank != -1			)					,training_args.fpaa					,)
		# Set the verbosity to info of the Transformers logger (on main process only):
		if is_main_process(training_args.local_rank			):
				transformers.utils.logging.set_verbosity_info()
				transformers.utils.logging.enable_default_handler()
				transformers.utils.logging.enable_explicit_format()
		logger.info('''Training/evaluation parameters %s'''					,__UpperCamelCase			)

		# Set seed
		set_seed(training_args.seed			)

		try:
				lowerCAmelCase_      :					int     =			hans_tasks_num_labels[data_args.task_name]
		except KeyError:
				raise ValueError('''Task not found: %s''' % (data_args.task_name)			)

		# Load pretrained model and tokenizer
		#
		# Distributed training:
		# The .from_pretrained methods guarantee that only one local process can concurrently
		# download model & vocab.

		lowerCAmelCase_      :					str     =			AutoConfig.from_pretrained(
		    model_args.config_name if model_args.config_name else model_args.model_name_or_path					,num_labels=__UpperCamelCase					,finetuning_task=data_args.task_name					,cache_dir=model_args.cache_dir					,)
		lowerCAmelCase_      :					int     =			AutoTokenizer.from_pretrained(
		    model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path					,cache_dir=model_args.cache_dir					,)
		lowerCAmelCase_      :					Dict     =			AutoModelForSequenceClassification.from_pretrained(
		    model_args.model_name_or_path					,from_tf=bool('''.ckpt''' in model_args.model_name_or_path			)					,config=__UpperCamelCase					,cache_dir=model_args.cache_dir					,)

		# Get datasets
		lowerCAmelCase_      :					Any     =			(
		    HansDataset(
		        data_dir=data_args.data_dir					,tokenizer=__UpperCamelCase					,task=data_args.task_name					,max_seq_length=data_args.max_seq_length					,overwrite_cache=data_args.overwrite_cache					,)
		    if training_args.do_train
		    else None
		)
		lowerCAmelCase_      :					List[str]     =			(
		    HansDataset(
		        data_dir=data_args.data_dir					,tokenizer=__UpperCamelCase					,task=data_args.task_name					,max_seq_length=data_args.max_seq_length					,overwrite_cache=data_args.overwrite_cache					,evaluate=__UpperCamelCase					,)
		    if training_args.do_eval
		    else None
		)

		# Initialize our Trainer
		lowerCAmelCase_      :					str     =			Trainer(
		    model=__UpperCamelCase					,args=__UpperCamelCase					,train_dataset=__UpperCamelCase					,eval_dataset=__UpperCamelCase					,data_collator=__UpperCamelCase					,)

		# Training
		if training_args.do_train:
				trainer.train(
				    model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path			) else None			)
				trainer.save_model()
				# For convenience, we also re-save the tokenizer to the same directory,
				# so that you can share your model easily on huggingface.co/models =)
				if trainer.is_world_master():
						tokenizer.save_pretrained(training_args.output_dir			)

    # Evaluation
		if training_args.do_eval:
				logger.info('''*** Evaluate ***'''			)

				lowerCAmelCase_      :					str     =			trainer.predict(__UpperCamelCase			)
				lowerCAmelCase_      :					Any     =			output.predictions
				lowerCAmelCase_      :					str     =			np.argmax(__UpperCamelCase					,axis=1			)

				lowerCAmelCase_      :					List[str]     =			[ex.pairID for ex in eval_dataset]
				lowerCAmelCase_      :					Dict     =			os.path.join(training_args.output_dir					,'''hans_predictions.txt'''			)
				lowerCAmelCase_      :					Tuple     =			eval_dataset.get_labels()
				if trainer.is_world_master():
						with open(__UpperCamelCase					,'''w'''			) as writer:
								writer.write('''pairID,gold_label\n'''			)
								for pid, pred in zip(__UpperCamelCase					,__UpperCamelCase			):
										writer.write('''ex''' + str(__UpperCamelCase			) + ''',''' + label_list[int(__UpperCamelCase			)] + '''\n'''			)

				trainer._log(output.metrics			)


def       UpperCamelCase(  __UpperCamelCase							:		str			):
		# For xla_spawn (TPUs)
		main()


if __name__ == "__main__":
						main()










from math import radians as angle_to_radians
from math import sin

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


def       UpperCamelCase(  __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       UpperCamelCase(  __UpperCamelCase							:		float					,__UpperCamelCase							:		float			):
		check_args(__UpperCamelCase					,__UpperCamelCase			)
		lowerCAmelCase_      :					Optional[Any]     =			angle_to_radians(2 * angle			)
		return round(init_velocity**2 * sin(__UpperCamelCase			) / g					,2			)


def       UpperCamelCase(  __UpperCamelCase							:		float					,__UpperCamelCase							:		float			):
		check_args(__UpperCamelCase					,__UpperCamelCase			)
		lowerCAmelCase_      :					Any     =			angle_to_radians(__UpperCamelCase			)
		return round(init_velocity**2 * sin(__UpperCamelCase			) ** 2 / (2 * g)					,2			)


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


def       UpperCamelCase(  ):
		lowerCAmelCase_ ,  lowerCAmelCase_      :					Any     =			25, 20
		assert horizontal_distance(__UpperCamelCase					,__UpperCamelCase			) == 4_0.9_7
		assert max_height(__UpperCamelCase					,__UpperCamelCase			) == 3.7_3
		assert total_time(__UpperCamelCase					,__UpperCamelCase			) == 1.7_4


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__  :  Dict       = 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]''')





