import itertools
import json
import os
import unittest

from transformers import AddedToken, LongformerTokenizer, LongformerTokenizerFast
from transformers.models.longformer.tokenization_longformer import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin
@require_tokenizers
class  A_			(							a_      ,							unittest.TestCase			):
  _SCREAMING_SNAKE_CASE     					=      LongformerTokenizer
  _SCREAMING_SNAKE_CASE     					=      True
  _SCREAMING_SNAKE_CASE     					=      LongformerTokenizerFast
  _SCREAMING_SNAKE_CASE     					=      True

  def 		_UpperCAmelCase (		self			:   int							):
   super().setUp()

   # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
   __a							=	[
       "l",
       "o",
       "w",
       "e",
       "r",
       "s",
       "t",
       "i",
       "d",
       "n",
       "\u0120",
       "\u0120l",
       "\u0120n",
       "\u0120lo",
       "\u0120low",
       "er",
       "\u0120lowest",
       "\u0120newer",
       "\u0120wider",
       "<unk>",
   ]
   __a							=	dict(zip(__SCREAMING_SNAKE_CASE  ,				range(len(__SCREAMING_SNAKE_CASE							)							)							)							)
   __a							=	["#version: 0.2", "\u0120 l", "\u0120l o", "\u0120lo w", "e r", ""]
   __a							=	{"unk_token": "<unk>"}

   __a							=	os.path.join(self.tmpdirname  ,				VOCAB_FILES_NAMES["vocab_file"]							)
   __a							=	os.path.join(self.tmpdirname  ,				VOCAB_FILES_NAMES["merges_file"]							)
   with open(self.vocab_file  ,				"w"  ,				encoding="utf-8"							) as fp:
    fp.write(json.dumps(__SCREAMING_SNAKE_CASE							) + "\n"							)
   with open(self.merges_file  ,				"w"  ,				encoding="utf-8"							) as fp:
    fp.write("\n".join(__SCREAMING_SNAKE_CASE							)							)

  def 		_UpperCAmelCase (		self			:   Dict  ,				**__SCREAMING_SNAKE_CASE			:   Any							):
   kwargs.update(self.special_tokens_map							)
   return self.tokenizer_class.from_pretrained(self.tmpdirname  ,				**__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   List[Any]  ,				**__SCREAMING_SNAKE_CASE			:   int							):
   kwargs.update(self.special_tokens_map							)
   return self.rust_tokenizer_class.from_pretrained(self.tmpdirname  ,				**__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   Any  ,				__SCREAMING_SNAKE_CASE			:   Tuple							):
   __a							=	"lower newer"
   __a							=	"lower newer"
   return input_text, output_text

  def 		_UpperCAmelCase (		self			:   Optional[int]							):
   __a							=	self.tokenizer_class(self.vocab_file  ,				self.merges_file  ,				**self.special_tokens_map							)
   __a							=	"lower newer"
   __a							=	["l", "o", "w", "er", "\u0120", "n", "e", "w", "er"]
   __a							=	tokenizer.tokenize(__SCREAMING_SNAKE_CASE							)  # , add_prefix_space=True)
   self.assertListEqual(__SCREAMING_SNAKE_CASE  ,				__SCREAMING_SNAKE_CASE							)

   __a							=	tokens + [tokenizer.unk_token]
   __a							=	[0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
   self.assertListEqual(tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE							)  ,				__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   List[str]							):
   __a							=	self.get_tokenizer()

   self.assertListEqual(tokenizer.encode("Hello world!"  ,				add_special_tokens=__SCREAMING_SNAKE_CASE							)  ,				[0, 3_14_14, 2_32, 3_28, 2]							)
   self.assertListEqual(
       tokenizer.encode("Hello world! cécé herlolip 418"  ,				add_special_tokens=__SCREAMING_SNAKE_CASE							)  ,				[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]  ,				)

  @slow
  def 		_UpperCAmelCase (		self			:   List[Any]							):
   __a							=	self.tokenizer_class.from_pretrained("allenai/longformer-base-4096"							)

   __a							=	tokenizer.encode("sequence builders"  ,				add_special_tokens=__SCREAMING_SNAKE_CASE							)
   __a							=	tokenizer.encode("multi-sequence build"  ,				add_special_tokens=__SCREAMING_SNAKE_CASE							)

   __a							=	tokenizer.encode(
       "sequence builders"  ,				add_special_tokens=__SCREAMING_SNAKE_CASE  ,				add_prefix_space=__SCREAMING_SNAKE_CASE							)
   __a							=	tokenizer.encode(
       "sequence builders"  ,				"multi-sequence build"  ,				add_special_tokens=__SCREAMING_SNAKE_CASE  ,				add_prefix_space=__SCREAMING_SNAKE_CASE							)

   __a							=	tokenizer.build_inputs_with_special_tokens(__SCREAMING_SNAKE_CASE							)
   __a							=	tokenizer.build_inputs_with_special_tokens(__SCREAMING_SNAKE_CASE  ,				__SCREAMING_SNAKE_CASE							)

   assert encoded_sentence == encoded_text_from_decode
   assert encoded_pair == encoded_pair_from_decode

  def 		_UpperCAmelCase (		self			:   Dict							):
   __a							=	self.get_tokenizer()

   __a							=	"Encode this sequence."
   __a							=	tokenizer.byte_encoder[" ".encode("utf-8"							)[0]]

   # Testing encoder arguments
   __a							=	tokenizer.encode(__SCREAMING_SNAKE_CASE  ,				add_special_tokens=__SCREAMING_SNAKE_CASE  ,				add_prefix_space=__SCREAMING_SNAKE_CASE							)
   __a							=	tokenizer.convert_ids_to_tokens(encoded[0]							)[0]
   self.assertNotEqual(__SCREAMING_SNAKE_CASE  ,				__SCREAMING_SNAKE_CASE							)

   __a							=	tokenizer.encode(__SCREAMING_SNAKE_CASE  ,				add_special_tokens=__SCREAMING_SNAKE_CASE  ,				add_prefix_space=__SCREAMING_SNAKE_CASE							)
   __a							=	tokenizer.convert_ids_to_tokens(encoded[0]							)[0]
   self.assertEqual(__SCREAMING_SNAKE_CASE  ,				__SCREAMING_SNAKE_CASE							)

   tokenizer.add_special_tokens({"bos_token": "<s>"}							)
   __a							=	tokenizer.encode(__SCREAMING_SNAKE_CASE  ,				add_special_tokens=__SCREAMING_SNAKE_CASE							)
   __a							=	tokenizer.convert_ids_to_tokens(encoded[1]							)[0]
   self.assertNotEqual(__SCREAMING_SNAKE_CASE  ,				__SCREAMING_SNAKE_CASE							)

   # Testing spaces after special tokens
   __a							=	"<mask>"
   tokenizer.add_special_tokens(
       {"mask_token": AddedToken(__SCREAMING_SNAKE_CASE  ,				lstrip=__SCREAMING_SNAKE_CASE  ,				rstrip=__SCREAMING_SNAKE_CASE							)}							)  # mask token has a left space
   __a							=	tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE							)

   __a							=	"Encode <mask> sequence"
   __a							=	"Encode <mask>sequence"

   __a							=	tokenizer.encode(__SCREAMING_SNAKE_CASE							)
   __a							=	encoded.index(__SCREAMING_SNAKE_CASE							)
   __a							=	tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]							)[0]
   self.assertEqual(__SCREAMING_SNAKE_CASE  ,				__SCREAMING_SNAKE_CASE							)

   __a							=	tokenizer.encode(__SCREAMING_SNAKE_CASE							)
   __a							=	encoded.index(__SCREAMING_SNAKE_CASE							)
   __a							=	tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]							)[0]
   self.assertNotEqual(__SCREAMING_SNAKE_CASE  ,				__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   Optional[int]							):
   pass

  def 		_UpperCAmelCase (		self			:   Optional[Any]							):
   for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
    with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""							):
     __a							=	self.rust_tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)
     __a							=	self.tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)
     __a							=	"A, <mask> AllenNLP sentence."
     __a							=	tokenizer_r.encode_plus(__SCREAMING_SNAKE_CASE  ,				add_special_tokens=__SCREAMING_SNAKE_CASE  ,				return_token_type_ids=__SCREAMING_SNAKE_CASE							)
     __a							=	tokenizer_p.encode_plus(__SCREAMING_SNAKE_CASE  ,				add_special_tokens=__SCREAMING_SNAKE_CASE  ,				return_token_type_ids=__SCREAMING_SNAKE_CASE							)

     # token_type_ids should put 0 everywhere
     self.assertEqual(sum(tokens_r["token_type_ids"]							)  ,				sum(tokens_p["token_type_ids"]							)							)

     # attention_mask should put 1 everywhere, so sum over length should be 1
     self.assertEqual(
         sum(tokens_r["attention_mask"]							) / len(tokens_r["attention_mask"]							)  ,				sum(tokens_p["attention_mask"]							) / len(tokens_p["attention_mask"]							)  ,				)

     __a							=	tokenizer_r.convert_ids_to_tokens(tokens_r["input_ids"]							)
     __a							=	tokenizer_p.convert_ids_to_tokens(tokens_p["input_ids"]							)

     # Rust correctly handles the space before the mask while python doesnt
     self.assertSequenceEqual(tokens_p["input_ids"]  ,				[0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2]							)
     self.assertSequenceEqual(tokens_r["input_ids"]  ,				[0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2]							)

     self.assertSequenceEqual(
         __SCREAMING_SNAKE_CASE  ,				["<s>", "A", ",", "<mask>", "ĠAllen", "N", "LP", "Ġsentence", ".", "</s>"]							)
     self.assertSequenceEqual(
         __SCREAMING_SNAKE_CASE  ,				["<s>", "A", ",", "<mask>", "ĠAllen", "N", "LP", "Ġsentence", ".", "</s>"]							)

  def 		_UpperCAmelCase (		self			:   Tuple							):
   for trim_offsets, add_prefix_space in itertools.product([True, False]  ,				repeat=2							):
    __a							=	self.rust_tokenizer_class.from_pretrained(
        self.tmpdirname  ,				use_fast=__SCREAMING_SNAKE_CASE  ,				add_prefix_space=__SCREAMING_SNAKE_CASE  ,				trim_offsets=__SCREAMING_SNAKE_CASE							)

    __a							=	json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()							)
    __a							=	json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()							)

    self.assertEqual(pre_tokenizer_state["add_prefix_space"]  ,				__SCREAMING_SNAKE_CASE							)

    self.assertEqual(post_processor_state["add_prefix_space"]  ,				__SCREAMING_SNAKE_CASE							)
    self.assertEqual(post_processor_state["trim_offsets"]  ,				__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   str							):
   # Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space` and
   # `trim_offsets`
   for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
    with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""							):
     __a							=	"hello"  # `hello` is a token in the vocabulary of `pretrained_name`
     __a							=	f"""{text_of_1_token} {text_of_1_token}"""

     __a							=	self.rust_tokenizer_class.from_pretrained(
         __SCREAMING_SNAKE_CASE  ,				use_fast=__SCREAMING_SNAKE_CASE  ,				add_prefix_space=__SCREAMING_SNAKE_CASE  ,				trim_offsets=__SCREAMING_SNAKE_CASE							)
     __a							=	tokenizer_r(__SCREAMING_SNAKE_CASE  ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE  ,				add_special_tokens=__SCREAMING_SNAKE_CASE							)
     self.assertEqual(encoding.offset_mapping[0]  ,				(0, len(__SCREAMING_SNAKE_CASE							))							)
     self.assertEqual(
         encoding.offset_mapping[1]  ,				(len(__SCREAMING_SNAKE_CASE							) + 1, len(__SCREAMING_SNAKE_CASE							) + 1 + len(__SCREAMING_SNAKE_CASE							))  ,				)

     __a							=	self.rust_tokenizer_class.from_pretrained(
         __SCREAMING_SNAKE_CASE  ,				use_fast=__SCREAMING_SNAKE_CASE  ,				add_prefix_space=__SCREAMING_SNAKE_CASE  ,				trim_offsets=__SCREAMING_SNAKE_CASE							)
     __a							=	tokenizer_r(__SCREAMING_SNAKE_CASE  ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE  ,				add_special_tokens=__SCREAMING_SNAKE_CASE							)
     self.assertEqual(encoding.offset_mapping[0]  ,				(0, len(__SCREAMING_SNAKE_CASE							))							)
     self.assertEqual(
         encoding.offset_mapping[1]  ,				(len(__SCREAMING_SNAKE_CASE							) + 1, len(__SCREAMING_SNAKE_CASE							) + 1 + len(__SCREAMING_SNAKE_CASE							))  ,				)

     __a							=	self.rust_tokenizer_class.from_pretrained(
         __SCREAMING_SNAKE_CASE  ,				use_fast=__SCREAMING_SNAKE_CASE  ,				add_prefix_space=__SCREAMING_SNAKE_CASE  ,				trim_offsets=__SCREAMING_SNAKE_CASE							)
     __a							=	tokenizer_r(__SCREAMING_SNAKE_CASE  ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE  ,				add_special_tokens=__SCREAMING_SNAKE_CASE							)
     self.assertEqual(encoding.offset_mapping[0]  ,				(0, len(__SCREAMING_SNAKE_CASE							))							)
     self.assertEqual(
         encoding.offset_mapping[1]  ,				(len(__SCREAMING_SNAKE_CASE							), len(__SCREAMING_SNAKE_CASE							) + 1 + len(__SCREAMING_SNAKE_CASE							))  ,				)

     __a							=	self.rust_tokenizer_class.from_pretrained(
         __SCREAMING_SNAKE_CASE  ,				use_fast=__SCREAMING_SNAKE_CASE  ,				add_prefix_space=__SCREAMING_SNAKE_CASE  ,				trim_offsets=__SCREAMING_SNAKE_CASE							)
     __a							=	tokenizer_r(__SCREAMING_SNAKE_CASE  ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE  ,				add_special_tokens=__SCREAMING_SNAKE_CASE							)
     self.assertEqual(encoding.offset_mapping[0]  ,				(0, len(__SCREAMING_SNAKE_CASE							))							)
     self.assertEqual(
         encoding.offset_mapping[1]  ,				(len(__SCREAMING_SNAKE_CASE							), len(__SCREAMING_SNAKE_CASE							) + 1 + len(__SCREAMING_SNAKE_CASE							))  ,				)

     __a							=	f""" {text}"""

     # tokenizer_r = self.rust_tokenizer_class.from_pretrained(
     #     pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True
     # )
     # encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False)
     # self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token)))
     # self.assertEqual(
     #     encoding.offset_mapping[1],
     #     (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)),
     # )

     __a							=	self.rust_tokenizer_class.from_pretrained(
         __SCREAMING_SNAKE_CASE  ,				use_fast=__SCREAMING_SNAKE_CASE  ,				add_prefix_space=__SCREAMING_SNAKE_CASE  ,				trim_offsets=__SCREAMING_SNAKE_CASE							)
     __a							=	tokenizer_r(__SCREAMING_SNAKE_CASE  ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE  ,				add_special_tokens=__SCREAMING_SNAKE_CASE							)
     self.assertEqual(encoding.offset_mapping[0]  ,				(1, 1 + len(__SCREAMING_SNAKE_CASE							))							)
     self.assertEqual(
         encoding.offset_mapping[1]  ,				(1 + len(__SCREAMING_SNAKE_CASE							) + 1, 1 + len(__SCREAMING_SNAKE_CASE							) + 1 + len(__SCREAMING_SNAKE_CASE							))  ,				)

     __a							=	self.rust_tokenizer_class.from_pretrained(
         __SCREAMING_SNAKE_CASE  ,				use_fast=__SCREAMING_SNAKE_CASE  ,				add_prefix_space=__SCREAMING_SNAKE_CASE  ,				trim_offsets=__SCREAMING_SNAKE_CASE							)
     __a							=	tokenizer_r(__SCREAMING_SNAKE_CASE  ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE  ,				add_special_tokens=__SCREAMING_SNAKE_CASE							)
     self.assertEqual(encoding.offset_mapping[0]  ,				(0, 1 + len(__SCREAMING_SNAKE_CASE							))							)
     self.assertEqual(
         encoding.offset_mapping[1]  ,				(1 + len(__SCREAMING_SNAKE_CASE							), 1 + len(__SCREAMING_SNAKE_CASE							) + 1 + len(__SCREAMING_SNAKE_CASE							))  ,				)

     __a							=	self.rust_tokenizer_class.from_pretrained(
         __SCREAMING_SNAKE_CASE  ,				use_fast=__SCREAMING_SNAKE_CASE  ,				add_prefix_space=__SCREAMING_SNAKE_CASE  ,				trim_offsets=__SCREAMING_SNAKE_CASE							)
     __a							=	tokenizer_r(__SCREAMING_SNAKE_CASE  ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE  ,				add_special_tokens=__SCREAMING_SNAKE_CASE							)
     self.assertEqual(encoding.offset_mapping[0]  ,				(0, 1 + len(__SCREAMING_SNAKE_CASE							))							)
     self.assertEqual(
         encoding.offset_mapping[1]  ,				(1 + len(__SCREAMING_SNAKE_CASE							), 1 + len(__SCREAMING_SNAKE_CASE							) + 1 + len(__SCREAMING_SNAKE_CASE							))  ,				)



from typing import TYPE_CHECKING

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


SCREAMING_SNAKE_CASE			:						Optional[int]				  =		{
    """configuration_bert""": ["""BERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """BertConfig""", """BertOnnxConfig"""],
    """tokenization_bert""": ["""BasicTokenizer""", """BertTokenizer""", """WordpieceTokenizer"""],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE			:						Optional[int]				  =		["""BertTokenizerFast"""]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE			:						List[Any]				  =		[
      """BERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """BertForMaskedLM""",
      """BertForMultipleChoice""",
      """BertForNextSentencePrediction""",
      """BertForPreTraining""",
      """BertForQuestionAnswering""",
      """BertForSequenceClassification""",
      """BertForTokenClassification""",
      """BertLayer""",
      """BertLMHeadModel""",
      """BertModel""",
      """BertPreTrainedModel""",
      """load_tf_weights_in_bert""",
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE			:						Union[str, Any]				  =		[
      """TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """TFBertEmbeddings""",
      """TFBertForMaskedLM""",
      """TFBertForMultipleChoice""",
      """TFBertForNextSentencePrediction""",
      """TFBertForPreTraining""",
      """TFBertForQuestionAnswering""",
      """TFBertForSequenceClassification""",
      """TFBertForTokenClassification""",
      """TFBertLMHeadModel""",
      """TFBertMainLayer""",
      """TFBertModel""",
      """TFBertPreTrainedModel""",
  ]
try:
  if not is_tensorflow_text_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE			:						Optional[Any]				  =		["""TFBertTokenizer"""]

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE			:						Any				  =		[
      """FlaxBertForCausalLM""",
      """FlaxBertForMaskedLM""",
      """FlaxBertForMultipleChoice""",
      """FlaxBertForNextSentencePrediction""",
      """FlaxBertForPreTraining""",
      """FlaxBertForQuestionAnswering""",
      """FlaxBertForSequenceClassification""",
      """FlaxBertForTokenClassification""",
      """FlaxBertModel""",
      """FlaxBertPreTrainedModel""",
  ]

if TYPE_CHECKING:
  from .configuration_bert import BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BertConfig, BertOnnxConfig
  from .tokenization_bert import BasicTokenizer, BertTokenizer, WordpieceTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_bert_fast import BertTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_bert import (
        BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        BertForMaskedLM,
        BertForMultipleChoice,
        BertForNextSentencePrediction,
        BertForPreTraining,
        BertForQuestionAnswering,
        BertForSequenceClassification,
        BertForTokenClassification,
        BertLayer,
        BertLMHeadModel,
        BertModel,
        BertPreTrainedModel,
        load_tf_weights_in_bert,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_bert import (
        TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFBertEmbeddings,
        TFBertForMaskedLM,
        TFBertForMultipleChoice,
        TFBertForNextSentencePrediction,
        TFBertForPreTraining,
        TFBertForQuestionAnswering,
        TFBertForSequenceClassification,
        TFBertForTokenClassification,
        TFBertLMHeadModel,
        TFBertMainLayer,
        TFBertModel,
        TFBertPreTrainedModel,
    )

  try:
    if not is_tensorflow_text_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_bert_tf import TFBertTokenizer

  try:
    if not is_flax_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_flax_bert import (
        FlaxBertForCausalLM,
        FlaxBertForMaskedLM,
        FlaxBertForMultipleChoice,
        FlaxBertForNextSentencePrediction,
        FlaxBertForPreTraining,
        FlaxBertForQuestionAnswering,
        FlaxBertForSequenceClassification,
        FlaxBertForTokenClassification,
        FlaxBertModel,
        FlaxBertPreTrainedModel,
    )

else:
  import sys

  SCREAMING_SNAKE_CASE			:						Optional[int]				  =		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


