





import collections

from .utils import ExplicitEnum, is_torch_available, logging


if is_torch_available():
				import torch


__lowerCAmelCase 	=      logging.get_logger(__name__)




class 	_UpperCAmelCase						:




					def __init__(    self     ,   __lowerCAmelCase     ,   __lowerCAmelCase=21     ,   __lowerCAmelCase=[]     ,   __lowerCAmelCase=None							)    ->	Tuple:
							UpperCamelCase__								=						model
							UpperCamelCase__								=						trace_batch_nums
							UpperCamelCase__								=						abort_after_batch_num

							# keep a LIFO buffer of frames to dump as soon as inf/nan is encountered to give context to the problem emergence
							UpperCamelCase__								=						collections.deque([]     ,   __lowerCAmelCase							)
							UpperCamelCase__								=						[]
							UpperCamelCase__								=						0
							UpperCamelCase__								=						0
							UpperCamelCase__								=						False
							UpperCamelCase__								=						"""                 """

							self.analyse_model()

							self.register_forward_hook()




					def 						snake_case_		(    self     ,   __lowerCAmelCase=None							)    ->	Any:
							if frame is not None:
									self.expand_frame(__lowerCAmelCase							)
							self.frames.append("""\n""".join(self.frame							)							)
							UpperCamelCase__								=						[]  # start a new frame




					def 						snake_case_		(    self     ,   __lowerCAmelCase							)    ->	int:
							self.frame.append(__lowerCAmelCase							)




					def 						snake_case_		(    self							)    ->	Union[str, Any]:
							print("""\n""".join(self.frames							)							)
							UpperCamelCase__								=						[]




					def 						snake_case_		(    self							)    ->	Union[str, Any]:
							UpperCamelCase__								=						[]




					def 						snake_case_		(    self							)    ->	List[str]:
							print(F"""\nDetected inf/nan during batch_number={self.batch_number}"""							)
							print(F"""Last {len(self.frames							)} forward frames:"""							)
							print(F"""{'abs min':8} {'abs max':8} metadata"""							)
							print("""\n""".join(self.frames							)							)
							print("""\n\n"""							)
							UpperCamelCase__								=						[]




					def 						snake_case_		(    self							)    ->	Union[str, Any]:
							# extract the fully qualified module names, to be able to report at run time. e.g.:
							# encoder.block.2.layer.0.SelfAttention.o
							#
							# for shared weights only the first shared module name will be registered
							UpperCamelCase__								=						{m: name for name, m in self.model.named_modules()}
							# self.longest_module_name = max(len(v) for v in self.module_names.values())




					def 						snake_case_		(    self     ,   __lowerCAmelCase     ,   __lowerCAmelCase							)    ->	List[Any]:
							if torch.is_tensor(__lowerCAmelCase							):
									self.expand_frame(get_abs_min_max(__lowerCAmelCase     ,   __lowerCAmelCase							)							)
									if detect_overflow(__lowerCAmelCase     ,   __lowerCAmelCase							):
											UpperCamelCase__								=						True
							elif var is None:
									self.expand_frame(F"""{'None':>17} {ctx}"""							)
							else:
									self.expand_frame(F"""{'not a tensor':>17} {ctx}"""							)




					def 						snake_case_		(    self							)    ->	Optional[Any]:
							self.expand_frame(F"""\n\n{self.prefix} *** Starting batch number={self.batch_number} ***"""							)
							self.expand_frame(F"""{'abs min':8} {'abs max':8} metadata"""							)




					def 						snake_case_		(    self							)    ->	int:
							self.expand_frame(F"""{self.prefix} *** Finished batch number={self.batch_number-1} ***\n\n"""							)




					def 						snake_case_		(    self     ,   __lowerCAmelCase     ,   __lowerCAmelCase     ,   __lowerCAmelCase							)    ->	Optional[Any]:
							self.expand_frame(F"""{self.prefix} {self.module_names[module]} {module.__class__.__name__}"""							)

							# params
							for name, p in module.named_parameters(recurse=__lowerCAmelCase							):
									self.analyse_variable(__lowerCAmelCase     ,   __lowerCAmelCase							)

							# inputs
							if isinstance(__lowerCAmelCase     ,   __lowerCAmelCase							):
									for i, x in enumerate(__lowerCAmelCase							):
											self.analyse_variable(__lowerCAmelCase     ,   F"""input[{i}]"""							)
							else:
									self.analyse_variable(__lowerCAmelCase     ,   """input"""							)

							# outputs
							if isinstance(__lowerCAmelCase     ,   __lowerCAmelCase							):
									for i, x in enumerate(__lowerCAmelCase							):
											# possibly a tuple of tuples
											if isinstance(__lowerCAmelCase     ,   __lowerCAmelCase							):
													for j, y in enumerate(__lowerCAmelCase							):
															self.analyse_variable(__lowerCAmelCase     ,   F"""output[{i}][{j}]"""							)
											else:
													self.analyse_variable(__lowerCAmelCase     ,   F"""output[{i}]"""							)
							else:
									self.analyse_variable(__lowerCAmelCase     ,   """output"""							)

							self.save_frame()




					def 						snake_case_		(    self							)    ->	Tuple:
							self.model.apply(self._register_forward_hook							)




					def 						snake_case_		(    self     ,   __lowerCAmelCase							)    ->	Optional[Any]:
							module.register_forward_hook(self.forward_hook							)




					def 						snake_case_		(    self     ,   __lowerCAmelCase     ,   __lowerCAmelCase     ,   __lowerCAmelCase							)    ->	Optional[int]:
							# - input is a tuple of packed inputs (could be non-Tensors)
							# - output could be a Tensor or a tuple of Tensors and non-Tensors

							UpperCamelCase__								=						False

							UpperCamelCase__								=						True if self.batch_number in self.trace_batch_nums else False
							if trace_mode:
									self.reset_saved_frames()

							if self.total_calls == 0:
									self.batch_start_frame()
							self.total_calls += 1

							# count batch numbers - the very first forward hook of the batch will be called when the
							# batch completes - i.e. it gets called very last - we know this batch has finished
							if module == self.model:
									self.batch_number += 1
									UpperCamelCase__								=						True

							self.create_frame(__lowerCAmelCase     ,   __lowerCAmelCase     ,   __lowerCAmelCase							)

							# if last_frame_of_batch:
							#     self.batch_end_frame()

							if trace_mode:
									self.trace_frames()

							if last_frame_of_batch:
									self.batch_start_frame()

							if self.detected_overflow and not trace_mode:
									self.dump_saved_frames()

									# now we can abort, as it's pointless to continue running
									raise ValueError(
									    """DebugUnderflowOverflow: inf/nan detected, aborting as there is no point running further. """
									    """Please scroll up above this traceback to see the activation values prior to this event."""							)

							# abort after certain batch if requested to do so
							if self.abort_after_batch_num is not None and self.batch_number > self.abort_after_batch_num:
									raise ValueError(
									    F"""DebugUnderflowOverflow: aborting after {self.batch_number} batches due to"""
									    F""" `abort_after_batch_num={self.abort_after_batch_num}` arg"""							)



def      a    (   _lowercase :  Any			,    _lowercase :  str							)  ->Dict:
		UpperCamelCase__								=						var.abs()
		return F"""{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}"""

def      a    (   _lowercase :  Optional[int]			,    _lowercase :  str							)  ->Optional[Any]:
		UpperCamelCase__								=						False
		if torch.isnan(_lowercase							).any().item():
				UpperCamelCase__								=						True
				print(F"""{ctx} has nans"""							)
		if torch.isinf(_lowercase							).any().item():
				UpperCamelCase__								=						True
				print(F"""{ctx} has infs"""							)

		# if needed to monitor large elements can enable the following
		if 0:  # and detected:
				UpperCamelCase__								=						var[torch.ge(var.abs()			,    1_0_0							)]
				if naaa.numel() > 0:
						print(F"""{ctx}:  n100={naaa.numel()}"""							)
				UpperCamelCase__								=						var[torch.ge(var.abs()			,    1_0_0_0							)]
				if naaaa.numel() > 0:
						print(F"""{ctx}: n1000={naaaa.numel()}"""							)
				UpperCamelCase__								=						var[torch.ge(var.abs()			,    1_0_0_0_0							)]
				if naaaaa.numel() > 0:
						print(F"""{ctx}: n10000={naaaaa.numel()}"""							)

		if 0:
				print(F"""min={var.min():9.2e} max={var.max():9.2e}"""							)

		if 0:
				print(F"""min={var.min():9.2e} max={var.max():9.2e} var={var.var():9.2e} mean={var.mean():9.2e} ({ctx})"""							)

		return detected




class 	_UpperCAmelCase						( _lowercase       ):
					__A        = "underflow_overflow"
					__A        = "tpu_metrics_debug"












import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


__lowerCAmelCase 	=      logging.get_logger(__name__)


__lowerCAmelCase 	=      {"vocab_file": "vocab.json", "merges_file": "merges.txt"}

# See all MVP models at https://huggingface.co/models?filter=mvp
__lowerCAmelCase 	=      {
    "vocab_file": {
        "RUCAIBox/mvp": "https://huggingface.co/RUCAIBox/mvp/resolve/main/vocab.json",
    },
    "added_tokens.json": {
        "RUCAIBox/mvp": "https://huggingface.co/RUCAIBox/mvp/resolve/main/added_tokens.json",
    },
    "merges_file": {
        "RUCAIBox/mvp": "https://huggingface.co/RUCAIBox/mvp/resolve/main/merges.txt",
    },
}

__lowerCAmelCase 	=      {
    "RUCAIBox/mvp": 1_024,
}

@lru_cache()
def      a    (   )  ->Any:
		UpperCamelCase__								=						(
		    list(range(ord("""!"""							)			,    ord("""~"""							) + 1							)							) + list(range(ord("""¡"""							)			,    ord("""¬"""							) + 1							)							) + list(range(ord("""®"""							)			,    ord("""ÿ"""							) + 1							)							)
		)
		UpperCamelCase__								=						bs[:]
		UpperCamelCase__								=						0
		for b in range(2**8							):
				if b not in bs:
						bs.append(_lowercase							)
						cs.append(2**8 + n							)
						n += 1
		UpperCamelCase__								=						[chr(_lowercase							) for n in cs]
		return dict(zip(_lowercase			,    _lowercase							)							)

def      a    (   _lowercase :  int							)  ->List[Any]:
		UpperCamelCase__								=						set()
		UpperCamelCase__								=						word[0]
		for char in word[1:]:
				pairs.add((prev_char, char)							)
				UpperCamelCase__								=						char
		return pairs




class 	_UpperCAmelCase						( _lowercase       ):
					__A        = VOCAB_FILES_NAMES
					__A        = PRETRAINED_VOCAB_FILES_MAP
					__A        = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					__A        = ["input_ids", "attention_mask"]




					def __init__(    self     ,   __lowerCAmelCase     ,   __lowerCAmelCase     ,   __lowerCAmelCase="replace"     ,   __lowerCAmelCase="<s>"     ,   __lowerCAmelCase="</s>"     ,   __lowerCAmelCase="</s>"     ,   __lowerCAmelCase="<s>"     ,   __lowerCAmelCase="<unk>"     ,   __lowerCAmelCase="<pad>"     ,   __lowerCAmelCase="<mask>"     ,   __lowerCAmelCase=False     ,   **__lowerCAmelCase     ,   )    ->	str:
							UpperCamelCase__								=						AddedToken(__lowerCAmelCase     ,   lstrip=__lowerCAmelCase     ,   rstrip=__lowerCAmelCase							) if isinstance(__lowerCAmelCase     ,   __lowerCAmelCase							) else bos_token
							UpperCamelCase__								=						AddedToken(__lowerCAmelCase     ,   lstrip=__lowerCAmelCase     ,   rstrip=__lowerCAmelCase							) if isinstance(__lowerCAmelCase     ,   __lowerCAmelCase							) else eos_token
							UpperCamelCase__								=						AddedToken(__lowerCAmelCase     ,   lstrip=__lowerCAmelCase     ,   rstrip=__lowerCAmelCase							) if isinstance(__lowerCAmelCase     ,   __lowerCAmelCase							) else sep_token
							UpperCamelCase__								=						AddedToken(__lowerCAmelCase     ,   lstrip=__lowerCAmelCase     ,   rstrip=__lowerCAmelCase							) if isinstance(__lowerCAmelCase     ,   __lowerCAmelCase							) else cls_token
							UpperCamelCase__								=						AddedToken(__lowerCAmelCase     ,   lstrip=__lowerCAmelCase     ,   rstrip=__lowerCAmelCase							) if isinstance(__lowerCAmelCase     ,   __lowerCAmelCase							) else unk_token
							UpperCamelCase__								=						AddedToken(__lowerCAmelCase     ,   lstrip=__lowerCAmelCase     ,   rstrip=__lowerCAmelCase							) if isinstance(__lowerCAmelCase     ,   __lowerCAmelCase							) else pad_token

							# Mask token behave like a normal word, i.e. include the space before it
							UpperCamelCase__								=						AddedToken(__lowerCAmelCase     ,   lstrip=__lowerCAmelCase     ,   rstrip=__lowerCAmelCase							) if isinstance(__lowerCAmelCase     ,   __lowerCAmelCase							) else mask_token

							super().__init__(
							    errors=__lowerCAmelCase     ,   bos_token=__lowerCAmelCase     ,   eos_token=__lowerCAmelCase     ,   unk_token=__lowerCAmelCase     ,   sep_token=__lowerCAmelCase     ,   cls_token=__lowerCAmelCase     ,   pad_token=__lowerCAmelCase     ,   mask_token=__lowerCAmelCase     ,   add_prefix_space=__lowerCAmelCase     ,   **__lowerCAmelCase     ,   )
							with open(__lowerCAmelCase     ,   encoding="""utf-8"""							) as vocab_handle:
									UpperCamelCase__								=						json.load(__lowerCAmelCase							)
							UpperCamelCase__								=						{v: k for k, v in self.encoder.items()}
							UpperCamelCase__								=						errors  # how to handle errors in decoding
							UpperCamelCase__								=						bytes_to_unicode()
							UpperCamelCase__								=						{v: k for k, v in self.byte_encoder.items()}
							with open(__lowerCAmelCase     ,   encoding="""utf-8"""							) as merges_handle:
									UpperCamelCase__								=						merges_handle.read().split("""\n"""							)[1:-1]
							UpperCamelCase__								=						[tuple(merge.split()							) for merge in bpe_merges]
							UpperCamelCase__								=						dict(zip(__lowerCAmelCase     ,   range(len(__lowerCAmelCase							)							)							)							)
							UpperCamelCase__								=						{}
							UpperCamelCase__								=						add_prefix_space

							# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
							UpperCamelCase__								=						re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""							)




					@property
					def 						snake_case_		(    self							)    ->	Union[str, Any]:
							return len(self.encoder							)




					def 						snake_case_		(    self							)    ->	Any:
							return dict(self.encoder     ,   **self.added_tokens_encoder							)




					def 						snake_case_		(    self     ,   __lowerCAmelCase							)    ->	List[str]:
							if token in self.cache:
									return self.cache[token]
							UpperCamelCase__								=						tuple(__lowerCAmelCase							)
							UpperCamelCase__								=						get_pairs(__lowerCAmelCase							)

							if not pairs:
									return token

							while True:
									UpperCamelCase__								=						min(__lowerCAmelCase     ,   key=lambda __lowerCAmelCase							: self.bpe_ranks.get(__lowerCAmelCase     ,   float("""inf"""							)							)							)
									if bigram not in self.bpe_ranks:
											break
									UpperCamelCase__	,      UpperCamelCase__								=						bigram
									UpperCamelCase__								=						[]
									UpperCamelCase__								=						0
									while i < len(__lowerCAmelCase							):
											try:
													UpperCamelCase__								=						word.index(__lowerCAmelCase     ,   __lowerCAmelCase							)
											except ValueError:
													new_word.extend(word[i:]							)
													break
											else:
													new_word.extend(word[i:j]							)
													UpperCamelCase__								=						j

											if word[i] == first and i < len(__lowerCAmelCase							) - 1 and word[i + 1] == second:
													new_word.append(first + second							)
													i += 2
											else:
													new_word.append(word[i]							)
													i += 1
									UpperCamelCase__								=						tuple(__lowerCAmelCase							)
									UpperCamelCase__								=						new_word
									if len(__lowerCAmelCase							) == 1:
											break
									else:
											UpperCamelCase__								=						get_pairs(__lowerCAmelCase							)
							UpperCamelCase__								=						""" """.join(__lowerCAmelCase							)
							UpperCamelCase__								=						word
							return word




					def 						snake_case_		(    self     ,   __lowerCAmelCase							)    ->	int:
							UpperCamelCase__								=						[]
							for token in re.findall(self.pat     ,   __lowerCAmelCase							):
									UpperCamelCase__								=						"""""".join(
									    self.byte_encoder[b] for b in token.encode("""utf-8"""							)							)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
									bpe_tokens.extend(bpe_token for bpe_token in self.bpe(__lowerCAmelCase							).split(""" """							)							)
							return bpe_tokens




					def 						snake_case_		(    self     ,   __lowerCAmelCase							)    ->	Dict:
							return self.encoder.get(__lowerCAmelCase     ,   self.encoder.get(self.unk_token							)							)




					def 						snake_case_		(    self     ,   __lowerCAmelCase							)    ->	Optional[Any]:
							return self.decoder.get(__lowerCAmelCase							)




					def 						snake_case_		(    self     ,   __lowerCAmelCase							)    ->	Any:
							UpperCamelCase__								=						"""""".join(__lowerCAmelCase							)
							UpperCamelCase__								=						bytearray([self.byte_decoder[c] for c in text]							).decode("""utf-8"""     ,   errors=self.errors							)
							return text




					def 						snake_case_		(    self     ,   __lowerCAmelCase     ,   __lowerCAmelCase = None							)    ->	Tuple[str]:
							if not os.path.isdir(__lowerCAmelCase							):
									logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""							)
									return
							UpperCamelCase__								=						os.path.join(
							    __lowerCAmelCase     ,   (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]							)
							UpperCamelCase__								=						os.path.join(
							    __lowerCAmelCase     ,   (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""]							)

							with open(__lowerCAmelCase     ,   """w"""     ,   encoding="""utf-8"""							) as f:
									f.write(json.dumps(self.encoder     ,   indent=2     ,   sort_keys=__lowerCAmelCase     ,   ensure_ascii=__lowerCAmelCase							) + """\n"""							)

							UpperCamelCase__								=						0
							with open(__lowerCAmelCase     ,   """w"""     ,   encoding="""utf-8"""							) as writer:
									writer.write("""#version: 0.2\n"""							)
									for bpe_tokens, token_index in sorted(self.bpe_ranks.items()     ,   key=lambda __lowerCAmelCase							: kv[1]							):
											if index != token_index:
													logger.warning(
													    F"""Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."""
													    """ Please check that the tokenizer is not corrupted!"""							)
													UpperCamelCase__								=						token_index
											writer.write(""" """.join(__lowerCAmelCase							) + """\n"""							)
											index += 1

							return vocab_file, merge_file




					def 						snake_case_		(    self     ,   __lowerCAmelCase     ,   __lowerCAmelCase = None							)    ->	List[int]:
							if token_ids_a is None:
									return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
							UpperCamelCase__								=						[self.cls_token_id]
							UpperCamelCase__								=						[self.sep_token_id]
							return cls + token_ids_a + sep + sep + token_ids_a + sep




					def 						snake_case_		(    self     ,   __lowerCAmelCase     ,   __lowerCAmelCase = None     ,   __lowerCAmelCase = False							)    ->	List[int]:
							if already_has_special_tokens:
									return super().get_special_tokens_mask(
									    token_ids_a=__lowerCAmelCase     ,   token_ids_a=__lowerCAmelCase     ,   already_has_special_tokens=__lowerCAmelCase							)

							if token_ids_a is None:
									return [1] + ([0] * len(__lowerCAmelCase							)) + [1]
							return [1] + ([0] * len(__lowerCAmelCase							)) + [1, 1] + ([0] * len(__lowerCAmelCase							)) + [1]




					def 						snake_case_		(    self     ,   __lowerCAmelCase     ,   __lowerCAmelCase = None							)    ->	List[int]:
							UpperCamelCase__								=						[self.sep_token_id]
							UpperCamelCase__								=						[self.cls_token_id]

							if token_ids_a is None:
									return len(cls + token_ids_a + sep							) * [0]
							return len(cls + token_ids_a + sep + sep + token_ids_a + sep							) * [0]




					def 						snake_case_		(    self     ,   __lowerCAmelCase     ,   __lowerCAmelCase=False     ,   **__lowerCAmelCase							)    ->	Optional[Any]:
							UpperCamelCase__								=						kwargs.pop("""add_prefix_space"""     ,   self.add_prefix_space							)
							if (is_split_into_words or add_prefix_space) and (len(__lowerCAmelCase							) > 0 and not text[0].isspace()):
									UpperCamelCase__								=						""" """ + text
							return (text, kwargs)





