



import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding

class       _SCREAMING_SNAKE_CASE	(__UpperCamelCase ):
     lowerCAmelCase					=			["""image_processor""", """tokenizer"""]
     lowerCAmelCase					=			"""CLIPImageProcessor"""
     lowerCAmelCase					=			("""CLIPTokenizer""", """CLIPTokenizerFast""")





     def __init__(       self :							Optional[Any]     ,  UpperCamelCase :							List[Any]=None     ,  UpperCamelCase :							Tuple=None     ,  **UpperCamelCase :							Optional[int]				)->List[Any]:
      __SCREAMING_SNAKE_CASE       :    Dict       =	None
      if "feature_extractor" in kwargs:
       warnings.warn(
           "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
           " instead."     ,  UpperCamelCase     ,  )
       __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	kwargs.pop("feature_extractor"				)

      __SCREAMING_SNAKE_CASE       :    Optional[int]       =	image_processor if image_processor is not None else feature_extractor
      if image_processor is None:
       raise ValueError("You need to specify an `image_processor`."				)
      if tokenizer is None:
       raise ValueError("You need to specify a `tokenizer`."				)

      super().__init__(UpperCamelCase     ,  UpperCamelCase				)





     def __call__(       self :							Optional[Any]     ,  UpperCamelCase :							int=None     ,  UpperCamelCase :							Optional[Any]=None     ,  UpperCamelCase :							str=None     ,  **UpperCamelCase :							Optional[int]				)->Any:

      if text is None and images is None:
       raise ValueError("You have to specify either text or images. Both cannot be none."				)

      if text is not None:
       __SCREAMING_SNAKE_CASE       :    Tuple       =	self.tokenizer(UpperCamelCase     ,  return_tensors=UpperCamelCase     ,  **UpperCamelCase				)

      if images is not None:
       __SCREAMING_SNAKE_CASE       :    List[Any]       =	self.image_processor(UpperCamelCase     ,  return_tensors=UpperCamelCase     ,  **UpperCamelCase				)

      if text is not None and images is not None:
       __SCREAMING_SNAKE_CASE       :    List[str]       =	image_features.pixel_values
       return encoding
      elif text is not None:
       return encoding
      else:
       return BatchEncoding(data=dict(**UpperCamelCase				)     ,  tensor_type=UpperCamelCase				)





     def 	__snake_case    (       self :							Optional[int]     ,  *UpperCamelCase :							Union[str, Any]     ,  **UpperCamelCase :							Optional[int]				)->str:
      return self.tokenizer.batch_decode(*UpperCamelCase     ,  **UpperCamelCase				)





     def 	__snake_case    (       self :							Any     ,  *UpperCamelCase :							List[str]     ,  **UpperCamelCase :							Union[str, Any]				)->Union[str, Any]:
      return self.tokenizer.decode(*UpperCamelCase     ,  **UpperCamelCase				)





     @property
     def 	__snake_case    (       self :							Dict				)->str:
      __SCREAMING_SNAKE_CASE       :    Optional[int]       =	self.tokenizer.model_input_names
      __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	self.image_processor.model_input_names
      return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names				)				)





     @property
     def 	__snake_case    (       self :							Dict				)->str:
      warnings.warn(
          "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."     ,  UpperCamelCase     ,  )
      return self.image_processor_class






     @property
     def 	__snake_case    (       self :							Dict				)->Optional[Any]:
      warnings.warn(
          "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."     ,  UpperCamelCase     ,  )
      return self.image_processor











from collections.abc import Generator
from math import sin






def 	_lowerCAmelCase						(				__lowerCamelCase   :     bytes     ):



 """simple docstring"""





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

 __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	b""
 for i in [3, 2, 1, 0]:
  little_endian += string_aa[8 * i : 8 * i + 8]
 return little_endian






def 	_lowerCAmelCase						(				__lowerCamelCase   :     int     ):



 """simple docstring"""





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

 __SCREAMING_SNAKE_CASE       :    Any       =	format(__lowerCamelCase		,	"08x"     )[-8:]
 __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	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 	_lowerCAmelCase						(				__lowerCamelCase   :     bytes     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    Any       =	b""
 for char in message:
  bit_string += format(__lowerCamelCase		,	"08b"     ).encode("utf-8"     )
 __SCREAMING_SNAKE_CASE       :    List[str]       =	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 	_lowerCAmelCase						(				__lowerCamelCase   :     bytes     ):



 """simple docstring"""





 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     ):
  __SCREAMING_SNAKE_CASE       :    int       =	bit_string[pos : pos + 512]
  __SCREAMING_SNAKE_CASE       :    Tuple       =	[]
  for i in range(0		,	512		,	32     ):
   block_words.append(int(to_little_endian(block[i : i + 32]     )		,	2     )     )
  yield block_words






def 	_lowerCAmelCase						(				__lowerCamelCase   :     int     ):



 """simple docstring"""





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

 __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	format(__lowerCamelCase		,	"032b"     )
 __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	""
 for c in i_str:
  new_str += "1" if c == "0" else "0"
 return int(__lowerCamelCase		,	2     )






def 	_lowerCAmelCase						(				__lowerCamelCase   :     int		,	__lowerCamelCase   :     int     ):



 """simple docstring"""





 return (a + b) % 2**32






def 	_lowerCAmelCase						(				__lowerCamelCase   :     int		,	__lowerCamelCase   :     int     ):



 """simple docstring"""





 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 	_lowerCAmelCase						(				__lowerCamelCase   :     bytes     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    Tuple       =	preprocess(__lowerCamelCase     )

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

 # Starting states
 __SCREAMING_SNAKE_CASE       :    Tuple       =	0X67452301
 __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	0Xefcdab89
 __SCREAMING_SNAKE_CASE       :    Optional[int]       =	0X98badcfe
 __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	0X10325476

 __SCREAMING_SNAKE_CASE       :    List[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     ):
  __SCREAMING_SNAKE_CASE       :    Any       =	aa
  __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	ba
  __SCREAMING_SNAKE_CASE       :    str       =	ca
  __SCREAMING_SNAKE_CASE       :    Dict       =	da

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

  # Add hashed chunk to running total
  __SCREAMING_SNAKE_CASE       :    Dict       =	sum_aa(__lowerCamelCase		,	__lowerCamelCase     )
  __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	sum_aa(__lowerCamelCase		,	__lowerCamelCase     )
  __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	sum_aa(__lowerCamelCase		,	__lowerCamelCase     )
  __SCREAMING_SNAKE_CASE       :    str       =	sum_aa(__lowerCamelCase		,	__lowerCamelCase     )

 __SCREAMING_SNAKE_CASE       :    List[str]       =	reformat_hex(__lowerCamelCase     ) + reformat_hex(__lowerCamelCase     ) + reformat_hex(__lowerCamelCase     ) + reformat_hex(__lowerCamelCase     )
 return digest


if __name__ == "__main__":
      import doctest

      doctest.testmod()






