


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

		"""simple docstring"""

		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :Any												= tempfile.mkdtemp()

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

							UpperCamelCase__   :Dict												= {
							    '''do_resize''': True,
							    '''size''': {'''height''': 224, '''width''': 224},
							    '''do_center_crop''': True,
							    '''crop_size''': {'''height''': 18, '''width''': 18},
							    '''do_normalize''': True,
							    '''image_mean''': [0.48145466, 0.4578275, 0.40821073],
							    '''image_std''': [0.26862954, 0.26130258, 0.27577711],
							    '''do_convert_rgb''': True,
							}
							UpperCamelCase__   :Optional[Any]												= os.path.join(self.tmpdirname    ,   _snake_case							)
							with open(self.image_processor_file    ,   '''w'''    ,   encoding='''utf-8'''							) as fp:
												json.dump(_snake_case    ,   _snake_case							)




		def     lowerCAmelCase__				(		self    ,   **UpperCamelCase_							):

							'''simple docstring'''


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




		def     lowerCAmelCase__				(		self    ,   **UpperCamelCase_							):

							'''simple docstring'''


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




		def     lowerCAmelCase__				(		self    ,   **UpperCamelCase_							):

							'''simple docstring'''


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




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							shutil.rmtree(self.tmpdirname							)




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


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

							UpperCamelCase__   :Optional[int]												= [Image.fromarray(np.moveaxis(_snake_case    ,   0    ,   -1							)							) for x in image_inputs]

							return image_inputs




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :Dict												= self.get_tokenizer()
							UpperCamelCase__   :List[str]												= self.get_rust_tokenizer()
							UpperCamelCase__   :Optional[int]												= self.get_image_processor()

							UpperCamelCase__   :Union[str, Any]												= ChineseCLIPProcessor(tokenizer=_snake_case    ,   image_processor=_snake_case							)
							processor_slow.save_pretrained(self.tmpdirname							)
							UpperCamelCase__   :Tuple												= ChineseCLIPProcessor.from_pretrained(self.tmpdirname    ,   use_fast=_snake_case							)

							UpperCamelCase__   :str												= ChineseCLIPProcessor(tokenizer=_snake_case    ,   image_processor=_snake_case							)
							processor_fast.save_pretrained(self.tmpdirname							)
							UpperCamelCase__   :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    ,   _snake_case							)
							self.assertIsInstance(processor_fast.tokenizer    ,   _snake_case							)

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




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :int												= ChineseCLIPProcessor(tokenizer=self.get_tokenizer()    ,   image_processor=self.get_image_processor()							)
							processor.save_pretrained(self.tmpdirname							)

							UpperCamelCase__   :Tuple												= self.get_tokenizer(cls_token='''(CLS)'''    ,   sep_token='''(SEP)'''							)
							UpperCamelCase__   :str												= self.get_image_processor(do_normalize=_snake_case							)

							UpperCamelCase__   :Optional[int]												= ChineseCLIPProcessor.from_pretrained(
							    self.tmpdirname    ,   cls_token='''(CLS)'''    ,   sep_token='''(SEP)'''    ,   do_normalize=_snake_case							)

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

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




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


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

							UpperCamelCase__   :int												= ChineseCLIPProcessor(tokenizer=_snake_case    ,   image_processor=_snake_case							)

							UpperCamelCase__   :Tuple												= self.prepare_image_inputs()

							UpperCamelCase__   :List[str]												= image_processor(_snake_case    ,   return_tensors='''np'''							)
							UpperCamelCase__   :int												= processor(images=_snake_case    ,   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     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :Any												= self.get_image_processor()
							UpperCamelCase__   :Tuple												= self.get_tokenizer()

							UpperCamelCase__   :str												= ChineseCLIPProcessor(tokenizer=_snake_case    ,   image_processor=_snake_case							)

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

							UpperCamelCase__   :Union[str, Any]												= processor(text=_snake_case							)

							UpperCamelCase__   :Optional[Any]												= tokenizer(_snake_case							)

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




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :Optional[int]												= self.get_image_processor()
							UpperCamelCase__   :Optional[int]												= self.get_tokenizer()

							UpperCamelCase__   :List[str]												= ChineseCLIPProcessor(tokenizer=_snake_case    ,   image_processor=_snake_case							)

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

							UpperCamelCase__   :List[str]												= processor(text=_snake_case    ,   images=_snake_case							)

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




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


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

							UpperCamelCase__   :Union[str, Any]												= ChineseCLIPProcessor(tokenizer=_snake_case    ,   image_processor=_snake_case							)

							UpperCamelCase__   :str												= [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

							UpperCamelCase__   :Union[str, Any]												= processor.batch_decode(_snake_case							)
							UpperCamelCase__   :Optional[int]												= tokenizer.batch_decode(_snake_case							)

							self.assertListEqual(_snake_case    ,   _snake_case							)




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :List[str]												= self.get_image_processor()
							UpperCamelCase__   :Union[str, Any]												= self.get_tokenizer()

							UpperCamelCase__   :Dict												= ChineseCLIPProcessor(tokenizer=_snake_case    ,   image_processor=_snake_case							)

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

							UpperCamelCase__   :int												= processor(text=_snake_case    ,   images=_snake_case							)

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

from math import ceil


def     __lowerCAmelCase			(			a__ = 1001  )       ->  int:
				__a										=    1

				for i in range(1						,    int(ceil(n / 2.0  )  )  ):
								__a										=    2 * i + 1
								__a										=    2 * i
								__a										=    total + 4 * odd**2 - 6 * even

				return total


if __name__ == "__main__":
					import sys

					if len(sys.argv) == 1:
										print(solution())
					else:
										try:
															A     :	List[Any]    = int(sys.argv[1])
															print(solution(n))
										except ValueError:
															print('Invalid entry - please enter a number')