



"""simple docstring"""







import unittest

from diffusers.models.unet_ad_blocks import *  # noqa F403
from diffusers.utils import torch_device

from .test_unet_blocks_common import UNetBlockTesterMixin
class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					str   	=				DownBlockaD  # noqa F405
		lowerCAmelCase			:					List[str]   	=				"down"







		def 					UpperCAmelCase    (	self						:  List[str]						)					->		Tuple:






				"""simple docstring"""



				lowercase__   :    Dict				=			[-0.0232, -0.9869, 0.8054, -0.0637, -0.1688, -1.4264, 0.4470, -1.3394, 0.0904]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Union[str, Any]   	=				ResnetDownsampleBlockaD  # noqa F405
		lowerCAmelCase			:					str   	=				"down"







		def 					UpperCAmelCase    (	self						:  Any						)					->		Any:






				"""simple docstring"""



				lowercase__   :    Dict				=			[0.0710, 0.2410, -0.7320, -1.0757, -1.1343, 0.3540, -0.0133, -0.2576, 0.0948]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Union[str, Any]   	=				AttnDownBlockaD  # noqa F405
		lowerCAmelCase			:					Optional[int]   	=				"down"







		def 					UpperCAmelCase    (	self						:  List[str]						)					->		List[str]:






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			[0.0636, 0.8964, -0.6234, -1.0131, 0.0844, 0.4935, 0.3437, 0.0911, -0.2957]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Tuple   	=				CrossAttnDownBlockaD  # noqa F405
		lowerCAmelCase			:					Optional[Any]   	=				"down"







		def 					UpperCAmelCase    (	self						:  Dict						)					->		Tuple:






				"""simple docstring"""



				lowercase__		,			lowercase__   :    Dict				=			super().prepare_init_args_and_inputs_for_common()
				lowercase__   :    Any				=			32
				return init_dict, inputs_dict







		def 					UpperCAmelCase    (	self						:  Any						)					->		str:






				"""simple docstring"""



				lowercase__   :    Dict				=			[0.2238, -0.7396, -0.2255, -0.3829, 0.1925, 1.1665, 0.0603, -0.7295, 0.1983]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Dict   	=				SimpleCrossAttnDownBlockaD  # noqa F405
		lowerCAmelCase			:					List[Any]   	=				"down"







		@property
		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Union[str, Any]:






				"""simple docstring"""



				return super().get_dummy_input(include_encoder_hidden_states=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		Optional[Any]:






				"""simple docstring"""



				lowercase__		,			lowercase__   :    Union[str, Any]				=			super().prepare_init_args_and_inputs_for_common()
				lowercase__   :    int				=			32
				return init_dict, inputs_dict







		@unittest.skipIf(torch_device == '''mps'''			,'''MPS result is not consistent'''						)
		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		str:






				"""simple docstring"""



				lowercase__   :    List[Any]				=			[0.7921, -0.0992, -0.1962, -0.7695, -0.4242, 0.7804, 0.4737, 0.2765, 0.3338]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Dict   	=				SkipDownBlockaD  # noqa F405
		lowerCAmelCase			:					Any   	=				"down"







		@property
		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Dict:






				"""simple docstring"""



				return super().get_dummy_input(include_skip_sample=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		Any:






				"""simple docstring"""



				lowercase__   :    int				=			[-0.0845, -0.2087, -0.2465, 0.0971, 0.1900, -0.0484, 0.2664, 0.4179, 0.5069]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					int   	=				AttnSkipDownBlockaD  # noqa F405
		lowerCAmelCase			:					List[Any]   	=				"down"







		@property
		def 					UpperCAmelCase    (	self						:  List[str]						)					->		str:






				"""simple docstring"""



				return super().get_dummy_input(include_skip_sample=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		List[Any]:






				"""simple docstring"""



				lowercase__   :    Any				=			[0.5539, 0.1609, 0.4924, 0.0537, -0.1995, 0.4050, 0.0979, -0.2721, -0.0642]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Optional[int]   	=				DownEncoderBlockaD  # noqa F405
		lowerCAmelCase			:					Optional[Any]   	=				"down"







		@property
		def 					UpperCAmelCase    (	self						:  str						)					->		Optional[int]:






				"""simple docstring"""



				return super().get_dummy_input(include_temb=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  int						)					->		List[Any]:






				"""simple docstring"""



				lowercase__   :    List[str]				=			{
				    '''in_channels''': 32,
				    '''out_channels''': 32,
				}
				lowercase__   :    Dict				=			self.dummy_input
				return init_dict, inputs_dict







		def 					UpperCAmelCase    (	self						:  str						)					->		List[str]:






				"""simple docstring"""



				lowercase__   :    int				=			[1.1102, 0.5302, 0.4872, -0.0023, -0.8042, 0.0483, -0.3489, -0.5632, 0.7626]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Union[str, Any]   	=				AttnDownEncoderBlockaD  # noqa F405
		lowerCAmelCase			:					Union[str, Any]   	=				"down"







		@property
		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		Optional[int]:






				"""simple docstring"""



				return super().get_dummy_input(include_temb=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Optional[Any]:






				"""simple docstring"""



				lowercase__   :    int				=			{
				    '''in_channels''': 32,
				    '''out_channels''': 32,
				}
				lowercase__   :    Optional[int]				=			self.dummy_input
				return init_dict, inputs_dict







		def 					UpperCAmelCase    (	self						:  int						)					->		Any:






				"""simple docstring"""



				lowercase__   :    Any				=			[0.8966, -0.1486, 0.8568, 0.8141, -0.9046, -0.1342, -0.0972, -0.7417, 0.1538]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					int   	=				UNetMidBlockaD  # noqa F405
		lowerCAmelCase			:					Optional[Any]   	=				"mid"







		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		Dict:






				"""simple docstring"""



				lowercase__   :    Union[str, Any]				=			{
				    '''in_channels''': 32,
				    '''temb_channels''': 128,
				}
				lowercase__   :    Tuple				=			self.dummy_input
				return init_dict, inputs_dict







		def 					UpperCAmelCase    (	self						:  int						)					->		List[Any]:






				"""simple docstring"""



				lowercase__   :    Dict				=			[-0.1062, 1.7248, 0.3494, 1.4569, -0.0910, -1.2421, -0.9984, 0.6736, 1.0028]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					int   	=				UNetMidBlockaDCrossAttn  # noqa F405
		lowerCAmelCase			:					str   	=				"mid"







		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		int:






				"""simple docstring"""



				lowercase__		,			lowercase__   :    List[Any]				=			super().prepare_init_args_and_inputs_for_common()
				lowercase__   :    Tuple				=			32
				return init_dict, inputs_dict







		def 					UpperCAmelCase    (	self						:  str						)					->		int:






				"""simple docstring"""



				lowercase__   :    Union[str, Any]				=			[0.0187, 2.4220, 0.4484, 1.1203, -0.6121, -1.5122, -0.8270, 0.7851, 1.8335]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Union[str, Any]   	=				UNetMidBlockaDSimpleCrossAttn  # noqa F405
		lowerCAmelCase			:					List[str]   	=				"mid"







		@property
		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		List[str]:






				"""simple docstring"""



				return super().get_dummy_input(include_encoder_hidden_states=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		Optional[int]:






				"""simple docstring"""



				lowercase__		,			lowercase__   :    Optional[Any]				=			super().prepare_init_args_and_inputs_for_common()
				lowercase__   :    List[Any]				=			32
				return init_dict, inputs_dict







		def 					UpperCAmelCase    (	self						:  str						)					->		Any:






				"""simple docstring"""



				lowercase__   :    Tuple				=			[0.7143, 1.9974, 0.5448, 1.3977, 0.1282, -1.1237, -1.4238, 0.5530, 0.8880]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Optional[int]   	=				UpBlockaD  # noqa F405
		lowerCAmelCase			:					List[Any]   	=				"up"







		@property
		def 					UpperCAmelCase    (	self						:  str						)					->		Optional[int]:






				"""simple docstring"""



				return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Dict:






				"""simple docstring"""



				lowercase__   :    Optional[int]				=			[-0.2041, -0.4165, -0.3022, 0.0041, -0.6628, -0.7053, 0.1928, -0.0325, 0.0523]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					List[str]   	=				ResnetUpsampleBlockaD  # noqa F405
		lowerCAmelCase			:					List[str]   	=				"up"







		@property
		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		str:






				"""simple docstring"""



				return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		Any:






				"""simple docstring"""



				lowercase__   :    List[Any]				=			[0.2287, 0.3549, -0.1346, 0.4797, -0.1715, -0.9649, 0.7305, -0.5864, -0.6244]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Optional[Any]   	=				CrossAttnUpBlockaD  # noqa F405
		lowerCAmelCase			:					Tuple   	=				"up"







		@property
		def 					UpperCAmelCase    (	self						:  str						)					->		Union[str, Any]:






				"""simple docstring"""



				return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  List[str]						)					->		int:






				"""simple docstring"""



				lowercase__		,			lowercase__   :    Optional[Any]				=			super().prepare_init_args_and_inputs_for_common()
				lowercase__   :    List[Any]				=			32
				return init_dict, inputs_dict







		def 					UpperCAmelCase    (	self						:  Any						)					->		List[str]:






				"""simple docstring"""



				lowercase__   :    int				=			[-0.1403, -0.3515, -0.0420, -0.1425, 0.3167, 0.5094, -0.2181, 0.5931, 0.5582]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					List[Any]   	=				SimpleCrossAttnUpBlockaD  # noqa F405
		lowerCAmelCase			:					Tuple   	=				"up"







		@property
		def 					UpperCAmelCase    (	self						:  List[str]						)					->		Dict:






				"""simple docstring"""



				return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE			,include_encoder_hidden_states=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  Any						)					->		List[Any]:






				"""simple docstring"""



				lowercase__		,			lowercase__   :    Any				=			super().prepare_init_args_and_inputs_for_common()
				lowercase__   :    int				=			32
				return init_dict, inputs_dict







		def 					UpperCAmelCase    (	self						:  str						)					->		List[str]:






				"""simple docstring"""



				lowercase__   :    Dict				=			[0.2645, 0.1480, 0.0909, 0.8044, -0.9758, -0.9083, 0.0994, -1.1453, -0.7402]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					str   	=				AttnUpBlockaD  # noqa F405
		lowerCAmelCase			:					int   	=				"up"







		@property
		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Tuple:






				"""simple docstring"""



				return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE						)







		@unittest.skipIf(torch_device == '''mps'''			,'''MPS result is not consistent'''						)
		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		str:






				"""simple docstring"""



				lowercase__   :    str				=			[0.0979, 0.1326, 0.0021, 0.0659, 0.2249, 0.0059, 0.1132, 0.5952, 0.1033]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					str   	=				SkipUpBlockaD  # noqa F405
		lowerCAmelCase			:					List[str]   	=				"up"







		@property
		def 					UpperCAmelCase    (	self						:  Any						)					->		int:






				"""simple docstring"""



				return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  List[str]						)					->		Dict:






				"""simple docstring"""



				lowercase__   :    Union[str, Any]				=			[-0.0893, -0.1234, -0.1506, -0.0332, 0.0123, -0.0211, 0.0566, 0.0143, 0.0362]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Tuple   	=				AttnSkipUpBlockaD  # noqa F405
		lowerCAmelCase			:					Union[str, Any]   	=				"up"







		@property
		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		int:






				"""simple docstring"""



				return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		Optional[Any]:






				"""simple docstring"""



				lowercase__   :    int				=			[0.0361, 0.0617, 0.2787, -0.0350, 0.0342, 0.3421, -0.0843, 0.0913, 0.3015]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Tuple   	=				UpDecoderBlockaD  # noqa F405
		lowerCAmelCase			:					List[str]   	=				"up"







		@property
		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		List[str]:






				"""simple docstring"""



				return super().get_dummy_input(include_temb=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Tuple:






				"""simple docstring"""



				lowercase__   :    str				=			{'''in_channels''': 32, '''out_channels''': 32}

				lowercase__   :    Any				=			self.dummy_input
				return init_dict, inputs_dict







		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		Optional[Any]:






				"""simple docstring"""



				lowercase__   :    Any				=			[0.4404, 0.1998, -0.9886, -0.3320, -0.3128, -0.7034, -0.6955, -0.2338, -0.3137]
				super().test_output(__SCREAMING_SNAKE_CASE						)





class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Dict   	=				AttnUpDecoderBlockaD  # noqa F405
		lowerCAmelCase			:					Any   	=				"up"







		@property
		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		Union[str, Any]:






				"""simple docstring"""



				return super().get_dummy_input(include_temb=__SCREAMING_SNAKE_CASE						)







		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Any:






				"""simple docstring"""



				lowercase__   :    int				=			{'''in_channels''': 32, '''out_channels''': 32}

				lowercase__   :    Optional[Any]				=			self.dummy_input
				return init_dict, inputs_dict







		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		str:






				"""simple docstring"""



				lowercase__   :    Any				=			[0.6738, 0.4491, 0.1055, 1.0710, 0.7316, 0.3339, 0.3352, 0.1023, 0.3568]
				super().test_output(__SCREAMING_SNAKE_CASE						)



'''simple docstring'''



import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
  from PIL import Image

  from transformers import CLIPImageProcessor, CLIPProcessor







@require_vision
class 						lowerCAmelCase__   (      unittest.TestCase					):



 """simple docstring"""



 def       UpperCAmelCase__		(		self					:       Union[str, Any]			)  -> List[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      tempfile.mkdtemp()

      # fmt: off
      __SCREAMING_SNAKE_CASE     =      ["""l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """lo""", """l</w>""", """w</w>""", """r</w>""", """t</w>""", """low</w>""", """er</w>""", """lowest</w>""", """newer</w>""", """wider""", """<unk>""", """<|startoftext|>""", """<|endoftext|>"""]
      # fmt: on
      __SCREAMING_SNAKE_CASE     =      dict(zip(__SCREAMING_SNAKE_CASE					,							range(len(__SCREAMING_SNAKE_CASE			)			)			)			)
      __SCREAMING_SNAKE_CASE     =      ["""#version: 0.2""", """l o""", """lo w</w>""", """e r</w>""", """"""]
      __SCREAMING_SNAKE_CASE     =      {"""unk_token""": """<unk>"""}

      __SCREAMING_SNAKE_CASE     =      os.path.join(self.tmpdirname					,							VOCAB_FILES_NAMES["""vocab_file"""]			)
      __SCREAMING_SNAKE_CASE     =      os.path.join(self.tmpdirname					,							VOCAB_FILES_NAMES["""merges_file"""]			)
      with open(self.vocab_file					,							"""w"""					,							encoding="""utf-8"""			) as fp:
           fp.write(json.dumps(__SCREAMING_SNAKE_CASE			) + """\n"""			)
      with open(self.merges_file					,							"""w"""					,							encoding="""utf-8"""			) as fp:
           fp.write("""\n""".join(__SCREAMING_SNAKE_CASE			)			)

      __SCREAMING_SNAKE_CASE     =      {
          """do_resize""": True,
          """size""": 20,
          """do_center_crop""": True,
          """crop_size""": 18,
          """do_normalize""": True,
          """image_mean""": [0.48145466, 0.4578275, 0.40821073],
          """image_std""": [0.26862954, 0.26130258, 0.27577711],
      }
      __SCREAMING_SNAKE_CASE     =      os.path.join(self.tmpdirname					,							__SCREAMING_SNAKE_CASE			)
      with open(self.image_processor_file					,							"""w"""					,							encoding="""utf-8"""			) as fp:
           json.dump(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       Optional[int]					,							**__SCREAMING_SNAKE_CASE					:       Optional[int]			)  -> str:


      """simple docstring"""




      return CLIPTokenizer.from_pretrained(self.tmpdirname					,							**__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       Tuple					,							**__SCREAMING_SNAKE_CASE					:       Any			)  -> int:


      """simple docstring"""




      return CLIPTokenizerFast.from_pretrained(self.tmpdirname					,							**__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       Optional[Any]					,							**__SCREAMING_SNAKE_CASE					:       Optional[int]			)  -> List[str]:


      """simple docstring"""




      return CLIPImageProcessor.from_pretrained(self.tmpdirname					,							**__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       Tuple			)  -> str:


      """simple docstring"""




      shutil.rmtree(self.tmpdirname			)
 def       UpperCAmelCase__		(		self					:       Optional[Any]			)  -> str:


      """simple docstring"""




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

      __SCREAMING_SNAKE_CASE     =      [Image.fromarray(np.moveaxis(__SCREAMING_SNAKE_CASE					,							0					,							-1			)			) for x in image_inputs]

      return image_inputs
 def       UpperCAmelCase__		(		self					:       Optional[int]			)  -> Any:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      self.get_tokenizer()
      __SCREAMING_SNAKE_CASE     =      self.get_rust_tokenizer()
      __SCREAMING_SNAKE_CASE     =      self.get_image_processor()

      __SCREAMING_SNAKE_CASE     =      CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE					,							image_processor=__SCREAMING_SNAKE_CASE			)
      processor_slow.save_pretrained(self.tmpdirname			)
      __SCREAMING_SNAKE_CASE     =      CLIPProcessor.from_pretrained(self.tmpdirname					,							use_fast=__SCREAMING_SNAKE_CASE			)

      __SCREAMING_SNAKE_CASE     =      CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE					,							image_processor=__SCREAMING_SNAKE_CASE			)
      processor_fast.save_pretrained(self.tmpdirname			)
      __SCREAMING_SNAKE_CASE     =      CLIPProcessor.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					,							__SCREAMING_SNAKE_CASE			)
      self.assertIsInstance(processor_fast.tokenizer					,							__SCREAMING_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					,							__SCREAMING_SNAKE_CASE			)
      self.assertIsInstance(processor_fast.image_processor					,							__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       Optional[int]			)  -> Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      CLIPProcessor(tokenizer=self.get_tokenizer()					,							image_processor=self.get_image_processor()			)
      processor.save_pretrained(self.tmpdirname			)

      __SCREAMING_SNAKE_CASE     =      self.get_tokenizer(bos_token="""(BOS)"""					,							eos_token="""(EOS)"""			)
      __SCREAMING_SNAKE_CASE     =      self.get_image_processor(do_normalize=__SCREAMING_SNAKE_CASE					,							padding_value=1.0			)

      __SCREAMING_SNAKE_CASE     =      CLIPProcessor.from_pretrained(
          self.tmpdirname					,							bos_token="""(BOS)"""					,							eos_token="""(EOS)"""					,							do_normalize=__SCREAMING_SNAKE_CASE					,							padding_value=1.0			)

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

      self.assertEqual(processor.image_processor.to_json_string()					,							image_processor_add_kwargs.to_json_string()			)
      self.assertIsInstance(processor.image_processor					,							__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       List[str]			)  -> Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      self.get_image_processor()
      __SCREAMING_SNAKE_CASE     =      self.get_tokenizer()

      __SCREAMING_SNAKE_CASE     =      CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE					,							image_processor=__SCREAMING_SNAKE_CASE			)

      __SCREAMING_SNAKE_CASE     =      self.prepare_image_inputs()

      __SCREAMING_SNAKE_CASE     =      image_processor(__SCREAMING_SNAKE_CASE					,							return_tensors="""np"""			)
      __SCREAMING_SNAKE_CASE     =      processor(images=__SCREAMING_SNAKE_CASE					,							return_tensors="""np"""			)

      for key in input_image_proc.keys():
           self.assertAlmostEqual(input_image_proc[key].sum()					,							input_processor[key].sum()					,							delta=1E-2			)
 def       UpperCAmelCase__		(		self					:       List[Any]			)  -> int:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      self.get_image_processor()
      __SCREAMING_SNAKE_CASE     =      self.get_tokenizer()

      __SCREAMING_SNAKE_CASE     =      CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE					,							image_processor=__SCREAMING_SNAKE_CASE			)

      __SCREAMING_SNAKE_CASE     =      """lower newer"""

      __SCREAMING_SNAKE_CASE     =      processor(text=__SCREAMING_SNAKE_CASE			)

      __SCREAMING_SNAKE_CASE     =      tokenizer(__SCREAMING_SNAKE_CASE			)

      for key in encoded_tok.keys():
           self.assertListEqual(encoded_tok[key]					,							encoded_processor[key]			)
 def       UpperCAmelCase__		(		self					:       Dict			)  -> Union[str, Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      self.get_image_processor()
      __SCREAMING_SNAKE_CASE     =      self.get_tokenizer()

      __SCREAMING_SNAKE_CASE     =      CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE					,							image_processor=__SCREAMING_SNAKE_CASE			)

      __SCREAMING_SNAKE_CASE     =      """lower newer"""
      __SCREAMING_SNAKE_CASE     =      self.prepare_image_inputs()

      __SCREAMING_SNAKE_CASE     =      processor(text=__SCREAMING_SNAKE_CASE					,							images=__SCREAMING_SNAKE_CASE			)

      self.assertListEqual(list(inputs.keys()			)					,							["""input_ids""", """attention_mask""", """pixel_values"""]			)

      # test if it raises when no input is passed
      with pytest.raises(__SCREAMING_SNAKE_CASE			):
           processor()
 def       UpperCAmelCase__		(		self					:       List[str]			)  -> Union[str, Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      self.get_image_processor()
      __SCREAMING_SNAKE_CASE     =      self.get_tokenizer()

      __SCREAMING_SNAKE_CASE     =      CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE					,							image_processor=__SCREAMING_SNAKE_CASE			)

      __SCREAMING_SNAKE_CASE     =      [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

      __SCREAMING_SNAKE_CASE     =      processor.batch_decode(__SCREAMING_SNAKE_CASE			)
      __SCREAMING_SNAKE_CASE     =      tokenizer.batch_decode(__SCREAMING_SNAKE_CASE			)

      self.assertListEqual(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)


 def       UpperCAmelCase__		(		self					:       int			)  -> str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      self.get_image_processor()
      __SCREAMING_SNAKE_CASE     =      self.get_tokenizer()

      __SCREAMING_SNAKE_CASE     =      CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE					,							image_processor=__SCREAMING_SNAKE_CASE			)

      __SCREAMING_SNAKE_CASE     =      """lower newer"""
      __SCREAMING_SNAKE_CASE     =      self.prepare_image_inputs()

      __SCREAMING_SNAKE_CASE     =      processor(text=__SCREAMING_SNAKE_CASE					,							images=__SCREAMING_SNAKE_CASE			)

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






