



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_      :      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:
     a_      :      int    =     ['BertTokenizerFast']

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     a_      :      Dict    =     [
         '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_      :      int    =     [
         '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_      :      Optional[Any]    =     ['TFBertTokenizer']

try:
     if not is_flax_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     a_      :      Optional[int]    =     [
         '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_      :      List[str]    =     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)










import logging
import os

from .state import PartialState
class    __UpperCamelCase			(       logging.LoggerAdapter				):

 """simple docstring"""



 @staticmethod
 def 						_UpperCAmelCase       (	SCREAMING_SNAKE_CASE      ) ->			Optional[Any]:
  a__												= PartialState()
  return not main_process_only or (main_process_only and state.is_main_process)



 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				*SCREAMING_SNAKE_CASE		,				**SCREAMING_SNAKE_CASE      ) ->			Optional[int]:
  if PartialState._shared_state == {}:
   raise RuntimeError(
       '''You must initialize the accelerate state by calling either `PartialState()` or `Accelerator()` before using the logging utility.'''      )
  a__												= kwargs.pop('''main_process_only'''		,				SCREAMING_SNAKE_CASE      )
  a__												= kwargs.pop('''in_order'''		,				SCREAMING_SNAKE_CASE      )

  if self.isEnabledFor(SCREAMING_SNAKE_CASE      ):
   if self._should_log(SCREAMING_SNAKE_CASE      ):
    a__							,			a__												= self.process(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )
    self.logger.log(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				*SCREAMING_SNAKE_CASE		,				**SCREAMING_SNAKE_CASE      )

   elif in_order:
    a__												= PartialState()
    for i in range(state.num_processes      ):
     if i == state.process_index:
      a__							,			a__												= self.process(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )
      self.logger.log(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				*SCREAMING_SNAKE_CASE		,				**SCREAMING_SNAKE_CASE      )
     state.wait_for_everyone()






def     __a					(		__UpperCAmelCase							,  __UpperCAmelCase = None       ):
 if log_level is None:
  a__												= os.environ.get('''ACCELERATE_LOG_LEVEL'''							,  __UpperCAmelCase       )
 a__												= logging.getLogger(__UpperCAmelCase       )
 if log_level is not None:
  logger.setLevel(log_level.upper()       )
  logger.root.setLevel(log_level.upper()       )
 return MultiProcessAdapter(__UpperCAmelCase							,  {}       )





