
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        A_   :




	'''simple docstring'''


	def __init__(       self		,    snake_case		,    snake_case=12		,    snake_case=7		,    snake_case=True		,    snake_case=True		,    snake_case=True		,    snake_case=99		,    snake_case=32		,    snake_case=32		,    snake_case=2		,    snake_case=4		,    snake_case=37		,    snake_case=0.1		,    snake_case=0.1		,    snake_case=512		,    snake_case=0.02		,    snake_case=0		,    snake_case=None		,    ):
		lowercase       =    parent
		lowercase       =    batch_size
		lowercase       =    seq_length
		lowercase       =    is_training
		lowercase       =    use_input_mask
		lowercase       =    use_labels
		lowercase       =    vocab_size
		lowercase       =    hidden_size
		lowercase       =    projection_dim
		lowercase       =    num_hidden_layers
		lowercase       =    num_attention_heads
		lowercase       =    intermediate_size
		lowercase       =    dropout
		lowercase       =    attention_dropout
		lowercase       =    max_position_embeddings
		lowercase       =    initializer_range
		lowercase       =    scope
		lowercase       =    bos_token_id





	def 	SCREAMING_SNAKE_CASE__						(       self       ):
		lowercase       =    ids_tensor([self.batch_size, self.seq_length]		,    self.vocab_size       )

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

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

		lowercase       =    self.get_config()

		return config, input_ids, tf.convert_to_tensor(_UpperCamelCase       )





	def 	SCREAMING_SNAKE_CASE__						(       self       ):
		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 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case		,    snake_case       ):
		lowercase       =    TFBlipTextModel(config=_UpperCamelCase       )
		lowercase       =    model(_UpperCamelCase		,    attention_mask=_UpperCamelCase		,    training=_UpperCamelCase       )
		lowercase       =    model(_UpperCamelCase		,    training=_UpperCamelCase       )
		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 	SCREAMING_SNAKE_CASE__						(       self       ):
		lowercase       =    self.prepare_config_and_inputs()
		lowercase  ,					lowercase  ,					lowercase       =    config_and_inputs
		lowercase       =    {'input_ids': input_ids, 'attention_mask': input_mask}
		return config, inputs_dict







@require_tf
class        A_   (			__a      ,	unittest.TestCase   ):




	'''simple docstring'''


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





	def 	SCREAMING_SNAKE_CASE__						(       self       ):
		lowercase       =    BlipTextModelTester(self       )
		lowercase       =    ConfigTester(self		,    config_class=_UpperCamelCase		,    hidden_size=37       )





	def 	SCREAMING_SNAKE_CASE__						(       self       ):
		self.config_tester.run_common_tests()





	def 	SCREAMING_SNAKE_CASE__						(       self       ):
		lowercase       =    self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*_UpperCamelCase       )





	def 	SCREAMING_SNAKE_CASE__						(       self       ):
		pass





	def 	SCREAMING_SNAKE_CASE__						(       self       ):
		pass





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





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





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





	@slow
	def 	SCREAMING_SNAKE_CASE__						(       self       ):
		for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			lowercase       =    TFBlipTextModel.from_pretrained(_UpperCamelCase       )
			self.assertIsNotNone(_UpperCamelCase       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case=True       ):
		super().test_pt_tf_model_equivalence(allow_missing_keys=_UpperCamelCase       )



import os
import re
import shutil
import sys
import tempfile
import unittest

import black


_A   =     os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, "utils"))

import check_copies  # noqa: E402


# This is the reference code that will be used in the tests.
# If DDPMSchedulerOutput is changed in scheduling_ddpm.py, this code needs to be manually updated.
_A   =     "    \"\"\"\n    Output class for the scheduler's step function output.\n\n    Args:\n        prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):\n            Computed sample (x_{t-1}) of previous timestep. `prev_sample` should be used as next model input in the\n            denoising loop.\n        pred_original_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):\n            The predicted denoised sample (x_{0}) based on the model output from the current timestep.\n            `pred_original_sample` can be used to preview progress or for guidance.\n    \"\"\"\n\n    prev_sample: torch.FloatTensor\n    pred_original_sample: Optional[torch.FloatTensor] = None\n"





class 	_lowerCAmelCase					(	unittest.TestCase       ):




				def      __a						(					self     )				->      str:
							lowerCAmelCase_						=	tempfile.mkdtemp()
							os.makedirs(os.path.join(self.diffusers_dir				,				"schedulers/"     )     )
							lowerCAmelCase_						=	self.diffusers_dir
							shutil.copy(
							    os.path.join(_UpperCamelCase				,				"src/diffusers/schedulers/scheduling_ddpm.py"     )				,				os.path.join(self.diffusers_dir				,				"schedulers/scheduling_ddpm.py"     )				,				)




				def      __a						(					self     )				->      Optional[int]:
							lowerCAmelCase_						=	"src/diffusers"
							shutil.rmtree(self.diffusers_dir     )




				def      __a						(					self				,				_UpperCamelCase				,				_UpperCamelCase				,				_UpperCamelCase				,				_UpperCamelCase=None     )				->      Optional[Any]:
							lowerCAmelCase_						=	comment + f"""\nclass {class_name}(nn.Module):\n""" + class_code
							if overwrite_result is not None:
										lowerCAmelCase_						=	comment + f"""\nclass {class_name}(nn.Module):\n""" + overwrite_result
							lowerCAmelCase_						=	black.Mode(target_versions={black.TargetVersion.PYaa}				,				line_length=119     )
							lowerCAmelCase_						=	black.format_str(_UpperCamelCase				,				mode=_UpperCamelCase     )
							lowerCAmelCase_						=	os.path.join(self.diffusers_dir				,				"new_code.py"     )
							with open(_UpperCamelCase				,				"w"				,				newline="\n"     ) as f:
										f.write(_UpperCamelCase     )
							if overwrite_result is None:
										self.assertTrue(len(check_copies.is_copy_consistent(_UpperCamelCase     )     ) == 0     )
							else:
										check_copies.is_copy_consistent(f.name				,				overwrite=_UpperCamelCase     )
										with open(_UpperCamelCase				,				"r"     ) as f:
													self.assertTrue(f.read()				,				_UpperCamelCase     )




				def      __a						(					self     )				->      Optional[Any]:
							lowerCAmelCase_						=	check_copies.find_code_in_diffusers("schedulers.scheduling_ddpm.DDPMSchedulerOutput"     )
							self.assertEqual(_UpperCamelCase				,				_UpperCamelCase     )




				def      __a						(					self     )				->      Tuple:
							# Base copy consistency
							self.check_copy_consistency(
							    "# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput"				,				"DDPMSchedulerOutput"				,				REFERENCE_CODE + "\n"				,				)

							# With no empty line at the end
							self.check_copy_consistency(
							    "# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput"				,				"DDPMSchedulerOutput"				,				_UpperCamelCase				,				)

							# Copy consistency with rename
							self.check_copy_consistency(
							    "# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->Test"				,				"TestSchedulerOutput"				,				re.sub("DDPM"				,				"Test"				,				_UpperCamelCase     )				,				)

							# Copy consistency with a really long name
							lowerCAmelCase_						=	"TestClassWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason"
							self.check_copy_consistency(
							    f"""# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->{long_class_name}"""				,				f"""{long_class_name}SchedulerOutput"""				,				re.sub("Bert"				,				_UpperCamelCase				,				_UpperCamelCase     )				,				)

							# Copy consistency with overwrite
							self.check_copy_consistency(
							    "# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->Test"				,				"TestSchedulerOutput"				,				_UpperCamelCase				,				overwrite_result=re.sub("DDPM"				,				"Test"				,				_UpperCamelCase     )				,				)



