



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 						UpperCAmelCase_					( unittest.TestCase):







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							str				     =					tempfile.mkdtemp()

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

														_lowerCAmelCase  :							Optional[int]				     =					{
														    "do_resize": True,
														    "size": {"height": 224, "width": 224},
														    "do_center_crop": True,
														    "crop_size": {"height": 18, "width": 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],
														    "do_convert_rgb": True,
														}
														_lowerCAmelCase  :							Union[str, Any]				     =					os.path.join(self.tmpdirname,    __a)
														with open(self.image_processor_file,    "w",    encoding="utf-8") as fp:
																					json.dump(__a,    __a)







							def      snake_case__   (     self,    **__a):

														'''simple docstring'''

														return BertTokenizer.from_pretrained(self.tmpdirname,    **__a)







							def      snake_case__   (     self,    **__a):

														'''simple docstring'''

														return BertTokenizerFast.from_pretrained(self.tmpdirname,    **__a)







							def      snake_case__   (     self,    **__a):

														'''simple docstring'''

														return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname,    **__a)







							def      snake_case__   (     self):

														'''simple docstring'''

														shutil.rmtree(self.tmpdirname)







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							str				     =					[np.random.randint(255,    size=(3, 30, 400),    dtype=np.uinta)]

														_lowerCAmelCase  :							Dict				     =					[Image.fromarray(np.moveaxis(__a,    0,    -1)) for x in image_inputs]

														return image_inputs







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Any				     =					self.get_tokenizer()
														_lowerCAmelCase  :							Optional[int]				     =					self.get_rust_tokenizer()
														_lowerCAmelCase  :							str				     =					self.get_image_processor()

														_lowerCAmelCase  :							Optional[Any]				     =					ChineseCLIPProcessor(tokenizer=__a,    image_processor=__a)
														processor_slow.save_pretrained(self.tmpdirname)
														_lowerCAmelCase  :							int				     =					ChineseCLIPProcessor.from_pretrained(self.tmpdirname,    use_fast=__a)

														_lowerCAmelCase  :							Dict				     =					ChineseCLIPProcessor(tokenizer=__a,    image_processor=__a)
														processor_fast.save_pretrained(self.tmpdirname)
														_lowerCAmelCase  :							Tuple				     =					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,    __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      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							str				     =					ChineseCLIPProcessor(tokenizer=self.get_tokenizer(),    image_processor=self.get_image_processor())
														processor.save_pretrained(self.tmpdirname)

														_lowerCAmelCase  :							str				     =					self.get_tokenizer(cls_token="(CLS)",    sep_token="(SEP)")
														_lowerCAmelCase  :							Any				     =					self.get_image_processor(do_normalize=__a)

														_lowerCAmelCase  :							Optional[int]				     =					ChineseCLIPProcessor.from_pretrained(
														    self.tmpdirname,    cls_token="(CLS)",    sep_token="(SEP)",    do_normalize=__a)

														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      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							List[Any]				     =					self.get_image_processor()
														_lowerCAmelCase  :							List[Any]				     =					self.get_tokenizer()

														_lowerCAmelCase  :							List[str]				     =					ChineseCLIPProcessor(tokenizer=__a,    image_processor=__a)

														_lowerCAmelCase  :							int				     =					self.prepare_image_inputs()

														_lowerCAmelCase  :							List[Any]				     =					image_processor(__a,    return_tensors="np")
														_lowerCAmelCase  :							Tuple				     =					processor(images=__a,    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      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							List[str]				     =					self.get_image_processor()
														_lowerCAmelCase  :							Any				     =					self.get_tokenizer()

														_lowerCAmelCase  :							Any				     =					ChineseCLIPProcessor(tokenizer=__a,    image_processor=__a)

														_lowerCAmelCase  :							Optional[Any]				     =					"Alexandra，T-shirt的价格是15便士。"

														_lowerCAmelCase  :							str				     =					processor(text=__a)

														_lowerCAmelCase  :							int				     =					tokenizer(__a)

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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Any				     =					self.get_image_processor()
														_lowerCAmelCase  :							Any				     =					self.get_tokenizer()

														_lowerCAmelCase  :							Optional[int]				     =					ChineseCLIPProcessor(tokenizer=__a,    image_processor=__a)

														_lowerCAmelCase  :							Union[str, Any]				     =					"Alexandra，T-shirt的价格是15便士。"
														_lowerCAmelCase  :							Dict				     =					self.prepare_image_inputs()

														_lowerCAmelCase  :							Optional[Any]				     =					processor(text=__a,    images=__a)

														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(__a):
																					processor()







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Optional[Any]				     =					self.get_image_processor()
														_lowerCAmelCase  :							List[str]				     =					self.get_tokenizer()

														_lowerCAmelCase  :							List[Any]				     =					ChineseCLIPProcessor(tokenizer=__a,    image_processor=__a)

														_lowerCAmelCase  :							Tuple				     =					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

														_lowerCAmelCase  :							List[Any]				     =					processor.batch_decode(__a)
														_lowerCAmelCase  :							int				     =					tokenizer.batch_decode(__a)

														self.assertListEqual(__a,    __a)







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							List[Any]				     =					self.get_image_processor()
														_lowerCAmelCase  :							Dict				     =					self.get_tokenizer()

														_lowerCAmelCase  :							List[Any]				     =					ChineseCLIPProcessor(tokenizer=__a,    image_processor=__a)

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

														_lowerCAmelCase  :							Dict				     =					processor(text=__a,    images=__a)

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





def        A       (      _lowerCamelCase						):





							'''simple docstring'''




							if length <= 0 or not isinstance(_lowerCamelCase       ,				_lowerCamelCase						):
														raise ValueError("Length must be a positive integer."						)
							return [n * (2 * n - 1) for n in range(_lowerCamelCase						)]


if __name__ == "__main__":
						print(hexagonal_numbers(length=5))
						print(hexagonal_numbers(length=10))
