





'''simple docstring'''
import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


a__							:							Tuple			='''
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      ,	__lowerCamelCase	):




 """simple docstring"""



 def 	_lowerCamelCase (	self	:							Dict     ):
        __UpperCamelCase	=  load_tool('summarization'     )
        self.tool.setup()
        __UpperCamelCase	=  load_tool('summarization'							,     remote=__A     )






 def 	_lowerCamelCase (	self	:							List[str]     ):
        __UpperCamelCase	=  self.tool(__A     )
        self.assertEqual(
            __A							,     'Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. 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. In 2022, the workshop concluded with the announcement of BLOOM.'							,     )






 def 	_lowerCamelCase (	self	:							List[Any]     ):
        __UpperCamelCase	=  self.remote_tool(__A     )
        self.assertEqual(
            __A							,     'Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. 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. In 2022, the workshop concluded with the announcement of BLOOM.'							,     )






 def 	_lowerCamelCase (	self	:							Union[str, Any]     ):
        __UpperCamelCase	=  self.tool(text=__A     )
        self.assertEqual(
            __A							,     'Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. 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. In 2022, the workshop concluded with the announcement of BLOOM.'							,     )






 def 	_lowerCamelCase (	self	:							Dict     ):
        __UpperCamelCase	=  self.remote_tool(text=__A     )
        self.assertEqual(
            __A							,     'Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. 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. In 2022, the workshop concluded with the announcement of BLOOM.'							,     )







'''simple docstring'''
import logging
import os
import sys
import threading
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

from tqdm import auto as tqdm_lib


a__							:							Optional[int]			=threading.Lock()
a__							:							Optional[logging.Handler]			=None

a__							:							Optional[Any]			={
    '''debug''': logging.DEBUG,
    '''info''': logging.INFO,
    '''warning''': logging.WARNING,
    '''error''': logging.ERROR,
    '''critical''': logging.CRITICAL,
}

a__							:							List[Any]			=logging.WARNING

a__							:							str			=True
def     lowercase__       (       )			->				int:



       """simple docstring"""






       __UpperCamelCase	=  os.getenv('DIFFUSERS_VERBOSITY'    ,  __lowercase					)
       if env_level_str:
              if env_level_str in log_levels:
                     return log_levels[env_level_str]
              else:
                     logging.getLogger().warning(
                         F'''Unknown option DIFFUSERS_VERBOSITY={env_level_str}, '''
                         F'''has to be one of: { ', '.join(log_levels.keys()					) }'''					)
       return _default_log_level
def     lowercase__       (       )			->				str:



       """simple docstring"""






       return __name__.split('.'					)[0]
def     lowercase__       (       )			->				logging.Logger:



       """simple docstring"""






       return logging.getLogger(_get_library_name()					)
def     lowercase__       (       )			->				None:



       """simple docstring"""






       global _default_handler

       with _lock:
              if _default_handler:
                     # This library has already configured the library root logger.
                     return
              __UpperCamelCase	=  logging.StreamHandler()  # Set sys.stderr as stream.
              __UpperCamelCase	=  sys.stderr.flush

              # Apply our default configuration to the library root logger.
              __UpperCamelCase	=  _get_library_root_logger()
              library_root_logger.addHandler(_default_handler					)
              library_root_logger.setLevel(_get_default_logging_level()					)
              __UpperCamelCase	=  False
def     lowercase__       (       )			->				None:



       """simple docstring"""






       global _default_handler

       with _lock:
              if not _default_handler:
                     return

              __UpperCamelCase	=  _get_library_root_logger()
              library_root_logger.removeHandler(_default_handler					)
              library_root_logger.setLevel(logging.NOTSET					)
              __UpperCamelCase	=  None
def     lowercase__       (       )			->				str:



       """simple docstring"""






       return log_levels
def     lowercase__       (       __lowercase						:  Optional[str] = None					)			->				logging.Logger:



       """simple docstring"""






       if name is None:
              __UpperCamelCase	=  _get_library_name()

       _configure_library_root_logger()
       return logging.getLogger(__lowercase					)
def     lowercase__       (       )			->				int:



       """simple docstring"""






       _configure_library_root_logger()
       return _get_library_root_logger().getEffectiveLevel()
def     lowercase__       (       __lowercase						:  int					)			->				None:



       """simple docstring"""






       _configure_library_root_logger()
       _get_library_root_logger().setLevel(__lowercase					)
def     lowercase__       (       )			->				Tuple:



       """simple docstring"""






       return set_verbosity(__lowercase					)
def     lowercase__       (       )			->				Union[str, Any]:



       """simple docstring"""






       return set_verbosity(__lowercase					)
def     lowercase__       (       )			->				Any:



       """simple docstring"""






       return set_verbosity(__lowercase					)
def     lowercase__       (       )			->				int:



       """simple docstring"""






       return set_verbosity(__lowercase					)
def     lowercase__       (       )			->				None:



       """simple docstring"""






       _configure_library_root_logger()

       assert _default_handler is not None
       _get_library_root_logger().removeHandler(_default_handler					)
def     lowercase__       (       )			->				None:



       """simple docstring"""






       _configure_library_root_logger()

       assert _default_handler is not None
       _get_library_root_logger().addHandler(_default_handler					)
def     lowercase__       (       __lowercase						:  logging.Handler					)			->				None:



       """simple docstring"""






       _configure_library_root_logger()

       assert handler is not None
       _get_library_root_logger().addHandler(__lowercase					)
def     lowercase__       (       __lowercase						:  logging.Handler					)			->				None:



       """simple docstring"""






       _configure_library_root_logger()

       assert handler is not None and handler not in _get_library_root_logger().handlers
       _get_library_root_logger().removeHandler(__lowercase					)
def     lowercase__       (       )			->				None:



       """simple docstring"""






       _configure_library_root_logger()
       __UpperCamelCase	=  False
def     lowercase__       (       )			->				None:



       """simple docstring"""






       _configure_library_root_logger()
       __UpperCamelCase	=  True
def     lowercase__       (       )			->				None:



       """simple docstring"""






       __UpperCamelCase	=  _get_library_root_logger().handlers

       for handler in handlers:
              __UpperCamelCase	=  logging.Formatter('[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s'					)
              handler.setFormatter(__lowercase					)
def     lowercase__       (       )			->				None:



       """simple docstring"""






       __UpperCamelCase	=  _get_library_root_logger().handlers

       for handler in handlers:
              handler.setFormatter(__lowercase					)
def     lowercase__       (       self						:  int    ,  *__lowercase						:  List[str]    ,  **__lowercase						:  List[Any]					)			->				Any:



       """simple docstring"""






       __UpperCamelCase	=  os.getenv('DIFFUSERS_NO_ADVISORY_WARNINGS'    ,  __lowercase					)
       if no_advisory_warnings:
              return
       self.warning(*__lowercase    ,  **__lowercase					)


a__							:							Dict			=warning_advice

class 					snake_case					:




 """simple docstring"""



 def __init__(	self	:							Optional[int]							,     *__A	:							int							,     **__A	:							Dict     ):  # pylint: disable=unused-argument
        __UpperCamelCase	=  args[0] if args else None






 def __iter__(	self	:							str     ):
        return iter(self._iterator     )






 def __getattr__(	self	:							Tuple							,     __A	:							Any     ):

        def empty_fn(*__A	:							Any							,     **__A	:							List[str]     ):  # pylint: disable=unused-argument
               return

        return empty_fn






 def __enter__(	self	:							str     ):
        return self






 def __exit__(	self	:							Optional[Any]							,     __A	:							Dict							,     __A	:							str							,     __A	:							Dict     ):
        return






class 					snake_case					:




 """simple docstring"""



 def __call__(	self	:							Union[str, Any]							,     *__A	:							Union[str, Any]							,     **__A	:							Dict     ):
        if _tqdm_active:
               return tqdm_lib.tqdm(*__A							,     **__A     )
        else:
               return EmptyTqdm(*__A							,     **__A     )






 def 	_lowerCamelCase (	self	:							Any							,     *__A	:							str							,     **__A	:							Optional[int]     ):
        __UpperCamelCase	=  None
        if _tqdm_active:
               return tqdm_lib.tqdm.set_lock(*__A							,     **__A     )






 def 	_lowerCamelCase (	self	:							Optional[int]     ):
        if _tqdm_active:
               return tqdm_lib.tqdm.get_lock()






a__							:							List[Any]			=_tqdm_cls()
def     lowercase__       (       )			->				bool:



       """simple docstring"""






       global _tqdm_active
       return bool(_tqdm_active					)
def     lowercase__       (       )			->				List[str]:



       """simple docstring"""






       global _tqdm_active
       __UpperCamelCase	=  True


def     lowercase__       (       )			->				str:



       """simple docstring"""






       global _tqdm_active
       __UpperCamelCase	=  False
