

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


if is_torch_available():
					import torch

if is_vision_available():
					from PIL import Image

					from transformers import ChineseCLIPImageProcessor

class 						__UpperCamelCase    (					unittest.TestCase						):




	def __init__(		self	:						Dict		,	lowerCAmelCase	:						List[str]		,	lowerCAmelCase	:						Optional[Any]=7		,	lowerCAmelCase	:						Optional[int]=3		,	lowerCAmelCase	:						Any=18		,	lowerCAmelCase	:						Optional[Any]=30		,	lowerCAmelCase	:						Optional[Any]=400		,	lowerCAmelCase	:						Union[str, Any]=True		,	lowerCAmelCase	:						Optional[Any]=None		,	lowerCAmelCase	:						str=True		,	lowerCAmelCase	:						Tuple=None		,	lowerCAmelCase	:						Optional[Any]=True		,	lowerCAmelCase	:						str=[0.48_145_466, 0.4_578_275, 0.40_821_073]		,	lowerCAmelCase	:						int=[0.26_862_954, 0.26_130_258, 0.27_577_711]		,	lowerCAmelCase	:						int=True		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			size if size is not None else {"height": 224, "width": 224}
		UpperCAmelCase_       				=			crop_size if crop_size is not None else {"height": 18, "width": 18}
		UpperCAmelCase_       				=			parent
		UpperCAmelCase_       				=			batch_size
		UpperCAmelCase_       				=			num_channels
		UpperCAmelCase_       				=			image_size
		UpperCAmelCase_       				=			min_resolution
		UpperCAmelCase_       				=			max_resolution
		UpperCAmelCase_       				=			do_resize
		UpperCAmelCase_       				=			size
		UpperCAmelCase_       				=			do_center_crop
		UpperCAmelCase_       				=			crop_size
		UpperCAmelCase_       				=			do_normalize
		UpperCAmelCase_       				=			image_mean
		UpperCAmelCase_       				=			image_std
		UpperCAmelCase_       				=			do_convert_rgb




	def       __A					(		self	:						Optional[int]							):


		'''simple docstring'''







		return {
		    "do_resize": self.do_resize,
		    "size": self.size,
		    "do_center_crop": self.do_center_crop,
		    "crop_size": self.crop_size,
		    "do_normalize": self.do_normalize,
		    "image_mean": self.image_mean,
		    "image_std": self.image_std,
		    "do_convert_rgb": self.do_convert_rgb,
		}




	def       __A					(		self	:						List[Any]		,	lowerCAmelCase	:						List[Any]=False		,	lowerCAmelCase	:						Dict=False		,	lowerCAmelCase	:						List[Any]=False							):


		'''simple docstring'''







		assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

		if equal_resolution:
			UpperCAmelCase_       				=			[]
			for i in range(self.batch_size							):
				image_inputs.append(
				    np.random.randint(
				        255		,	size=(self.num_channels, self.max_resolution, self.max_resolution)		,	dtype=np.uinta							)							)
		else:
			UpperCAmelCase_       				=			[]
			for i in range(self.batch_size							):
				UpperCAmelCase_				,   UpperCAmelCase_       				=			np.random.choice(np.arange(self.min_resolution		,	self.max_resolution							)		,	2							)
				image_inputs.append(np.random.randint(255		,	size=(self.num_channels, width, height)		,	dtype=np.uinta							)							)

		if not numpify and not torchify:
			# PIL expects the channel dimension as last dimension
			UpperCAmelCase_       				=			[Image.fromarray(np.moveaxis(__UpperCamelCase		,	0		,	-1							)							) for x in image_inputs]

		if torchify:
			UpperCAmelCase_       				=			[torch.from_numpy(__UpperCamelCase							) for x in image_inputs]

		return image_inputs


@require_torch
@require_vision
class 						__UpperCamelCase    (					lowercase     ,     unittest.TestCase						):
	SCREAMING_SNAKE_CASE__    				=     ChineseCLIPImageProcessor if is_vision_available() else None




	def       __A					(		self	:						List[Any]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			ChineseCLIPImageProcessingTester(self		,	do_center_crop=__UpperCamelCase							)




	@property
	def       __A					(		self	:						int							):


		'''simple docstring'''







		return self.image_processor_tester.prepare_image_processor_dict()




	def       __A					(		self	:						Optional[Any]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			self.image_processing_class(**self.image_processor_dict							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"do_resize"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"size"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"do_center_crop"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"center_crop"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"do_normalize"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"image_mean"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"image_std"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"do_convert_rgb"							)							)




	def       __A					(		self	:						Optional[int]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			self.image_processing_class.from_dict(self.image_processor_dict							)
		self.assertEqual(image_processor.size		,	{"height": 224, "width": 224}							)
		self.assertEqual(image_processor.crop_size		,	{"height": 18, "width": 18}							)

		UpperCAmelCase_       				=			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       __A					(		self	:						Any							):


		'''simple docstring'''







		pass




	def       __A					(		self	:						List[str]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			self.image_processing_class(**self.image_processor_dict							)
		# create random PIL images
		UpperCAmelCase_       				=			self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase							)
		for image in image_inputs:
			self.assertIsInstance(__UpperCamelCase		,	Image.Image							)

		# Test not batched input
		UpperCAmelCase_       				=			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
		UpperCAmelCase_       				=			image_processing(__UpperCamelCase		,	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       __A					(		self	:						str							):


		'''simple docstring'''







		UpperCAmelCase_       				=			self.image_processing_class(**self.image_processor_dict							)
		# create random numpy tensors
		UpperCAmelCase_       				=			self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase		,	numpify=__UpperCamelCase							)
		for image in image_inputs:
			self.assertIsInstance(__UpperCamelCase		,	np.ndarray							)

		# Test not batched input
		UpperCAmelCase_       				=			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
		UpperCAmelCase_       				=			image_processing(__UpperCamelCase		,	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       __A					(		self	:						Optional[int]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			self.image_processing_class(**self.image_processor_dict							)
		# create random PyTorch tensors
		UpperCAmelCase_       				=			self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase		,	torchify=__UpperCamelCase							)
		for image in image_inputs:
			self.assertIsInstance(__UpperCamelCase		,	torch.Tensor							)

		# Test not batched input
		UpperCAmelCase_       				=			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
		UpperCAmelCase_       				=			image_processing(__UpperCamelCase		,	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"],
		    )		,	)


@require_torch
@require_vision
class 						__UpperCamelCase    (					lowercase     ,     unittest.TestCase						):
	SCREAMING_SNAKE_CASE__    				=     ChineseCLIPImageProcessor if is_vision_available() else None




	def       __A					(		self	:						List[str]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			ChineseCLIPImageProcessingTester(self		,	num_channels=4		,	do_center_crop=__UpperCamelCase							)
		UpperCAmelCase_       				=			3




	@property
	def       __A					(		self	:						Optional[int]							):


		'''simple docstring'''







		return self.image_processor_tester.prepare_image_processor_dict()




	def       __A					(		self	:						Dict							):


		'''simple docstring'''







		UpperCAmelCase_       				=			self.image_processing_class(**self.image_processor_dict							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"do_resize"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"size"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"do_center_crop"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"center_crop"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"do_normalize"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"image_mean"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"image_std"							)							)
		self.assertTrue(hasattr(__UpperCamelCase		,	"do_convert_rgb"							)							)




	def       __A					(		self	:						List[Any]							):


		'''simple docstring'''







		pass




	def       __A					(		self	:						List[str]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			self.image_processing_class(**self.image_processor_dict							)
		# create random PIL images
		UpperCAmelCase_       				=			self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase							)
		for image in image_inputs:
			self.assertIsInstance(__UpperCamelCase		,	Image.Image							)

		# Test not batched input
		UpperCAmelCase_       				=			image_processing(image_inputs[0]		,	return_tensors="pt"							).pixel_values
		self.assertEqual(
		    encoded_images.shape		,	(
		        1,
		        self.expected_encoded_image_num_channels,
		        self.image_processor_tester.crop_size["height"],
		        self.image_processor_tester.crop_size["width"],
		    )		,	)

		# Test batched
		UpperCAmelCase_       				=			image_processing(__UpperCamelCase		,	return_tensors="pt"							).pixel_values
		self.assertEqual(
		    encoded_images.shape		,	(
		        self.image_processor_tester.batch_size,
		        self.expected_encoded_image_num_channels,
		        self.image_processor_tester.crop_size["height"],
		        self.image_processor_tester.crop_size["width"],
		    )		,	)


import warnings
from typing import Dict, List, Optional, Tuple

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


_a:    Dict 							=			logging.get_logger(__name__)

class 						__UpperCamelCase    (					lowercase						):
	SCREAMING_SNAKE_CASE__    				=     ['input_ids', 'attention_mask']




	def __init__(		self	:						Tuple		,	lowerCAmelCase	:						Union[str, Any]="</s>"		,	lowerCAmelCase	:						str="<unk>"		,	lowerCAmelCase	:						Optional[int]="<pad>"		,	lowerCAmelCase	:						List[str]=125		,	lowerCAmelCase	:						List[Any]=None		,	**lowerCAmelCase	:						Optional[Any]		,	):


		'''simple docstring'''







		if extra_ids > 0 and additional_special_tokens is None:
			UpperCAmelCase_       				=			[F"<extra_id_{i}>" for i in range(lowerCAmelCase							)]
		elif extra_ids > 0 and additional_special_tokens is not None:
			# Check that we have the right number of extra_id special tokens
			UpperCAmelCase_       				=			len(set(filter(lambda lowerCAmelCase							: bool("extra_id" in str(lowerCAmelCase							)							)		,	lowerCAmelCase							)							)							)
			if extra_tokens != extra_ids:
				raise ValueError(
				    F"Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are"
				    " provided to ByT5Tokenizer. In this case the additional_special_tokens must include the"
				    " extra_ids tokens"							)

		UpperCAmelCase_       				=			AddedToken(lowerCAmelCase		,	lstrip=lowerCAmelCase		,	rstrip=lowerCAmelCase							) if isinstance(lowerCAmelCase		,	lowerCAmelCase							) else pad_token
		UpperCAmelCase_       				=			AddedToken(lowerCAmelCase		,	lstrip=lowerCAmelCase		,	rstrip=lowerCAmelCase							) if isinstance(lowerCAmelCase		,	lowerCAmelCase							) else eos_token
		UpperCAmelCase_       				=			AddedToken(lowerCAmelCase		,	lstrip=lowerCAmelCase		,	rstrip=lowerCAmelCase							) if isinstance(lowerCAmelCase		,	lowerCAmelCase							) else unk_token

		super().__init__(
		    eos_token=lowerCAmelCase		,	unk_token=lowerCAmelCase		,	pad_token=lowerCAmelCase		,	extra_ids=lowerCAmelCase		,	additional_special_tokens=lowerCAmelCase		,	**lowerCAmelCase		,	)

		UpperCAmelCase_       				=			extra_ids

		UpperCAmelCase_       				=			2**8  # utf is 8 bits

		# define special tokens dict
		UpperCAmelCase_       				=			{
		    self.pad_token: 0,
		    self.eos_token: 1,
		    self.unk_token: 2,
		}
		UpperCAmelCase_       				=			len(self.special_tokens_encoder							)
		UpperCAmelCase_       				=			len(lowerCAmelCase							)
		for i, token in enumerate(lowerCAmelCase							):
			UpperCAmelCase_       				=			self.vocab_size + i - n
		UpperCAmelCase_       				=			{v: k for k, v in self.special_tokens_encoder.items()}




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


		'''simple docstring'''







		return self._utf_vocab_size + self._num_special_tokens + self._extra_ids




	def       __A					(		self	:						List[Any]		,	lowerCAmelCase	:						List[int]		,	lowerCAmelCase	:						Optional[List[int]] = None		,	lowerCAmelCase	:						bool = False							):


		'''simple docstring'''







		if already_has_special_tokens:
			return super().get_special_tokens_mask(
			    token_ids_a=lowerCAmelCase		,	token_ids_a=lowerCAmelCase		,	already_has_special_tokens=lowerCAmelCase							)

		# normal case: some special tokens
		if token_ids_a is None:
			return ([0] * len(lowerCAmelCase							)) + [1]
		return ([0] * len(lowerCAmelCase							)) + [1] + ([0] * len(lowerCAmelCase							)) + [1]




	def       __A					(		self	:						Any		,	lowerCAmelCase	:						List[int]							):


		'''simple docstring'''







		if len(lowerCAmelCase							) > 0 and token_ids[-1] == self.eos_token_id:
			warnings.warn(
			    F"This sequence already has {self.eos_token}. In future versions this behavior may lead to duplicated"
			    " eos tokens being added."							)
			return token_ids
		else:
			return token_ids + [self.eos_token_id]




	def       __A					(		self	:						Optional[Any]		,	lowerCAmelCase	:						List[int]		,	lowerCAmelCase	:						Optional[List[int]] = None							):


		'''simple docstring'''







		UpperCAmelCase_       				=			[self.eos_token_id]

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




	def       __A					(		self	:						Tuple		,	lowerCAmelCase	:						List[int]		,	lowerCAmelCase	:						Optional[List[int]] = None							):


		'''simple docstring'''







		UpperCAmelCase_       				=			self._add_eos_if_not_present(lowerCAmelCase							)
		if token_ids_a is None:
			return token_ids_a
		else:
			UpperCAmelCase_       				=			self._add_eos_if_not_present(lowerCAmelCase							)
			return token_ids_a + token_ids_a




	def       __A					(		self	:						List[str]		,	lowerCAmelCase	:						str							):


		'''simple docstring'''







		UpperCAmelCase_       				=			[chr(lowerCAmelCase							) for i in text.encode("utf-8"							)]
		return tokens




	def       __A					(		self	:						Optional[Any]		,	lowerCAmelCase	:						List[Any]							):


		'''simple docstring'''







		if token in self.special_tokens_encoder:
			UpperCAmelCase_       				=			self.special_tokens_encoder[token]
		elif token in self.added_tokens_encoder:
			UpperCAmelCase_       				=			self.added_tokens_encoder[token]
		elif len(lowerCAmelCase							) != 1:
			UpperCAmelCase_       				=			self.unk_token_id
		else:
			UpperCAmelCase_       				=			ord(lowerCAmelCase							) + self._num_special_tokens
		return token_id




	def       __A					(		self	:						str		,	lowerCAmelCase	:						Any							):


		'''simple docstring'''







		if index in self.special_tokens_decoder:
			UpperCAmelCase_       				=			self.special_tokens_decoder[index]
		else:
			UpperCAmelCase_       				=			chr(index - self._num_special_tokens							)
		return token




	def       __A					(		self	:						Union[str, Any]		,	lowerCAmelCase	:						Union[str, Any]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			b""
		for token in tokens:
			if token in self.special_tokens_decoder:
				UpperCAmelCase_       				=			self.special_tokens_decoder[token].encode("utf-8"							)
			elif token in self.added_tokens_decoder:
				UpperCAmelCase_       				=			self.special_tokens_decoder[token].encode("utf-8"							)
			elif token in self.special_tokens_encoder:
				UpperCAmelCase_       				=			token.encode("utf-8"							)
			elif token in self.added_tokens_encoder:
				UpperCAmelCase_       				=			token.encode("utf-8"							)
			else:
				UpperCAmelCase_       				=			bytes([ord(lowerCAmelCase							)]							)
			bstring += tok_string
		UpperCAmelCase_       				=			bstring.decode("utf-8"		,	errors="ignore"							)
		return string




	def       __A					(		self	:						List[Any]		,	lowerCAmelCase	:						str		,	lowerCAmelCase	:						Optional[str] = None							):


		'''simple docstring'''







		return ()