
import os
from typing import List, Union

import tensorflow as tf
from tensorflow_text import BertTokenizer as BertTokenizerLayer
from tensorflow_text import FastBertTokenizer, ShrinkLongestTrimmer, case_fold_utfa, combine_segments, pad_model_inputs

from .tokenization_bert import BertTokenizer



class       a_   ( tf.keras.layers.Layer						):






			def __init__(			self							, __UpperCamelCase							, __UpperCamelCase							, __UpperCamelCase = None							, __UpperCamelCase = None							, __UpperCamelCase = None							, __UpperCamelCase = "longest"							, __UpperCamelCase = True							, __UpperCamelCase = 512							, __UpperCamelCase = None							, __UpperCamelCase = True							, __UpperCamelCase = True							, __UpperCamelCase = True							, **__UpperCamelCase							, ):
									super().__init__()
									if use_fast_bert_tokenizer:
															_lowercase									=				FastBertTokenizer(
															    __UpperCamelCase							, token_out_type=tf.intaa							, lower_case_nfd_strip_accents=__UpperCamelCase							, **__UpperCamelCase     )
									else:
															_lowercase									=				tf.lookup.StaticVocabularyTable(
															    tf.lookup.KeyValueTensorInitializer(
															        keys=__UpperCamelCase							, key_dtype=tf.string							, values=tf.range(tf.size(__UpperCamelCase							, out_type=tf.intaa     )							, dtype=tf.intaa     )							, value_dtype=tf.intaa							, )							, num_oov_buckets=1							, )
															_lowercase									=				BertTokenizerLayer(
															    __UpperCamelCase							, token_out_type=tf.intaa							, lower_case=__UpperCamelCase							, **__UpperCamelCase     )

									_lowercase									=				vocab_list
									_lowercase									=				do_lower_case
									_lowercase									=				cls_token_id or vocab_list.index("""[CLS]"""     )
									_lowercase									=				sep_token_id or vocab_list.index("""[SEP]"""     )
									_lowercase									=				pad_token_id or vocab_list.index("""[PAD]"""     )
									_lowercase									=				ShrinkLongestTrimmer(max_length - 3							, axis=1     )  # Allow room for special tokens
									_lowercase									=				max_length
									_lowercase									=				padding
									_lowercase									=				truncation
									_lowercase									=				pad_to_multiple_of
									_lowercase									=				return_token_type_ids
									_lowercase									=				return_attention_mask






			@classmethod
			def       UpperCamelCase_							(			cls							, __UpperCamelCase							, **__UpperCamelCase     ):  # noqa: F821
									_lowercase									=				kwargs.pop("""do_lower_case"""							, __UpperCamelCase     )
									_lowercase									=				tokenizer.do_lower_case if do_lower_case is None else do_lower_case
									_lowercase									=				kwargs.pop("""cls_token_id"""							, __UpperCamelCase     )
									_lowercase									=				tokenizer.cls_token_id if cls_token_id is None else cls_token_id
									_lowercase									=				kwargs.pop("""sep_token_id"""							, __UpperCamelCase     )
									_lowercase									=				tokenizer.sep_token_id if sep_token_id is None else sep_token_id
									_lowercase									=				kwargs.pop("""pad_token_id"""							, __UpperCamelCase     )
									_lowercase									=				tokenizer.pad_token_id if pad_token_id is None else pad_token_id

									_lowercase									=				tokenizer.get_vocab()
									_lowercase									=				sorted([(wordpiece, idx) for wordpiece, idx in vocab.items()]							, key=lambda __UpperCamelCase     : x[1]     )
									_lowercase									=				[entry[0] for entry in vocab]
									return cls(
									    vocab_list=__UpperCamelCase							, do_lower_case=__UpperCamelCase							, cls_token_id=__UpperCamelCase							, sep_token_id=__UpperCamelCase							, pad_token_id=__UpperCamelCase							, **__UpperCamelCase							, )






			@classmethod
			def       UpperCamelCase_							(			cls							, __UpperCamelCase							, *__UpperCamelCase							, **__UpperCamelCase     ):
									try:
															_lowercase									=				BertTokenizer.from_pretrained(__UpperCamelCase							, *__UpperCamelCase							, **__UpperCamelCase     )
									except:  # noqa: E722
															from .tokenization_bert_fast import BertTokenizerFast

															_lowercase									=				BertTokenizerFast.from_pretrained(__UpperCamelCase							, *__UpperCamelCase							, **__UpperCamelCase     )
									return cls.from_tokenizer(__UpperCamelCase							, **__UpperCamelCase     )






			def       UpperCamelCase_							(			self							, __UpperCamelCase     ):
									if self.do_lower_case:
															_lowercase									=				case_fold_utfa(__UpperCamelCase     )
									_lowercase									=				self.tf_tokenizer.tokenize(__UpperCamelCase     )
									return tokens.merge_dims(1							, -1     )






			def       UpperCamelCase_							(			self							, __UpperCamelCase							, __UpperCamelCase=None							, __UpperCamelCase=None							, __UpperCamelCase=None							, __UpperCamelCase=None							, __UpperCamelCase=None							, __UpperCamelCase=None							, __UpperCamelCase=None							, ):
									if padding is None:
															_lowercase									=				self.padding
									if padding not in ("longest", "max_length"):
															raise ValueError("""Padding must be either 'longest' or 'max_length'!"""     )
									if max_length is not None and text_pair is not None:
															# Because we have to instantiate a Trimmer to do it properly
															raise ValueError("""max_length cannot be overridden at call time when truncating paired texts!"""     )
									if max_length is None:
															_lowercase									=				self.max_length
									if truncation is None:
															_lowercase									=				self.truncation
									if pad_to_multiple_of is None:
															_lowercase									=				self.pad_to_multiple_of
									if return_token_type_ids is None:
															_lowercase									=				self.return_token_type_ids
									if return_attention_mask is None:
															_lowercase									=				self.return_attention_mask
									if not isinstance(__UpperCamelCase							, tf.Tensor     ):
															_lowercase									=				tf.convert_to_tensor(__UpperCamelCase     )
									if text_pair is not None and not isinstance(__UpperCamelCase							, tf.Tensor     ):
															_lowercase									=				tf.convert_to_tensor(__UpperCamelCase     )
									if text_pair is not None:
															if text.shape.rank > 1:
																					raise ValueError("""text argument should not be multidimensional when a text pair is supplied!"""     )
															if text_pair.shape.rank > 1:
																					raise ValueError("""text_pair should not be multidimensional!"""     )
									if text.shape.rank == 2:
															_lowercase					,	_lowercase									=				text[:, 0], text[:, 1]
									_lowercase									=				self.unpaired_tokenize(__UpperCamelCase     )
									if text_pair is None:  # Unpaired text
															if truncation:
																					_lowercase									=				text[:, : max_length - 2]  # Allow room for special tokens
															_lowercase					,	_lowercase									=				combine_segments(
															    (text,)							, start_of_sequence_id=self.cls_token_id							, end_of_segment_id=self.sep_token_id     )
									else:  # Paired text
															_lowercase									=				self.unpaired_tokenize(__UpperCamelCase     )
															if truncation:
																					_lowercase					,	_lowercase									=				self.paired_trimmer.trim([text, text_pair]     )
															_lowercase					,	_lowercase									=				combine_segments(
															    (text, text_pair)							, start_of_sequence_id=self.cls_token_id							, end_of_segment_id=self.sep_token_id     )
									if padding == "longest":
															_lowercase									=				input_ids.bounding_shape(axis=1     )
															if pad_to_multiple_of is not None:
																					# No ceiling division in tensorflow, so we negate floordiv instead
																					_lowercase									=				pad_to_multiple_of * (-tf.math.floordiv(-pad_length							, __UpperCamelCase     ))
									else:
															_lowercase									=				max_length

									_lowercase					,	_lowercase									=				pad_model_inputs(__UpperCamelCase							, max_seq_length=__UpperCamelCase							, pad_value=self.pad_token_id     )
									_lowercase									=				{"""input_ids""": input_ids}
									if return_attention_mask:
															_lowercase									=				attention_mask
									if return_token_type_ids:
															_lowercase					,	_lowercase									=				pad_model_inputs(
															    __UpperCamelCase							, max_seq_length=__UpperCamelCase							, pad_value=self.pad_token_id     )
															_lowercase									=				token_type_ids
									return output






			def       UpperCamelCase_							(			self     ):
									return {
									    "vocab_list": self.vocab_list,
									    "do_lower_case": self.do_lower_case,
									    "cls_token_id": self.cls_token_id,
									    "sep_token_id": self.sep_token_id,
									    "pad_token_id": self.pad_token_id,
									}

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


A		:   int         =    {'''configuration_vilt''': ['''VILT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ViltConfig''']}

try:
		if not is_vision_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		A		:   int         =    ['''ViltFeatureExtractor''']
		A		:   List[Any]         =    ['''ViltImageProcessor''']
		A		:   Dict         =    ['''ViltProcessor''']

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		A		:   Tuple         =    [
		    '''VILT_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''ViltForImageAndTextRetrieval''',
		    '''ViltForImagesAndTextClassification''',
		    '''ViltForTokenClassification''',
		    '''ViltForMaskedLM''',
		    '''ViltForQuestionAnswering''',
		    '''ViltLayer''',
		    '''ViltModel''',
		    '''ViltPreTrainedModel''',
		]


if TYPE_CHECKING:
		from .configuration_vilt import VILT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViltConfig

		try:
				if not is_vision_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .feature_extraction_vilt import ViltFeatureExtractor
				from .image_processing_vilt import ViltImageProcessor
				from .processing_vilt import ViltProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_vilt import (
				    VILT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    ViltForImageAndTextRetrieval,
				    ViltForImagesAndTextClassification,
				    ViltForMaskedLM,
				    ViltForQuestionAnswering,
				    ViltForTokenClassification,
				    ViltLayer,
				    ViltModel,
				    ViltPreTrainedModel,
				)


else:
		import sys

		A		:   Dict         =    _LazyModule(__name__, globals()['''__file__'''], _import_structure)