





"""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       ):
         __a	:  Dict         =					tempfile.mkdtemp()

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

         __a	:  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.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
             '''image_std''': [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
             '''do_convert_rgb''': True,
         }
         __a	:  str         =					os.path.join(self.tmpdirname		,     _UpperCAmelCase       )
         with open(self.image_processor_file		,     '''w'''		,     encoding='''utf-8'''       ) as fp:
             json.dump(_UpperCAmelCase		,     _UpperCAmelCase       )







     def 	_lowerCamelCase						(  self		,     **_UpperCAmelCase       ):
         return BertTokenizer.from_pretrained(self.tmpdirname		,     **_UpperCAmelCase       )







     def 	_lowerCamelCase						(  self		,     **_UpperCAmelCase       ):
         return BertTokenizerFast.from_pretrained(self.tmpdirname		,     **_UpperCAmelCase       )







     def 	_lowerCamelCase						(  self		,     **_UpperCAmelCase       ):
         return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname		,     **_UpperCAmelCase       )







     def 	_lowerCamelCase						(  self       ):
         shutil.rmtree(self.tmpdirname       )







     def 	_lowerCamelCase						(  self       ):
         __a	:  Optional[int]         =					[np.random.randint(255		,     size=(3, 30, 400)		,     dtype=np.uinta       )]

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

         return image_inputs







     def 	_lowerCamelCase						(  self       ):
         __a	:  int         =					self.get_tokenizer()
         __a	:  Optional[int]         =					self.get_rust_tokenizer()
         __a	:  Dict         =					self.get_image_processor()

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

         __a	:  List[str]         =					ChineseCLIPProcessor(tokenizer=_UpperCAmelCase		,     image_processor=_UpperCAmelCase       )
         processor_fast.save_pretrained(self.tmpdirname       )
         __a	:  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		,     _UpperCAmelCase       )
         self.assertIsInstance(processor_fast.tokenizer		,     _UpperCAmelCase       )

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







     def 	_lowerCamelCase						(  self       ):
         __a	:  Optional[Any]         =					ChineseCLIPProcessor(tokenizer=self.get_tokenizer()		,     image_processor=self.get_image_processor()       )
         processor.save_pretrained(self.tmpdirname       )

         __a	:  Optional[int]         =					self.get_tokenizer(cls_token='''(CLS)'''		,     sep_token='''(SEP)'''       )
         __a	:  Tuple         =					self.get_image_processor(do_normalize=_UpperCAmelCase       )

         __a	:  int         =					ChineseCLIPProcessor.from_pretrained(
             self.tmpdirname		,     cls_token='''(CLS)'''		,     sep_token='''(SEP)'''		,     do_normalize=_UpperCAmelCase       )

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

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







     def 	_lowerCamelCase						(  self       ):
         __a	:  Any         =					self.get_image_processor()
         __a	:  int         =					self.get_tokenizer()

         __a	:  Union[str, Any]         =					ChineseCLIPProcessor(tokenizer=_UpperCAmelCase		,     image_processor=_UpperCAmelCase       )

         __a	:  List[str]         =					self.prepare_image_inputs()

         __a	:  Optional[int]         =					image_processor(_UpperCAmelCase		,     return_tensors='''np'''       )
         __a	:  Optional[int]         =					processor(images=_UpperCAmelCase		,     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       ):
         __a	:  Tuple         =					self.get_image_processor()
         __a	:  Union[str, Any]         =					self.get_tokenizer()

         __a	:  Tuple         =					ChineseCLIPProcessor(tokenizer=_UpperCAmelCase		,     image_processor=_UpperCAmelCase       )

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

         __a	:  int         =					processor(text=_UpperCAmelCase       )

         __a	:  Optional[Any]         =					tokenizer(_UpperCAmelCase       )

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







     def 	_lowerCamelCase						(  self       ):
         __a	:  List[Any]         =					self.get_image_processor()
         __a	:  List[Any]         =					self.get_tokenizer()

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

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

         __a	:  Tuple         =					processor(text=_UpperCAmelCase		,     images=_UpperCAmelCase       )

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







     def 	_lowerCamelCase						(  self       ):
         __a	:  List[Any]         =					self.get_image_processor()
         __a	:  Union[str, Any]         =					self.get_tokenizer()

         __a	:  Tuple         =					ChineseCLIPProcessor(tokenizer=_UpperCAmelCase		,     image_processor=_UpperCAmelCase       )

         __a	:  Union[str, Any]         =					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

         __a	:  int         =					processor.batch_decode(_UpperCAmelCase       )
         __a	:  Optional[Any]         =					tokenizer.batch_decode(_UpperCAmelCase       )

         self.assertListEqual(_UpperCAmelCase		,     _UpperCAmelCase       )







     def 	_lowerCamelCase						(  self       ):
         __a	:  str         =					self.get_image_processor()
         __a	:  int         =					self.get_tokenizer()

         __a	:  Union[str, Any]         =					ChineseCLIPProcessor(tokenizer=_UpperCAmelCase		,     image_processor=_UpperCAmelCase       )

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

         __a	:  str         =					processor(text=_UpperCAmelCase		,     images=_UpperCAmelCase       )

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






"""simple docstring"""






def       __A (     a_  :int				,    a_  :int)						->						str:
				if a < 0 or b < 0:
								raise ValueError('''the value of both inputs must be positive''')

				__a	:  Union[str, Any]         =					str(bin(a_))[2:]  # remove the leading "0b"
				__a	:  Union[str, Any]         =					str(bin(a_))[2:]  # remove the leading "0b"

				__a	:  Optional[Any]         =					max(len(a_)				,    len(a_))

				return "0b" + "".join(
				    str(int(char_a != char_b))
				    for char_a, char_b in zip(a_binary.zfill(a_)				,    b_binary.zfill(a_)))


if __name__ == "__main__":
		import doctest

		doctest.testmod()