





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,
)


a__      :     Tuple         =		{
    '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:
      a__      :     List[str]         =		['BertTokenizerFast']

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      a__      :     str         =		[
          '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:
      a__      :     str         =		[
          '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:
      a__      :     Tuple         =		['TFBertTokenizer']

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      a__      :     Tuple         =		[
          '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

      a__      :     Dict         =		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)










import enum
import shutil
import sys


a__   ,				a__      :     int         =		shutil.get_terminal_size()

a__      :     Tuple         =		{'UP': 'A', 'DOWN': 'B', 'RIGHT': 'C', 'LEFT': 'D'}





class UpperCAmelCase_				( enum.Enum ):
  __lowerCAmelCase   :						int							=   0
  __lowerCAmelCase   :						Optional[int]							=   1




def      UpperCAmelCase_    (    _UpperCAmelCase							:Optional[int]  ,						_UpperCAmelCase							:int=""				)	->				str:
     '''simple docstring'''


     sys.stdout.write(str(_UpperCAmelCase				) + end				)
     sys.stdout.flush()

def      UpperCAmelCase_    (    _UpperCAmelCase							:Union[str, Any]  ,						_UpperCAmelCase							:Tuple  ,						_UpperCAmelCase							:Tuple=""				)	->				List[Any]:
     '''simple docstring'''


     forceWrite(f'\u001b[{color}m{content}\u001b[0m'  ,						_UpperCAmelCase				)

def      UpperCAmelCase_    (    )	->				Dict:
     '''simple docstring'''


     forceWrite('''\r'''				)

def      UpperCAmelCase_    (    _UpperCAmelCase							:int  ,						_UpperCAmelCase							:str				)	->				List[Any]:
     '''simple docstring'''


     forceWrite(f'\033[{num_lines}{CURSOR_TO_CHAR[direction.upper()]}'				)

def      UpperCAmelCase_    (    )	->				List[Any]:
     '''simple docstring'''


     forceWrite(''' ''' * TERMINAL_WIDTH				)
     reset_cursor()


def      UpperCAmelCase_    (    )	->				Tuple:
     '''simple docstring'''


     reset_cursor()
     forceWrite('''-''' * TERMINAL_WIDTH				)



