



"""simple docstring"""







import os
import re
import warnings
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_ta import TaTokenizer
else:
							lowerCAmelCase_   						=   None


lowerCAmelCase_   						=   logging.get_logger(__name__)

lowerCAmelCase_   						=   {'vocab_file': 'spiece.model', 'tokenizer_file': 'tokenizer.json'}

lowerCAmelCase_   						=   {
    'vocab_file': {
        't5-small': 'https://huggingface.co/t5-small/resolve/main/spiece.model',
        't5-base': 'https://huggingface.co/t5-base/resolve/main/spiece.model',
        't5-large': 'https://huggingface.co/t5-large/resolve/main/spiece.model',
        't5-3b': 'https://huggingface.co/t5-3b/resolve/main/spiece.model',
        't5-11b': 'https://huggingface.co/t5-11b/resolve/main/spiece.model',
    },
    'tokenizer_file': {
        't5-small': 'https://huggingface.co/t5-small/resolve/main/tokenizer.json',
        't5-base': 'https://huggingface.co/t5-base/resolve/main/tokenizer.json',
        't5-large': 'https://huggingface.co/t5-large/resolve/main/tokenizer.json',
        't5-3b': 'https://huggingface.co/t5-3b/resolve/main/tokenizer.json',
        't5-11b': 'https://huggingface.co/t5-11b/resolve/main/tokenizer.json',
    },
}


# TODO(PVP) - this should be removed in Transformers v5
lowerCAmelCase_   						=   {
    't5-small': 512,
    't5-base': 512,
    't5-large': 512,
    't5-3b': 512,
    't5-11b': 512,
}
class        __A       (	A_    ):







		'''simple docstring'''





		lowerCAmelCase			:					Tuple   	=				VOCAB_FILES_NAMES
		lowerCAmelCase			:					Dict   	=				PRETRAINED_VOCAB_FILES_MAP
		lowerCAmelCase			:					List[Any]   	=				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		lowerCAmelCase			:					Optional[int]   	=				["input_ids", "attention_mask"]
		lowerCAmelCase			:					int   	=				TaTokenizer

		lowerCAmelCase			:					List[int]   	=				[]







		def __init__(	self						:  Any			,_snake_case						:  Optional[int]=None			,_snake_case						:  Dict=None			,_snake_case						:  Optional[Any]="</s>"			,_snake_case						:  Tuple="<unk>"			,_snake_case						:  str="<pad>"			,_snake_case						:  Optional[Any]=100			,_snake_case						:  str=None			,**_snake_case						:  str			,)					->		int:






				"""simple docstring"""



				if extra_ids > 0 and additional_special_tokens is None:
						lowercase__   :    Tuple				=			[f"""<extra_id_{i}>""" for i in range(_snake_case						)]
				elif extra_ids > 0 and additional_special_tokens is not None:
						# Check that we have the right number of extra special tokens
						lowercase__   :    List[Any]				=			len(set(filter(lambda _snake_case						: bool('''extra_id_''' in str(_snake_case						)						)			,_snake_case						)						)						)
						if extra_tokens != extra_ids:
								raise ValueError(
								    f"""Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are"""
								    ''' provided to T5Tokenizer. In this case the additional_special_tokens must include the extra_ids'''
								    ''' tokens'''						)

				super().__init__(
				    _snake_case			,tokenizer_file=_snake_case			,eos_token=_snake_case			,unk_token=_snake_case			,pad_token=_snake_case			,extra_ids=_snake_case			,additional_special_tokens=_snake_case			,**_snake_case			,)

				lowercase__   :    List[Any]				=			vocab_file
				lowercase__   :    int				=			False if not self.vocab_file else True
				lowercase__   :    List[str]				=			extra_ids







		@staticmethod
		def 					UpperCAmelCase    (	_snake_case						:  Union[str, Any]			,_snake_case						:  Optional[int]			,_snake_case						:  str						)					->		List[str]:






				"""simple docstring"""



				if pretrained_model_name_or_path in TaTokenizerFast.max_model_input_sizes:
						lowercase__   :    int				=			TaTokenizerFast.max_model_input_sizes[pretrained_model_name_or_path]
						if init_max_model_length is not None and init_max_model_length != max_model_length:
								return init_max_model_length
						elif init_max_model_length is None:
								warnings.warn(
								    '''This tokenizer was incorrectly instantiated with a model max length of'''
								    f""" {deprecated_max_model_length} which will be corrected in Transformers v5.\nFor now, this"""
								    ''' behavior is kept to avoid breaking backwards compatibility when padding/encoding with'''
								    ''' `truncation is True`.\n- Be aware that you SHOULD NOT rely on'''
								    f""" {pretrained_model_name_or_path} automatically truncating your input to"""
								    f""" {deprecated_max_model_length} when padding/encoding.\n- If you want to encode/pad to sequences"""
								    f""" longer than {deprecated_max_model_length} you can either instantiate this tokenizer with"""
								    ''' `model_max_length` or pass `max_length` when encoding/padding.\n- To avoid this warning, please'''
								    ''' instantiate this tokenizer with `model_max_length` set to your preferred value.'''			,_snake_case			,)

				return max_model_length







		def 					UpperCAmelCase    (	self						:  Optional[int]			,_snake_case						:  str			,_snake_case						:  Optional[str] = None						)					->		Tuple[str]:






				"""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(_snake_case						):
						logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""						)
						return
				lowercase__   :    Union[str, Any]				=			os.path.join(
				    _snake_case			,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']						)

				if os.path.abspath(self.vocab_file						) != os.path.abspath(_snake_case						):
						copyfile(self.vocab_file			,_snake_case						)
						logger.info(f"""Copy vocab file to {out_vocab_file}"""						)

				return (out_vocab_file,)







		def 					UpperCAmelCase    (	self						:  Dict			,_snake_case						:  List[int]			,_snake_case						:  Optional[List[int]] = None						)					->		List[int]:






				"""simple docstring"""



				lowercase__   :    Any				=			token_ids_a + [self.eos_token_id]
				if token_ids_a is None:
						return self.prefix_tokens + token_ids_a
				else:
						lowercase__   :    Dict				=			token_ids_a + [self.eos_token_id]
						return self.prefix_tokens + token_ids_a + token_ids_a







		def 					UpperCAmelCase    (	self						:  int			,_snake_case						:  List[int]			,_snake_case						:  Optional[List[int]] = None						)					->		List[int]:






				"""simple docstring"""



				lowercase__   :    Tuple				=			[self.eos_token_id]

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







		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		Union[str, Any]:






				"""simple docstring"""



				return list(
				    set(filter(lambda _snake_case						: bool(re.search(r'''<extra_id_\d+>'''			,_snake_case						)						) is not None			,self.additional_special_tokens						)						)						)







		def 					UpperCAmelCase    (	self						:  Any						)					->		Optional[int]:






				"""simple docstring"""



				return [self.convert_tokens_to_ids(_snake_case						) for token in self.get_sentinel_tokens()]





"""simple docstring"""







from ...configuration_utils import PretrainedConfig


lowerCAmelCase_   						=   {
    'google/tapas-base-finetuned-sqa': (
        'https://huggingface.co/google/tapas-base-finetuned-sqa/resolve/main/config.json'
    ),
    'google/tapas-base-finetuned-wtq': (
        'https://huggingface.co/google/tapas-base-finetuned-wtq/resolve/main/config.json'
    ),
    'google/tapas-base-finetuned-wikisql-supervised': (
        'https://huggingface.co/google/tapas-base-finetuned-wikisql-supervised/resolve/main/config.json'
    ),
    'google/tapas-base-finetuned-tabfact': (
        'https://huggingface.co/google/tapas-base-finetuned-tabfact/resolve/main/config.json'
    ),
}
class        __A       (	A_    ):







		'''simple docstring'''





		lowerCAmelCase			:					str   	=				"tapas"







		def __init__(	self						:  List[Any]			,_snake_case						:  Dict=30_522			,_snake_case						:  Union[str, Any]=768			,_snake_case						:  int=12			,_snake_case						:  Union[str, Any]=12			,_snake_case						:  Union[str, Any]=3_072			,_snake_case						:  List[Any]="gelu"			,_snake_case						:  Optional[int]=0.1			,_snake_case						:  Tuple=0.1			,_snake_case						:  List[Any]=1_024			,_snake_case						:  Any=[3, 256, 256, 2, 256, 256, 10]			,_snake_case						:  List[Any]=0.02			,_snake_case						:  Union[str, Any]=1e-12			,_snake_case						:  str=0			,_snake_case						:  Any=10.0			,_snake_case						:  int=0			,_snake_case						:  Optional[Any]=1.0			,_snake_case						:  List[str]=None			,_snake_case						:  Tuple=1.0			,_snake_case						:  Tuple=False			,_snake_case						:  List[Any]=None			,_snake_case						:  int=1.0			,_snake_case						:  List[Any]=1.0			,_snake_case						:  Optional[int]=False			,_snake_case						:  Optional[int]=False			,_snake_case						:  Optional[int]="ratio"			,_snake_case						:  Any=None			,_snake_case						:  Union[str, Any]=None			,_snake_case						:  List[str]=64			,_snake_case						:  Optional[Any]=32			,_snake_case						:  Optional[Any]=False			,_snake_case						:  Optional[int]=True			,_snake_case						:  Dict=False			,_snake_case						:  Tuple=False			,_snake_case						:  int=True			,_snake_case						:  List[str]=False			,_snake_case						:  Dict=None			,_snake_case						:  Optional[int]=None			,**_snake_case						:  int			,)					->		List[Any]:






				"""simple docstring"""



				super().__init__(pad_token_id=_snake_case			,**_snake_case						)

				# BERT hyperparameters (with updated max_position_embeddings and type_vocab_sizes)
				lowercase__   :    Optional[int]				=			vocab_size
				lowercase__   :    List[str]				=			hidden_size
				lowercase__   :    Any				=			num_hidden_layers
				lowercase__   :    Optional[Any]				=			num_attention_heads
				lowercase__   :    Optional[int]				=			hidden_act
				lowercase__   :    List[Any]				=			intermediate_size
				lowercase__   :    List[Any]				=			hidden_dropout_prob
				lowercase__   :    Dict				=			attention_probs_dropout_prob
				lowercase__   :    str				=			max_position_embeddings
				lowercase__   :    Dict				=			type_vocab_sizes
				lowercase__   :    Optional[Any]				=			initializer_range
				lowercase__   :    Dict				=			layer_norm_eps

				# Fine-tuning task hyperparameters
				lowercase__   :    Any				=			positive_label_weight
				lowercase__   :    int				=			num_aggregation_labels
				lowercase__   :    List[str]				=			aggregation_loss_weight
				lowercase__   :    Optional[int]				=			use_answer_as_supervision
				lowercase__   :    Optional[Any]				=			answer_loss_importance
				lowercase__   :    Union[str, Any]				=			use_normalized_answer_loss
				lowercase__   :    str				=			huber_loss_delta
				lowercase__   :    str				=			temperature
				lowercase__   :    int				=			aggregation_temperature
				lowercase__   :    List[Any]				=			use_gumbel_for_cells
				lowercase__   :    Tuple				=			use_gumbel_for_aggregation
				lowercase__   :    Union[str, Any]				=			average_approximation_function
				lowercase__   :    Union[str, Any]				=			cell_selection_preference
				lowercase__   :    Any				=			answer_loss_cutoff
				lowercase__   :    List[Any]				=			max_num_rows
				lowercase__   :    str				=			max_num_columns
				lowercase__   :    int				=			average_logits_per_cell
				lowercase__   :    str				=			select_one_column
				lowercase__   :    str				=			allow_empty_column_selection
				lowercase__   :    Any				=			init_cell_selection_weights_to_zero
				lowercase__   :    Optional[int]				=			reset_position_index_per_cell
				lowercase__   :    Union[str, Any]				=			disable_per_token_loss

				# Aggregation hyperparameters
				lowercase__   :    Optional[Any]				=			aggregation_labels
				lowercase__   :    List[Any]				=			no_aggregation_label_index

				if isinstance(self.aggregation_labels			,_snake_case						):
						lowercase__   :    Union[str, Any]				=			{int(_snake_case						): v for k, v in aggregation_labels.items()}
