
"""simple docstring"""


import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image

							from transformers import MobileNetVaImageProcessor

class    A_     (					unittest.TestCase       ):



							"""simple docstring"""






							def __init__(  self  :Dict					,							lowerCamelCase_  :Union[str, Any]					,							lowerCamelCase_  :Optional[int]=7					,							lowerCamelCase_  :Optional[Any]=3					,							lowerCamelCase_  :str=18					,							lowerCamelCase_  :int=30					,							lowerCamelCase_  :int=400					,							lowerCamelCase_  :int=True					,							lowerCamelCase_  :Optional[int]=None					,							lowerCamelCase_  :str=True					,							lowerCamelCase_  :Dict=None					,							):





										"""simple docstring"""

										lowerCamelCase__     :					Dict		=size if size is not None else {'shortest_edge': 20}
										lowerCamelCase__     :					int		=crop_size if crop_size is not None else {'height': 18, 'width': 18}
										lowerCamelCase__     :					Any		=parent
										lowerCamelCase__     :					Optional[int]		=batch_size
										lowerCamelCase__     :					List[str]		=num_channels
										lowerCamelCase__     :					Tuple		=image_size
										lowerCamelCase__     :					Optional[Any]		=min_resolution
										lowerCamelCase__     :					List[str]		=max_resolution
										lowerCamelCase__     :					Dict		=do_resize
										lowerCamelCase__     :					int		=size
										lowerCamelCase__     :					List[str]		=do_center_crop
										lowerCamelCase__     :					Tuple		=crop_size





							def 				UpperCAmelCase__							(  self  :List[str]	):





										"""simple docstring"""

										return {
										    "do_resize": self.do_resize,
										    "size": self.size,
										    "do_center_crop": self.do_center_crop,
										    "crop_size": self.crop_size,
										}






@require_torch
@require_vision
class    A_     (					A__				, unittest.TestCase       ):



							"""simple docstring"""






							SCREAMING_SNAKE_CASE_     				=       MobileNetVaImageProcessor if is_vision_available() else None





							def 				UpperCAmelCase__							(  self  :Dict	):





										"""simple docstring"""

										lowerCamelCase__     :					Optional[int]		=MobileNetVaImageProcessingTester(self	)





							@property
							def 				UpperCAmelCase__							(  self  :Optional[Any]	):





										"""simple docstring"""

										return self.image_processor_tester.prepare_image_processor_dict()





							def 				UpperCAmelCase__							(  self  :str	):





										"""simple docstring"""

										lowerCamelCase__     :					List[Any]		=self.image_processing_class(**self.image_processor_dict	)
										self.assertTrue(hasattr(lowerCamelCase_					,							'do_resize'	)	)
										self.assertTrue(hasattr(lowerCamelCase_					,							'size'	)	)
										self.assertTrue(hasattr(lowerCamelCase_					,							'do_center_crop'	)	)
										self.assertTrue(hasattr(lowerCamelCase_					,							'center_crop'	)	)





							def 				UpperCAmelCase__							(  self  :int	):





										"""simple docstring"""

										lowerCamelCase__     :					List[Any]		=self.image_processing_class.from_dict(self.image_processor_dict	)
										self.assertEqual(image_processor.size					,							{'shortest_edge': 20}	)
										self.assertEqual(image_processor.crop_size					,							{'height': 18, 'width': 18}	)

										lowerCamelCase__     :					Optional[Any]		=self.image_processing_class.from_dict(self.image_processor_dict					,							size=42					,							crop_size=84	)
										self.assertEqual(image_processor.size					,							{'shortest_edge': 42}	)
										self.assertEqual(image_processor.crop_size					,							{'height': 84, 'width': 84}	)





							def 				UpperCAmelCase__							(  self  :Any	):





										"""simple docstring"""

										pass





							def 				UpperCAmelCase__							(  self  :Any	):





										"""simple docstring"""

										lowerCamelCase__     :					Any		=self.image_processing_class(**self.image_processor_dict	)
										# create random PIL images
										lowerCamelCase__     :					Optional[Any]		=prepare_image_inputs(self.image_processor_tester					,							equal_resolution=lowerCamelCase_	)
										for image in image_inputs:
													self.assertIsInstance(lowerCamelCase_					,							Image.Image	)

										# Test not batched input
										lowerCamelCase__     :					int		=image_processing(image_inputs[0]					,							return_tensors='pt'	).pixel_values
										self.assertEqual(
										    encoded_images.shape					,							(
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )					,							)

										# Test batched
										lowerCamelCase__     :					str		=image_processing(lowerCamelCase_					,							return_tensors='pt'	).pixel_values
										self.assertEqual(
										    encoded_images.shape					,							(
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )					,							)





							def 				UpperCAmelCase__							(  self  :Optional[Any]	):





										"""simple docstring"""

										lowerCamelCase__     :					int		=self.image_processing_class(**self.image_processor_dict	)
										# create random numpy tensors
										lowerCamelCase__     :					int		=prepare_image_inputs(self.image_processor_tester					,							equal_resolution=lowerCamelCase_					,							numpify=lowerCamelCase_	)
										for image in image_inputs:
													self.assertIsInstance(lowerCamelCase_					,							np.ndarray	)

										# Test not batched input
										lowerCamelCase__     :					List[Any]		=image_processing(image_inputs[0]					,							return_tensors='pt'	).pixel_values
										self.assertEqual(
										    encoded_images.shape					,							(
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )					,							)

										# Test batched
										lowerCamelCase__     :					Optional[Any]		=image_processing(lowerCamelCase_					,							return_tensors='pt'	).pixel_values
										self.assertEqual(
										    encoded_images.shape					,							(
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )					,							)





							def 				UpperCAmelCase__							(  self  :Optional[int]	):





										"""simple docstring"""

										lowerCamelCase__     :					int		=self.image_processing_class(**self.image_processor_dict	)
										# create random PyTorch tensors
										lowerCamelCase__     :					Any		=prepare_image_inputs(self.image_processor_tester					,							equal_resolution=lowerCamelCase_					,							torchify=lowerCamelCase_	)
										for image in image_inputs:
													self.assertIsInstance(lowerCamelCase_					,							torch.Tensor	)

										# Test not batched input
										lowerCamelCase__     :					Dict		=image_processing(image_inputs[0]					,							return_tensors='pt'	).pixel_values
										self.assertEqual(
										    encoded_images.shape					,							(
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )					,							)

										# Test batched
										lowerCamelCase__     :					List[str]		=image_processing(lowerCamelCase_					,							return_tensors='pt'	).pixel_values
										self.assertEqual(
										    encoded_images.shape					,							(
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )					,							)

"""simple docstring"""


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_     (					A__       ):



							"""simple docstring"""






							SCREAMING_SNAKE_CASE_     				=       VOCAB_FILES_NAMES
							SCREAMING_SNAKE_CASE_     				=       PRETRAINED_VOCAB_FILES_MAP
							SCREAMING_SNAKE_CASE_     				=       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							SCREAMING_SNAKE_CASE_     				=       ["""input_ids""", """attention_mask"""]
							SCREAMING_SNAKE_CASE_     				=       CLIPTokenizer





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





										"""simple docstring"""

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

										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 				UpperCAmelCase__							(  self  :Union[str, Any]	):





										"""simple docstring"""

										lowerCamelCase__     :					List[str]		=self.backend_tokenizer.decode

										def new_decode_method(*lowerCamelCase_  :Optional[int]					,							**lowerCamelCase_  :List[Any]	):
													lowerCamelCase__     :					Any		=orig_decode_method(*lowerCamelCase_					,							**lowerCamelCase_	)
													lowerCamelCase__     :					Optional[int]		=text.replace(self.backend_tokenizer.model.end_of_word_suffix					,							' '	).strip()
													return text

										lowerCamelCase__     :					Optional[Any]		=new_decode_method





							def 				UpperCAmelCase__							(  self  :List[str]					,							lowerCamelCase_  :List[int]					,							lowerCamelCase_  :Optional[List[int]] = None	):





										"""simple docstring"""

										lowerCamelCase__     :					Any		=[self.bos_token_id]
										lowerCamelCase__     :					Any		=[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 				UpperCAmelCase__							(  self  :List[Any]					,							lowerCamelCase_  :List[int]					,							lowerCamelCase_  :Optional[List[int]] = None	):





										"""simple docstring"""

										lowerCamelCase__     :					List[str]		=[self.bos_token_id]
										lowerCamelCase__     :					Optional[Any]		=[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 				UpperCAmelCase__							(  self  :Tuple					,							lowerCamelCase_  :str					,							lowerCamelCase_  :Optional[str] = None	):





										"""simple docstring"""

										lowerCamelCase__     :					int		=self._tokenizer.model.save(lowerCamelCase_					,							name=lowerCamelCase_	)
										return tuple(lowerCamelCase_	)