
"""simple docstring"""


import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


SCREAMING_SNAKE_CASE      =     """
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   __a  (      unittest.TestCase    ,     _lowerCAmelCase	):






       def 	_SCREAMING_SNAKE_CASE       (  self :							Optional[int]			)->  Tuple:







              """simple docstring"""
              UpperCamelCase					 =		load_tool("text-question-answering"			)
              self.tool.setup()
              UpperCamelCase					 =		load_tool("text-question-answering"       ,      remote=UpperCAmelCase_			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							Dict			)->  Any:







              """simple docstring"""
              UpperCamelCase					 =		self.tool(UpperCAmelCase_       ,      "What did Hugging Face do in April 2021?"			)
              self.assertEqual(UpperCAmelCase_       ,      "launched the BigScience Research Workshop"			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							List[Any]			)->  Optional[int]:







              """simple docstring"""
              UpperCamelCase					 =		self.remote_tool(UpperCAmelCase_       ,      "What did Hugging Face do in April 2021?"			)
              self.assertEqual(UpperCAmelCase_       ,      "launched the BigScience Research Workshop"			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							int			)->  Dict:







              """simple docstring"""
              UpperCamelCase					 =		self.tool(text=UpperCAmelCase_       ,      question="What did Hugging Face do in April 2021?"			)
              self.assertEqual(UpperCAmelCase_       ,      "launched the BigScience Research Workshop"			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							int			)->  int:







              """simple docstring"""
              UpperCamelCase					 =		self.remote_tool(text=UpperCAmelCase_       ,      question="What did Hugging Face do in April 2021?"			)
              self.assertEqual(UpperCAmelCase_       ,      "launched the BigScience Research Workshop"			)







"""simple docstring"""


from .integrations import (
    is_optuna_available,
    is_ray_available,
    is_sigopt_available,
    is_wandb_available,
    run_hp_search_optuna,
    run_hp_search_ray,
    run_hp_search_sigopt,
    run_hp_search_wandb,
)
from .trainer_utils import (
    HPSearchBackend,
    default_hp_space_optuna,
    default_hp_space_ray,
    default_hp_space_sigopt,
    default_hp_space_wandb,
)
from .utils import logging


SCREAMING_SNAKE_CASE      =     logging.get_logger(__name__)



class   __a  :
       UpperCamelCase_		:					str
       UpperCamelCase_		:					str   =			None






       @staticmethod
       def 	_SCREAMING_SNAKE_CASE       (  )->  Union[str, Any]:







              """simple docstring"""
              raise NotImplementedError






       def 	_SCREAMING_SNAKE_CASE       (  self :							List[str]       ,      UpperCAmelCase_ :							Optional[int]       ,      UpperCAmelCase_ :							int       ,      UpperCAmelCase_ :							str       ,      **UpperCAmelCase_ :							Dict			)->  Union[str, Any]:







              """simple docstring"""
              raise NotImplementedError






       def 	_SCREAMING_SNAKE_CASE       (  self :							Optional[int]       ,      UpperCAmelCase_ :							str			)->  Any:







              """simple docstring"""
              raise NotImplementedError






       def 	_SCREAMING_SNAKE_CASE       (  self :							Union[str, Any]			)->  List[str]:







              """simple docstring"""
              if not self.is_available():
                     raise RuntimeError(
                         f"You picked the {self.name} backend, but it is not installed. Run {self.pip_install()}."			)






       @classmethod
       def 	_SCREAMING_SNAKE_CASE       (  cls :							Union[str, Any]			)->  int:







              """simple docstring"""
              return f"`pip install {cls.pip_package or cls.name}`"





class   __a  (      _lowerCAmelCase	):
       UpperCamelCase_		:					List[str]   =			'''optuna'''






       @staticmethod
       def 	_SCREAMING_SNAKE_CASE       (  )->  Union[str, Any]:







              """simple docstring"""
              return is_optuna_available()






       def 	_SCREAMING_SNAKE_CASE       (  self :							Dict       ,      UpperCAmelCase_ :							List[str]       ,      UpperCAmelCase_ :							int       ,      UpperCAmelCase_ :							str       ,      **UpperCAmelCase_ :							Optional[Any]			)->  Union[str, Any]:







              """simple docstring"""
              return run_hp_search_optuna(UpperCAmelCase_       ,      UpperCAmelCase_       ,      UpperCAmelCase_       ,      **UpperCAmelCase_			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							Dict       ,      UpperCAmelCase_ :							Union[str, Any]			)->  Union[str, Any]:







              """simple docstring"""
              return default_hp_space_optuna(UpperCAmelCase_			)





class   __a  (      _lowerCAmelCase	):
       UpperCamelCase_		:					Optional[int]   =			'''ray'''
       UpperCamelCase_		:					Tuple   =			'''\'ray[tune]\''''






       @staticmethod
       def 	_SCREAMING_SNAKE_CASE       (  )->  Any:







              """simple docstring"""
              return is_ray_available()






       def 	_SCREAMING_SNAKE_CASE       (  self :							List[Any]       ,      UpperCAmelCase_ :							Any       ,      UpperCAmelCase_ :							int       ,      UpperCAmelCase_ :							str       ,      **UpperCAmelCase_ :							int			)->  int:







              """simple docstring"""
              return run_hp_search_ray(UpperCAmelCase_       ,      UpperCAmelCase_       ,      UpperCAmelCase_       ,      **UpperCAmelCase_			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							str       ,      UpperCAmelCase_ :							str			)->  Union[str, Any]:







              """simple docstring"""
              return default_hp_space_ray(UpperCAmelCase_			)





class   __a  (      _lowerCAmelCase	):
       UpperCamelCase_		:					Union[str, Any]   =			'''sigopt'''






       @staticmethod
       def 	_SCREAMING_SNAKE_CASE       (  )->  List[str]:







              """simple docstring"""
              return is_sigopt_available()






       def 	_SCREAMING_SNAKE_CASE       (  self :							Tuple       ,      UpperCAmelCase_ :							List[str]       ,      UpperCAmelCase_ :							int       ,      UpperCAmelCase_ :							str       ,      **UpperCAmelCase_ :							Tuple			)->  Tuple:







              """simple docstring"""
              return run_hp_search_sigopt(UpperCAmelCase_       ,      UpperCAmelCase_       ,      UpperCAmelCase_       ,      **UpperCAmelCase_			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							List[Any]       ,      UpperCAmelCase_ :							Tuple			)->  Optional[Any]:







              """simple docstring"""
              return default_hp_space_sigopt(UpperCAmelCase_			)





class   __a  (      _lowerCAmelCase	):
       UpperCamelCase_		:					Any   =			'''wandb'''






       @staticmethod
       def 	_SCREAMING_SNAKE_CASE       (  )->  List[Any]:







              """simple docstring"""
              return is_wandb_available()






       def 	_SCREAMING_SNAKE_CASE       (  self :							int       ,      UpperCAmelCase_ :							Optional[int]       ,      UpperCAmelCase_ :							int       ,      UpperCAmelCase_ :							str       ,      **UpperCAmelCase_ :							List[str]			)->  str:







              """simple docstring"""
              return run_hp_search_wandb(UpperCAmelCase_       ,      UpperCAmelCase_       ,      UpperCAmelCase_       ,      **UpperCAmelCase_			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							Tuple       ,      UpperCAmelCase_ :							List[Any]			)->  List[Any]:







              """simple docstring"""
              return default_hp_space_wandb(UpperCAmelCase_			)





SCREAMING_SNAKE_CASE      =     {
    HPSearchBackend(backend.name): backend for backend in [OptunaBackend, RayTuneBackend, SigOptBackend, WandbBackend]
}



def 	lowerCamelCase__			(							)->							str:







       """simple docstring"""
       UpperCamelCase					 =		[backend for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() if backend.is_available()]
       if len(UpperCAmelCase_				) > 0:
              UpperCamelCase					 =		available_backends[0].name
              if len(UpperCAmelCase_				) > 1:
                     logger.info(
                         F"{len(UpperCAmelCase_				)} hyperparameter search backends available. Using {name} as the default."				)
              return name
       raise RuntimeError(
           "No hyperparameter search backend available.\n"
           + "\n".join(
               F" - To install {backend.name} run {backend.pip_install()}"
               for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values()				)				)





