





'''simple docstring'''



from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


_SCREAMING_SNAKE_CASE   =      logging.get_logger(__name__)


if is_vision_available():
	import PIL






class 							__lowercase    ( __SCREAMING_SNAKE_CASE  ):







	'''simple docstring'''

	a      :			Any     =    ["pixel_values"]


	def __init__(self       ,_lowerCamelCase = True       ,_lowerCamelCase = None       ,_lowerCamelCase = PILImageResampling.BICUBIC       ,_lowerCamelCase = True       ,_lowerCamelCase = None       ,_lowerCamelCase = True       ,_lowerCamelCase = 1 / 255       ,_lowerCamelCase = True       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = True       ,**_lowerCamelCase       ,):







				'''simple docstring'''





				super().__init__(**_SCREAMING_SNAKE_CASE	)
				__lowercase			  =							size if size is not None else {"shortest_edge": 224}
				__lowercase			  =							get_size_dict(_SCREAMING_SNAKE_CASE       ,default_to_square=_SCREAMING_SNAKE_CASE	)
				__lowercase			  =							crop_size if crop_size is not None else {"height": 224, "width": 224}
				__lowercase			  =							get_size_dict(_SCREAMING_SNAKE_CASE       ,default_to_square=_SCREAMING_SNAKE_CASE       ,param_name='''crop_size'''	)

				__lowercase			  =							do_resize
				__lowercase			  =							size
				__lowercase			  =							resample
				__lowercase			  =							do_center_crop
				__lowercase			  =							crop_size
				__lowercase			  =							do_rescale
				__lowercase			  =							rescale_factor
				__lowercase			  =							do_normalize
				__lowercase			  =							image_mean if image_mean is not None else OPENAI_CLIP_MEAN
				__lowercase			  =							image_std if image_std is not None else OPENAI_CLIP_STD
				__lowercase			  =							do_convert_rgb


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase = PILImageResampling.BICUBIC       ,_lowerCamelCase = None       ,**_lowerCamelCase       ,):







				'''simple docstring'''





				__lowercase			  =							get_size_dict(_SCREAMING_SNAKE_CASE       ,default_to_square=_SCREAMING_SNAKE_CASE	)
				if "shortest_edge" not in size:
							raise ValueError(f"The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}"	)
				__lowercase			  =							get_resize_output_image_size(_SCREAMING_SNAKE_CASE       ,size=size['''shortest_edge''']       ,default_to_square=_SCREAMING_SNAKE_CASE	)
				return resize(_SCREAMING_SNAKE_CASE       ,size=_SCREAMING_SNAKE_CASE       ,resample=_SCREAMING_SNAKE_CASE       ,data_format=_SCREAMING_SNAKE_CASE       ,**_SCREAMING_SNAKE_CASE	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase = None       ,**_lowerCamelCase       ,):







				'''simple docstring'''





				__lowercase			  =							get_size_dict(_SCREAMING_SNAKE_CASE	)
				if "height" not in size or "width" not in size:
							raise ValueError(f"The `size` parameter must contain the keys (height, width). Got {size.keys()}"	)
				return center_crop(_SCREAMING_SNAKE_CASE       ,size=(size['''height'''], size['''width'''])       ,data_format=_SCREAMING_SNAKE_CASE       ,**_SCREAMING_SNAKE_CASE	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase = None       ,**_lowerCamelCase       ,):







				'''simple docstring'''





				return rescale(_SCREAMING_SNAKE_CASE       ,scale=_SCREAMING_SNAKE_CASE       ,data_format=_SCREAMING_SNAKE_CASE       ,**_SCREAMING_SNAKE_CASE	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase = None       ,**_lowerCamelCase       ,):







				'''simple docstring'''





				return normalize(_SCREAMING_SNAKE_CASE       ,mean=_SCREAMING_SNAKE_CASE       ,std=_SCREAMING_SNAKE_CASE       ,data_format=_SCREAMING_SNAKE_CASE       ,**_SCREAMING_SNAKE_CASE	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = ChannelDimension.FIRST       ,**_lowerCamelCase       ,):







				'''simple docstring'''





				__lowercase			  =							do_resize if do_resize is not None else self.do_resize
				__lowercase			  =							size if size is not None else self.size
				__lowercase			  =							get_size_dict(_SCREAMING_SNAKE_CASE       ,param_name='''size'''       ,default_to_square=_SCREAMING_SNAKE_CASE	)
				__lowercase			  =							resample if resample is not None else self.resample
				__lowercase			  =							do_center_crop if do_center_crop is not None else self.do_center_crop
				__lowercase			  =							crop_size if crop_size is not None else self.crop_size
				__lowercase			  =							get_size_dict(_SCREAMING_SNAKE_CASE       ,param_name='''crop_size'''       ,default_to_square=_SCREAMING_SNAKE_CASE	)
				__lowercase			  =							do_rescale if do_rescale is not None else self.do_rescale
				__lowercase			  =							rescale_factor if rescale_factor is not None else self.rescale_factor
				__lowercase			  =							do_normalize if do_normalize is not None else self.do_normalize
				__lowercase			  =							image_mean if image_mean is not None else self.image_mean
				__lowercase			  =							image_std if image_std is not None else self.image_std
				__lowercase			  =							do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

				__lowercase			  =							make_list_of_images(_SCREAMING_SNAKE_CASE	)

				if not valid_images(_SCREAMING_SNAKE_CASE	):
							raise ValueError(
							    '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
							    '''torch.Tensor, tf.Tensor or jax.ndarray.'''	)

				if do_resize and size is None:
							raise ValueError('''Size must be specified if do_resize is True.'''	)

				if do_center_crop and crop_size is None:
							raise ValueError('''Crop size must be specified if do_center_crop is True.'''	)

				if do_rescale and rescale_factor is None:
							raise ValueError('''Rescale factor must be specified if do_rescale is True.'''	)

				if do_normalize and (image_mean is None or image_std is None):
							raise ValueError('''Image mean and std must be specified if do_normalize is True.'''	)

				# PIL RGBA images are converted to RGB
				if do_convert_rgb:
							__lowercase			  =							[convert_to_rgb(_SCREAMING_SNAKE_CASE	) for image in images]

				# All transformations expect numpy arrays.
				__lowercase			  =							[to_numpy_array(_SCREAMING_SNAKE_CASE	) for image in images]

				if do_resize:
							__lowercase			  =							[self.resize(image=_SCREAMING_SNAKE_CASE       ,size=_SCREAMING_SNAKE_CASE       ,resample=_SCREAMING_SNAKE_CASE	) for image in images]

				if do_center_crop:
							__lowercase			  =							[self.center_crop(image=_SCREAMING_SNAKE_CASE       ,size=_SCREAMING_SNAKE_CASE	) for image in images]

				if do_rescale:
							__lowercase			  =							[self.rescale(image=_SCREAMING_SNAKE_CASE       ,scale=_SCREAMING_SNAKE_CASE	) for image in images]

				if do_normalize:
							__lowercase			  =							[self.normalize(image=_SCREAMING_SNAKE_CASE       ,mean=_SCREAMING_SNAKE_CASE       ,std=_SCREAMING_SNAKE_CASE	) for image in images]

				__lowercase			  =							[to_channel_dimension_format(_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE	) for image in images]

				__lowercase			  =							{"pixel_values": images}
				return BatchFeature(data=_SCREAMING_SNAKE_CASE       ,tensor_type=_SCREAMING_SNAKE_CASE	)












'''simple docstring'''



import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_electra import ElectraTokenizer


_SCREAMING_SNAKE_CASE   =      {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}

_SCREAMING_SNAKE_CASE   =      {
    '''vocab_file''': {
        '''google/electra-small-generator''': (
            '''https://huggingface.co/google/electra-small-generator/resolve/main/vocab.txt'''
        ),
        '''google/electra-base-generator''': '''https://huggingface.co/google/electra-base-generator/resolve/main/vocab.txt''',
        '''google/electra-large-generator''': (
            '''https://huggingface.co/google/electra-large-generator/resolve/main/vocab.txt'''
        ),
        '''google/electra-small-discriminator''': (
            '''https://huggingface.co/google/electra-small-discriminator/resolve/main/vocab.txt'''
        ),
        '''google/electra-base-discriminator''': (
            '''https://huggingface.co/google/electra-base-discriminator/resolve/main/vocab.txt'''
        ),
        '''google/electra-large-discriminator''': (
            '''https://huggingface.co/google/electra-large-discriminator/resolve/main/vocab.txt'''
        ),
    },
    '''tokenizer_file''': {
        '''google/electra-small-generator''': (
            '''https://huggingface.co/google/electra-small-generator/resolve/main/tokenizer.json'''
        ),
        '''google/electra-base-generator''': (
            '''https://huggingface.co/google/electra-base-generator/resolve/main/tokenizer.json'''
        ),
        '''google/electra-large-generator''': (
            '''https://huggingface.co/google/electra-large-generator/resolve/main/tokenizer.json'''
        ),
        '''google/electra-small-discriminator''': (
            '''https://huggingface.co/google/electra-small-discriminator/resolve/main/tokenizer.json'''
        ),
        '''google/electra-base-discriminator''': (
            '''https://huggingface.co/google/electra-base-discriminator/resolve/main/tokenizer.json'''
        ),
        '''google/electra-large-discriminator''': (
            '''https://huggingface.co/google/electra-large-discriminator/resolve/main/tokenizer.json'''
        ),
    },
}

_SCREAMING_SNAKE_CASE   =      {
    '''google/electra-small-generator''': 5_1_2,
    '''google/electra-base-generator''': 5_1_2,
    '''google/electra-large-generator''': 5_1_2,
    '''google/electra-small-discriminator''': 5_1_2,
    '''google/electra-base-discriminator''': 5_1_2,
    '''google/electra-large-discriminator''': 5_1_2,
}

_SCREAMING_SNAKE_CASE   =      {
    '''google/electra-small-generator''': {'''do_lower_case''': True},
    '''google/electra-base-generator''': {'''do_lower_case''': True},
    '''google/electra-large-generator''': {'''do_lower_case''': True},
    '''google/electra-small-discriminator''': {'''do_lower_case''': True},
    '''google/electra-base-discriminator''': {'''do_lower_case''': True},
    '''google/electra-large-discriminator''': {'''do_lower_case''': True},
}






class 							__lowercase    ( lowerCAmelCase__  ):







	'''simple docstring'''

	a      :			str     =    VOCAB_FILES_NAMES
	a      :			Dict     =    PRETRAINED_VOCAB_FILES_MAP
	a      :			int     =    PRETRAINED_INIT_CONFIGURATION
	a      :			Tuple     =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	a      :			List[Any]     =    ElectraTokenizer


	def __init__(self       ,_lowerCamelCase=None       ,_lowerCamelCase=None       ,_lowerCamelCase=True       ,_lowerCamelCase="[UNK]"       ,_lowerCamelCase="[SEP]"       ,_lowerCamelCase="[PAD]"       ,_lowerCamelCase="[CLS]"       ,_lowerCamelCase="[MASK]"       ,_lowerCamelCase=True       ,_lowerCamelCase=None       ,**_lowerCamelCase       ,)							->							List[Any]:







				'''simple docstring'''





				super().__init__(
				    _lowerCamelCase       ,tokenizer_file=_lowerCamelCase       ,do_lower_case=_lowerCamelCase       ,unk_token=_lowerCamelCase       ,sep_token=_lowerCamelCase       ,pad_token=_lowerCamelCase       ,cls_token=_lowerCamelCase       ,mask_token=_lowerCamelCase       ,tokenize_chinese_chars=_lowerCamelCase       ,strip_accents=_lowerCamelCase       ,**_lowerCamelCase       ,)

				__lowercase			  =							json.loads(self.backend_tokenizer.normalizer.__getstate__()	)
				if (
				    normalizer_state.get('''lowercase'''       ,_lowerCamelCase	) != do_lower_case
				    or normalizer_state.get('''strip_accents'''       ,_lowerCamelCase	) != strip_accents
				    or normalizer_state.get('''handle_chinese_chars'''       ,_lowerCamelCase	) != tokenize_chinese_chars
				):
							__lowercase			  =							getattr(_lowerCamelCase       ,normalizer_state.pop('''type'''	)	)
							__lowercase			  =							do_lower_case
							__lowercase			  =							strip_accents
							__lowercase			  =							tokenize_chinese_chars
							__lowercase			  =							normalizer_class(**_lowerCamelCase	)

				__lowercase			  =							do_lower_case


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase=None	)							->							str:







				'''simple docstring'''





				__lowercase			  =							[self.cls_token_id] + token_ids_a + [self.sep_token_id]

				if token_ids_a:
							output += token_ids_a + [self.sep_token_id]

				return output


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase = None	)							->							List[int]:







				'''simple docstring'''





				__lowercase			  =							[self.sep_token_id]
				__lowercase			  =							[self.cls_token_id]
				if token_ids_a is None:
							return len(cls + token_ids_a + sep	) * [0]
				return len(cls + token_ids_a + sep	) * [0] + len(token_ids_a + sep	) * [1]


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase = None	)							->							Tuple[str]:







				'''simple docstring'''





				__lowercase			  =							self._tokenizer.model.save(_lowerCamelCase       ,name=_lowerCamelCase	)
				return tuple(_lowerCamelCase	)





