





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       A__     ( unittest.TestCase    ):





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      int 			=     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(A_     )





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      Dict 			=     logging.get_verbosity()

       UpperCamelCase			:      str 			=     logging.get_logger("transformers.models.bart.tokenization_bart"     )
       UpperCamelCase			:      Optional[Any] 			=     "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(A_     ) as cl:
         logger.warning(A_     )
        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(A_     ) as cl:
        logger.warning(A_     )
       self.assertEqual(cl.out ,							""     )

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

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





      @mockenv(TRANSFORMERS_VERBOSITY="error"     )
      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       transformers.utils.logging._reset_library_root_logger()
       # this action activates the env var
       UpperCamelCase			:      List[str] 			=     logging.get_logger("transformers.models.bart.tokenization_bart"     )

       UpperCamelCase			:      Tuple 			=     os.getenv("TRANSFORMERS_VERBOSITY" ,							A_     )
       UpperCamelCase			:      List[str] 			=     logging.log_levels[env_level_str]

       UpperCamelCase			:      str 			=     logging.get_verbosity()
       self.assertEqual(
           A_ ,							A_ ,							F"""TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}""" ,							)

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





      @mockenv(TRANSFORMERS_VERBOSITY="super-error"     )
      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       transformers.utils.logging._reset_library_root_logger()
       UpperCamelCase			:      Optional[int] 			=     logging.logging.getLogger()
       with CaptureLogger(A_     ) 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  __UpperCamelCase(				self     ):
       '''simple docstring'''




       transformers.utils.logging._reset_library_root_logger()

       UpperCamelCase			:      Union[str, 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(A_     ) as cl:
         logger.warning_advice(A_     )
        self.assertEqual(cl.out ,							""     )

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



def 	A_       (  )		->				Optional[Any]:
 disable_progress_bar()
 assert are_progress_bars_disabled()

 enable_progress_bar()
 assert not are_progress_bars_disabled()







from typing import TYPE_CHECKING

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


__lowerCamelCase :  int										=  {
    """configuration_convbert""": ["""CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ConvBertConfig""", """ConvBertOnnxConfig"""],
    """tokenization_convbert""": ["""ConvBertTokenizer"""],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __lowerCamelCase :  Dict										=  ["""ConvBertTokenizerFast"""]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __lowerCamelCase :  int										=  [
        """CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """ConvBertForMaskedLM""",
        """ConvBertForMultipleChoice""",
        """ConvBertForQuestionAnswering""",
        """ConvBertForSequenceClassification""",
        """ConvBertForTokenClassification""",
        """ConvBertLayer""",
        """ConvBertModel""",
        """ConvBertPreTrainedModel""",
        """load_tf_weights_in_convbert""",
    ]


try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __lowerCamelCase :  str										=  [
        """TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """TFConvBertForMaskedLM""",
        """TFConvBertForMultipleChoice""",
        """TFConvBertForQuestionAnswering""",
        """TFConvBertForSequenceClassification""",
        """TFConvBertForTokenClassification""",
        """TFConvBertLayer""",
        """TFConvBertModel""",
        """TFConvBertPreTrainedModel""",
    ]


if TYPE_CHECKING:
    from .configuration_convbert import CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvBertConfig, ConvBertOnnxConfig
    from .tokenization_convbert import ConvBertTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_convbert_fast import ConvBertTokenizerFast

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_convbert import (
            CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
            ConvBertForMaskedLM,
            ConvBertForMultipleChoice,
            ConvBertForQuestionAnswering,
            ConvBertForSequenceClassification,
            ConvBertForTokenClassification,
            ConvBertLayer,
            ConvBertModel,
            ConvBertPreTrainedModel,
            load_tf_weights_in_convbert,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_convbert import (
            TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFConvBertForMaskedLM,
            TFConvBertForMultipleChoice,
            TFConvBertForQuestionAnswering,
            TFConvBertForSequenceClassification,
            TFConvBertForTokenClassification,
            TFConvBertLayer,
            TFConvBertModel,
            TFConvBertPreTrainedModel,
        )


else:
    import sys

    __lowerCamelCase :  List[str]										=  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
