




"""simple docstring"""





import argparse
import os
import re


A				=							"""src/transformers"""

# Pattern that looks at the indentation in a line.
A				=							re.compile(r"""^(\s*)\S""")
# Pattern that matches `"key":" and puts `key` in group 0.
A				=							re.compile(r"""^\s*\"([^\"]+)\":""")
# Pattern that matches `_import_structure["key"]` and puts `key` in group 0.
A				=							re.compile(r"""^\s*_import_structure\[\"([^\"]+)\"\]""")
# Pattern that matches `"key",` and puts `key` in group 0.
A				=							re.compile(r"""^\s*\"([^\"]+)\",\s*$""")
# Pattern that matches any `[stuff]` and puts `stuff` in group 0.
A				=							re.compile(r"""\[([^\]]+)\]""")

def        _UpperCamelCase     (      UpperCamelCase				)      ->      Optional[Any]:


			"""simple docstring"""
			__UpperCAmelCase						:			Any												=       _re_indent.search(UpperCamelCase				)
			return "" if search is None else search.groups()[0]

def        _UpperCamelCase     (      UpperCamelCase					,							UpperCamelCase=""					,							UpperCamelCase=None					,							UpperCamelCase=None				)      ->      Any:


			"""simple docstring"""
			__UpperCAmelCase						:			List[Any]												=       0
			__UpperCAmelCase						:			Union[str, Any]												=       code.split("\n"				)
			if start_prompt is not None:
						while not lines[index].startswith(UpperCamelCase				):
									index += 1
						__UpperCAmelCase						:			Optional[Any]												=       ["\n".join(lines[:index]				)]
			else:
						__UpperCAmelCase						:			Dict												=       []

			# We split into blocks until we get to the `end_prompt` (or the end of the block).
			__UpperCAmelCase						:			Any												=       [lines[index]]
			index += 1
			while index < len(UpperCamelCase				) and (end_prompt is None or not lines[index].startswith(UpperCamelCase				)):
						if len(lines[index]				) > 0 and get_indent(lines[index]				) == indent_level:
									if len(UpperCamelCase				) > 0 and get_indent(current_block[-1]				).startswith(indent_level + " "				):
												current_block.append(lines[index]				)
												blocks.append("\n".join(UpperCamelCase				)				)
												if index < len(UpperCamelCase				) - 1:
															__UpperCAmelCase						:			Optional[Any]												=       [lines[index + 1]]
															index += 1
												else:
															__UpperCAmelCase						:			Optional[Any]												=       []
									else:
												blocks.append("\n".join(UpperCamelCase				)				)
												__UpperCAmelCase						:			str												=       [lines[index]]
						else:
									current_block.append(lines[index]				)
						index += 1

			# Adds current block if it's nonempty.
			if len(UpperCamelCase				) > 0:
						blocks.append("\n".join(UpperCamelCase				)				)

			# Add final block after end_prompt if provided.
			if end_prompt is not None and index < len(UpperCamelCase				):
						blocks.append("\n".join(lines[index:]				)				)

			return blocks

def        _UpperCamelCase     (      UpperCamelCase				)      ->      Optional[int]:


			"""simple docstring"""

			def _inner(UpperCamelCase				):
						return key(UpperCamelCase				).lower().replace("_"					,							""				)

			return _inner

def        _UpperCamelCase     (      UpperCamelCase					,							UpperCamelCase=None				)      ->      Optional[int]:


			"""simple docstring"""

			# If no key is provided, we use a noop.
			def noop(UpperCamelCase				):
						return x

			if key is None:
						__UpperCAmelCase						:			Optional[Any]												=       noop
			# Constants are all uppercase, they go first.
			__UpperCAmelCase						:			Optional[int]												=       [obj for obj in objects if key(UpperCamelCase				).isupper()]
			# Classes are not all uppercase but start with a capital, they go second.
			__UpperCAmelCase						:			Tuple												=       [obj for obj in objects if key(UpperCamelCase				)[0].isupper() and not key(UpperCamelCase				).isupper()]
			# Functions begin with a lowercase, they go last.
			__UpperCAmelCase						:			int												=       [obj for obj in objects if not key(UpperCamelCase				)[0].isupper()]

			__UpperCAmelCase						:			Dict												=       ignore_underscore(UpperCamelCase				)
			return sorted(UpperCamelCase					,							key=UpperCamelCase				) + sorted(UpperCamelCase					,							key=UpperCamelCase				) + sorted(UpperCamelCase					,							key=UpperCamelCase				)

def        _UpperCamelCase     (      UpperCamelCase				)      ->      List[Any]:


			"""simple docstring"""

			# This inner function sort imports between [ ].
			def _replace(UpperCamelCase				):
						__UpperCAmelCase						:			Dict												=       match.groups()[0]
						if "," not in imports:
									return f"[{imports}]"
						__UpperCAmelCase						:			Optional[int]												=       [part.strip().replace("\""					,							""				) for part in imports.split(","				)]
						# We will have a final empty element if the line finished with a comma.
						if len(keys[-1]				) == 0:
									__UpperCAmelCase						:			Dict												=       keys[:-1]
						return "[" + ", ".join([f"\"{k}\"" for k in sort_objects(UpperCamelCase				)]				) + "]"

			__UpperCAmelCase						:			Optional[int]												=       import_statement.split("\n"				)
			if len(UpperCamelCase				) > 3:
						# Here we have to sort internal imports that are on several lines (one per name):
						# key: [
						#     "object1",
						#     "object2",
						#     ...
						# ]

						# We may have to ignore one or two lines on each side.
						__UpperCAmelCase						:			Any												=       2 if lines[1].strip() == "[" else 1
						__UpperCAmelCase						:			Union[str, Any]												=       [(i, _re_strip_line.search(UpperCamelCase				).groups()[0]) for i, line in enumerate(lines[idx:-idx]				)]
						__UpperCAmelCase						:			Dict												=       sort_objects(UpperCamelCase					,							key=lambda UpperCamelCase				: x[1]				)
						__UpperCAmelCase						:			List[str]												=       [lines[x[0] + idx] for x in sorted_indices]
						return "\n".join(lines[:idx] + sorted_lines + lines[-idx:]				)
			elif len(UpperCamelCase				) == 3:
						# Here we have to sort internal imports that are on one separate line:
						# key: [
						#     "object1", "object2", ...
						# ]
						if _re_bracket_content.search(lines[1]				) is not None:
									__UpperCAmelCase						:			Dict												=       _re_bracket_content.sub(_replace					,							lines[1]				)
						else:
									__UpperCAmelCase						:			str												=       [part.strip().replace("\""					,							""				) for part in lines[1].split(","				)]
									# We will have a final empty element if the line finished with a comma.
									if len(keys[-1]				) == 0:
												__UpperCAmelCase						:			str												=       keys[:-1]
									__UpperCAmelCase						:			Optional[Any]												=       get_indent(lines[1]				) + ", ".join([f"\"{k}\"" for k in sort_objects(UpperCamelCase				)]				)
						return "\n".join(UpperCamelCase				)
			else:
						# Finally we have to deal with imports fitting on one line
						__UpperCAmelCase						:			Optional[Any]												=       _re_bracket_content.sub(_replace					,							UpperCamelCase				)
						return import_statement

def        _UpperCamelCase     (      UpperCamelCase					,							UpperCamelCase=True				)      ->      Dict:


			"""simple docstring"""
			with open(UpperCamelCase					,							encoding="utf-8"				) as f:
						__UpperCAmelCase						:			Any												=       f.read()

			if "_import_structure" not in code:
						return

			# Blocks of indent level 0
			__UpperCAmelCase						:			Optional[Any]												=       split_code_in_indented_blocks(
			    UpperCamelCase					,							start_prompt="_import_structure = {"					,							end_prompt="if TYPE_CHECKING:"				)

			# We ignore block 0 (everything untils start_prompt) and the last block (everything after end_prompt).
			for block_idx in range(1					,							len(UpperCamelCase				) - 1				):
						# Check if the block contains some `_import_structure`s thingy to sort.
						__UpperCAmelCase						:			Dict												=       main_blocks[block_idx]
						__UpperCAmelCase						:			str												=       block.split("\n"				)

						# Get to the start of the imports.
						__UpperCAmelCase						:			List[Any]												=       0
						while line_idx < len(UpperCamelCase				) and "_import_structure" not in block_lines[line_idx]:
									# Skip dummy import blocks
									if "import dummy" in block_lines[line_idx]:
												__UpperCAmelCase						:			Optional[int]												=       len(UpperCamelCase				)
									else:
												line_idx += 1
						if line_idx >= len(UpperCamelCase				):
									continue

						# Ignore beginning and last line: they don't contain anything.
						__UpperCAmelCase						:			Any												=       "\n".join(block_lines[line_idx:-1]				)
						__UpperCAmelCase						:			Optional[Any]												=       get_indent(block_lines[1]				)
						# Slit the internal block into blocks of indent level 1.
						__UpperCAmelCase						:			List[str]												=       split_code_in_indented_blocks(UpperCamelCase					,							indent_level=UpperCamelCase				)
						# We have two categories of import key: list or _import_structure[key].append/extend
						__UpperCAmelCase						:			Union[str, Any]												=       _re_direct_key if "_import_structure = {" in block_lines[0] else _re_indirect_key
						# Grab the keys, but there is a trap: some lines are empty or just comments.
						__UpperCAmelCase						:			List[str]												=       [(pattern.search(UpperCamelCase				).groups()[0] if pattern.search(UpperCamelCase				) is not None else None) for b in internal_blocks]
						# We only sort the lines with a key.
						__UpperCAmelCase						:			str												=       [(i, key) for i, key in enumerate(UpperCamelCase				) if key is not None]
						__UpperCAmelCase						:			Optional[int]												=       [x[0] for x in sorted(UpperCamelCase					,							key=lambda UpperCamelCase				: x[1]				)]

						# We reorder the blocks by leaving empty lines/comments as they were and reorder the rest.
						__UpperCAmelCase						:			Optional[int]												=       0
						__UpperCAmelCase						:			List[str]												=       []
						for i in range(len(UpperCamelCase				)				):
									if keys[i] is None:
												reorderded_blocks.append(internal_blocks[i]				)
									else:
												__UpperCAmelCase						:			str												=       sort_objects_in_import(internal_blocks[sorted_indices[count]]				)
												reorderded_blocks.append(UpperCamelCase				)
												count += 1

        # And we put our main block back together with its first and last line.
						__UpperCAmelCase						:			List[str]												=       "\n".join(block_lines[:line_idx] + reorderded_blocks + [block_lines[-1]]				)

			if code != "\n".join(UpperCamelCase				):
						if check_only:
									return True
						else:
									print(f"Overwriting {file}."				)
									with open(UpperCamelCase					,							"w"					,							encoding="utf-8"				) as f:
												f.write("\n".join(UpperCamelCase				)				)

def        _UpperCamelCase     (      UpperCamelCase=True				)      ->      Any:


			"""simple docstring"""
			__UpperCAmelCase						:			Optional[Any]												=       []
			for root, _, files in os.walk(UpperCamelCase				):
						if "__init__.py" in files:
									__UpperCAmelCase						:			Optional[Any]												=       sort_imports(os.path.join(UpperCamelCase					,							"__init__.py"				)					,							check_only=UpperCamelCase				)
									if result:
												__UpperCAmelCase						:			Tuple												=       [os.path.join(UpperCamelCase					,							"__init__.py"				)]
			if len(UpperCamelCase				) > 0:
						raise ValueError(f"Would overwrite {len(UpperCamelCase				)} files, run `make style`."				)


if __name__ == "__main__":
					A				=							argparse.ArgumentParser()
					parser.add_argument("""--check_only""", action="""store_true""", help="""Whether to only check or fix style.""")
					A				=							parser.parse_args()

					sort_imports_in_all_inits(check_only=args.check_only)








from __future__ import annotations

import unittest

from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
  import tensorflow as tf

  from transformers import (
      TF_MODEL_FOR_PRETRAINING_MAPPING,
      TFMobileBertForMaskedLM,
      TFMobileBertForMultipleChoice,
      TFMobileBertForNextSentencePrediction,
      TFMobileBertForPreTraining,
      TFMobileBertForQuestionAnswering,
      TFMobileBertForSequenceClassification,
      TFMobileBertForTokenClassification,
      TFMobileBertModel,
  )


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

    '''simple docstring'''






    UpperCAmelCase__				    = (
        (
            TFMobileBertModel,
            TFMobileBertForMaskedLM,
            TFMobileBertForNextSentencePrediction,
            TFMobileBertForPreTraining,
            TFMobileBertForQuestionAnswering,
            TFMobileBertForSequenceClassification,
            TFMobileBertForTokenClassification,
            TFMobileBertForMultipleChoice,
        )
        if is_tf_available()
        else ()
    )
    UpperCAmelCase__				    = (
        {
            '''feature-extraction''': TFMobileBertModel,
            '''fill-mask''': TFMobileBertForMaskedLM,
            '''question-answering''': TFMobileBertForQuestionAnswering,
            '''text-classification''': TFMobileBertForSequenceClassification,
            '''token-classification''': TFMobileBertForTokenClassification,
            '''zero-shot''': TFMobileBertForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    UpperCAmelCase__				    = False
    UpperCAmelCase__				    = False


    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[Any]   ,					UpperCAmelCase__ :      Dict   ,					UpperCAmelCase__ :      Tuple   ,					UpperCAmelCase__ :      str=False)		->Optional[Any]:





           '''simple docstring'''

           A__ 					=       super()._prepare_for_class(UpperCAmelCase__   ,					UpperCAmelCase__   ,					return_labels=UpperCAmelCase__)

           if return_labels:
                  if model_class in get_values(UpperCAmelCase__):
                         A__ 					=       tf.zeros(self.model_tester.batch_size   ,					dtype=tf.intaa)

           return inputs_dict


    class 							UpperCamelCase_       (					UpperCAmelCase__	):

        '''simple docstring'''






        def __init__(     self :      List[Any]   ,					UpperCAmelCase__ :      str   ,					UpperCAmelCase__ :      int=13   ,					UpperCAmelCase__ :      str=7   ,					UpperCAmelCase__ :      Optional[Any]=True   ,					UpperCAmelCase__ :      Optional[int]=True   ,					UpperCAmelCase__ :      Union[str, Any]=True   ,					UpperCAmelCase__ :      Optional[int]=True   ,					UpperCAmelCase__ :      str=99   ,					UpperCAmelCase__ :      List[str]=32   ,					UpperCAmelCase__ :      Optional[int]=32   ,					UpperCAmelCase__ :      Any=2   ,					UpperCAmelCase__ :      List[str]=4   ,					UpperCAmelCase__ :      Optional[Any]=37   ,					UpperCAmelCase__ :      Optional[int]="gelu"   ,					UpperCAmelCase__ :      Any=0.1   ,					UpperCAmelCase__ :      Optional[Any]=0.1   ,					UpperCAmelCase__ :      List[Any]=512   ,					UpperCAmelCase__ :      Tuple=16   ,					UpperCAmelCase__ :      Any=2   ,					UpperCAmelCase__ :      Dict=0.02   ,					UpperCAmelCase__ :      int=3   ,					UpperCAmelCase__ :      List[str]=4   ,					UpperCAmelCase__ :      Tuple=None   ,					)		->Any:





               '''simple docstring'''

               A__ 					=       parent
               A__ 					=       batch_size
               A__ 					=       seq_length
               A__ 					=       is_training
               A__ 					=       use_input_mask
               A__ 					=       use_token_type_ids
               A__ 					=       use_labels
               A__ 					=       vocab_size
               A__ 					=       hidden_size
               A__ 					=       num_hidden_layers
               A__ 					=       num_attention_heads
               A__ 					=       intermediate_size
               A__ 					=       hidden_act
               A__ 					=       hidden_dropout_prob
               A__ 					=       attention_probs_dropout_prob
               A__ 					=       max_position_embeddings
               A__ 					=       type_vocab_size
               A__ 					=       type_sequence_label_size
               A__ 					=       initializer_range
               A__ 					=       num_labels
               A__ 					=       num_choices
               A__ 					=       scope
               A__ 					=       embedding_size


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





               '''simple docstring'''

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

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

               A__ 					=       None
               if self.use_token_type_ids:
                      A__ 					=       ids_tensor([self.batch_size, self.seq_length]   ,					self.type_vocab_size)

               A__ 					=       None
               A__ 					=       None
               A__ 					=       None
               if self.use_labels:
                      A__ 					=       ids_tensor([self.batch_size]   ,					self.type_sequence_label_size)
                      A__ 					=       ids_tensor([self.batch_size, self.seq_length]   ,					self.num_labels)
                      A__ 					=       ids_tensor([self.batch_size]   ,					self.num_choices)

               A__ 					=       MobileBertConfig(
                   vocab_size=self.vocab_size   ,					hidden_size=self.hidden_size   ,					num_hidden_layers=self.num_hidden_layers   ,					num_attention_heads=self.num_attention_heads   ,					intermediate_size=self.intermediate_size   ,					hidden_act=self.hidden_act   ,					hidden_dropout_prob=self.hidden_dropout_prob   ,					attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,					max_position_embeddings=self.max_position_embeddings   ,					type_vocab_size=self.type_vocab_size   ,					initializer_range=self.initializer_range   ,					embedding_size=self.embedding_size   ,					)

               return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


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





               '''simple docstring'''

               A__ 					=       TFMobileBertModel(config=UpperCAmelCase__)
               A__ 					=       {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
               A__ 					=       model(UpperCAmelCase__)

               A__ 					=       [input_ids, input_mask]
               A__ 					=       model(UpperCAmelCase__)

               A__ 					=       model(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 :      List[str]   ,					UpperCAmelCase__ :      int   ,					UpperCAmelCase__ :      str   ,					UpperCAmelCase__ :      Any   ,					UpperCAmelCase__ :      int   ,					UpperCAmelCase__ :      Optional[int]   ,					UpperCAmelCase__ :      Any   ,					UpperCAmelCase__ :      Tuple)		->Optional[Any]:





               '''simple docstring'''

               A__ 					=       TFMobileBertForMaskedLM(config=UpperCAmelCase__)
               A__ 					=       {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
               A__ 					=       model(UpperCAmelCase__)
               self.parent.assertEqual(result.logits.shape   ,					(self.batch_size, self.seq_length, self.vocab_size))


        def 			SCREAMING_SNAKE_CASE				(     self :      Dict   ,					UpperCAmelCase__ :      List[Any]   ,					UpperCAmelCase__ :      Optional[Any]   ,					UpperCAmelCase__ :      List[Any]   ,					UpperCAmelCase__ :      int   ,					UpperCAmelCase__ :      int   ,					UpperCAmelCase__ :      List[Any]   ,					UpperCAmelCase__ :      Optional[Any])		->int:





               '''simple docstring'''

               A__ 					=       TFMobileBertForNextSentencePrediction(config=UpperCAmelCase__)
               A__ 					=       {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
               A__ 					=       model(UpperCAmelCase__)
               self.parent.assertEqual(result.logits.shape   ,					(self.batch_size, 2))


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





               '''simple docstring'''

               A__ 					=       TFMobileBertForPreTraining(config=UpperCAmelCase__)
               A__ 					=       {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
               A__ 					=       model(UpperCAmelCase__)
               self.parent.assertEqual(
                   result.prediction_logits.shape   ,					(self.batch_size, self.seq_length, self.vocab_size))
               self.parent.assertEqual(result.seq_relationship_logits.shape   ,					(self.batch_size, 2))


        def 			SCREAMING_SNAKE_CASE				(     self :      Tuple   ,					UpperCAmelCase__ :      List[Any]   ,					UpperCAmelCase__ :      Union[str, Any]   ,					UpperCAmelCase__ :      Any   ,					UpperCAmelCase__ :      Any   ,					UpperCAmelCase__ :      int   ,					UpperCAmelCase__ :      List[str]   ,					UpperCAmelCase__ :      Tuple)		->Dict:





               '''simple docstring'''

               A__ 					=       self.num_labels
               A__ 					=       TFMobileBertForSequenceClassification(config=UpperCAmelCase__)
               A__ 					=       {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
               A__ 					=       model(UpperCAmelCase__)
               self.parent.assertEqual(result.logits.shape   ,					(self.batch_size, self.num_labels))


        def 			SCREAMING_SNAKE_CASE				(     self :      Any   ,					UpperCAmelCase__ :      List[Any]   ,					UpperCAmelCase__ :      int   ,					UpperCAmelCase__ :      str   ,					UpperCAmelCase__ :      Any   ,					UpperCAmelCase__ :      Optional[Any]   ,					UpperCAmelCase__ :      str   ,					UpperCAmelCase__ :      int)		->Dict:





               '''simple docstring'''

               A__ 					=       self.num_choices
               A__ 					=       TFMobileBertForMultipleChoice(config=UpperCAmelCase__)
               A__ 					=       tf.tile(tf.expand_dims(UpperCAmelCase__   ,					1)   ,					(1, self.num_choices, 1))
               A__ 					=       tf.tile(tf.expand_dims(UpperCAmelCase__   ,					1)   ,					(1, self.num_choices, 1))
               A__ 					=       tf.tile(tf.expand_dims(UpperCAmelCase__   ,					1)   ,					(1, self.num_choices, 1))
               A__ 					=       {
                   '''input_ids''': multiple_choice_inputs_ids,
                   '''attention_mask''': multiple_choice_input_mask,
                   '''token_type_ids''': multiple_choice_token_type_ids,
               }
               A__ 					=       model(UpperCAmelCase__)
               self.parent.assertEqual(result.logits.shape   ,					(self.batch_size, self.num_choices))


        def 			SCREAMING_SNAKE_CASE				(     self :      Dict   ,					UpperCAmelCase__ :      Union[str, Any]   ,					UpperCAmelCase__ :      int   ,					UpperCAmelCase__ :      Optional[int]   ,					UpperCAmelCase__ :      List[Any]   ,					UpperCAmelCase__ :      Any   ,					UpperCAmelCase__ :      Dict   ,					UpperCAmelCase__ :      Optional[int])		->int:





               '''simple docstring'''

               A__ 					=       self.num_labels
               A__ 					=       TFMobileBertForTokenClassification(config=UpperCAmelCase__)
               A__ 					=       {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
               A__ 					=       model(UpperCAmelCase__)
               self.parent.assertEqual(result.logits.shape   ,					(self.batch_size, self.seq_length, self.num_labels))


        def 			SCREAMING_SNAKE_CASE				(     self :      List[Any]   ,					UpperCAmelCase__ :      Optional[Any]   ,					UpperCAmelCase__ :      Dict   ,					UpperCAmelCase__ :      List[Any]   ,					UpperCAmelCase__ :      Tuple   ,					UpperCAmelCase__ :      Union[str, Any]   ,					UpperCAmelCase__ :      Any   ,					UpperCAmelCase__ :      Union[str, Any])		->Union[str, Any]:





               '''simple docstring'''

               A__ 					=       TFMobileBertForQuestionAnswering(config=UpperCAmelCase__)
               A__ 					=       {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
               A__ 					=       model(UpperCAmelCase__)
               self.parent.assertEqual(result.start_logits.shape   ,					(self.batch_size, self.seq_length))
               self.parent.assertEqual(result.end_logits.shape   ,					(self.batch_size, self.seq_length))





        def 			SCREAMING_SNAKE_CASE				(     self :      Any)		->str:





               '''simple docstring'''

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


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





           '''simple docstring'''

           A__ 					=       TFMobileBertModelTest.TFMobileBertModelTester(self)
           A__ 					=       ConfigTester(self   ,					config_class=UpperCAmelCase__   ,					hidden_size=37)


    def 			SCREAMING_SNAKE_CASE				(     self :      Tuple)		->Optional[int]:





           '''simple docstring'''

           self.config_tester.run_common_tests()


    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[Any])		->Dict:





           '''simple docstring'''

           A__ 					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_model(*UpperCAmelCase__)


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





           '''simple docstring'''

           A__ 					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_masked_lm(*UpperCAmelCase__)


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





           '''simple docstring'''

           A__ 					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_multiple_choice(*UpperCAmelCase__)


    def 			SCREAMING_SNAKE_CASE				(     self :      Tuple)		->Dict:





           '''simple docstring'''

           A__ 					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*UpperCAmelCase__)


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





           '''simple docstring'''

           A__ 					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_pretraining(*UpperCAmelCase__)


    def 			SCREAMING_SNAKE_CASE				(     self :      int)		->Optional[int]:





           '''simple docstring'''

           A__ 					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_question_answering(*UpperCAmelCase__)


    def 			SCREAMING_SNAKE_CASE				(     self :      Tuple)		->Optional[int]:





           '''simple docstring'''

           A__ 					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_sequence_classification(*UpperCAmelCase__)


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





           '''simple docstring'''

           A__ 					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_token_classification(*UpperCAmelCase__)





    @slow
    def 			SCREAMING_SNAKE_CASE				(     self :      str)		->List[Any]:





           '''simple docstring'''

           for model_name in ["google/mobilebert-uncased"]:
                  A__ 					=       TFMobileBertModel.from_pretrained(UpperCAmelCase__)
                  self.assertIsNotNone(UpperCAmelCase__)


@require_tf
class 							UpperCamelCase_       (					unittest.TestCase	):

    '''simple docstring'''






    @slow
    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[Any])		->Any:





           '''simple docstring'''

           A__ 					=       TFMobileBertForPreTraining.from_pretrained('''google/mobilebert-uncased''')
           A__ 					=       tf.constant([[0, 1, 2, 3, 4, 5]])
           A__ 					=       model(UpperCAmelCase__)[0]

           A__ 					=       [1, 6, 30_522]
           self.assertEqual(output.shape   ,					UpperCAmelCase__)

           A__ 					=       tf.constant(
               [
                   [
                       [-4.5919547, -9.248295, -9.645256],
                       [-6.7306175, -6.440284, -6.6052837],
                       [-7.2743506, -6.7847915, -6.024673],
                   ]
               ])
           tf.debugging.assert_near(output[:, :3, :3]   ,					UpperCAmelCase__   ,					atol=1e-4)


