






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

       '''simple docstring'''



       def 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





            __snake_case			:Dict          =						logging.get_logger()

            # the current default level is logging.WARNING
            __snake_case			:Tuple          =						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 					__lowercase						(							self    ) ->      List[str]:






            '''simple docstring'''





            __snake_case			:int          =						logging.get_verbosity()

            __snake_case			:Tuple          =						logging.get_logger("""transformers.models.bart.tokenization_bart"""    )
            __snake_case			:Optional[int]          =						"""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 					__lowercase						(							self    ) ->      Optional[int]:






            '''simple docstring'''





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

            __snake_case			:Dict          =						os.getenv("""TRANSFORMERS_VERBOSITY"""			,						a__    )
            __snake_case			:Union[str, Any]          =						logging.log_levels[env_level_str]

            __snake_case			:Any          =						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
            __snake_case			:Any          =						""""""
            transformers.utils.logging._reset_library_root_logger()



       @mockenv(TRANSFORMERS_VERBOSITY="""super-error"""    )
       def 					__lowercase						(							self    ) ->      List[Any]:






            '''simple docstring'''





            transformers.utils.logging._reset_library_root_logger()
            __snake_case			:Optional[Any]          =						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 					__lowercase						(							self    ) ->      Any:






            '''simple docstring'''





            transformers.utils.logging._reset_library_root_logger()

            __snake_case			:Union[str, Any]          =						logging.get_logger("""transformers.models.bart.tokenization_bart"""    )
            __snake_case			: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   UpperCamelCase  (       ):




     '''simple docstring'''






     disable_progress_bar()
     assert are_progress_bars_disabled()

     enable_progress_bar()
     assert not are_progress_bars_disabled()










import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


lowerCamelCase__							=     """
Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf originally as a company that developed a chatbot app targeted at teenagers.[2] After open-sourcing the model behind the chatbot, the company pivoted to focus on being a platform for machine learning.

In March 2021, Hugging Face raised $40 million in a Series B funding round.[3]

On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model.[4] In 2022, the workshop concluded with the announcement of BLOOM, a multilingual large language model with 176 billion parameters.[5]
"""




class 			snake_case__   (							unittest.TestCase	,    lowercase_):

       '''simple docstring'''



       def 					__lowercase						(							self    ) ->      List[str]:






            '''simple docstring'''





            __snake_case			:int          =						load_tool("""text-question-answering"""    )
            self.tool.setup()
            __snake_case			:Tuple          =						load_tool("""text-question-answering"""			,						remote=a__    )



       def 					__lowercase						(							self    ) ->      Any:






            '''simple docstring'''





            __snake_case			:List[str]          =						self.tool(a__			,						"""What did Hugging Face do in April 2021?"""    )
            self.assertEqual(a__			,						"""launched the BigScience Research Workshop"""    )



       def 					__lowercase						(							self    ) ->      Any:






            '''simple docstring'''





            __snake_case			:List[str]          =						self.remote_tool(a__			,						"""What did Hugging Face do in April 2021?"""    )
            self.assertEqual(a__			,						"""launched the BigScience Research Workshop"""    )



       def 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





            __snake_case			:Optional[int]          =						self.tool(text=a__			,						question="""What did Hugging Face do in April 2021?"""    )
            self.assertEqual(a__			,						"""launched the BigScience Research Workshop"""    )



       def 					__lowercase						(							self    ) ->      Tuple:






            '''simple docstring'''





            __snake_case			:List[str]          =						self.remote_tool(text=a__			,						question="""What did Hugging Face do in April 2021?"""    )
            self.assertEqual(a__			,						"""launched the BigScience Research Workshop"""    )


