






import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip 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 CLIPImageProcessor, CLIPProcessor




@require_vision
class  UpperCamelCase_      (			unittest.TestCase				):



	'''simple docstring'''




	def 							_UpperCamelCase			(       self					)       ->    Optional[Any]:
								snake_case_				=							tempfile.mkdtemp()

								# fmt: off
								snake_case_				=							['l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'lo', 'l</w>', 'w</w>', 'r</w>', 't</w>', 'low</w>', 'er</w>', 'lowest</w>', 'newer</w>', 'wider', '<unk>', '<|startoftext|>', '<|endoftext|>']
								# fmt: on
								snake_case_				=							dict(zip(a       ,			range(len(a					)					)					)					)
								snake_case_				=							['#version: 0.2', 'l o', 'lo w</w>', 'e r</w>', '']
								snake_case_				=							{'unk_token': '<unk>'}

								snake_case_				=							os.path.join(self.tmpdirname       ,			VOCAB_FILES_NAMES['vocab_file']					)
								snake_case_				=							os.path.join(self.tmpdirname       ,			VOCAB_FILES_NAMES['merges_file']					)
								with open(self.vocab_file       ,			'w'       ,			encoding='utf-8'					) as fp:
															fp.write(json.dumps(a					) + '\n'					)
								with open(self.merges_file       ,			'w'       ,			encoding='utf-8'					) as fp:
															fp.write('\n'.join(a					)					)

								snake_case_				=							{
								    'do_resize': True,
								    'size': 20,
								    'do_center_crop': True,
								    'crop_size': 18,
								    'do_normalize': True,
								    'image_mean': [0.48_145_466, 0.4_578_275, 0.40_821_073],
								    'image_std': [0.26_862_954, 0.26_130_258, 0.27_577_711],
								}
								snake_case_				=							os.path.join(self.tmpdirname       ,			a					)
								with open(self.image_processor_file       ,			'w'       ,			encoding='utf-8'					) as fp:
															json.dump(a       ,			a					)




	def 							_UpperCamelCase			(       self       ,			**a					)       ->    Optional[int]:
								return CLIPTokenizer.from_pretrained(self.tmpdirname       ,			**a					)




	def 							_UpperCamelCase			(       self       ,			**a					)       ->    List[Any]:
								return CLIPTokenizerFast.from_pretrained(self.tmpdirname       ,			**a					)




	def 							_UpperCamelCase			(       self       ,			**a					)       ->    Any:
								return CLIPImageProcessor.from_pretrained(self.tmpdirname       ,			**a					)




	def 							_UpperCamelCase			(       self					)       ->    Union[str, Any]:
								shutil.rmtree(self.tmpdirname					)




	def 							_UpperCamelCase			(       self					)       ->    Optional[Any]:
								snake_case_				=							[np.random.randint(2_55       ,			size=(3, 30, 4_00)       ,			dtype=np.uinta					)]

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

								return image_inputs




	def 							_UpperCamelCase			(       self					)       ->    List[str]:
								snake_case_				=							self.get_tokenizer()
								snake_case_				=							self.get_rust_tokenizer()
								snake_case_				=							self.get_image_processor()

								snake_case_				=							CLIPProcessor(tokenizer=a       ,			image_processor=a					)
								processor_slow.save_pretrained(self.tmpdirname					)
								snake_case_				=							CLIPProcessor.from_pretrained(self.tmpdirname       ,			use_fast=a					)

								snake_case_				=							CLIPProcessor(tokenizer=a       ,			image_processor=a					)
								processor_fast.save_pretrained(self.tmpdirname					)
								snake_case_				=							CLIPProcessor.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       ,			a					)
								self.assertIsInstance(processor_fast.tokenizer       ,			a					)

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




	def 							_UpperCamelCase			(       self					)       ->    List[str]:
								snake_case_				=							CLIPProcessor(tokenizer=self.get_tokenizer()       ,			image_processor=self.get_image_processor()					)
								processor.save_pretrained(self.tmpdirname					)

								snake_case_				=							self.get_tokenizer(bos_token='(BOS)'       ,			eos_token='(EOS)'					)
								snake_case_				=							self.get_image_processor(do_normalize=a       ,			padding_value=1.0					)

								snake_case_				=							CLIPProcessor.from_pretrained(
								    self.tmpdirname       ,			bos_token='(BOS)'       ,			eos_token='(EOS)'       ,			do_normalize=a       ,			padding_value=1.0					)

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

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




	def 							_UpperCamelCase			(       self					)       ->    int:
								snake_case_				=							self.get_image_processor()
								snake_case_				=							self.get_tokenizer()

								snake_case_				=							CLIPProcessor(tokenizer=a       ,			image_processor=a					)

								snake_case_				=							self.prepare_image_inputs()

								snake_case_				=							image_processor(a       ,			return_tensors='np'					)
								snake_case_				=							processor(images=a       ,			return_tensors='np'					)

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




	def 							_UpperCamelCase			(       self					)       ->    Optional[Any]:
								snake_case_				=							self.get_image_processor()
								snake_case_				=							self.get_tokenizer()

								snake_case_				=							CLIPProcessor(tokenizer=a       ,			image_processor=a					)

								snake_case_				=							'lower newer'

								snake_case_				=							processor(text=a					)

								snake_case_				=							tokenizer(a					)

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




	def 							_UpperCamelCase			(       self					)       ->    int:
								snake_case_				=							self.get_image_processor()
								snake_case_				=							self.get_tokenizer()

								snake_case_				=							CLIPProcessor(tokenizer=a       ,			image_processor=a					)

								snake_case_				=							'lower newer'
								snake_case_				=							self.prepare_image_inputs()

								snake_case_				=							processor(text=a       ,			images=a					)

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

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




	def 							_UpperCamelCase			(       self					)       ->    List[Any]:
								snake_case_				=							self.get_image_processor()
								snake_case_				=							self.get_tokenizer()

								snake_case_				=							CLIPProcessor(tokenizer=a       ,			image_processor=a					)

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

								snake_case_				=							processor.batch_decode(a					)
								snake_case_				=							tokenizer.batch_decode(a					)

								self.assertListEqual(a       ,			a					)






	def 							_UpperCamelCase			(       self					)       ->    Any:
								snake_case_				=							self.get_image_processor()
								snake_case_				=							self.get_tokenizer()

								snake_case_				=							CLIPProcessor(tokenizer=a       ,			image_processor=a					)

								snake_case_				=							'lower newer'
								snake_case_				=							self.prepare_image_inputs()

								snake_case_				=							processor(text=a       ,			images=a					)

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













class  UpperCamelCase_      :



	'''simple docstring'''




	def __init__(       self       ,			a					)       ->    None:
								snake_case_				=							set_counts
								snake_case_				=							max(a					)
								snake_case_				=							len(a					)
								snake_case_				=							[1] * num_sets
								snake_case_				=							list(range(a					)					)




	def 							_UpperCamelCase			(       self       ,			a       ,			a					)       ->    bool:
								snake_case_				=							self.get_parent(a					)
								snake_case_				=							self.get_parent(a					)

								if src_parent == dst_parent:
															return False

								if self.ranks[dst_parent] >= self.ranks[src_parent]:
															self.set_counts[dst_parent] += self.set_counts[src_parent]
															snake_case_				=							0
															snake_case_				=							dst_parent
															if self.ranks[dst_parent] == self.ranks[src_parent]:
																						self.ranks[dst_parent] += 1
															snake_case_				=							self.set_counts[dst_parent]
								else:
															self.set_counts[src_parent] += self.set_counts[dst_parent]
															snake_case_				=							0
															snake_case_				=							src_parent
															snake_case_				=							self.set_counts[src_parent]

								snake_case_				=							max(self.max_set       ,			a					)
								return True






	def 							_UpperCamelCase			(       self       ,			a					)       ->    int:
								if self.parents[disj_set] == disj_set:
															return disj_set
								snake_case_				=							self.get_parent(self.parents[disj_set]					)
								return self.parents[disj_set]





