



'''simple docstring'''

import os
import unittest

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    BertTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english


@require_tokenizers
class 						a__  (					__snake_case,      unittest.TestCase						):
	__magic_name__		:     Any						     =  BertTokenizer
	__magic_name__		:     List[str]						     =  BertTokenizerFast
	__magic_name__		:     List[Any]						     =  True
	__magic_name__		:     int						     =  True
	__magic_name__		:     Tuple						     =  filter_non_english


	def 					lowercase__	(self			:			Tuple   )  ->      str:

					"""simple docstring"""

					super().setUp()

					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			[
					    """[UNK]""",
					    """[CLS]""",
					    """[SEP]""",
					    """[PAD]""",
					    """[MASK]""",
					    """want""",
					    """##want""",
					    """##ed""",
					    """wa""",
					    """un""",
					    """runn""",
					    """##ing""",
					    """,""",
					    """low""",
					    """lowest""",
					]
					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			os.path.join(self.tmpdirname,       VOCAB_FILES_NAMES['''vocab_file''']   )
					with open(self.vocab_file,       '''w''',       encoding='''utf-8'''   ) as vocab_writer:
									vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]   )   )


	def 					lowercase__	(self			:			Tuple,       __UpperCAmelCase			:			str   )  ->      str:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Tuple          =			"""UNwant\u00E9d,running"""
					SCREAMING_SNAKE_CASE	:    List[Any]          =			"""unwanted, running"""
					return input_text, output_text


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

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Tuple          =			self.tokenizer_class(self.vocab_file   )

					SCREAMING_SNAKE_CASE	:    int          =			tokenizer.tokenize('''UNwant\u00E9d,running'''   )
					self.assertListEqual(__UpperCAmelCase,       ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']   )
					self.assertListEqual(tokenizer.convert_tokens_to_ids(__UpperCAmelCase   ),       [9, 6, 7, 12, 10, 11]   )


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

					"""simple docstring"""

					if not self.test_rust_tokenizer:
									return

					SCREAMING_SNAKE_CASE	:    Dict          =			self.get_tokenizer()
					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			self.get_rust_tokenizer()

					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			"""UNwant\u00E9d,running"""

					SCREAMING_SNAKE_CASE	:    List[Any]          =			tokenizer.tokenize(__UpperCAmelCase   )
					SCREAMING_SNAKE_CASE	:    Optional[int]          =			rust_tokenizer.tokenize(__UpperCAmelCase   )
					self.assertListEqual(__UpperCAmelCase,       __UpperCAmelCase   )

					SCREAMING_SNAKE_CASE	:    int          =			tokenizer.encode(__UpperCAmelCase,       add_special_tokens=__UpperCAmelCase   )
					SCREAMING_SNAKE_CASE	:    Dict          =			rust_tokenizer.encode(__UpperCAmelCase,       add_special_tokens=__UpperCAmelCase   )
					self.assertListEqual(__UpperCAmelCase,       __UpperCAmelCase   )

					SCREAMING_SNAKE_CASE	:    str          =			self.get_rust_tokenizer()
					SCREAMING_SNAKE_CASE	:    List[str]          =			tokenizer.encode(__UpperCAmelCase   )
					SCREAMING_SNAKE_CASE	:    Dict          =			rust_tokenizer.encode(__UpperCAmelCase   )
					self.assertListEqual(__UpperCAmelCase,       __UpperCAmelCase   )

					# With lower casing
					SCREAMING_SNAKE_CASE	:    Any          =			self.get_tokenizer(do_lower_case=__UpperCAmelCase   )
					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			self.get_rust_tokenizer(do_lower_case=__UpperCAmelCase   )

					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			"""UNwant\u00E9d,running"""

					SCREAMING_SNAKE_CASE	:    Tuple          =			tokenizer.tokenize(__UpperCAmelCase   )
					SCREAMING_SNAKE_CASE	:    Optional[int]          =			rust_tokenizer.tokenize(__UpperCAmelCase   )
					self.assertListEqual(__UpperCAmelCase,       __UpperCAmelCase   )

					SCREAMING_SNAKE_CASE	:    Dict          =			tokenizer.encode(__UpperCAmelCase,       add_special_tokens=__UpperCAmelCase   )
					SCREAMING_SNAKE_CASE	:    Any          =			rust_tokenizer.encode(__UpperCAmelCase,       add_special_tokens=__UpperCAmelCase   )
					self.assertListEqual(__UpperCAmelCase,       __UpperCAmelCase   )

					SCREAMING_SNAKE_CASE	:    Dict          =			self.get_rust_tokenizer()
					SCREAMING_SNAKE_CASE	:    str          =			tokenizer.encode(__UpperCAmelCase   )
					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			rust_tokenizer.encode(__UpperCAmelCase   )
					self.assertListEqual(__UpperCAmelCase,       __UpperCAmelCase   )


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

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    str          =			BasicTokenizer()

					self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz'''   ),       ['''ah''', '''\u535A''', '''\u63A8''', '''zz''']   )


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

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			BasicTokenizer(do_lower_case=__UpperCAmelCase   )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''   ),       ['''hello''', '''!''', '''how''', '''are''', '''you''', '''?''']   )
					self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''   ),       ['''hello''']   )


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

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    int          =			BasicTokenizer(do_lower_case=__UpperCAmelCase,       strip_accents=__UpperCAmelCase   )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''   ),       ['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?''']   )
					self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''   ),       ['''h\u00E9llo''']   )


	def 					lowercase__	(self			:			Tuple   )  ->      List[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    str          =			BasicTokenizer(do_lower_case=__UpperCAmelCase,       strip_accents=__UpperCAmelCase   )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''   ),       ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']   )
					self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''   ),       ['''hello''']   )


	def 					lowercase__	(self			:			Optional[int]   )  ->      Union[str, Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			BasicTokenizer(do_lower_case=__UpperCAmelCase   )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''   ),       ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']   )
					self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''   ),       ['''hello''']   )


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

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    List[str]          =			BasicTokenizer(do_lower_case=__UpperCAmelCase   )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''   ),       ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']   )


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

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    List[Any]          =			BasicTokenizer(do_lower_case=__UpperCAmelCase,       strip_accents=__UpperCAmelCase   )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''   ),       ['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']   )


	def 					lowercase__	(self			:			Tuple   )  ->      Tuple:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    List[Any]          =			BasicTokenizer(do_lower_case=__UpperCAmelCase,       strip_accents=__UpperCAmelCase   )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''   ),       ['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']   )


	def 					lowercase__	(self			:			Any   )  ->      Dict:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    str          =			BasicTokenizer(do_lower_case=__UpperCAmelCase,       never_split=['''[UNK]''']   )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]'''   ),       ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]''']   )


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

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Dict          =			BasicTokenizer()
					SCREAMING_SNAKE_CASE	:    int          =			"""a\n'll !!to?'d of, can't."""
					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			["""a""", """'""", """ll""", """!""", """!""", """to""", """?""", """'""", """d""", """of""", """,""", """can""", """'""", """t""", """."""]
					self.assertListEqual(tokenizer.tokenize(__UpperCAmelCase   ),       __UpperCAmelCase   )


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

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    int          =			["""[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing"""]

					SCREAMING_SNAKE_CASE	:    Dict          =			{}
					for i, token in enumerate(__UpperCAmelCase   ):
									SCREAMING_SNAKE_CASE	:    Optional[Any]          =			i
					SCREAMING_SNAKE_CASE	:    Tuple          =			WordpieceTokenizer(vocab=__UpperCAmelCase,       unk_token='''[UNK]'''   )

					self.assertListEqual(tokenizer.tokenize(''''''   ),       []   )

					self.assertListEqual(tokenizer.tokenize('''unwanted running'''   ),       ['''un''', '''##want''', '''##ed''', '''runn''', '''##ing''']   )

					self.assertListEqual(tokenizer.tokenize('''unwantedX running'''   ),       ['''[UNK]''', '''runn''', '''##ing''']   )


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

					"""simple docstring"""

					self.assertTrue(_is_whitespace(''' '''   )   )
					self.assertTrue(_is_whitespace('''\t'''   )   )
					self.assertTrue(_is_whitespace('''\r'''   )   )
					self.assertTrue(_is_whitespace('''\n'''   )   )
					self.assertTrue(_is_whitespace('''\u00A0'''   )   )

					self.assertFalse(_is_whitespace('''A'''   )   )
					self.assertFalse(_is_whitespace('''-'''   )   )


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

					"""simple docstring"""

					self.assertTrue(_is_control('''\u0005'''   )   )

					self.assertFalse(_is_control('''A'''   )   )
					self.assertFalse(_is_control(''' '''   )   )
					self.assertFalse(_is_control('''\t'''   )   )
					self.assertFalse(_is_control('''\r'''   )   )


	def 					lowercase__	(self			:			Tuple   )  ->      int:

					"""simple docstring"""

					self.assertTrue(_is_punctuation('''-'''   )   )
					self.assertTrue(_is_punctuation('''$'''   )   )
					self.assertTrue(_is_punctuation('''`'''   )   )
					self.assertTrue(_is_punctuation('''.'''   )   )

					self.assertFalse(_is_punctuation('''A'''   )   )
					self.assertFalse(_is_punctuation(''' '''   )   )


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

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			self.get_tokenizer()
					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			self.get_rust_tokenizer()

					# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
					self.assertListEqual([tokenizer.tokenize(__UpperCAmelCase   ) for t in ['''Test''', '''\xad''', '''test''']],       [['''[UNK]'''], [], ['''[UNK]''']]   )

					self.assertListEqual(
					    [rust_tokenizer.tokenize(__UpperCAmelCase   ) for t in ['''Test''', '''\xad''', '''test''']],       [['''[UNK]'''], [], ['''[UNK]''']]   )


	@slow
	def 					lowercase__	(self			:			Dict   )  ->      Any:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Any          =			self.tokenizer_class.from_pretrained('''bert-base-uncased'''   )

					SCREAMING_SNAKE_CASE	:    int          =			tokenizer.encode('''sequence builders''',       add_special_tokens=__UpperCAmelCase   )
					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			tokenizer.encode('''multi-sequence build''',       add_special_tokens=__UpperCAmelCase   )

					SCREAMING_SNAKE_CASE	:    Optional[int]          =			tokenizer.build_inputs_with_special_tokens(__UpperCAmelCase   )
					SCREAMING_SNAKE_CASE	:    List[str]          =			tokenizer.build_inputs_with_special_tokens(__UpperCAmelCase,       __UpperCAmelCase   )

					assert encoded_sentence == [101] + text + [102]
					assert encoded_pair == [101] + text + [102] + text_a + [102]


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

					"""simple docstring"""

					for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
									with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''   ):
													SCREAMING_SNAKE_CASE	:    Optional[Any]          =			self.rust_tokenizer_class.from_pretrained(__UpperCAmelCase,       **__UpperCAmelCase   )

													SCREAMING_SNAKE_CASE	:    str          =			F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
													SCREAMING_SNAKE_CASE	:    Optional[int]          =			tokenizer_r.encode_plus(
													    __UpperCAmelCase,       return_attention_mask=__UpperCAmelCase,       return_token_type_ids=__UpperCAmelCase,       return_offsets_mapping=__UpperCAmelCase,       add_special_tokens=__UpperCAmelCase,       )

													SCREAMING_SNAKE_CASE	:    Any          =			tokenizer_r.do_lower_case if hasattr(__UpperCAmelCase,       '''do_lower_case'''   ) else False
													SCREAMING_SNAKE_CASE	:    str          =			(
													    [
													        ((0, 0), tokenizer_r.cls_token),
													        ((0, 1), """A"""),
													        ((1, 2), ""","""),
													        ((3, 5), """na"""),
													        ((5, 6), """##ï"""),
													        ((6, 8), """##ve"""),
													        ((9, 15), tokenizer_r.mask_token),
													        ((16, 21), """Allen"""),
													        ((21, 23), """##NL"""),
													        ((23, 24), """##P"""),
													        ((25, 33), """sentence"""),
													        ((33, 34), """."""),
													        ((0, 0), tokenizer_r.sep_token),
													    ]
													    if not do_lower_case
													    else [
													        ((0, 0), tokenizer_r.cls_token),
													        ((0, 1), """a"""),
													        ((1, 2), ""","""),
													        ((3, 8), """naive"""),
													        ((9, 15), tokenizer_r.mask_token),
													        ((16, 21), """allen"""),
													        ((21, 23), """##nl"""),
													        ((23, 24), """##p"""),
													        ((25, 33), """sentence"""),
													        ((33, 34), """."""),
													        ((0, 0), tokenizer_r.sep_token),
													    ]
													)

													self.assertEqual(
													    [e[1] for e in expected_results],       tokenizer_r.convert_ids_to_tokens(tokens['''input_ids''']   )   )
													self.assertEqual([e[0] for e in expected_results],       tokens['''offset_mapping''']   )






	def 					lowercase__	(self			:			Dict   )  ->      Tuple:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			["""的""", """人""", """有"""]
					SCREAMING_SNAKE_CASE	:    Any          =			"""""".join(__UpperCAmelCase   )
					for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
									with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''   ):
													SCREAMING_SNAKE_CASE	:    int          =			True
													SCREAMING_SNAKE_CASE	:    List[Any]          =			self.tokenizer_class.from_pretrained(__UpperCAmelCase,       **__UpperCAmelCase   )
													SCREAMING_SNAKE_CASE	:    Optional[Any]          =			self.rust_tokenizer_class.from_pretrained(__UpperCAmelCase,       **__UpperCAmelCase   )

													SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			tokenizer_p.encode(__UpperCAmelCase,       add_special_tokens=__UpperCAmelCase   )
													SCREAMING_SNAKE_CASE	:    Optional[int]          =			tokenizer_r.encode(__UpperCAmelCase,       add_special_tokens=__UpperCAmelCase   )

													SCREAMING_SNAKE_CASE	:    Optional[Any]          =			tokenizer_r.convert_ids_to_tokens(__UpperCAmelCase   )
													SCREAMING_SNAKE_CASE	:    List[str]          =			tokenizer_p.convert_ids_to_tokens(__UpperCAmelCase   )

													# it is expected that each Chinese character is not preceded by "##"
													self.assertListEqual(__UpperCAmelCase,       __UpperCAmelCase   )
													self.assertListEqual(__UpperCAmelCase,       __UpperCAmelCase   )

													SCREAMING_SNAKE_CASE	:    Dict          =			False
													SCREAMING_SNAKE_CASE	:    List[Any]          =			self.rust_tokenizer_class.from_pretrained(__UpperCAmelCase,       **__UpperCAmelCase   )
													SCREAMING_SNAKE_CASE	:    Optional[int]          =			self.tokenizer_class.from_pretrained(__UpperCAmelCase,       **__UpperCAmelCase   )

													SCREAMING_SNAKE_CASE	:    List[Any]          =			tokenizer_r.encode(__UpperCAmelCase,       add_special_tokens=__UpperCAmelCase   )
													SCREAMING_SNAKE_CASE	:    Optional[int]          =			tokenizer_p.encode(__UpperCAmelCase,       add_special_tokens=__UpperCAmelCase   )

													SCREAMING_SNAKE_CASE	:    Optional[int]          =			tokenizer_r.convert_ids_to_tokens(__UpperCAmelCase   )
													SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			tokenizer_p.convert_ids_to_tokens(__UpperCAmelCase   )

													# it is expected that only the first Chinese character is not preceded by "##".
													SCREAMING_SNAKE_CASE	:    Optional[int]          =			[
													    F'''##{token}''' if idx != 0 else token for idx, token in enumerate(__UpperCAmelCase   )
													]
													self.assertListEqual(__UpperCAmelCase,       __UpperCAmelCase   )
													self.assertListEqual(__UpperCAmelCase,       __UpperCAmelCase   )












"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_lowerCAmelCase            =	{
    'configuration_mobilebert': [
        'MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'MobileBertConfig',
        'MobileBertOnnxConfig',
    ],
    'tokenization_mobilebert': ['MobileBertTokenizer'],
}

try:
				if not is_tokenizers_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowerCAmelCase            =	['MobileBertTokenizerFast']

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowerCAmelCase            =	[
				    'MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'MobileBertForMaskedLM',
				    'MobileBertForMultipleChoice',
				    'MobileBertForNextSentencePrediction',
				    'MobileBertForPreTraining',
				    'MobileBertForQuestionAnswering',
				    'MobileBertForSequenceClassification',
				    'MobileBertForTokenClassification',
				    'MobileBertLayer',
				    'MobileBertModel',
				    'MobileBertPreTrainedModel',
				    'load_tf_weights_in_mobilebert',
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowerCAmelCase            =	[
				    'TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'TFMobileBertForMaskedLM',
				    'TFMobileBertForMultipleChoice',
				    'TFMobileBertForNextSentencePrediction',
				    'TFMobileBertForPreTraining',
				    'TFMobileBertForQuestionAnswering',
				    'TFMobileBertForSequenceClassification',
				    'TFMobileBertForTokenClassification',
				    'TFMobileBertMainLayer',
				    'TFMobileBertModel',
				    'TFMobileBertPreTrainedModel',
				]


if TYPE_CHECKING:
				from .configuration_mobilebert import (
				    MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
				    MobileBertConfig,
				    MobileBertOnnxConfig,
				)
				from .tokenization_mobilebert import MobileBertTokenizer

				try:
								if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_mobilebert_fast import MobileBertTokenizerFast

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_mobilebert import (
								    MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    MobileBertForMaskedLM,
								    MobileBertForMultipleChoice,
								    MobileBertForNextSentencePrediction,
								    MobileBertForPreTraining,
								    MobileBertForQuestionAnswering,
								    MobileBertForSequenceClassification,
								    MobileBertForTokenClassification,
								    MobileBertLayer,
								    MobileBertModel,
								    MobileBertPreTrainedModel,
								    load_tf_weights_in_mobilebert,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_mobilebert import (
								    TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFMobileBertForMaskedLM,
								    TFMobileBertForMultipleChoice,
								    TFMobileBertForNextSentencePrediction,
								    TFMobileBertForPreTraining,
								    TFMobileBertForQuestionAnswering,
								    TFMobileBertForSequenceClassification,
								    TFMobileBertForTokenClassification,
								    TFMobileBertMainLayer,
								    TFMobileBertModel,
								    TFMobileBertPreTrainedModel,
								)

else:
				import sys

				_lowerCAmelCase            =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
