




"""simple docstring"""







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






						def __init__(							self				:			List[Any]						,						lowerCAmelCase				:			List[str]						,						lowerCAmelCase				:			Optional[int]=12						,						lowerCAmelCase				:			List[Any]=7						,						lowerCAmelCase				:			Any=True						,						lowerCAmelCase				:			Union[str, Any]=True						,						lowerCAmelCase				:			Dict=True						,						lowerCAmelCase				:			Dict=99						,						lowerCAmelCase				:			Optional[int]=32						,						lowerCAmelCase				:			Union[str, Any]=32						,						lowerCAmelCase				:			str=2						,						lowerCAmelCase				:			List[Any]=4						,						lowerCAmelCase				:			str=37						,						lowerCAmelCase				:			Union[str, Any]=0.1						,						lowerCAmelCase				:			List[Any]=0.1						,						lowerCAmelCase				:			Union[str, Any]=512						,						lowerCAmelCase				:			Optional[Any]=0.02						,						lowerCAmelCase				:			Any=0						,						lowerCAmelCase				:			Tuple=None						,						):
										lowerCAmelCase  =				parent
										lowerCAmelCase  =				batch_size
										lowerCAmelCase  =				seq_length
										lowerCAmelCase  =				is_training
										lowerCAmelCase  =				use_input_mask
										lowerCAmelCase  =				use_labels
										lowerCAmelCase  =				vocab_size
										lowerCAmelCase  =				hidden_size
										lowerCAmelCase  =				projection_dim
										lowerCAmelCase  =				num_hidden_layers
										lowerCAmelCase  =				num_attention_heads
										lowerCAmelCase  =				intermediate_size
										lowerCAmelCase  =				dropout
										lowerCAmelCase  =				attention_dropout
										lowerCAmelCase  =				max_position_embeddings
										lowerCAmelCase  =				initializer_range
										lowerCAmelCase  =				scope
										lowerCAmelCase  =				bos_token_id






						def   __lowercase (							self				:			int					):
										lowerCAmelCase  =				ids_tensor([self.batch_size, self.seq_length]						,						self.vocab_size					)

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

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

										lowerCAmelCase  =				self.get_config()

										return config, input_ids, tf.convert_to_tensor(UpperCamelCase_					)






						def   __lowercase (							self				:			int					):
										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   __lowercase (							self				:			Optional[Any]						,						lowerCAmelCase				:			Dict						,						lowerCAmelCase				:			Optional[Any]						,						lowerCAmelCase				:			Tuple					):
										lowerCAmelCase  =				TFBlipTextModel(config=UpperCamelCase_					)
										lowerCAmelCase  =				model(UpperCamelCase_						,						attention_mask=UpperCamelCase_						,						training=UpperCamelCase_					)
										lowerCAmelCase  =				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   __lowercase (							self				:			Dict					):
										lowerCAmelCase  =				self.prepare_config_and_inputs()
										lowerCAmelCase  =				config_and_inputs
										lowerCAmelCase  =				{"input_ids": input_ids, "attention_mask": input_mask}
										return config, inputs_dict






@require_tf
class       SCREAMING_SNAKE_CASE__					(					_a						,				unittest.TestCase					):
						_a    						=						(TFBlipTextModel,) if is_tf_available() else ()
						_a    						=						False
						_a    						=						False
						_a    						=						False






						def   __lowercase (							self				:			Tuple					):
										lowerCAmelCase  =				BlipTextModelTester(self					)
										lowerCAmelCase  =				ConfigTester(self						,						config_class=UpperCamelCase_						,						hidden_size=37					)






						def   __lowercase (							self				:			Optional[int]					):
										self.config_tester.run_common_tests()






						def   __lowercase (							self				:			Optional[int]					):
										lowerCAmelCase  =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*UpperCamelCase_					)






						def   __lowercase (							self				:			Tuple					):
										pass






						def   __lowercase (							self				:			List[Any]					):
										pass






						@unittest.skip(reason="""Blip does not use inputs_embeds"""					)
						def   __lowercase (							self				:			int					):
										pass






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






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






						@slow
						def   __lowercase (							self				:			Optional[int]					):
										for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowerCAmelCase  =				TFBlipTextModel.from_pretrained(UpperCamelCase_					)
														self.assertIsNotNone(UpperCamelCase_					)






						def   __lowercase (							self				:			Tuple						,						lowerCAmelCase				:			Any=True					):
										super().test_pt_tf_model_equivalence(allow_missing_keys=UpperCamelCase_					)











"""simple docstring"""







import argparse
import collections
import os
import re

from transformers.utils import direct_transformers_import


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_table.py
a      =							'src/transformers'
a      =							'docs/source/en'
a      =							'.'





def 							lowercase					(snake_case__   : int      ,       snake_case__   : Optional[int]      ,       snake_case__   : Tuple )     ->  Any:


				'''simple docstring'''






				with open(snake_case__      ,       """r"""      ,       encoding="""utf-8"""      ,       newline="""\n""" ) as f:
								lowerCAmelCase  =				f.readlines()
				# Find the start prompt.
				lowerCAmelCase  =				0
				while not lines[start_index].startswith(snake_case__ ):
								start_index += 1
				start_index += 1

				lowerCAmelCase  =				start_index
				while not lines[end_index].startswith(snake_case__ ):
								end_index += 1
				end_index -= 1

				while len(lines[start_index] ) <= 1:
								start_index += 1
				while len(lines[end_index] ) <= 1:
								end_index -= 1
				end_index += 1
				return "".join(lines[start_index:end_index] ), start_index, end_index, lines


# Add here suffixes that are used to identify models, separated by |
a      =							'Model|Encoder|Decoder|ForConditionalGeneration'
# Regexes that match TF/Flax/PT model names.
a      =							re.compile(R'TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')
a      =							re.compile(R'Flax(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')
# Will match any TF or Flax model too so need to be in an else branch afterthe two previous regexes.
a      =							re.compile(R'(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')


# This is to make sure the transformers module imported is the one in the repo.
a      =							direct_transformers_import(TRANSFORMERS_PATH)





def 							lowercase					(snake_case__   : int )     ->  Any:


				'''simple docstring'''






				lowerCAmelCase  =				re.finditer(""".+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)"""      ,       snake_case__ )
				return [m.group(0 ) for m in matches]





def 							lowercase					(snake_case__   : str      ,       snake_case__   : Tuple )     ->  int:


				'''simple docstring'''






				lowerCAmelCase  =				2 if text == """✅""" or text == """❌""" else len(snake_case__ )
				lowerCAmelCase  =				(width - text_length) // 2
				lowerCAmelCase  =				width - text_length - left_indent
				return " " * left_indent + text + " " * right_indent





def 							lowercase					()     ->  str:


				'''simple docstring'''






				lowerCAmelCase  =				transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
				lowerCAmelCase  =				{
				    name: config_maping_names[code]
				    for code, name in transformers_module.MODEL_NAMES_MAPPING.items()
				    if code in config_maping_names
				}
				lowerCAmelCase  =				{name: config.replace("""Config"""      ,       """""" ) for name, config in model_name_to_config.items()}

				# Dictionaries flagging if each model prefix has a slow/fast tokenizer, backend in PT/TF/Flax.
				lowerCAmelCase  =				collections.defaultdict(snake_case__ )
				lowerCAmelCase  =				collections.defaultdict(snake_case__ )
				lowerCAmelCase  =				collections.defaultdict(snake_case__ )
				lowerCAmelCase  =				collections.defaultdict(snake_case__ )
				lowerCAmelCase  =				collections.defaultdict(snake_case__ )

				# Let's lookup through all transformers object (once).
				for attr_name in dir(snake_case__ ):
								lowerCAmelCase  =				None
								if attr_name.endswith("""Tokenizer""" ):
												lowerCAmelCase  =				slow_tokenizers
												lowerCAmelCase  =				attr_name[:-9]
								elif attr_name.endswith("""TokenizerFast""" ):
												lowerCAmelCase  =				fast_tokenizers
												lowerCAmelCase  =				attr_name[:-13]
								elif _re_tf_models.match(snake_case__ ) is not None:
												lowerCAmelCase  =				tf_models
												lowerCAmelCase  =				_re_tf_models.match(snake_case__ ).groups()[0]
								elif _re_flax_models.match(snake_case__ ) is not None:
												lowerCAmelCase  =				flax_models
												lowerCAmelCase  =				_re_flax_models.match(snake_case__ ).groups()[0]
								elif _re_pt_models.match(snake_case__ ) is not None:
												lowerCAmelCase  =				pt_models
												lowerCAmelCase  =				_re_pt_models.match(snake_case__ ).groups()[0]

								if lookup_dict is not None:
												while len(snake_case__ ) > 0:
																if attr_name in model_name_to_prefix.values():
																				lowerCAmelCase  =				True
																				break
																# Try again after removing the last word in the name
																lowerCAmelCase  =				"""""".join(camel_case_split(snake_case__ )[:-1] )

    # Let's build that table!
				lowerCAmelCase  =				list(model_name_to_config.keys() )
				model_names.sort(key=str.lower )
				lowerCAmelCase  =				["""Model""", """Tokenizer slow""", """Tokenizer fast""", """PyTorch support""", """TensorFlow support""", """Flax Support"""]
				# We'll need widths to properly display everything in the center (+2 is to leave one extra space on each side).
				lowerCAmelCase  =				[len(snake_case__ ) + 2 for c in columns]
				lowerCAmelCase  =				max([len(snake_case__ ) for name in model_names] ) + 2

				# Build the table per se
				lowerCAmelCase  =				"""|""" + """|""".join([_center_text(snake_case__      ,       snake_case__ ) for c, w in zip(snake_case__      ,       snake_case__ )] ) + """|\n"""
				# Use ":-----:" format to center-aligned table cell texts
				table += "|" + "|".join([""":""" + """-""" * (w - 2) + """:""" for w in widths] ) + "|\n"

				lowerCAmelCase  =				{True: """✅""", False: """❌"""}
				for name in model_names:
								lowerCAmelCase  =				model_name_to_prefix[name]
								lowerCAmelCase  =				[
								    name,
								    check[slow_tokenizers[prefix]],
								    check[fast_tokenizers[prefix]],
								    check[pt_models[prefix]],
								    check[tf_models[prefix]],
								    check[flax_models[prefix]],
								]
								table += "|" + "|".join([_center_text(snake_case__      ,       snake_case__ ) for l, w in zip(snake_case__      ,       snake_case__ )] ) + "|\n"
				return table





def 							lowercase					(snake_case__   : Dict=False )     ->  Any:


				'''simple docstring'''






				lowerCAmelCase ,						lowerCAmelCase ,						lowerCAmelCase ,						lowerCAmelCase  =				_find_text_in_file(
				    filename=os.path.join(snake_case__      ,       """index.md""" )      ,       start_prompt="""<!--This table is updated automatically from the auto modules"""      ,       end_prompt="""<!-- End table-->"""      ,       )
				lowerCAmelCase  =				get_model_table_from_auto_modules()

				if current_table != new_table:
								if overwrite:
												with open(os.path.join(snake_case__      ,       """index.md""" )      ,       """w"""      ,       encoding="""utf-8"""      ,       newline="""\n""" ) as f:
																f.writelines(lines[:start_index] + [new_table] + lines[end_index:] )
								else:
												raise ValueError(
												    """The model table in the `index.md` has not been updated. Run `make fix-copies` to fix this.""" )


if __name__ == "__main__":
		a      =							argparse.ArgumentParser()
		parser.add_argument('--fix_and_overwrite', action='store_true', help='Whether to fix inconsistencies.')
		a      =							parser.parse_args()

		check_model_table(args.fix_and_overwrite)





