



'''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, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
       import PIL


lowerCAmelCase_     :       Optional[Any]								=						logging.get_logger(__name__)
class 	lowerCamelCase_							(					UpperCamelCase__			):
      _lowerCAmelCase     :   List[Any]	     =				['pixel_values']







      def __init__(  self   :      Dict				,    lowerCAmelCase__   :      Optional[int] = True				,    lowerCAmelCase__   :      Optional[int] = None				,    lowerCAmelCase__   :      str = PIL.Image.BICUBIC				,    lowerCAmelCase__   :      Dict = True				,    lowerCAmelCase__   :      str = None				,    lowerCAmelCase__   :      Union[str, Any] = 1 / 2_55				,    lowerCAmelCase__   :      List[str] = True				,    lowerCAmelCase__   :      Dict = True				,    lowerCAmelCase__   :      List[Any] = None				,    lowerCAmelCase__   :      Union[str, Any] = None				,    **lowerCAmelCase__   :      str				,    ):

             """simple docstring"""
             super().__init__(**_a				)
             SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			size if size is not None else {"""height""": 2_56, """width""": 2_56}
             SCREAMING_SNAKE_CASE					:      List[Any]     					=			get_size_dict(_a				)
             SCREAMING_SNAKE_CASE					:      Tuple     					=			crop_size if crop_size is not None else {"""height""": 2_24, """width""": 2_24}
             SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			get_size_dict(_a				,    param_name='''crop_size'''				)

             SCREAMING_SNAKE_CASE					:      str     					=			do_resize
             SCREAMING_SNAKE_CASE					:      Optional[int]     					=			size
             SCREAMING_SNAKE_CASE					:      Any     					=			resample
             SCREAMING_SNAKE_CASE					:      Any     					=			do_center_crop
             SCREAMING_SNAKE_CASE					:      List[Any]     					=			crop_size
             SCREAMING_SNAKE_CASE					:      Any     					=			do_rescale
             SCREAMING_SNAKE_CASE					:      List[Any]     					=			rescale_factor
             SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			do_normalize
             SCREAMING_SNAKE_CASE					:      Tuple     					=			image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
             SCREAMING_SNAKE_CASE					:      int     					=			image_std if image_std is not None else IMAGENET_STANDARD_STD







      def 					__lowercase    (  self   :      Tuple				,    lowerCAmelCase__   :      Union[str, Any]				,    lowerCAmelCase__   :      Optional[Any]				,    lowerCAmelCase__   :      List[Any] = PIL.Image.BICUBIC				,    lowerCAmelCase__   :      Any = None				,    **lowerCAmelCase__   :      Optional[Any]				,    ):

             """simple docstring"""
             SCREAMING_SNAKE_CASE					:      List[Any]     					=			get_size_dict(_a				)
             if "height" not in size or "width" not in size:
                    raise ValueError(F"""The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}"""				)
             return resize(
                 _a				,    size=(size['''height'''], size['''width'''])				,    resample=_a				,    data_format=_a				,    **_a				)







      def 					__lowercase    (  self   :      Dict				,    lowerCAmelCase__   :      int				,    lowerCAmelCase__   :      Optional[int]				,    lowerCAmelCase__   :      str = None				,    **lowerCAmelCase__   :      Dict				,    ):

             """simple docstring"""
             SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			get_size_dict(_a				)
             if "height" not in size or "width" not in size:
                    raise ValueError(F"""The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}"""				)
             return center_crop(_a				,    size=(size['''height'''], size['''width'''])				,    data_format=_a				,    **_a				)







      def 					__lowercase    (  self   :      List[Any]				,    lowerCAmelCase__   :      Union[str, Any]				,    lowerCAmelCase__   :      Dict				,    lowerCAmelCase__   :      Any = None				,    **lowerCAmelCase__   :      Union[str, Any]				,    ):

             """simple docstring"""
             return rescale(_a				,    scale=_a				,    data_format=_a				,    **_a				)







      def 					__lowercase    (  self   :      Optional[int]				,    lowerCAmelCase__   :      Dict				,    lowerCAmelCase__   :      List[str]				,    lowerCAmelCase__   :      str				,    lowerCAmelCase__   :      str = None				,    **lowerCAmelCase__   :      str				,    ):

             """simple docstring"""
             return normalize(_a				,    mean=_a				,    std=_a				,    data_format=_a				,    **_a				)







      def 					__lowercase    (  self   :      Optional[int]				,    lowerCAmelCase__   :      Any				,    lowerCAmelCase__   :      Tuple = None				,    lowerCAmelCase__   :      List[Any] = None				,    lowerCAmelCase__   :      Dict=None				,    lowerCAmelCase__   :      List[Any] = None				,    lowerCAmelCase__   :      Union[str, Any] = None				,    lowerCAmelCase__   :      List[str] = None				,    lowerCAmelCase__   :      Dict = None				,    lowerCAmelCase__   :      Any = None				,    lowerCAmelCase__   :      str = None				,    lowerCAmelCase__   :      Union[str, Any] = None				,    lowerCAmelCase__   :      Dict = None				,    lowerCAmelCase__   :      List[Any] = ChannelDimension.FIRST				,    **lowerCAmelCase__   :      Optional[Any]				,    ):

             """simple docstring"""
             SCREAMING_SNAKE_CASE					:      int     					=			do_resize if do_resize is not None else self.do_resize
             SCREAMING_SNAKE_CASE					:      List[str]     					=			resample if resample is not None else self.resample
             SCREAMING_SNAKE_CASE					:      Optional[int]     					=			do_center_crop if do_center_crop is not None else self.do_center_crop
             SCREAMING_SNAKE_CASE					:      Any     					=			do_rescale if do_rescale is not None else self.do_rescale
             SCREAMING_SNAKE_CASE					:      str     					=			rescale_factor if rescale_factor is not None else self.rescale_factor
             SCREAMING_SNAKE_CASE					:      Tuple     					=			do_normalize if do_normalize is not None else self.do_normalize
             SCREAMING_SNAKE_CASE					:      Any     					=			image_mean if image_mean is not None else self.image_mean
             SCREAMING_SNAKE_CASE					:      List[Any]     					=			image_std if image_std is not None else self.image_std

             SCREAMING_SNAKE_CASE					:      List[Any]     					=			size if size is not None else self.size
             SCREAMING_SNAKE_CASE					:      Optional[int]     					=			get_size_dict(_a				)
             SCREAMING_SNAKE_CASE					:      List[str]     					=			crop_size if crop_size is not None else self.crop_size
             SCREAMING_SNAKE_CASE					:      Any     					=			get_size_dict(_a				,    param_name='''crop_size'''				)

             SCREAMING_SNAKE_CASE					:      Tuple     					=			make_list_of_images(_a				)

             if not valid_images(_a				):
                    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 or resample is None:
                    raise ValueError('''Size and resample 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.'''				)

             # All transformations expect numpy arrays.
             SCREAMING_SNAKE_CASE					:      Dict     					=			[to_numpy_array(_a				) for image in images]

             if do_resize:
                    SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			[self.resize(image=_a				,    size=_a				,    resample=_a				) for image in images]

             if do_center_crop:
                    SCREAMING_SNAKE_CASE					:      Tuple     					=			[self.center_crop(image=_a				,    size=_a				) for image in images]

             if do_rescale:
                    SCREAMING_SNAKE_CASE					:      Any     					=			[self.rescale(image=_a				,    scale=_a				) for image in images]

             if do_normalize:
                    SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			[self.normalize(image=_a				,    mean=_a				,    std=_a				) for image in images]

             SCREAMING_SNAKE_CASE					:      Optional[int]     					=			[to_channel_dimension_format(_a				,    _a				) for image in images]

             SCREAMING_SNAKE_CASE					:      int     					=			{"""pixel_values""": images}
             return BatchFeature(data=_a				,    tensor_type=_a				)









'''simple docstring'''



import json
import os
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 FEATURE_EXTRACTOR_NAME, is_vision_available


if is_vision_available():
							from PIL import Image

							from transformers import ChineseCLIPImageProcessor, ChineseCLIPProcessor
@require_vision
class 	lowerCamelCase_							(					unittest.TestCase			):







						def 					__lowercase    (  self   :      Optional[int]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			tempfile.mkdtemp()

													SCREAMING_SNAKE_CASE					:      int     					=			[
													    '''[UNK]''',
													    '''[CLS]''',
													    '''[SEP]''',
													    '''[PAD]''',
													    '''[MASK]''',
													    '''的''',
													    '''价''',
													    '''格''',
													    '''是''',
													    '''15''',
													    '''便''',
													    '''alex''',
													    '''##andra''',
													    '''，''',
													    '''。''',
													    '''-''',
													    '''t''',
													    '''shirt''',
													]
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			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]				)				)

													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			{
													    '''do_resize''': True,
													    '''size''': {'''height''': 2_24, '''width''': 2_24},
													    '''do_center_crop''': True,
													    '''crop_size''': {'''height''': 18, '''width''': 18},
													    '''do_normalize''': True,
													    '''image_mean''': [0.4814_5466, 0.457_8275, 0.4082_1073],
													    '''image_std''': [0.2686_2954, 0.2613_0258, 0.2757_7711],
													    '''do_convert_rgb''': True,
													}
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			os.path.join(self.tmpdirname				,    lowerCAmelCase__				)
													with open(self.image_processor_file				,    '''w'''				,    encoding='''utf-8'''				) as fp:
																				json.dump(lowerCAmelCase__				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      str				,    **lowerCAmelCase__   :      int				):

													"""simple docstring"""
													return BertTokenizer.from_pretrained(self.tmpdirname				,    **lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Any				,    **lowerCAmelCase__   :      Dict				):

													"""simple docstring"""
													return BertTokenizerFast.from_pretrained(self.tmpdirname				,    **lowerCAmelCase__				)







						def 					__lowercase    (  self   :      List[Any]				,    **lowerCAmelCase__   :      Dict				):

													"""simple docstring"""
													return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname				,    **lowerCAmelCase__				)







						def 					__lowercase    (  self   :      List[Any]				):

													"""simple docstring"""
													shutil.rmtree(self.tmpdirname				)







						def 					__lowercase    (  self   :      int				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Dict     					=			[np.random.randint(2_55				,    size=(3, 30, 4_00)				,    dtype=np.uinta				)]

													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			[Image.fromarray(np.moveaxis(lowerCAmelCase__				,    0				,    -1				)				) for x in image_inputs]

													return image_inputs







						def 					__lowercase    (  self   :      int				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Dict     					=			self.get_tokenizer()
													SCREAMING_SNAKE_CASE					:      str     					=			self.get_rust_tokenizer()
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.get_image_processor()

													SCREAMING_SNAKE_CASE					:      Dict     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)
													processor_slow.save_pretrained(self.tmpdirname				)
													SCREAMING_SNAKE_CASE					:      List[str]     					=			ChineseCLIPProcessor.from_pretrained(self.tmpdirname				,    use_fast=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      int     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)
													processor_fast.save_pretrained(self.tmpdirname				)
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			ChineseCLIPProcessor.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				,    lowerCAmelCase__				)
													self.assertIsInstance(processor_fast.tokenizer				,    lowerCAmelCase__				)

													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				,    lowerCAmelCase__				)
													self.assertIsInstance(processor_fast.image_processor				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Tuple				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			ChineseCLIPProcessor(tokenizer=self.get_tokenizer()				,    image_processor=self.get_image_processor()				)
													processor.save_pretrained(self.tmpdirname				)

													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.get_tokenizer(cls_token='''(CLS)'''				,    sep_token='''(SEP)'''				)
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.get_image_processor(do_normalize=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			ChineseCLIPProcessor.from_pretrained(
													    self.tmpdirname				,    cls_token='''(CLS)'''				,    sep_token='''(SEP)'''				,    do_normalize=lowerCAmelCase__				)

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

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







						def 					__lowercase    (  self   :      Optional[Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Any     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      str     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Tuple     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      Tuple     					=			self.prepare_image_inputs()

													SCREAMING_SNAKE_CASE					:      List[Any]     					=			image_processor(lowerCAmelCase__				,    return_tensors='''np'''				)
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			processor(images=lowerCAmelCase__				,    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 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Tuple     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      int     					=			'''Alexandra，T-shirt的价格是15便士。'''

													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			processor(text=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      List[str]     					=			tokenizer(lowerCAmelCase__				)

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







						def 					__lowercase    (  self   :      Optional[int]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Tuple     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      str     					=			'''Alexandra，T-shirt的价格是15便士。'''
													SCREAMING_SNAKE_CASE					:      Tuple     					=			self.prepare_image_inputs()

													SCREAMING_SNAKE_CASE					:      List[str]     					=			processor(text=lowerCAmelCase__				,    images=lowerCAmelCase__				)

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

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







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Tuple     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Tuple     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

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

													SCREAMING_SNAKE_CASE					:      Any     					=			processor.batch_decode(lowerCAmelCase__				)
													SCREAMING_SNAKE_CASE					:      Tuple     					=			tokenizer.batch_decode(lowerCAmelCase__				)

													self.assertListEqual(lowerCAmelCase__				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      str     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      List[str]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Dict     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      int     					=			'''Alexandra，T-shirt的价格是15便士。'''
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.prepare_image_inputs()

													SCREAMING_SNAKE_CASE					:      Any     					=			processor(text=lowerCAmelCase__				,    images=lowerCAmelCase__				)

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




