



import tempfile
import unittest

import numpy as np

from diffusers import (
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionPipeline,
    PNDMScheduler,
)
from diffusers.utils.testing_utils import is_onnx_available, nightly, require_onnxruntime, require_torch_gpu

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
			import onnxruntime as ort

class        UpperCAmelCase_  (       UpperCamelCase_   ,   unittest.TestCase	):

						'''simple docstring'''




						UpperCamelCase__      :			Tuple      =  '''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''






						def 	_A     (   self				,							_A=0		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= np.random.RandomState(_A		)
													__SCREAMING_SNAKE_CASE									= {
													    'prompt': 'A painting of a squirrel eating a burger',
													    'generator': generator,
													    'num_inference_steps': 2,
													    'guidance_scale': 7.5,
													    'output_type': 'numpy',
													}
													return inputs






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,							provider='CPUExecutionProvider'		)
													pipe.set_progress_bar_config(disable=_A		)

													__SCREAMING_SNAKE_CASE									= self.get_dummy_inputs()
													__SCREAMING_SNAKE_CASE									= pipe(**_A		).images
													__SCREAMING_SNAKE_CASE									= image[0, -3:, -3:, -1]

													assert image.shape == (1, 128, 128, 3)
													__SCREAMING_SNAKE_CASE									= np.array([0.6_5_0_7_2, 0.5_8_4_9_2, 0.4_8_2_1_9, 0.5_5_5_2_1, 0.5_3_1_8_0, 0.5_5_9_3_9, 0.5_0_6_9_7, 0.3_9_8_0_0, 0.4_6_4_5_5]		)

													assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-2






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,							provider='CPUExecutionProvider'		)
													__SCREAMING_SNAKE_CASE									= PNDMScheduler.from_config(pipe.scheduler.config				,							skip_prk_steps=_A		)
													pipe.set_progress_bar_config(disable=_A		)

													__SCREAMING_SNAKE_CASE									= self.get_dummy_inputs()
													__SCREAMING_SNAKE_CASE									= pipe(**_A		).images
													__SCREAMING_SNAKE_CASE									= image[0, -3:, -3:, -1]

													assert image.shape == (1, 128, 128, 3)
													__SCREAMING_SNAKE_CASE									= np.array([0.6_5_8_6_3, 0.5_9_4_2_5, 0.4_9_3_2_6, 0.5_6_3_1_3, 0.5_3_8_7_5, 0.5_6_6_2_7, 0.5_1_0_6_5, 0.3_9_7_7_7, 0.4_6_3_3_0]		)

													assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-2






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,							provider='CPUExecutionProvider'		)
													__SCREAMING_SNAKE_CASE									= LMSDiscreteScheduler.from_config(pipe.scheduler.config		)
													pipe.set_progress_bar_config(disable=_A		)

													__SCREAMING_SNAKE_CASE									= self.get_dummy_inputs()
													__SCREAMING_SNAKE_CASE									= pipe(**_A		).images
													__SCREAMING_SNAKE_CASE									= image[0, -3:, -3:, -1]

													assert image.shape == (1, 128, 128, 3)
													__SCREAMING_SNAKE_CASE									= np.array([0.5_3_7_5_5, 0.6_0_7_8_6, 0.4_7_4_0_2, 0.4_9_4_8_8, 0.5_1_8_6_9, 0.4_9_8_1_9, 0.4_7_9_8_5, 0.3_8_9_5_7, 0.4_4_2_7_9]		)

													assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-2






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,							provider='CPUExecutionProvider'		)
													__SCREAMING_SNAKE_CASE									= EulerDiscreteScheduler.from_config(pipe.scheduler.config		)
													pipe.set_progress_bar_config(disable=_A		)

													__SCREAMING_SNAKE_CASE									= self.get_dummy_inputs()
													__SCREAMING_SNAKE_CASE									= pipe(**_A		).images
													__SCREAMING_SNAKE_CASE									= image[0, -3:, -3:, -1]

													assert image.shape == (1, 128, 128, 3)
													__SCREAMING_SNAKE_CASE									= np.array([0.5_3_7_5_5, 0.6_0_7_8_6, 0.4_7_4_0_2, 0.4_9_4_8_8, 0.5_1_8_6_9, 0.4_9_8_1_9, 0.4_7_9_8_5, 0.3_8_9_5_7, 0.4_4_2_7_9]		)

													assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-2






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,							provider='CPUExecutionProvider'		)
													__SCREAMING_SNAKE_CASE									= EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config		)
													pipe.set_progress_bar_config(disable=_A		)

													__SCREAMING_SNAKE_CASE									= self.get_dummy_inputs()
													__SCREAMING_SNAKE_CASE									= pipe(**_A		).images
													__SCREAMING_SNAKE_CASE									= image[0, -3:, -3:, -1]

													assert image.shape == (1, 128, 128, 3)
													__SCREAMING_SNAKE_CASE									= np.array([0.5_3_8_1_7, 0.6_0_8_1_2, 0.4_7_3_8_4, 0.4_9_5_3_0, 0.5_1_8_9_4, 0.4_9_8_1_4, 0.4_7_9_8_4, 0.3_8_9_5_8, 0.4_4_2_7_1]		)

													assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-2






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,							provider='CPUExecutionProvider'		)
													__SCREAMING_SNAKE_CASE									= DPMSolverMultistepScheduler.from_config(pipe.scheduler.config		)
													pipe.set_progress_bar_config(disable=_A		)

													__SCREAMING_SNAKE_CASE									= self.get_dummy_inputs()
													__SCREAMING_SNAKE_CASE									= pipe(**_A		).images
													__SCREAMING_SNAKE_CASE									= image[0, -3:, -3:, -1]

													assert image.shape == (1, 128, 128, 3)
													__SCREAMING_SNAKE_CASE									= np.array([0.5_3_8_9_5, 0.6_0_8_0_8, 0.4_7_9_3_3, 0.4_9_6_0_8, 0.5_1_8_8_6, 0.4_9_9_5_0, 0.4_8_0_5_3, 0.3_8_9_5_7, 0.4_4_2_0_0]		)

													assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-2






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,							provider='CPUExecutionProvider'		)
													pipe.set_progress_bar_config(disable=_A		)

													__SCREAMING_SNAKE_CASE									= self.get_dummy_inputs()
													__SCREAMING_SNAKE_CASE									= 3 * [inputs['prompt']]

													# forward
													__SCREAMING_SNAKE_CASE									= pipe(**_A		)
													__SCREAMING_SNAKE_CASE									= output.images[0, -3:, -3:, -1]

													__SCREAMING_SNAKE_CASE									= self.get_dummy_inputs()
													__SCREAMING_SNAKE_CASE									= 3 * [inputs.pop('prompt'		)]

													__SCREAMING_SNAKE_CASE									= pipe.tokenizer(
													    _A				,							padding='max_length'				,							max_length=pipe.tokenizer.model_max_length				,							truncation=_A				,							return_tensors='np'				,							)
													__SCREAMING_SNAKE_CASE									= text_inputs['input_ids']

													__SCREAMING_SNAKE_CASE									= pipe.text_encoder(input_ids=text_inputs.astype(np.intaa		)		)[0]

													__SCREAMING_SNAKE_CASE									= prompt_embeds

													# forward
													__SCREAMING_SNAKE_CASE									= pipe(**_A		)
													__SCREAMING_SNAKE_CASE									= output.images[0, -3:, -3:, -1]

													assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()		).max() < 1e-4






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,							provider='CPUExecutionProvider'		)
													pipe.set_progress_bar_config(disable=_A		)

													__SCREAMING_SNAKE_CASE									= self.get_dummy_inputs()
													__SCREAMING_SNAKE_CASE									= 3 * ['this is a negative prompt']
													__SCREAMING_SNAKE_CASE									= negative_prompt
													__SCREAMING_SNAKE_CASE									= 3 * [inputs['prompt']]

													# forward
													__SCREAMING_SNAKE_CASE									= pipe(**_A		)
													__SCREAMING_SNAKE_CASE									= output.images[0, -3:, -3:, -1]

													__SCREAMING_SNAKE_CASE									= self.get_dummy_inputs()
													__SCREAMING_SNAKE_CASE									= 3 * [inputs.pop('prompt'		)]

													__SCREAMING_SNAKE_CASE									= []
													for p in [prompt, negative_prompt]:
																				__SCREAMING_SNAKE_CASE									= pipe.tokenizer(
																				    _A				,							padding='max_length'				,							max_length=pipe.tokenizer.model_max_length				,							truncation=_A				,							return_tensors='np'				,							)
																				__SCREAMING_SNAKE_CASE									= text_inputs['input_ids']

																				embeds.append(pipe.text_encoder(input_ids=text_inputs.astype(np.intaa		)		)[0]		)

													__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE									= embeds

													# forward
													__SCREAMING_SNAKE_CASE									= pipe(**_A		)
													__SCREAMING_SNAKE_CASE									= output.images[0, -3:, -3:, -1]

													assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()		).max() < 1e-4







@nightly
@require_onnxruntime
@require_torch_gpu
class        UpperCAmelCase_  (       unittest.TestCase	):

						'''simple docstring'''




						@property
						def 	_A     (   self		):







													'''simple docstring'''

													return (
													    "CUDAExecutionProvider",
													    {
													        "gpu_mem_limit": "15000000000",  # 15GB
													        "arena_extend_strategy": "kSameAsRequested",
													    },
													)






						@property
						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= ort.SessionOptions()
													__SCREAMING_SNAKE_CASE									= False
													return options






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(
													    'CompVis/stable-diffusion-v1-4'				,							revision='onnx'				,							safety_checker=_A				,							feature_extractor=_A				,							provider=self.gpu_provider				,							sess_options=self.gpu_options				,							)
													sd_pipe.set_progress_bar_config(disable=_A		)

													__SCREAMING_SNAKE_CASE									= 'A painting of a squirrel eating a burger'
													np.random.seed(0		)
													__SCREAMING_SNAKE_CASE									= sd_pipe([prompt]				,							guidance_scale=6.0				,							num_inference_steps=10				,							output_type='np'		)
													__SCREAMING_SNAKE_CASE									= output.images

													__SCREAMING_SNAKE_CASE									= image[0, -3:, -3:, -1]

													assert image.shape == (1, 512, 512, 3)
													__SCREAMING_SNAKE_CASE									= np.array([0.0_4_5_2, 0.0_3_9_0, 0.0_0_8_7, 0.0_3_5_0, 0.0_6_1_7, 0.0_3_6_4, 0.0_5_4_4, 0.0_5_2_3, 0.0_7_2_0]		)

													assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-3






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= DDIMScheduler.from_pretrained(
													    'runwayml/stable-diffusion-v1-5'				,							subfolder='scheduler'				,							revision='onnx'		)
													__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(
													    'runwayml/stable-diffusion-v1-5'				,							revision='onnx'				,							scheduler=_A				,							safety_checker=_A				,							feature_extractor=_A				,							provider=self.gpu_provider				,							sess_options=self.gpu_options				,							)
													sd_pipe.set_progress_bar_config(disable=_A		)

													__SCREAMING_SNAKE_CASE									= 'open neural network exchange'
													__SCREAMING_SNAKE_CASE									= np.random.RandomState(0		)
													__SCREAMING_SNAKE_CASE									= sd_pipe([prompt]				,							guidance_scale=7.5				,							num_inference_steps=10				,							generator=_A				,							output_type='np'		)
													__SCREAMING_SNAKE_CASE									= output.images
													__SCREAMING_SNAKE_CASE									= image[0, -3:, -3:, -1]

													assert image.shape == (1, 512, 512, 3)
													__SCREAMING_SNAKE_CASE									= np.array([0.2_8_6_7, 0.1_9_7_4, 0.1_4_8_1, 0.7_2_9_4, 0.7_2_5_1, 0.6_6_6_7, 0.4_1_9_4, 0.5_6_4_2, 0.6_4_8_6]		)

													assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-3






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= LMSDiscreteScheduler.from_pretrained(
													    'runwayml/stable-diffusion-v1-5'				,							subfolder='scheduler'				,							revision='onnx'		)
													__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(
													    'runwayml/stable-diffusion-v1-5'				,							revision='onnx'				,							scheduler=_A				,							safety_checker=_A				,							feature_extractor=_A				,							provider=self.gpu_provider				,							sess_options=self.gpu_options				,							)
													sd_pipe.set_progress_bar_config(disable=_A		)

													__SCREAMING_SNAKE_CASE									= 'open neural network exchange'
													__SCREAMING_SNAKE_CASE									= np.random.RandomState(0		)
													__SCREAMING_SNAKE_CASE									= sd_pipe([prompt]				,							guidance_scale=7.5				,							num_inference_steps=10				,							generator=_A				,							output_type='np'		)
													__SCREAMING_SNAKE_CASE									= output.images
													__SCREAMING_SNAKE_CASE									= image[0, -3:, -3:, -1]

													assert image.shape == (1, 512, 512, 3)
													__SCREAMING_SNAKE_CASE									= np.array([0.2_3_0_6, 0.1_9_5_9, 0.1_5_9_3, 0.6_5_4_9, 0.6_3_9_4, 0.5_4_0_8, 0.5_0_6_5, 0.6_0_1_0, 0.6_1_6_1]		)

													assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-3






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= 0

													def test_callback_fn(_A				,							_A				,							_A		) -> None:
																				__SCREAMING_SNAKE_CASE									= True
																				nonlocal number_of_steps
																				number_of_steps += 1
																				if step == 0:
																											assert latents.shape == (1, 4, 64, 64)
																											__SCREAMING_SNAKE_CASE									= latents[0, -3:, -3:, -1]
																											__SCREAMING_SNAKE_CASE									= np.array(
																											    [-0.6_7_7_2, -0.3_8_3_5, -1.2_4_5_6, 0.1_9_0_5, -1.0_9_7_4, 0.6_9_6_7, -1.9_3_5_3, 0.0_1_7_8, 1.0_1_6_7]		)

																											assert np.abs(latents_slice.flatten() - expected_slice		).max() < 1e-3
																				elif step == 5:
																											assert latents.shape == (1, 4, 64, 64)
																											__SCREAMING_SNAKE_CASE									= latents[0, -3:, -3:, -1]
																											__SCREAMING_SNAKE_CASE									= np.array(
																											    [-0.3_3_5_1, 0.2_2_4_1, -0.1_8_3_7, -0.2_3_2_5, -0.6_5_7_7, 0.3_3_9_3, -0.0_2_4_1, 0.5_8_9_9, 1.3_8_7_5]		)

																											assert np.abs(latents_slice.flatten() - expected_slice		).max() < 1e-3

													__SCREAMING_SNAKE_CASE									= False

													__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(
													    'runwayml/stable-diffusion-v1-5'				,							revision='onnx'				,							safety_checker=_A				,							feature_extractor=_A				,							provider=self.gpu_provider				,							sess_options=self.gpu_options				,							)
													pipe.set_progress_bar_config(disable=_A		)

													__SCREAMING_SNAKE_CASE									= 'Andromeda galaxy in a bottle'

													__SCREAMING_SNAKE_CASE									= np.random.RandomState(0		)
													pipe(
													    prompt=_A				,							num_inference_steps=5				,							guidance_scale=7.5				,							generator=_A				,							callback=_A				,							callback_steps=1				,							)
													assert test_callback_fn.has_been_called
													assert number_of_steps == 6






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(
													    'runwayml/stable-diffusion-v1-5'				,							revision='onnx'				,							safety_checker=_A				,							feature_extractor=_A				,							provider=self.gpu_provider				,							sess_options=self.gpu_options				,							)
													assert isinstance(_A				,							_A		)
													assert pipe.safety_checker is None

													__SCREAMING_SNAKE_CASE									= pipe('example prompt'				,							num_inference_steps=2		).images[0]
													assert image is not None

													# check that there's no error when saving a pipeline with one of the models being None
													with tempfile.TemporaryDirectory() as tmpdirname:
																				pipe.save_pretrained(_A		)
																				__SCREAMING_SNAKE_CASE									= OnnxStableDiffusionPipeline.from_pretrained(_A		)

													# sanity check that the pipeline still works
													assert pipe.safety_checker is None
													__SCREAMING_SNAKE_CASE									= pipe('example prompt'				,							num_inference_steps=2		).images[0]
													assert image is not None











from __future__ import annotations

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_tf, slow
from transformers.utils import is_tf_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask


if is_tf_available():
			import tensorflow as tf

			from transformers import TFBlipTextModel
			from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST

class        UpperCAmelCase_  :

						'''simple docstring'''




						def __init__(   self				,							_A				,							_A=12				,							_A=7				,							_A=True				,							_A=True				,							_A=True				,							_A=99				,							_A=32				,							_A=32				,							_A=2				,							_A=4				,							_A=37				,							_A=0.1				,							_A=0.1				,							_A=512				,							_A=0.0_2				,							_A=0				,							_A=None				,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= parent
													__SCREAMING_SNAKE_CASE									= batch_size
													__SCREAMING_SNAKE_CASE									= seq_length
													__SCREAMING_SNAKE_CASE									= is_training
													__SCREAMING_SNAKE_CASE									= use_input_mask
													__SCREAMING_SNAKE_CASE									= use_labels
													__SCREAMING_SNAKE_CASE									= vocab_size
													__SCREAMING_SNAKE_CASE									= hidden_size
													__SCREAMING_SNAKE_CASE									= projection_dim
													__SCREAMING_SNAKE_CASE									= num_hidden_layers
													__SCREAMING_SNAKE_CASE									= num_attention_heads
													__SCREAMING_SNAKE_CASE									= intermediate_size
													__SCREAMING_SNAKE_CASE									= dropout
													__SCREAMING_SNAKE_CASE									= attention_dropout
													__SCREAMING_SNAKE_CASE									= max_position_embeddings
													__SCREAMING_SNAKE_CASE									= initializer_range
													__SCREAMING_SNAKE_CASE									= scope
													__SCREAMING_SNAKE_CASE									= bos_token_id






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= ids_tensor([self.batch_size, self.seq_length]				,							self.vocab_size		)

													__SCREAMING_SNAKE_CASE									= None
													if self.use_input_mask:
																				__SCREAMING_SNAKE_CASE									= random_attention_mask([self.batch_size, self.seq_length]		)

													if input_mask is not None:
																				__SCREAMING_SNAKE_CASE									= input_mask.numpy()
																				__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE									= input_mask.shape
																				__SCREAMING_SNAKE_CASE									= np.random.randint(1				,							seq_length - 1				,							size=(batch_size,)		)
																				for batch_idx, start_index in enumerate(_A		):
																											__SCREAMING_SNAKE_CASE									= 1
																											__SCREAMING_SNAKE_CASE									= 0

													__SCREAMING_SNAKE_CASE									= self.get_config()

													return config, input_ids, tf.convert_to_tensor(_A		)






						def 	_A     (   self		):







													'''simple docstring'''

													return BlipTextConfig(
													    vocab_size=self.vocab_size				,							hidden_size=self.hidden_size				,							projection_dim=self.projection_dim				,							num_hidden_layers=self.num_hidden_layers				,							num_attention_heads=self.num_attention_heads				,							intermediate_size=self.intermediate_size				,							dropout=self.dropout				,							attention_dropout=self.attention_dropout				,							max_position_embeddings=self.max_position_embeddings				,							initializer_range=self.initializer_range				,							bos_token_id=self.bos_token_id				,							)






						def 	_A     (   self				,							_A				,							_A				,							_A		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= TFBlipTextModel(config=_A		)
													__SCREAMING_SNAKE_CASE									= model(_A				,							attention_mask=_A				,							training=_A		)
													__SCREAMING_SNAKE_CASE									= model(_A				,							training=_A		)
													self.parent.assertEqual(result.last_hidden_state.shape				,							(self.batch_size, self.seq_length, self.hidden_size)		)
													self.parent.assertEqual(result.pooler_output.shape				,							(self.batch_size, self.hidden_size)		)






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= self.prepare_config_and_inputs()
													__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE									= config_and_inputs
													__SCREAMING_SNAKE_CASE									= {'input_ids': input_ids, 'attention_mask': input_mask}
													return config, inputs_dict







@require_tf
class        UpperCAmelCase_  (       UpperCamelCase_   ,   unittest.TestCase	):

						'''simple docstring'''




						UpperCamelCase__      :			str      =  (TFBlipTextModel,) if is_tf_available() else ()
						UpperCamelCase__      :			int      =  False
						UpperCamelCase__      :			Optional[Any]      =  False
						UpperCamelCase__      :			Tuple      =  False






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= BlipTextModelTester(self		)
													__SCREAMING_SNAKE_CASE									= ConfigTester(self				,							config_class=_A				,							hidden_size=37		)






						def 	_A     (   self		):







													'''simple docstring'''

													self.config_tester.run_common_tests()






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*_A		)






						def 	_A     (   self		):







													'''simple docstring'''

													pass






						def 	_A     (   self		):







													'''simple docstring'''

													pass






						@unittest.skip(reason='Blip does not use inputs_embeds'		)
						def 	_A     (   self		):







													'''simple docstring'''

													pass






						@unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'		)
						def 	_A     (   self		):







													'''simple docstring'''

													pass






						@unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'		)
						def 	_A     (   self		):







													'''simple docstring'''

													pass






						@slow
						def 	_A     (   self		):







													'''simple docstring'''

													for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				__SCREAMING_SNAKE_CASE									= TFBlipTextModel.from_pretrained(_A		)
																				self.assertIsNotNone(_A		)






						def 	_A     (   self				,							_A=True		):







													'''simple docstring'''

													super().test_pt_tf_model_equivalence(allow_missing_keys=_A		)






