





'''simple docstring'''




import json
import os
import shutil
import tempfile
import unittest

import numpy as np

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer
from transformers.testing_utils import require_tokenizers, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
  from PIL import Image

  from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor


@require_tokenizers
@require_vision
class 					SCREAMING_SNAKE_CASE       (unittest.TestCase				):


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Tuple						=			tempfile.mkdtemp()

          # fmt: off
          __A		:					List[Any]						=			['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing', ',', 'low', 'lowest']
          # fmt: on
          __A		:					List[str]						=			os.path.join(self.tmpdirname		,      VOCAB_FILES_NAMES['vocab_file'])
          with open(self.vocab_file		,      'w'		,      encoding='utf-8') as vocab_writer:
               vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]))

          __A		:					List[Any]						=			{
              'do_resize': True,
              'size': {'height': 18, 'width': 18},
              'do_normalize': True,
              'image_mean': [0.5, 0.5, 0.5],
              'image_std': [0.5, 0.5, 0.5],
          }
          __A		:					int						=			os.path.join(self.tmpdirname		,      _UpperCAmelCase)
          with open(self.image_processor_file		,      'w'		,      encoding='utf-8') as fp:
               json.dump(_UpperCAmelCase		,      _UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self		,      **_UpperCAmelCase):

          '''simple docstring'''






          return BertTokenizer.from_pretrained(self.tmpdirname		,      **_UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self		,      **_UpperCAmelCase):

          '''simple docstring'''






          return ViTImageProcessor.from_pretrained(self.tmpdirname		,      **_UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          shutil.rmtree(self.tmpdirname)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Union[str, Any]						=			[np.random.randint(255		,      size=(3, 30, 400)		,      dtype=np.uinta)]

          __A		:					List[str]						=			[Image.fromarray(np.moveaxis(_UpperCAmelCase		,      0		,      -1)) for x in image_inputs]

          return image_inputs


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[Any]						=			self.get_tokenizer()
          __A		:					List[Any]						=			self.get_image_processor()

          __A		:					Dict						=			VisionTextDualEncoderProcessor(tokenizer=_UpperCAmelCase		,      image_processor=_UpperCAmelCase)

          processor.save_pretrained(self.tmpdirname)
          __A		:					Union[str, Any]						=			VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname)

          self.assertEqual(processor.tokenizer.get_vocab()		,      tokenizer.get_vocab())
          self.assertIsInstance(processor.tokenizer		,      (BertTokenizer, BertTokenizerFast))

          self.assertEqual(processor.image_processor.to_json_string()		,      image_processor.to_json_string())
          self.assertIsInstance(processor.image_processor		,      _UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[int]						=			VisionTextDualEncoderProcessor(
              tokenizer=self.get_tokenizer()		,      image_processor=self.get_image_processor())
          processor.save_pretrained(self.tmpdirname)

          __A		:					Optional[Any]						=			self.get_tokenizer(bos_token='(BOS)'		,      eos_token='(EOS)')
          __A		:					Optional[Any]						=			self.get_image_processor(do_normalize=_UpperCAmelCase		,      padding_value=1.0)

          __A		:					Tuple						=			VisionTextDualEncoderProcessor.from_pretrained(
              self.tmpdirname		,      bos_token='(BOS)'		,      eos_token='(EOS)'		,      do_normalize=_UpperCAmelCase		,      padding_value=1.0)

          self.assertEqual(processor.tokenizer.get_vocab()		,      tokenizer_add_kwargs.get_vocab())
          self.assertIsInstance(processor.tokenizer		,      (BertTokenizer, BertTokenizerFast))

          self.assertEqual(processor.image_processor.to_json_string()		,      image_processor_add_kwargs.to_json_string())
          self.assertIsInstance(processor.image_processor		,      _UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Any						=			self.get_image_processor()
          __A		:					Any						=			self.get_tokenizer()

          __A		:					Optional[int]						=			VisionTextDualEncoderProcessor(tokenizer=_UpperCAmelCase		,      image_processor=_UpperCAmelCase)

          __A		:					List[Any]						=			self.prepare_image_inputs()

          __A		:					str						=			image_processor(_UpperCAmelCase		,      return_tensors='np')
          __A		:					Tuple						=			processor(images=_UpperCAmelCase		,      return_tensors='np')

          for key in input_feat_extract.keys():
               self.assertAlmostEqual(input_feat_extract[key].sum()		,      input_processor[key].sum()		,      delta=1e-2)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[int]						=			self.get_image_processor()
          __A		:					Optional[int]						=			self.get_tokenizer()

          __A		:					Optional[int]						=			VisionTextDualEncoderProcessor(tokenizer=_UpperCAmelCase		,      image_processor=_UpperCAmelCase)

          __A		:					Union[str, Any]						=			'lower newer'

          __A		:					Optional[Any]						=			processor(text=_UpperCAmelCase)

          __A		:					List[Any]						=			tokenizer(_UpperCAmelCase)

          for key in encoded_tok.keys():
               self.assertListEqual(encoded_tok[key]		,      encoded_processor[key])


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					List[str]						=			self.get_image_processor()
          __A		:					Any						=			self.get_tokenizer()

          __A		:					Any						=			VisionTextDualEncoderProcessor(tokenizer=_UpperCAmelCase		,      image_processor=_UpperCAmelCase)

          __A		:					Union[str, Any]						=			'lower newer'
          __A		:					Dict						=			self.prepare_image_inputs()

          __A		:					Dict						=			processor(text=_UpperCAmelCase		,      images=_UpperCAmelCase)

          self.assertListEqual(list(inputs.keys())		,      ['input_ids', 'token_type_ids', 'attention_mask', 'pixel_values'])

          # test if it raises when no input is passed
          with self.assertRaises(_UpperCAmelCase):
               processor()


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					List[Any]						=			self.get_image_processor()
          __A		:					Optional[int]						=			self.get_tokenizer()

          __A		:					List[str]						=			VisionTextDualEncoderProcessor(tokenizer=_UpperCAmelCase		,      image_processor=_UpperCAmelCase)

          __A		:					Any						=			[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

          __A		:					List[str]						=			processor.batch_decode(_UpperCAmelCase)
          __A		:					Union[str, Any]						=			tokenizer.batch_decode(_UpperCAmelCase)

          self.assertListEqual(_UpperCAmelCase		,      _UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Union[str, Any]						=			self.get_image_processor()
          __A		:					Union[str, Any]						=			self.get_tokenizer()

          __A		:					str						=			VisionTextDualEncoderProcessor(tokenizer=_UpperCAmelCase		,      image_processor=_UpperCAmelCase)

          __A		:					Optional[Any]						=			'lower newer'
          __A		:					str						=			self.prepare_image_inputs()

          __A		:					str						=			processor(text=_UpperCAmelCase		,      images=_UpperCAmelCase)

          self.assertListEqual(list(inputs.keys())		,      processor.model_input_names)






'''simple docstring'''




from ...configuration_utils import PretrainedConfig


lowercase__       : Any         =       {
    '''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 					SCREAMING_SNAKE_CASE       (a__				):
     lowerCAmelCase						     =			'''tapas'''


     def __init__(		self		,      _UpperCAmelCase=3_0522		,      _UpperCAmelCase=768		,      _UpperCAmelCase=12		,      _UpperCAmelCase=12		,      _UpperCAmelCase=3072		,      _UpperCAmelCase="gelu"		,      _UpperCAmelCase=0.1		,      _UpperCAmelCase=0.1		,      _UpperCAmelCase=1024		,      _UpperCAmelCase=[3, 256, 256, 2, 256, 256, 10]		,      _UpperCAmelCase=0.02		,      _UpperCAmelCase=1e-1_2		,      _UpperCAmelCase=0		,      _UpperCAmelCase=10.0		,      _UpperCAmelCase=0		,      _UpperCAmelCase=1.0		,      _UpperCAmelCase=None		,      _UpperCAmelCase=1.0		,      _UpperCAmelCase=False		,      _UpperCAmelCase=None		,      _UpperCAmelCase=1.0		,      _UpperCAmelCase=1.0		,      _UpperCAmelCase=False		,      _UpperCAmelCase=False		,      _UpperCAmelCase="ratio"		,      _UpperCAmelCase=None		,      _UpperCAmelCase=None		,      _UpperCAmelCase=64		,      _UpperCAmelCase=32		,      _UpperCAmelCase=False		,      _UpperCAmelCase=True		,      _UpperCAmelCase=False		,      _UpperCAmelCase=False		,      _UpperCAmelCase=True		,      _UpperCAmelCase=False		,      _UpperCAmelCase=None		,      _UpperCAmelCase=None		,      **_UpperCAmelCase		,      ):

          '''simple docstring'''






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

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

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

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

          if isinstance(self.aggregation_labels		,      _UpperCAmelCase):
               __A		:					Optional[Any]						=			{int(_UpperCAmelCase): v for k, v in aggregation_labels.items()}