

import json
import os
import random
import shutil
import tempfile
import unittest

import numpy as np
import pytest

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


if is_vision_available():
	from PIL import Image

	from transformers import FlavaImageProcessor, FlavaProcessor
	from transformers.models.flava.image_processing_flava import (
	    FLAVA_CODEBOOK_MEAN,
	    FLAVA_CODEBOOK_STD,
	    FLAVA_IMAGE_MEAN,
	    FLAVA_IMAGE_STD,
	)


@require_vision
class 			_SCREAMING_SNAKE_CASE      (  unittest.TestCase):







						def        _snake_case				(			self							)->							str:
													lowerCamelCase_								=tempfile.mkdtemp()

													# fmt: off
													lowerCamelCase_								=["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing""", """,""", """low""", """lowest"""]
													# fmt: on
													lowerCamelCase_								=os.path.join(self.tmpdirname     ,						VOCAB_FILES_NAMES["""vocab_file"""]							)

													with open(self.vocab_file     ,						"""w"""     ,						encoding="""utf-8"""							) as fp:
																				fp.write("""""".join([x + """\n""" for x in vocab_tokens]							)							)

													lowerCamelCase_								={
													    """image_mean""": FLAVA_IMAGE_MEAN,
													    """image_std""": FLAVA_IMAGE_STD,
													    """do_normalize""": True,
													    """do_resize""": True,
													    """size""": 224,
													    """do_center_crop""": True,
													    """crop_size""": 224,
													    """input_size_patches""": 14,
													    """total_mask_patches""": 75,
													    """mask_group_max_patches""": None,
													    """mask_group_min_patches""": 16,
													    """mask_group_min_aspect_ratio""": 0.3,
													    """mask_group_max_aspect_ratio""": None,
													    """codebook_do_resize""": True,
													    """codebook_size""": 112,
													    """codebook_do_center_crop""": True,
													    """codebook_crop_size""": 112,
													    """codebook_do_map_pixels""": True,
													    """codebook_do_normalize""": True,
													    """codebook_image_mean""": FLAVA_CODEBOOK_MEAN,
													    """codebook_image_std""": FLAVA_CODEBOOK_STD,
													}

													lowerCamelCase_								=os.path.join(self.tmpdirname     ,						_SCREAMING_SNAKE_CASE							)
													with open(self.image_processor_file     ,						"""w"""     ,						encoding="""utf-8"""							) as fp:
																				json.dump(_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							)







						def        _snake_case				(			self     ,						**_SCREAMING_SNAKE_CASE							)->							Tuple:
													return BertTokenizer.from_pretrained(self.tmpdirname     ,						**_SCREAMING_SNAKE_CASE							)







						def        _snake_case				(			self     ,						**_SCREAMING_SNAKE_CASE							)->							List[str]:
													return BertTokenizerFast.from_pretrained(self.tmpdirname     ,						**_SCREAMING_SNAKE_CASE							)







						def        _snake_case				(			self     ,						**_SCREAMING_SNAKE_CASE							)->							Optional[int]:
													return FlavaImageProcessor.from_pretrained(self.tmpdirname     ,						**_SCREAMING_SNAKE_CASE							)







						def        _snake_case				(			self							)->							List[Any]:
													shutil.rmtree(self.tmpdirname							)







						def        _snake_case				(			self							)->							List[str]:
													lowerCamelCase_								=[np.random.randint(255     ,						size=(3, 30, 400)     ,						dtype=np.uinta							)]

													lowerCamelCase_								=[Image.fromarray(np.moveaxis(_SCREAMING_SNAKE_CASE     ,						0     ,						-1							)							) for x in image_inputs]

													return image_inputs







						def        _snake_case				(			self							)->							Tuple:
													lowerCamelCase_								=self.get_tokenizer()
													lowerCamelCase_								=self.get_rust_tokenizer()
													lowerCamelCase_								=self.get_image_processor()

													lowerCamelCase_								=FlavaProcessor(tokenizer=_SCREAMING_SNAKE_CASE     ,						image_processor=_SCREAMING_SNAKE_CASE							)
													processor_slow.save_pretrained(self.tmpdirname							)
													lowerCamelCase_								=FlavaProcessor.from_pretrained(self.tmpdirname     ,						use_fast=_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								=FlavaProcessor(tokenizer=_SCREAMING_SNAKE_CASE     ,						image_processor=_SCREAMING_SNAKE_CASE							)
													processor_fast.save_pretrained(self.tmpdirname							)
													lowerCamelCase_								=FlavaProcessor.from_pretrained(self.tmpdirname							)

													self.assertEqual(processor_slow.tokenizer.get_vocab()     ,						tokenizer_slow.get_vocab()							)
													self.assertEqual(processor_fast.tokenizer.get_vocab()     ,						tokenizer_fast.get_vocab()							)
													self.assertEqual(tokenizer_slow.get_vocab()     ,						tokenizer_fast.get_vocab()							)
													self.assertIsInstance(processor_slow.tokenizer     ,						_SCREAMING_SNAKE_CASE							)
													self.assertIsInstance(processor_fast.tokenizer     ,						_SCREAMING_SNAKE_CASE							)

													self.assertEqual(processor_slow.image_processor.to_json_string()     ,						image_processor.to_json_string()							)
													self.assertEqual(processor_fast.image_processor.to_json_string()     ,						image_processor.to_json_string()							)
													self.assertIsInstance(processor_slow.image_processor     ,						_SCREAMING_SNAKE_CASE							)
													self.assertIsInstance(processor_fast.image_processor     ,						_SCREAMING_SNAKE_CASE							)







						def        _snake_case				(			self							)->							Union[str, Any]:
													lowerCamelCase_								=FlavaProcessor(tokenizer=self.get_tokenizer()     ,						image_processor=self.get_image_processor()							)
													processor.save_pretrained(self.tmpdirname							)

													lowerCamelCase_								=self.get_tokenizer(bos_token="""(BOS)"""     ,						eos_token="""(EOS)"""							)
													lowerCamelCase_								=self.get_image_processor(do_normalize=_SCREAMING_SNAKE_CASE     ,						padding_value=1.0							)

													lowerCamelCase_								=FlavaProcessor.from_pretrained(
													    self.tmpdirname     ,						bos_token="""(BOS)"""     ,						eos_token="""(EOS)"""     ,						do_normalize=_SCREAMING_SNAKE_CASE     ,						padding_value=1.0							)

													self.assertEqual(processor.tokenizer.get_vocab()     ,						tokenizer_add_kwargs.get_vocab()							)
													self.assertIsInstance(processor.tokenizer     ,						_SCREAMING_SNAKE_CASE							)

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







						def        _snake_case				(			self							)->							Union[str, Any]:
													lowerCamelCase_								=self.get_image_processor()
													lowerCamelCase_								=self.get_tokenizer()

													lowerCamelCase_								=FlavaProcessor(tokenizer=_SCREAMING_SNAKE_CASE     ,						image_processor=_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								=self.prepare_image_inputs()

													lowerCamelCase_								=image_processor(_SCREAMING_SNAKE_CASE     ,						return_tensors="""np"""							)
													lowerCamelCase_								=processor(images=_SCREAMING_SNAKE_CASE     ,						return_tensors="""np"""							)

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

													# With rest of the args
													random.seed(1234							)
													lowerCamelCase_								=image_processor(
													    _SCREAMING_SNAKE_CASE     ,						return_image_mask=_SCREAMING_SNAKE_CASE     ,						return_codebook_pixels=_SCREAMING_SNAKE_CASE     ,						return_tensors="""np"""							)
													random.seed(1234							)
													lowerCamelCase_								=processor(
													    images=_SCREAMING_SNAKE_CASE     ,						return_image_mask=_SCREAMING_SNAKE_CASE     ,						return_codebook_pixels=_SCREAMING_SNAKE_CASE     ,						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        _snake_case				(			self							)->							Tuple:
													lowerCamelCase_								=self.get_image_processor()
													lowerCamelCase_								=self.get_tokenizer()

													lowerCamelCase_								=FlavaProcessor(tokenizer=_SCREAMING_SNAKE_CASE     ,						image_processor=_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								="""lower newer"""

													lowerCamelCase_								=processor(text=_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								=tokenizer(_SCREAMING_SNAKE_CASE							)

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







						def        _snake_case				(			self							)->							Optional[int]:
													lowerCamelCase_								=self.get_image_processor()
													lowerCamelCase_								=self.get_tokenizer()

													lowerCamelCase_								=FlavaProcessor(tokenizer=_SCREAMING_SNAKE_CASE     ,						image_processor=_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								="""lower newer"""
													lowerCamelCase_								=self.prepare_image_inputs()

													lowerCamelCase_								=processor(text=_SCREAMING_SNAKE_CASE     ,						images=_SCREAMING_SNAKE_CASE							)

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

													# add extra args
													lowerCamelCase_								=processor(text=_SCREAMING_SNAKE_CASE     ,						images=_SCREAMING_SNAKE_CASE     ,						return_codebook_pixels=_SCREAMING_SNAKE_CASE     ,						return_image_mask=_SCREAMING_SNAKE_CASE							)

													self.assertListEqual(
													    list(inputs.keys()							)     ,						[
													        """input_ids""",
													        """token_type_ids""",
													        """attention_mask""",
													        """pixel_values""",
													        """codebook_pixel_values""",
													        """bool_masked_pos""",
													    ]     ,						)

													# test if it raises when no input is passed
													with pytest.raises(_SCREAMING_SNAKE_CASE							):
																				processor()







						def        _snake_case				(			self							)->							List[str]:
													lowerCamelCase_								=self.get_image_processor()
													lowerCamelCase_								=self.get_tokenizer()

													lowerCamelCase_								=FlavaProcessor(tokenizer=_SCREAMING_SNAKE_CASE     ,						image_processor=_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								=[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

													lowerCamelCase_								=processor.batch_decode(_SCREAMING_SNAKE_CASE							)
													lowerCamelCase_								=tokenizer.batch_decode(_SCREAMING_SNAKE_CASE							)

													self.assertListEqual(_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							)







						def        _snake_case				(			self							)->							Tuple:
													lowerCamelCase_								=self.get_image_processor()
													lowerCamelCase_								=self.get_tokenizer()

													lowerCamelCase_								=FlavaProcessor(tokenizer=_SCREAMING_SNAKE_CASE     ,						image_processor=_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								="""lower newer"""
													lowerCamelCase_								=self.prepare_image_inputs()

													lowerCamelCase_								=processor(text=_SCREAMING_SNAKE_CASE     ,						images=_SCREAMING_SNAKE_CASE							)

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



from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__A	:   List[Any]	=					logging.get_logger(__name__)

__A	:   Tuple	=					{
    'google/electra-small-generator': 'https://huggingface.co/google/electra-small-generator/resolve/main/config.json',
    'google/electra-base-generator': 'https://huggingface.co/google/electra-base-generator/resolve/main/config.json',
    'google/electra-large-generator': 'https://huggingface.co/google/electra-large-generator/resolve/main/config.json',
    'google/electra-small-discriminator': (
        'https://huggingface.co/google/electra-small-discriminator/resolve/main/config.json'
    ),
    'google/electra-base-discriminator': (
        'https://huggingface.co/google/electra-base-discriminator/resolve/main/config.json'
    ),
    'google/electra-large-discriminator': (
        'https://huggingface.co/google/electra-large-discriminator/resolve/main/config.json'
    ),
}


class 			_SCREAMING_SNAKE_CASE      (  lowerCAmelCase__):
						_UpperCamelCase:Tuple	=		"electra"







						def __init__(			self     ,						_SCREAMING_SNAKE_CASE=3_0522     ,						_SCREAMING_SNAKE_CASE=128     ,						_SCREAMING_SNAKE_CASE=256     ,						_SCREAMING_SNAKE_CASE=12     ,						_SCREAMING_SNAKE_CASE=4     ,						_SCREAMING_SNAKE_CASE=1024     ,						_SCREAMING_SNAKE_CASE="gelu"     ,						_SCREAMING_SNAKE_CASE=0.1     ,						_SCREAMING_SNAKE_CASE=0.1     ,						_SCREAMING_SNAKE_CASE=512     ,						_SCREAMING_SNAKE_CASE=2     ,						_SCREAMING_SNAKE_CASE=0.0_2     ,						_SCREAMING_SNAKE_CASE=1E-12     ,						_SCREAMING_SNAKE_CASE="first"     ,						_SCREAMING_SNAKE_CASE=True     ,						_SCREAMING_SNAKE_CASE="gelu"     ,						_SCREAMING_SNAKE_CASE=0.1     ,						_SCREAMING_SNAKE_CASE=0     ,						_SCREAMING_SNAKE_CASE="absolute"     ,						_SCREAMING_SNAKE_CASE=True     ,						_SCREAMING_SNAKE_CASE=None     ,						**_SCREAMING_SNAKE_CASE     ,						)->							Optional[int]:
													super().__init__(pad_token_id=_SCREAMING_SNAKE_CASE     ,						**_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								=vocab_size
													lowerCamelCase_								=embedding_size
													lowerCamelCase_								=hidden_size
													lowerCamelCase_								=num_hidden_layers
													lowerCamelCase_								=num_attention_heads
													lowerCamelCase_								=intermediate_size
													lowerCamelCase_								=hidden_act
													lowerCamelCase_								=hidden_dropout_prob
													lowerCamelCase_								=attention_probs_dropout_prob
													lowerCamelCase_								=max_position_embeddings
													lowerCamelCase_								=type_vocab_size
													lowerCamelCase_								=initializer_range
													lowerCamelCase_								=layer_norm_eps

													lowerCamelCase_								=summary_type
													lowerCamelCase_								=summary_use_proj
													lowerCamelCase_								=summary_activation
													lowerCamelCase_								=summary_last_dropout
													lowerCamelCase_								=position_embedding_type
													lowerCamelCase_								=use_cache
													lowerCamelCase_								=classifier_dropout


class 			_SCREAMING_SNAKE_CASE      (  lowerCAmelCase__):







						@property
						def        _snake_case				(			self							)->							Mapping[str, Mapping[int, str]]:
													if self.task == "multiple-choice":
																				lowerCamelCase_								={0: """batch""", 1: """choice""", 2: """sequence"""}
													else:
																				lowerCamelCase_								={0: """batch""", 1: """sequence"""}
													return OrderedDict(
													    [
													        ("""input_ids""", dynamic_axis),
													        ("""attention_mask""", dynamic_axis),
													        ("""token_type_ids""", dynamic_axis),
													    ]							)
