
'''simple docstring'''


import subprocess
from argparse import ArgumentParser
from typing import List, Union

from huggingface_hub.hf_api import HfFolder, create_repo, whoami
from requests.exceptions import HTTPError

from . import BaseTransformersCLICommand




class     __snake_case			(    _a	):




		@staticmethod
		def 	_snake_case	(  _SCREAMING_SNAKE_CASE					:Dict)					->			Union[str, Any]:






								'''simple docstring'''






								UpperCamelCase_     :	Dict					     =     parser.add_parser("""login"""			,    help="""Log in using the same credentials as on huggingface.co""")
								login_parser.set_defaults(func=lambda _SCREAMING_SNAKE_CASE: LoginCommand(_A))
								UpperCamelCase_     :	Union[str, Any]					     =     parser.add_parser("""whoami"""			,    help="""Find out which huggingface.co account you are logged in as.""")
								whoami_parser.set_defaults(func=lambda _SCREAMING_SNAKE_CASE: WhoamiCommand(_A))
								UpperCamelCase_     :	Optional[Any]					     =     parser.add_parser("""logout"""			,    help="""Log out""")
								logout_parser.set_defaults(func=lambda _SCREAMING_SNAKE_CASE: LogoutCommand(_A))

								# new system: git-based repo system
								UpperCamelCase_     :	Union[str, Any]					     =     parser.add_parser(
								    """repo"""			,    help="""Deprecated: use `huggingface-cli` instead. Commands to interact with your huggingface.co repos."""			,    )
								UpperCamelCase_     :	Optional[int]					     =     repo_parser.add_subparsers(
								    help="""Deprecated: use `huggingface-cli` instead. huggingface.co repos related commands""")
								UpperCamelCase_     :	List[Any]					     =     repo_subparsers.add_parser(
								    """create"""			,    help="""Deprecated: use `huggingface-cli` instead. Create a new repo on huggingface.co""")
								repo_create_parser.add_argument(
								    """name"""			,    type=_A			,    help="""Name for your model\'s repo. Will be namespaced under your username to build the model id."""			,    )
								repo_create_parser.add_argument("""--organization"""			,    type=_A			,    help="""Optional: organization namespace.""")
								repo_create_parser.add_argument("""-y"""			,    """--yes"""			,    action="""store_true"""			,    help="""Optional: answer Yes to the prompt""")
								repo_create_parser.set_defaults(func=lambda _SCREAMING_SNAKE_CASE: RepoCreateCommand(_A))







class     __snake_case			:
		a_          =					"\u001b[1m"
		a_          =					"\u001b[31m"
		a_          =					"\u001b[90m"
		a_          =					"\u001b[0m"




		@classmethod
		def 	_snake_case	(  cls					:Dict			,    _SCREAMING_SNAKE_CASE					:Tuple)					->			Optional[int]:






								'''simple docstring'''






								return F"""{cls._bold}{s}{cls._reset}"""




		@classmethod
		def 	_snake_case	(  cls					:Union[str, Any]			,    _SCREAMING_SNAKE_CASE					:int)					->			str:






								'''simple docstring'''






								return F"""{cls._bold}{cls._red}{s}{cls._reset}"""





		@classmethod
		def 	_snake_case	(  cls					:List[str]			,    _SCREAMING_SNAKE_CASE					:Union[str, Any])					->			Tuple:






								'''simple docstring'''






								return F"""{cls._gray}{s}{cls._reset}"""







def 					__magic_name__(       UpperCAmelCase__ :       int							,				UpperCAmelCase__ :       Any	):
						UpperCamelCase_     :	Optional[Any]					     =     [max(len(str(UpperCAmelCase__	)	) for x in col	) for col in zip(*UpperCAmelCase__							,				UpperCAmelCase__	)]
						UpperCamelCase_     :	str					     =     ("""{{:{}}} """ * len(UpperCAmelCase__	)).format(*UpperCAmelCase__	)
						UpperCamelCase_     :	Any					     =     []
						lines.append(row_format.format(*UpperCAmelCase__	)	)
						lines.append(row_format.format(*["""-""" * w for w in col_widths]	)	)
						for row in rows:
												lines.append(row_format.format(*UpperCAmelCase__	)	)
						return "\n".join(UpperCAmelCase__	)




class     __snake_case			:




		def __init__(  self					:int			,    _SCREAMING_SNAKE_CASE					:Optional[Any])					->			str:






								'''simple docstring'''






								UpperCamelCase_     :	int					     =     args







class     __snake_case			(    _a	):




		def 	_snake_case	(  self					:Tuple)					->			Dict:






								'''simple docstring'''






								print(
								    ANSI.red(
								        """ERROR! `huggingface-cli login` uses an outdated login mechanism """
								        """that is not compatible with the Hugging Face Hub backend anymore. """
								        """Please use `huggingface-cli login instead."""))







class     __snake_case			(    _a	):




		def 	_snake_case	(  self					:str)					->			List[str]:






								'''simple docstring'''






								print(
								    ANSI.red(
								        """WARNING! `transformers-cli whoami` is deprecated and will be removed in v5. Please use """
								        """`huggingface-cli whoami` instead."""))
								UpperCamelCase_     :	Any					     =     HfFolder.get_token()
								if token is None:
														print("""Not logged in""")
														exit()
								try:
														UpperCamelCase_     ,UpperCamelCase_     :	Optional[Any]					     =     whoami(_A)
														print(_A)
														if orgs:
																				print(ANSI.bold("""orgs: """)			,    """,""".join(_A))
								except HTTPError as e:
														print(_A)
														print(ANSI.red(e.response.text))
														exit(1)







class     __snake_case			(    _a	):




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






								'''simple docstring'''






								print(
								    ANSI.red(
								        """ERROR! `transformers-cli logout` uses an outdated logout mechanism """
								        """that is not compatible with the Hugging Face Hub backend anymore. """
								        """Please use `huggingface-cli logout instead."""))







class     __snake_case			(    _a	):




		def 	_snake_case	(  self					:Dict)					->			str:






								'''simple docstring'''






								print(
								    ANSI.red(
								        """WARNING! Managing repositories through transformers-cli is deprecated. """
								        """Please use `huggingface-cli` instead."""))
								UpperCamelCase_     :	Optional[int]					     =     HfFolder.get_token()
								if token is None:
														print("""Not logged in""")
														exit(1)
								try:
														UpperCamelCase_     :	List[Any]					     =     subprocess.check_output(["""git""", """--version"""]).decode("""utf-8""")
														print(ANSI.gray(stdout.strip()))
								except FileNotFoundError:
														print("""Looks like you do not have git installed, please install.""")

								try:
														UpperCamelCase_     :	Any					     =     subprocess.check_output(["""git-lfs""", """--version"""]).decode("""utf-8""")
														print(ANSI.gray(stdout.strip()))
								except FileNotFoundError:
														print(
														    ANSI.red(
														        """Looks like you do not have git-lfs installed, please install."""
														        """ You can install from https://git-lfs.github.com/."""
														        """ Then run `git lfs install` (you only have to do this once)."""))
								print("""""")

								UpperCamelCase_     ,UpperCamelCase_     :	Any					     =     whoami(_A)
								UpperCamelCase_     :	int					     =     self.args.organization if self.args.organization is not None else user
								UpperCamelCase_     :	Optional[Any]					     =     F"""{namespace}/{self.args.name}"""
								print(F"""You are about to create {ANSI.bold(_A)}""")

								if not self.args.yes:
														UpperCamelCase_     :	Dict					     =     input("""Proceed? [Y/n] """).lower()
														if not (choice == "" or choice == "y" or choice == "yes"):
																				print("""Abort""")
																				exit()
								try:
														UpperCamelCase_     :	Optional[int]					     =     create_repo(_A			,    name=self.args.name			,    organization=self.args.organization)
								except HTTPError as e:
														print(_A)
														print(ANSI.red(e.response.text))
														exit(1)
								print("""\nYour repo now lives at:""")
								print(F"""  {ANSI.bold(_A)}""")
								print("""\nYou can clone it locally with the command below, and commit/push as usual.""")
								print(F"""\n  git clone {url}""")
								print("""""")







import jax
import jax.numpy as jnp
from bigbird_flax import FlaxBigBirdForNaturalQuestions
from datasets import load_from_disk

from transformers import BigBirdTokenizerFast


lowerCamelCase   					=  {0: '''null''', 1: '''short''', 2: '''long''', 3: '''yes''', 4: '''no'''}
lowerCamelCase   					=  set(''''''.join(['''‘''', '''’''', '''´''', '''`''', '''.''', ''',''', '''-''', '''"''']))


def 							__lowercase     (	UpperCAmelCase__		,       UpperCAmelCase__=0		,       UpperCAmelCase__=None   ):

					"""simple docstring"""






					return [" ".join(x.split(' '   )[begin:end]   ) for x in answers if len(x.split(' '   )   ) > 1]


def 							__lowercase     (	UpperCAmelCase__		,       UpperCAmelCase__=False   ):

					"""simple docstring"""






					if make_sub_answers:
										# if answers are longer than one word, make sure a predictions is correct if it coresponds to the complete 1: or :-1 sub word
										# *e.g.* if the correct answer contains a prefix such as "the", or "a"
										__lowerCAmelCase       =				(
										    given_answers + get_sub_answers(UpperCAmelCase__		,       begin=1   ) + get_sub_answers(UpperCAmelCase__		,       end=-1   )
										)
					__lowerCAmelCase       =				[]
					for answer in given_answers:
										__lowerCAmelCase       =				answer.replace('_'		,       ' '   ).lower()
										__lowerCAmelCase       =				''.join(c if c not in PUNCTUATION_SET_TO_EXCLUDE else ' ' for c in alias   )
										answers.append(' '.join(alias.split()   ).strip()   )
					return set(UpperCAmelCase__   )


def 							__lowercase     (	UpperCAmelCase__		,       UpperCAmelCase__		,       UpperCAmelCase__=1		,       UpperCAmelCase__=100   ):

					"""simple docstring"""






					__lowerCAmelCase,						__lowerCAmelCase       =				jax.lax.top_k(UpperCAmelCase__		,       UpperCAmelCase__   )
					__lowerCAmelCase,						__lowerCAmelCase       =				jax.lax.top_k(UpperCAmelCase__		,       UpperCAmelCase__   )

					__lowerCAmelCase       =				best_end_idx[:, None] - best_start_idx[None, :]
					__lowerCAmelCase       =				jnp.logical_or(widths < 0		,       widths > max_size   )
					__lowerCAmelCase       =				(best_end_scores[:, None] + best_start_scores[None, :]) - (1E8 * mask)
					__lowerCAmelCase       =				jnp.argmax(UpperCAmelCase__   ).item()

					return best_start_idx[best_score % top_k], best_end_idx[best_score // top_k]


def 							__lowercase     (	UpperCAmelCase__   ):

					"""simple docstring"""






					__lowerCAmelCase       =				sample['question']['text']
					__lowerCAmelCase       =				sample['document']['tokens']['token']
					__lowerCAmelCase       =				sample['document']['tokens']['is_html']
					__lowerCAmelCase       =				sample['annotations']['long_answer']
					__lowerCAmelCase       =				sample['annotations']['short_answers']

					__lowerCAmelCase       =				' '.join([context[i] for i in range(len(UpperCAmelCase__   )   ) if not is_html[i]]   )

					# 0 - No ; 1 - Yes
					for answer in sample["annotations"]["yes_no_answer"]:
										if answer == 0 or answer == 1:
															return {
															    "question": question,
															    "context": context_string,
															    "short": [],
															    "long": [],
															    "category": "no" if answer == 0 else "yes",
															}

					__lowerCAmelCase       =				[]
					for s in short_answers:
										short_targets.extend(s['text']   )
					__lowerCAmelCase       =				list(set(UpperCAmelCase__   )   )

					__lowerCAmelCase       =				[]
					for s in long_answers:
										if s["start_token"] == -1:
															continue
										__lowerCAmelCase       =				context[s['start_token'] : s['end_token']]
										__lowerCAmelCase       =				is_html[s['start_token'] : s['end_token']]
										__lowerCAmelCase       =				' '.join([answer[i] for i in range(len(UpperCAmelCase__   )   ) if not html[i]]   )
										if new_answer not in long_targets:
															long_targets.append(UpperCAmelCase__   )

					__lowerCAmelCase       =				'long_short' if len(short_targets + long_targets   ) > 0 else 'null'

					return {
					    "question": question,
					    "context": context_string,
					    "short": short_targets,
					    "long": long_targets,
					    "category": category,
					}


def 							__lowercase     (	):

					"""simple docstring"""






					__lowerCAmelCase       =				load_from_disk('natural-questions-validation'   )
					__lowerCAmelCase       =				dataset.map(UpperCAmelCase__   ).remove_columns(['annotations', 'document', 'id']   )
					print(UpperCAmelCase__   )

					__lowerCAmelCase       =				dataset.filter(lambda UpperCAmelCase__   : (len(x['question']   ) + len(x['context']   )) < 4 * 4_096   )
					__lowerCAmelCase       =				short_validation_dataset.filter(lambda UpperCAmelCase__   : x["category"] != "null"   )
					short_validation_dataset

					__lowerCAmelCase       =				'vasudevgupta/flax-bigbird-natural-questions'
					__lowerCAmelCase       =				FlaxBigBirdForNaturalQuestions.from_pretrained(UpperCAmelCase__   )
					__lowerCAmelCase       =				BigBirdTokenizerFast.from_pretrained(UpperCAmelCase__   )

					@jax.jit
					def forward(*UpperCAmelCase__		,       **UpperCAmelCase__   ):
										__lowerCAmelCase,						__lowerCAmelCase,						__lowerCAmelCase       =				model(*UpperCAmelCase__		,       **UpperCAmelCase__   )
										return start_logits, end_logits, jnp.argmax(UpperCAmelCase__		,       axis=-1   )

					def evaluate(UpperCAmelCase__   ):
										# encode question and context so that they are separated by a tokenizer.sep_token and cut at max_length
										__lowerCAmelCase       =				tokenizer(
										    example['question']		,       example['context']		,       return_tensors='np'		,       max_length=4_096		,       padding='max_length'		,       truncation=UpperCAmelCase__		,       )

										__lowerCAmelCase,						__lowerCAmelCase,						__lowerCAmelCase       =				forward(**UpperCAmelCase__   )

										__lowerCAmelCase       =				CATEGORY_MAPPING[category.item()]

										__lowerCAmelCase       =				example['long'] + example['short']
										if example["category"] in ["yes", "no", "null"]:
															__lowerCAmelCase       =				[example['category']]
										__lowerCAmelCase       =				example['category'] != 'null'
										# Now target can be: "yes", "no", "null", "list of long & short answers"

										if predicted_category in ["yes", "no", "null"]:
															__lowerCAmelCase       =				[predicted_category]
															__lowerCAmelCase       =				example['output'] == example['targets']
															__lowerCAmelCase       =				predicted_category != 'null'
															return example

										__lowerCAmelCase       =				38 if predicted_category == 'short' else 1_024
										__lowerCAmelCase,						__lowerCAmelCase       =				get_best_valid_start_end_idx(
										    start_scores[0]		,       end_scores[0]		,       top_k=8		,       max_size=UpperCAmelCase__   )

										__lowerCAmelCase       =				inputs['input_ids'][0].tolist()
										__lowerCAmelCase       =				[tokenizer.decode(input_ids[start_score : end_score + 1]   )]

										__lowerCAmelCase       =				expand_to_aliases(example['targets']		,       make_sub_answers=UpperCAmelCase__   )
										__lowerCAmelCase       =				expand_to_aliases(example['output']   )

										# some preprocessing to both prediction and answer
										__lowerCAmelCase       =				{''.join(a.split()   ) for a in answers}
										__lowerCAmelCase       =				{''.join(p.split()   ) for p in predictions}
										__lowerCAmelCase       =				{s for s in predictions if s not in ['``', '\'\'', '`', '\'']}

										# if there is a common element, it's a exact match
										__lowerCAmelCase       =				len(list(answers & predictions   )   ) > 0
										__lowerCAmelCase       =				predicted_category != 'null' and len(UpperCAmelCase__   ) > 0

										return example

					__lowerCAmelCase       =				short_validation_dataset.map(UpperCAmelCase__   )

					__lowerCAmelCase       =				len(UpperCAmelCase__   )
					__lowerCAmelCase       =				len(short_validation_dataset.filter(lambda UpperCAmelCase__   : x["match"] == 1   )   )
					print('EM score:'		,       (matched / total) * 100		,       '%'   )


if __name__ == "__main__":
		main()






