





"""simple docstring"""





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__   =  {
    "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__   =  ["BertTokenizerFast"]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       SCREAMING_SNAKE_CASE__   =  [
           "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__   =  [
           "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__   =  ["TFBertTokenizer"]

try:
       if not is_flax_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       SCREAMING_SNAKE_CASE__   =  [
           "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__   =  _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)













"""simple docstring"""





import logging
import os

from .state import PartialState

class 						lowercase   (   logging.LoggerAdapter   ):





      @staticmethod
      def        _snake_case     (			lowercase					)						->	Optional[Any]:
            lowerCAmelCase    		=			PartialState()
            return not main_process_only or (main_process_only and state.is_main_process)





      def        _snake_case     (			self ,		lowercase ,		lowercase ,		*lowercase ,		**lowercase					)						->	Dict:
            if PartialState._shared_state == {}:
                  raise RuntimeError(
                      """You must initialize the accelerate state by calling either `PartialState()` or `Accelerator()` before using the logging utility."""					)
            lowerCAmelCase    		=			kwargs.pop("""main_process_only""" ,		lowercase					)
            lowerCAmelCase    		=			kwargs.pop("""in_order""" ,		lowercase					)

            if self.isEnabledFor(lowercase					):
                  if self._should_log(lowercase					):
                        lowerCAmelCase		,						lowerCAmelCase    		=			self.process(lowercase ,		lowercase					)
                        self.logger.log(lowercase ,		lowercase ,		*lowercase ,		**lowercase					)

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







def      UpperCAmelCase__				(    SCREAMING_SNAKE_CASE	:		str				,		SCREAMING_SNAKE_CASE	:		str = None     ):







      '''simple docstring'''




      if log_level is None:
            lowerCAmelCase    		=			os.environ.get("""ACCELERATE_LOG_LEVEL"""				,		SCREAMING_SNAKE_CASE     )
      lowerCAmelCase    		=			logging.getLogger(SCREAMING_SNAKE_CASE     )
      if log_level is not None:
            logger.setLevel(log_level.upper()     )
            logger.root.setLevel(log_level.upper()     )
      return MultiProcessAdapter(SCREAMING_SNAKE_CASE				,		{}     )






