


'''simple docstring'''



import os
import unittest

from huggingface_hub.utils import are_progress_bars_disabled

import transformers.models.bart.tokenization_bart
from transformers import logging
from transformers.testing_utils import CaptureLogger, mockenv, mockenv_context
from transformers.utils.logging import disable_progress_bar, enable_progress_bar


class 		_snake_case					(     unittest.TestCase	):




     def 				snake_case__						(      self):
        UpperCAmelCase__  :					Optional[Any]        =     logging.get_logger()

        # the current default level is logging.WARNING
        UpperCAmelCase__  :					Any        =     logging.get_verbosity()

        logging.set_verbosity_error()
        self.assertEqual(logger.getEffectiveLevel()							,							logging.get_verbosity())

        logging.set_verbosity_warning()
        self.assertEqual(logger.getEffectiveLevel()							,							logging.get_verbosity())

        logging.set_verbosity_info()
        self.assertEqual(logger.getEffectiveLevel()							,							logging.get_verbosity())

        logging.set_verbosity_debug()
        self.assertEqual(logger.getEffectiveLevel()							,							logging.get_verbosity())

        # restore to the original level
        logging.set_verbosity(_lowerCamelCase)




     def 				snake_case__						(      self):
        UpperCAmelCase__  :					Union[str, Any]        =     logging.get_verbosity()

        UpperCAmelCase__  :					Optional[Any]        =     logging.get_logger("""transformers.models.bart.tokenization_bart""")
        UpperCAmelCase__  :					str        =     """Testing 1, 2, 3"""

        # should be able to log warnings (if default settings weren't overridden by `pytest --log-level-all`)
        if level_origin <= logging.WARNING:
           with CaptureLogger(_lowerCamelCase) as cl:
              logger.warning(_lowerCamelCase)
           self.assertEqual(cl.out							,							msg + """\n""")

        # this is setting the level for all of `transformers.*` loggers
        logging.set_verbosity_error()

        # should not be able to log warnings
        with CaptureLogger(_lowerCamelCase) as cl:
           logger.warning(_lowerCamelCase)
        self.assertEqual(cl.out							,							"""""")

        # should be able to log warnings again
        logging.set_verbosity_warning()
        with CaptureLogger(_lowerCamelCase) as cl:
           logger.warning(_lowerCamelCase)
        self.assertEqual(cl.out							,							msg + """\n""")

        # restore to the original level
        logging.set_verbosity(_lowerCamelCase)




     @mockenv(TRANSFORMERS_VERBOSITY="""error""")
     def 				snake_case__						(      self):
        # reset for the env var to take effect, next time some logger call is made
        transformers.utils.logging._reset_library_root_logger()
        # this action activates the env var
        UpperCAmelCase__  :					int        =     logging.get_logger("""transformers.models.bart.tokenization_bart""")

        UpperCAmelCase__  :					Optional[int]        =     os.getenv("""TRANSFORMERS_VERBOSITY"""							,							_lowerCamelCase)
        UpperCAmelCase__  :					Any        =     logging.log_levels[env_level_str]

        UpperCAmelCase__  :					Dict        =     logging.get_verbosity()
        self.assertEqual(
            _lowerCamelCase							,							_lowerCamelCase							,							f'''TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}'''							,							)

        # restore to the original level
        UpperCAmelCase__  :					int        =     """"""
        transformers.utils.logging._reset_library_root_logger()




     @mockenv(TRANSFORMERS_VERBOSITY="""super-error""")
     def 				snake_case__						(      self):
        # reset for the env var to take effect, next time some logger call is made
        transformers.utils.logging._reset_library_root_logger()
        UpperCAmelCase__  :					str        =     logging.logging.getLogger()
        with CaptureLogger(_lowerCamelCase) as cl:
           # this action activates the env var
           logging.get_logger("""transformers.models.bart.tokenization_bart""")
        self.assertIn("""Unknown option TRANSFORMERS_VERBOSITY=super-error"""							,							cl.out)

        # no need to restore as nothing was changed




     def 				snake_case__						(      self):
        # testing `logger.warning_advice()`
        transformers.utils.logging._reset_library_root_logger()

        UpperCAmelCase__  :					Optional[Any]        =     logging.get_logger("""transformers.models.bart.tokenization_bart""")
        UpperCAmelCase__  :					List[Any]        =     """Testing 1, 2, 3"""

        with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS="""1"""):
           # nothing should be logged as env var disables this method
           with CaptureLogger(_lowerCamelCase) as cl:
              logger.warning_advice(_lowerCamelCase)
           self.assertEqual(cl.out							,							"""""")

        with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS=""""""):
           # should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset
           with CaptureLogger(_lowerCamelCase) as cl:
              logger.warning_advice(_lowerCamelCase)
           self.assertEqual(cl.out							,							msg + """\n""")







def     _UpperCamelCase      (		):
   disable_progress_bar()
   assert are_progress_bars_disabled()

   enable_progress_bar()
   assert not are_progress_bars_disabled()



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


__A	={
    '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	=['BertTokenizerFast']

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

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