



import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
						from .tokenization_xglm import XGLMTokenizer
else:
						UpperCAmelCase_			      =  None


UpperCAmelCase_			      =  logging.get_logger(__name__)

UpperCAmelCase_			      =  {'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''}

UpperCAmelCase_			      =  {
    '''vocab_file''': {
        '''facebook/xglm-564M''': '''https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model''',
    },
    '''tokenizer_file''': {
        '''facebook/xglm-564M''': '''https://huggingface.co/facebook/xglm-564M/resolve/main/tokenizer.json''',
    },
}

UpperCAmelCase_			      =  {
    '''facebook/xglm-564M''': 2_048,
}





class 		__SCREAMING_SNAKE_CASE      (				lowercase__      ):






				"""simple docstring"""

				SCREAMING_SNAKE_CASE_ 				=  VOCAB_FILES_NAMES
				SCREAMING_SNAKE_CASE_ 				=  PRETRAINED_VOCAB_FILES_MAP
				SCREAMING_SNAKE_CASE_ 				=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				SCREAMING_SNAKE_CASE_ 				=  ['input_ids', 'attention_mask']
				SCREAMING_SNAKE_CASE_ 				=  XGLMTokenizer







				def __init__(				self						,	SCREAMING_SNAKE_CASE__=None						,	SCREAMING_SNAKE_CASE__=None						,	SCREAMING_SNAKE_CASE__="<s>"						,	SCREAMING_SNAKE_CASE__="</s>"						,	SCREAMING_SNAKE_CASE__="</s>"						,	SCREAMING_SNAKE_CASE__="<s>"						,	SCREAMING_SNAKE_CASE__="<unk>"						,	SCREAMING_SNAKE_CASE__="<pad>"						,	**SCREAMING_SNAKE_CASE__						,	):






					"""simple docstring"""

					_snake_case					:							Tuple					     =   7
					_snake_case					:							Optional[int]					     =   [f'''<madeupword{i}>''' for i in range(self.num_madeup_words      )]

					_snake_case					:							Tuple					     =   kwargs.get("""additional_special_tokens"""						,	[]      )
					kwargs["additional_special_tokens"] += [
					    word for word in madeup_words if word not in kwargs["additional_special_tokens"]
					]

					super().__init__(
					    SCREAMING_SNAKE_CASE__						,	tokenizer_file=SCREAMING_SNAKE_CASE__						,	bos_token=SCREAMING_SNAKE_CASE__						,	eos_token=SCREAMING_SNAKE_CASE__						,	sep_token=SCREAMING_SNAKE_CASE__						,	cls_token=SCREAMING_SNAKE_CASE__						,	unk_token=SCREAMING_SNAKE_CASE__						,	pad_token=SCREAMING_SNAKE_CASE__						,	**SCREAMING_SNAKE_CASE__						,	)

					_snake_case					:							str					     =   vocab_file
					_snake_case					:							Optional[Any]					     =   False if not self.vocab_file else True







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = None      ):






					"""simple docstring"""

					if token_ids_a is None:
						return [self.sep_token_id] + token_ids_a
					_snake_case					:							int					     =   [self.sep_token_id]
					return sep + token_ids_a + sep + sep + token_ids_a







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = None      ):






					"""simple docstring"""

					_snake_case					:							Dict					     =   [self.sep_token_id]

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







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = None      ):






					"""simple docstring"""

					if not self.can_save_slow_tokenizer:
						raise ValueError(
						    """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
						    """tokenizer."""      )

					if not os.path.isdir(SCREAMING_SNAKE_CASE__      ):
						logger.error(f'''Vocabulary path ({save_directory}) should be a directory.'''      )
						return
					_snake_case					:							Union[str, Any]					     =   os.path.join(
					    SCREAMING_SNAKE_CASE__						,	(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]      )

					if os.path.abspath(self.vocab_file      ) != os.path.abspath(SCREAMING_SNAKE_CASE__      ):
						copyfile(self.vocab_file						,	SCREAMING_SNAKE_CASE__      )

					return (out_vocab_file,)










from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


UpperCAmelCase_			      =  logging.get_logger(__name__)

UpperCAmelCase_			      =  {
    '''google/bigbird-pegasus-large-arxiv''': (
        '''https://huggingface.co/google/bigbird-pegasus-large-arxiv/resolve/main/config.json'''
    ),
    '''google/bigbird-pegasus-large-pubmed''': (
        '''https://huggingface.co/google/bigbird-pegasus-large-pubmed/resolve/main/config.json'''
    ),
    '''google/bigbird-pegasus-large-bigpatent''': (
        '''https://huggingface.co/google/bigbird-pegasus-large-bigpatent/resolve/main/config.json'''
    ),
    # See all BigBirdPegasus models at https://huggingface.co/models?filter=bigbird_pegasus
}





class 		__SCREAMING_SNAKE_CASE      (				lowercase__      ):






				"""simple docstring"""

				SCREAMING_SNAKE_CASE_ 				=  'bigbird_pegasus'
				SCREAMING_SNAKE_CASE_ 				=  ['past_key_values']
				SCREAMING_SNAKE_CASE_ 				=  {
				    'num_attention_heads': 'encoder_attention_heads',
				    'hidden_size': 'd_model',
				    'attention_probs_dropout_prob': 'attention_dropout',
				}







				def __init__(				self						,	SCREAMING_SNAKE_CASE__=9_61_03						,	SCREAMING_SNAKE_CASE__=40_96						,	SCREAMING_SNAKE_CASE__=16						,	SCREAMING_SNAKE_CASE__=40_96						,	SCREAMING_SNAKE_CASE__=16						,	SCREAMING_SNAKE_CASE__=16						,	SCREAMING_SNAKE_CASE__=40_96						,	SCREAMING_SNAKE_CASE__=16						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=True						,	SCREAMING_SNAKE_CASE__=True						,	SCREAMING_SNAKE_CASE__="gelu_new"						,	SCREAMING_SNAKE_CASE__=10_24						,	SCREAMING_SNAKE_CASE__=0.1						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=0.02						,	SCREAMING_SNAKE_CASE__=2						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=True						,	SCREAMING_SNAKE_CASE__=0						,	SCREAMING_SNAKE_CASE__=2						,	SCREAMING_SNAKE_CASE__=1						,	SCREAMING_SNAKE_CASE__="block_sparse"						,	SCREAMING_SNAKE_CASE__=64						,	SCREAMING_SNAKE_CASE__=3						,	SCREAMING_SNAKE_CASE__=False						,	**SCREAMING_SNAKE_CASE__						,	):






					"""simple docstring"""

					_snake_case					:							Dict					     =   vocab_size
					_snake_case					:							Any					     =   max_position_embeddings
					_snake_case					:							Any					     =   d_model
					_snake_case					:							Dict					     =   encoder_ffn_dim
					_snake_case					:							Union[str, Any]					     =   encoder_layers
					_snake_case					:							Optional[int]					     =   encoder_attention_heads
					_snake_case					:							Optional[int]					     =   decoder_ffn_dim
					_snake_case					:							List[Any]					     =   decoder_layers
					_snake_case					:							str					     =   decoder_attention_heads
					_snake_case					:							Optional[Any]					     =   dropout
					_snake_case					:							Optional[Any]					     =   attention_dropout
					_snake_case					:							int					     =   activation_dropout
					_snake_case					:							Any					     =   activation_function
					_snake_case					:							Optional[Any]					     =   init_std
					_snake_case					:							Tuple					     =   encoder_layerdrop
					_snake_case					:							List[Any]					     =   decoder_layerdrop
					_snake_case					:							Optional[Any]					     =   classifier_dropout
					_snake_case					:							List[Any]					     =   use_cache
					_snake_case					:							Union[str, Any]					     =   encoder_layers
					_snake_case					:							Union[str, Any]					     =   scale_embedding  # scale factor will be sqrt(d_model) if True

					# extra config
					_snake_case					:							str					     =   attention_type
					_snake_case					:							Tuple					     =   block_size
					_snake_case					:							List[Any]					     =   num_random_blocks
					_snake_case					:							List[str]					     =   use_bias

					super().__init__(
					    pad_token_id=SCREAMING_SNAKE_CASE__						,	bos_token_id=SCREAMING_SNAKE_CASE__						,	eos_token_id=SCREAMING_SNAKE_CASE__						,	is_encoder_decoder=SCREAMING_SNAKE_CASE__						,	decoder_start_token_id=SCREAMING_SNAKE_CASE__						,	**SCREAMING_SNAKE_CASE__						,	)





class 		__SCREAMING_SNAKE_CASE      (				lowercase__      ):






				"""simple docstring"""

				@property
				def 		__lowerCamelCase(				self      ):






					"""simple docstring"""

					if self.task in ["default", "seq2seq-lm"]:
						_snake_case					:							Dict					     =   OrderedDict(
						    [
						        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
						        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
						    ]      )

						if self.use_past:
							_snake_case					:							Any					     =   {0: """batch"""}
							_snake_case					:							str					     =   {0: """batch""", 1: """past_decoder_sequence + sequence"""}
						else:
							_snake_case					:							int					     =   {0: """batch""", 1: """decoder_sequence"""}
							_snake_case					:							Optional[Any]					     =   {0: """batch""", 1: """decoder_sequence"""}

						if self.use_past:
							self.fill_with_past_key_values_(SCREAMING_SNAKE_CASE__						,	direction="""inputs"""      )
					elif self.task == "causal-lm":
						# TODO: figure this case out.
						_snake_case					:							Any					     =   OrderedDict(
						    [
						        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
						        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
						    ]      )
						if self.use_past:
							_snake_case     , _snake_case					:							Tuple					     =   self.num_layers
							for i in range(SCREAMING_SNAKE_CASE__      ):
								_snake_case					:							Dict					     =   {0: """batch""", 2: """past_sequence + sequence"""}
								_snake_case					:							int					     =   {0: """batch""", 2: """past_sequence + sequence"""}
					else:
						_snake_case					:							Dict					     =   OrderedDict(
						    [
						        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
						        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
						        ("""decoder_input_ids""", {0: """batch""", 1: """decoder_sequence"""}),
						        ("""decoder_attention_mask""", {0: """batch""", 1: """decoder_sequence"""}),
						    ]      )

					return common_inputs







				@property
				def 		__lowerCamelCase(				self      ):






					"""simple docstring"""

					if self.task in ["default", "seq2seq-lm"]:
						_snake_case					:							str					     =   super().outputs
					else:
						_snake_case					:							List[Any]					     =   super(SCREAMING_SNAKE_CASE__						,	self      ).outputs
						if self.use_past:
							_snake_case     , _snake_case					:							List[str]					     =   self.num_layers
							for i in range(SCREAMING_SNAKE_CASE__      ):
								_snake_case					:							Optional[Any]					     =   {0: """batch""", 2: """past_sequence + sequence"""}
								_snake_case					:							List[str]					     =   {0: """batch""", 2: """past_sequence + sequence"""}
					return common_outputs







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = False						,	SCREAMING_SNAKE_CASE__ = None						,	):






					"""simple docstring"""

					_snake_case					:							Optional[Any]					     =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )

					# Generate decoder inputs
					_snake_case					:							Union[str, Any]					     =   seq_length if not self.use_past else 1
					_snake_case					:							Tuple					     =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )
					_snake_case					:							Union[str, Any]					     =   {f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
					_snake_case					:							Optional[int]					     =   dict(**SCREAMING_SNAKE_CASE__						,	**SCREAMING_SNAKE_CASE__      )

					if self.use_past:
						if not is_torch_available():
							raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""      )
						else:
							import torch
						_snake_case     , _snake_case					:							int					     =   common_inputs["""input_ids"""].shape
						_snake_case					:							List[Any]					     =   common_inputs["""decoder_input_ids"""].shape[1]
						_snake_case     , _snake_case					:							List[Any]					     =   self.num_attention_heads
						_snake_case					:							Any					     =   (
						    batch,
						    num_encoder_attention_heads,
						    encoder_seq_length,
						    self._config.hidden_size // num_encoder_attention_heads,
						)
						_snake_case					:							int					     =   decoder_seq_length + 3
						_snake_case					:							List[Any]					     =   (
						    batch,
						    num_decoder_attention_heads,
						    decoder_past_length,
						    self._config.hidden_size // num_decoder_attention_heads,
						)

						_snake_case					:							List[str]					     =   torch.cat(
						    [common_inputs["""decoder_attention_mask"""], torch.ones(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )]						,	dim=1      )

						_snake_case					:							Dict					     =   []
						# If the number of encoder and decoder layers are present in the model configuration, both are considered
						_snake_case     , _snake_case					:							str					     =   self.num_layers
						_snake_case					:							Any					     =   min(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )
						_snake_case					:							Any					     =   max(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      ) - min_num_layers
						_snake_case					:							Union[str, Any]					     =   """encoder""" if num_encoder_layers > num_decoder_layers else """decoder"""

						for _ in range(SCREAMING_SNAKE_CASE__      ):
							common_inputs["past_key_values"].append(
							    (
							        torch.zeros(SCREAMING_SNAKE_CASE__      ),
							        torch.zeros(SCREAMING_SNAKE_CASE__      ),
							        torch.zeros(SCREAMING_SNAKE_CASE__      ),
							        torch.zeros(SCREAMING_SNAKE_CASE__      ),
							    )      )
						# TODO: test this.
						_snake_case					:							List[Any]					     =   encoder_shape if remaining_side_name == """encoder""" else decoder_shape
						for _ in range(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      ):
							common_inputs["past_key_values"].append((torch.zeros(SCREAMING_SNAKE_CASE__      ), torch.zeros(SCREAMING_SNAKE_CASE__      ))      )
					return common_inputs







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = False						,	SCREAMING_SNAKE_CASE__ = None						,	):






					"""simple docstring"""

					_snake_case					:							Tuple					     =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )

					if self.use_past:
						if not is_torch_available():
							raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""      )
						else:
							import torch
						_snake_case     , _snake_case					:							Optional[Any]					     =   common_inputs["""input_ids"""].shape
						# Not using the same length for past_key_values
						_snake_case					:							Dict					     =   seqlen + 2
						_snake_case     , _snake_case					:							Optional[int]					     =   self.num_layers
						_snake_case     , _snake_case					:							List[Any]					     =   self.num_attention_heads
						_snake_case					:							str					     =   (
						    batch,
						    num_encoder_attention_heads,
						    past_key_values_length,
						    self._config.hidden_size // num_encoder_attention_heads,
						)

						_snake_case					:							Optional[int]					     =   common_inputs["""attention_mask"""].dtype
						_snake_case					:							str					     =   torch.cat(
						    [common_inputs["""attention_mask"""], torch.ones(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	dtype=SCREAMING_SNAKE_CASE__      )]						,	dim=1      )
						_snake_case					:							Tuple					     =   [
						    (torch.zeros(SCREAMING_SNAKE_CASE__      ), torch.zeros(SCREAMING_SNAKE_CASE__      )) for _ in range(SCREAMING_SNAKE_CASE__      )
						]
					return common_inputs







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = False						,	SCREAMING_SNAKE_CASE__ = None						,	):






					"""simple docstring"""

					_snake_case					:							Optional[int]					     =   compute_effective_axis_dimension(
					    SCREAMING_SNAKE_CASE__						,	fixed_dimension=OnnxConfig.default_fixed_batch						,	num_token_to_add=0      )

					# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
					_snake_case					:							List[str]					     =   tokenizer.num_special_tokens_to_add(SCREAMING_SNAKE_CASE__      )
					_snake_case					:							Tuple					     =   compute_effective_axis_dimension(
					    SCREAMING_SNAKE_CASE__						,	fixed_dimension=OnnxConfig.default_fixed_sequence						,	num_token_to_add=SCREAMING_SNAKE_CASE__      )

					# Generate dummy inputs according to compute batch and sequence
					_snake_case					:							str					     =   [""" """.join([tokenizer.unk_token]      ) * seq_length] * batch_size
					_snake_case					:							Optional[int]					     =   dict(tokenizer(SCREAMING_SNAKE_CASE__						,	return_tensors=SCREAMING_SNAKE_CASE__      )      )
					return common_inputs







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = False						,	SCREAMING_SNAKE_CASE__ = None						,	):






					"""simple docstring"""

					if self.task in ["default", "seq2seq-lm"]:
						_snake_case					:							int					     =   self._generate_dummy_inputs_for_default_and_seqaseq_lm(
						    SCREAMING_SNAKE_CASE__						,	batch_size=SCREAMING_SNAKE_CASE__						,	seq_length=SCREAMING_SNAKE_CASE__						,	is_pair=SCREAMING_SNAKE_CASE__						,	framework=SCREAMING_SNAKE_CASE__      )

					elif self.task == "causal-lm":
						_snake_case					:							List[Any]					     =   self._generate_dummy_inputs_for_causal_lm(
						    SCREAMING_SNAKE_CASE__						,	batch_size=SCREAMING_SNAKE_CASE__						,	seq_length=SCREAMING_SNAKE_CASE__						,	is_pair=SCREAMING_SNAKE_CASE__						,	framework=SCREAMING_SNAKE_CASE__      )
					else:
						_snake_case					:							Dict					     =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
						    SCREAMING_SNAKE_CASE__						,	batch_size=SCREAMING_SNAKE_CASE__						,	seq_length=SCREAMING_SNAKE_CASE__						,	is_pair=SCREAMING_SNAKE_CASE__						,	framework=SCREAMING_SNAKE_CASE__      )

					return common_inputs







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      ):






					"""simple docstring"""

					if self.task in ["default", "seq2seq-lm"]:
						_snake_case					:							Union[str, Any]					     =   super()._flatten_past_key_values_(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )
					else:
						_snake_case					:							int					     =   super(SCREAMING_SNAKE_CASE__						,	self      )._flatten_past_key_values_(
						    SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )





