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


lowerCamelCase_				:		Dict       						=       logging.get_logger(__name__)


if is_vision_available():
	import PIL


class 						a__							(   __snake_case		):
			A__				:   Optional[Any]								=			['pixel_values']



			def __init__(						self      ,						UpperCAmelCase = True      ,						UpperCAmelCase = None      ,						UpperCAmelCase = PILImageResampling.BICUBIC      ,						UpperCAmelCase = True      ,						UpperCAmelCase = None      ,						UpperCAmelCase = True      ,						UpperCAmelCase = 1 / 2_5_5      ,						UpperCAmelCase = True      ,						UpperCAmelCase = None      ,						UpperCAmelCase = None      ,						UpperCAmelCase = True      ,						**UpperCAmelCase      ,						) ->    None:
								super().__init__(**UpperCAmelCase    )
								__a							=   size if size is not None else {'shortest_edge': 2_2_4}
								__a							=   get_size_dict(UpperCAmelCase      ,						default_to_square=UpperCAmelCase    )
								__a							=   crop_size if crop_size is not None else {'height': 2_2_4, 'width': 2_2_4}
								__a							=   get_size_dict(UpperCAmelCase    )

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



			def __SCREAMING_SNAKE_CASE							(						self      ,						UpperCAmelCase      ,						UpperCAmelCase      ,						UpperCAmelCase = PILImageResampling.BICUBIC      ,						UpperCAmelCase = None      ,						**UpperCAmelCase      ,						) ->    np.ndarray:
								__a							=   get_size_dict(UpperCAmelCase      ,						default_to_square=UpperCAmelCase    )
								__a							=   get_resize_output_image_size(
								    UpperCAmelCase      ,						size=(size['height'], size['width'])      ,						default_to_square=UpperCAmelCase    )
								return resize(UpperCAmelCase      ,						size=UpperCAmelCase      ,						resample=UpperCAmelCase      ,						data_format=UpperCAmelCase      ,						**UpperCAmelCase    )



			def __SCREAMING_SNAKE_CASE							(						self      ,						UpperCAmelCase      ,						UpperCAmelCase      ,						UpperCAmelCase = None      ,						**UpperCAmelCase      ,						) ->    np.ndarray:
								__a							=   get_size_dict(UpperCAmelCase    )
								return center_crop(UpperCAmelCase      ,						size=(size['height'], size['width'])      ,						data_format=UpperCAmelCase      ,						**UpperCAmelCase    )



			def __SCREAMING_SNAKE_CASE							(						self      ,						UpperCAmelCase      ,						UpperCAmelCase      ,						UpperCAmelCase = None      ,						**UpperCAmelCase      ,						) ->    Dict:
								return rescale(UpperCAmelCase      ,						scale=UpperCAmelCase      ,						data_format=UpperCAmelCase      ,						**UpperCAmelCase    )



			def __SCREAMING_SNAKE_CASE							(						self      ,						UpperCAmelCase      ,						UpperCAmelCase      ,						UpperCAmelCase      ,						UpperCAmelCase = None      ,						**UpperCAmelCase      ,						) ->    np.ndarray:
								return normalize(UpperCAmelCase      ,						mean=UpperCAmelCase      ,						std=UpperCAmelCase      ,						data_format=UpperCAmelCase      ,						**UpperCAmelCase    )







			def __SCREAMING_SNAKE_CASE							(						self      ,						UpperCAmelCase      ,						UpperCAmelCase = None      ,						UpperCAmelCase = None      ,						UpperCAmelCase = None      ,						UpperCAmelCase = None      ,						UpperCAmelCase = None      ,						UpperCAmelCase = None      ,						UpperCAmelCase = None      ,						UpperCAmelCase = None      ,						UpperCAmelCase = None      ,						UpperCAmelCase = None      ,						UpperCAmelCase = None      ,						UpperCAmelCase = None      ,						UpperCAmelCase = ChannelDimension.FIRST      ,						**UpperCAmelCase      ,						) ->    PIL.Image.Image:
								__a							=   do_resize if do_resize is not None else self.do_resize
								__a							=   size if size is not None else self.size
								__a							=   get_size_dict(UpperCAmelCase      ,						default_to_square=UpperCAmelCase    )
								__a							=   resample if resample is not None else self.resample
								__a							=   do_center_crop if do_center_crop is not None else self.do_center_crop
								__a							=   crop_size if crop_size is not None else self.crop_size
								__a							=   get_size_dict(UpperCAmelCase    )
								__a							=   do_rescale if do_rescale is not None else self.do_rescale
								__a							=   rescale_factor if rescale_factor is not None else self.rescale_factor
								__a							=   do_normalize if do_normalize is not None else self.do_normalize
								__a							=   image_mean if image_mean is not None else self.image_mean
								__a							=   image_std if image_std is not None else self.image_std
								__a							=   do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

								__a							=   make_list_of_images(UpperCAmelCase    )

								if not valid_images(UpperCAmelCase    ):
													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:
													__a							=   [convert_to_rgb(UpperCAmelCase    ) for image in images]

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

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

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

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

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

								__a							=   [to_channel_dimension_format(UpperCAmelCase      ,						UpperCAmelCase    ) for image in images]

								__a							=   {'pixel_values': images}
								return BatchFeature(data=UpperCAmelCase      ,						tensor_type=UpperCAmelCase    )





from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_clip import CLIPTokenizer


lowerCAmelCase__							= logging.get_logger(__name__)

lowerCAmelCase__							= {'vocab_file': 'vocab.json', 'merges_file': 'merges.txt', 'tokenizer_file': 'tokenizer.json'}

lowerCAmelCase__							= {
    'vocab_file': {
        'openai/clip-vit-base-patch32': 'https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/vocab.json',
    },
    'merges_file': {
        'openai/clip-vit-base-patch32': 'https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/merges.txt',
    },
    'tokenizer_file': {
        'openai/clip-vit-base-patch32': (
            'https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/tokenizer.json'
        ),
    },
}

lowerCAmelCase__							= {
    'openai/clip-vit-base-patch32': 77,
}
class 				a_ (						SCREAMING_SNAKE_CASE						):






 '''simple docstring'''






 UpperCAmelCase_	 =					VOCAB_FILES_NAMES
 UpperCAmelCase_	 =					PRETRAINED_VOCAB_FILES_MAP
 UpperCAmelCase_	 =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 UpperCAmelCase_	 =					['input_ids', 'attention_mask']
 UpperCAmelCase_	 =					CLIPTokenizer




 def __init__(			self					:  Optional[int]			,    lowercase__					:  Optional[int]=None			,    lowercase__					:  Tuple=None			,    lowercase__					:  Tuple=None			,    lowercase__					:  str="<|endoftext|>"			,    lowercase__					:  List[str]="<|startoftext|>"			,    lowercase__					:  Union[str, Any]="<|endoftext|>"			,    lowercase__					:  Any="<|endoftext|>"			,    **lowercase__					:  Any			,    ):







        '''simple docstring'''



        super().__init__(
            lowercase__			,    lowercase__			,    tokenizer_file=lowercase__			,    unk_token=lowercase__			,    bos_token=lowercase__			,    eos_token=lowercase__			,    pad_token=lowercase__			,    **lowercase__			,    )

        if not isinstance(self.backend_tokenizer.pre_tokenizer			,    pre_tokenizers.Sequence):
               raise ValueError(
                   'The `backend_tokenizer` provided does not match the expected format. The CLIP tokenizer has been'
                   ' heavily modified from transformers version 4.17.0. You need to convert the tokenizer you are using'
                   ' to be compatible with this version.The easiest way to do so is'
                   ' `CLIPTokenizerFast.from_pretrained("path_to_local_folder_or_hub_repo, from_slow=True)`. If you want'
                   ' to use your existing tokenizer, you will have to revert to a version prior to 4.17.0 of'
                   ' transformers.')

        self._wrap_decode_method_backend_tokenizer()




 def 		__snake_case						(			self					:  Optional[int]):







        '''simple docstring'''



        lowerCAmelCase__     	=					self.backend_tokenizer.decode

        def new_decode_method(*lowercase__					:  str			,    **lowercase__					:  int):
               lowerCAmelCase__     	=					orig_decode_method(*lowercase__			,    **lowercase__)
               lowerCAmelCase__     	=					text.replace(self.backend_tokenizer.model.end_of_word_suffix			,    ' ').strip()
               return text

        lowerCAmelCase__     	=					new_decode_method




 def 		__snake_case						(			self					:  Tuple			,    lowercase__					:  List[int]			,    lowercase__					:  Optional[List[int]] = None):







        '''simple docstring'''



        lowerCAmelCase__     	=					[self.bos_token_id]
        lowerCAmelCase__     	=					[self.eos_token_id]

        if token_ids_a is None:
               return bos_token + token_ids_a + eos_token
        return bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token




 def 		__snake_case						(			self					:  Any			,    lowercase__					:  List[int]			,    lowercase__					:  Optional[List[int]] = None):







        '''simple docstring'''



        lowerCAmelCase__     	=					[self.bos_token_id]
        lowerCAmelCase__     	=					[self.eos_token_id]

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




 def 		__snake_case						(			self					:  Dict			,    lowercase__					:  str			,    lowercase__					:  Optional[str] = None):







        '''simple docstring'''



        lowerCAmelCase__     	=					self._tokenizer.model.save(lowercase__			,    name=lowercase__)
        return tuple(lowercase__)
