



from collections.abc import Generator
from math import sin




def      __UpperCamelCase     (  _lowerCAmelCase		)	->  bytes:






    if len(_lowerCAmelCase		) != 32:
        raise ValueError("""Input must be of length 32"""		)

    A			:	Optional[int]										=       B""""""
    for i in [3, 2, 1, 0]:
        little_endian += string_aa[8 * i : 8 * i + 8]
    return little_endian




def      __UpperCamelCase     (  _lowerCAmelCase		)	->  bytes:






    if i < 0:
        raise ValueError("""Input must be non-negative"""		)

    A			:	Any										=       format(_lowerCAmelCase				,					"""08x"""		)[-8:]
    A			:	List[str]										=       B""""""
    for i in [3, 2, 1, 0]:
        little_endian_hex += hex_rep[2 * i : 2 * i + 2].encode("""utf-8"""		)
    return little_endian_hex




def      __UpperCamelCase     (  _lowerCAmelCase		)	->  bytes:
    A			:	Tuple										=       B""""""
    for char in message:
        bit_string += format(_lowerCAmelCase				,					"""08b"""		).encode("""utf-8"""		)
    A			:	Optional[Any]										=       format(len(_lowerCAmelCase		)				,					"""064b"""		).encode("""utf-8"""		)

    # Pad bit_string to a multiple of 512 chars
    bit_string += b"1"
    while len(_lowerCAmelCase		) % 512 != 448:
        bit_string += b"0"
    bit_string += to_little_endian(start_len[32:]		) + to_little_endian(start_len[:32]		)

    return bit_string




def      __UpperCamelCase     (  _lowerCAmelCase		)	->  Generator[list[int], None, None]:






    if len(_lowerCAmelCase		) % 512 != 0:
        raise ValueError("""Input must have length that's a multiple of 512"""		)

    for pos in range(0				,					len(_lowerCAmelCase		)				,					512		):
        A			:	Any										=       bit_string[pos : pos + 512]
        A			:	int										=       []
        for i in range(0				,					512				,					32		):
            block_words.append(int(to_little_endian(block[i : i + 32]		)				,					2		)		)
        yield block_words




def      __UpperCamelCase     (  _lowerCAmelCase		)	->  int:






    if i < 0:
        raise ValueError("""Input must be non-negative"""		)

    A			:	str										=       format(_lowerCAmelCase				,					"""032b"""		)
    A			:	Optional[int]										=       """"""
    for c in i_str:
        new_str += "1" if c == "0" else "0"
    return int(_lowerCAmelCase				,					2		)




def      __UpperCamelCase     (  _lowerCAmelCase				,					_lowerCAmelCase		)	->  int:
    return (a + b) % 2**32




def      __UpperCamelCase     (  _lowerCAmelCase				,					_lowerCAmelCase		)	->  int:






    if i < 0:
        raise ValueError("""Input must be non-negative"""		)
    if shift < 0:
        raise ValueError("""Shift must be non-negative"""		)
    return ((i << shift) ^ (i >> (32 - shift))) % 2**32




def      __UpperCamelCase     (  _lowerCAmelCase		)	->  bytes:
    A			:	Any										=       preprocess(_lowerCAmelCase		)

    A			:	Any										=       [int(2**32 * abs(sin(i + 1		)		)		) for i in range(64		)]

    # Starting states
    A			:	Dict										=       0X6745_2301
    A			:	List[str]										=       0Xefcd_ab89
    A			:	Tuple										=       0X98ba_dcfe
    A			:	int										=       0X1032_5476

    A			:	Union[str, Any]										=       [
        7,
        12,
        17,
        22,
        7,
        12,
        17,
        22,
        7,
        12,
        17,
        22,
        7,
        12,
        17,
        22,
        5,
        9,
        14,
        20,
        5,
        9,
        14,
        20,
        5,
        9,
        14,
        20,
        5,
        9,
        14,
        20,
        4,
        11,
        16,
        23,
        4,
        11,
        16,
        23,
        4,
        11,
        16,
        23,
        4,
        11,
        16,
        23,
        6,
        10,
        15,
        21,
        6,
        10,
        15,
        21,
        6,
        10,
        15,
        21,
        6,
        10,
        15,
        21,
    ]

    # Process bit string in chunks, each with 16 32-char words
    for block_words in get_block_words(_lowerCAmelCase		):
        A			:	Any										=       aa
        A			:	Optional[int]										=       ba
        A			:	List[str]										=       ca
        A			:	Any										=       da

        # Hash current chunk
        for i in range(64		):
            if i <= 15:
                # f = (b & c) | (not_32(b) & d)     # Alternate definition for f
                A			:	Dict										=       d ^ (b & (c ^ d))
                A			:	Optional[int]										=       i
            elif i <= 31:
                # f = (d & b) | (not_32(d) & c)     # Alternate definition for f
                A			:	Optional[int]										=       c ^ (d & (b ^ c))
                A			:	List[Any]										=       (5 * i + 1) % 16
            elif i <= 47:
                A			:	Dict										=       b ^ c ^ d
                A			:	Any										=       (3 * i + 5) % 16
            else:
                A			:	Union[str, Any]										=       c ^ (b | not_aa(_lowerCAmelCase		))
                A			:	Union[str, Any]										=       (7 * i) % 16
            A			:	List[Any]										=       (f + a + added_consts[i] + block_words[g]) % 2**32
            A			:	Any										=       d
            A			:	Optional[int]										=       c
            A			:	List[Any]										=       b
            A			:	int										=       sum_aa(_lowerCAmelCase				,					left_rotate_aa(_lowerCAmelCase				,					shift_amounts[i]		)		)

        # Add hashed chunk to running total
        A			:	Optional[int]										=       sum_aa(_lowerCAmelCase				,					_lowerCAmelCase		)
        A			:	List[Any]										=       sum_aa(_lowerCAmelCase				,					_lowerCAmelCase		)
        A			:	List[Any]										=       sum_aa(_lowerCAmelCase				,					_lowerCAmelCase		)
        A			:	List[str]										=       sum_aa(_lowerCAmelCase				,					_lowerCAmelCase		)

    A			:	Union[str, Any]										=       reformat_hex(_lowerCAmelCase		) + reformat_hex(_lowerCAmelCase		) + reformat_hex(_lowerCAmelCase		) + reformat_hex(_lowerCAmelCase		)
    return digest


if __name__ == "__main__":
     import doctest

     doctest.testmod()







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




    '''simple docstring'''






    def       _lowerCAmelCase (	self		):
        A			:	str										=       tempfile.mkdtemp()

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

        A			:	Any										=       {
            """do_resize""": True,
            """size""": {"""height""": 224, """width""": 224},
            """do_center_crop""": True,
            """crop_size""": {"""height""": 18, """width""": 18},
            """do_normalize""": True,
            """image_mean""": [0.4814_5466, 0.457_8275, 0.4082_1073],
            """image_std""": [0.2686_2954, 0.2613_0258, 0.2757_7711],
            """do_convert_rgb""": True,
        }
        A			:	int										=       os.path.join(self.tmpdirname,		lowerCamelCase__		)
        with open(self.image_processor_file,		"""w""",		encoding="""utf-8"""		) as fp:
            json.dump(lowerCamelCase__,		lowerCamelCase__		)






    def       _lowerCAmelCase (	self,		**lowerCamelCase__		):
        return BertTokenizer.from_pretrained(self.tmpdirname,		**lowerCamelCase__		)






    def       _lowerCAmelCase (	self,		**lowerCamelCase__		):
        return BertTokenizerFast.from_pretrained(self.tmpdirname,		**lowerCamelCase__		)






    def       _lowerCAmelCase (	self,		**lowerCamelCase__		):
        return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname,		**lowerCamelCase__		)






    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			:	List[Any]										=       [Image.fromarray(np.moveaxis(lowerCamelCase__,		0,		-1		)		) for x in image_inputs]

        return image_inputs






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

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

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

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






    def       _lowerCAmelCase (	self		):
        A			:	str										=       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			:	Optional[int]										=       self.get_image_processor(do_normalize=lowerCamelCase__		)

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

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

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






    def       _lowerCAmelCase (	self		):
        A			:	Tuple										=       self.get_image_processor()
        A			:	List[str]										=       self.get_tokenizer()

        A			:	List[str]										=       ChineseCLIPProcessor(tokenizer=lowerCamelCase__,		image_processor=lowerCamelCase__		)

        A			:	Any										=       self.prepare_image_inputs()

        A			:	Union[str, Any]										=       image_processor(lowerCamelCase__,		return_tensors="""np"""		)
        A			:	str										=       processor(images=lowerCamelCase__,		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			:	List[str]										=       self.get_image_processor()
        A			:	Tuple										=       self.get_tokenizer()

        A			:	str										=       ChineseCLIPProcessor(tokenizer=lowerCamelCase__,		image_processor=lowerCamelCase__		)

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

        A			:	Optional[Any]										=       processor(text=lowerCamelCase__		)

        A			:	int										=       tokenizer(lowerCamelCase__		)

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






    def       _lowerCAmelCase (	self		):
        A			:	Dict										=       self.get_image_processor()
        A			:	List[str]										=       self.get_tokenizer()

        A			:	int										=       ChineseCLIPProcessor(tokenizer=lowerCamelCase__,		image_processor=lowerCamelCase__		)

        A			:	str										=       """Alexandra，T-shirt的价格是15便士。"""
        A			:	Dict										=       self.prepare_image_inputs()

        A			:	Optional[int]										=       processor(text=lowerCamelCase__,		images=lowerCamelCase__		)

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






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

        A			:	List[str]										=       ChineseCLIPProcessor(tokenizer=lowerCamelCase__,		image_processor=lowerCamelCase__		)

        A			:	int										=       [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

        A			:	List[Any]										=       processor.batch_decode(lowerCamelCase__		)
        A			:	str										=       tokenizer.batch_decode(lowerCamelCase__		)

        self.assertListEqual(lowerCamelCase__,		lowerCamelCase__		)






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

        A			:	Any										=       ChineseCLIPProcessor(tokenizer=lowerCamelCase__,		image_processor=lowerCamelCase__		)

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

        A			:	str										=       processor(text=lowerCamelCase__,		images=lowerCamelCase__		)

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


