

# flake8: noqa
# Lint as: python3

from typing import Dict, List, Optional, Type

from .. import config
from ..utils import logging
from .formatting import (
    ArrowFormatter,
    CustomFormatter,
    Formatter,
    PandasFormatter,
    PythonFormatter,
    TensorFormatter,
    format_table,
    query_table,
)
from .np_formatter import NumpyFormatter


UpperCamelCase__  :      List[Any]			=    logging.get_logger(__name__)

UpperCamelCase__  :      Dict[Optional[str], Type[Formatter]]			=    {}
UpperCamelCase__  :      Dict[Optional[str], str]			=    {}
UpperCamelCase__  :      Dict[Optional[str], Exception]			=    {}


def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		type ,   _SCREAMING_SNAKE_CASE					:		Optional[str] ,   _SCREAMING_SNAKE_CASE					:		Optional[List[str]] = None ,   ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						aliases if aliases is not None else []
    if format_type in _FORMAT_TYPES:
        logger.warning(
            f"""Overwriting format type '{format_type}' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})"""       )
    SCREAMING_SNAKE_CASE_									=						formatter_cls
    for alias in set(aliases + [format_type]       ):
        if alias in _FORMAT_TYPES_ALIASES:
            logger.warning(
                f"""Overwriting format type alias '{alias}' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})"""       )
        SCREAMING_SNAKE_CASE_									=						format_type


def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		Exception ,   _SCREAMING_SNAKE_CASE					:		Optional[str] ,   _SCREAMING_SNAKE_CASE					:		Optional[List[str]] = None       ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						aliases if aliases is not None else []
    for alias in set(aliases + [format_type]       ):
        SCREAMING_SNAKE_CASE_									=						unavailable_error


# Here we define all the available formatting functions that can be used by `Dataset.set_format`
_register_formatter(PythonFormatter, None, aliases=["python"])
_register_formatter(ArrowFormatter, "arrow", aliases=["pa", "pyarrow"])
_register_formatter(NumpyFormatter, "numpy", aliases=["np"])
_register_formatter(PandasFormatter, "pandas", aliases=["pd"])
_register_formatter(CustomFormatter, "custom")

if config.TORCH_AVAILABLE:
       from .torch_formatter import TorchFormatter

       _register_formatter(TorchFormatter, "torch", aliases=["pt", "pytorch"])
else:
       UpperCamelCase__  :      str			=    ValueError("PyTorch needs to be installed to be able to return PyTorch tensors.")
       _register_unavailable_formatter(_torch_error, "torch", aliases=["pt", "pytorch"])

if config.TF_AVAILABLE:
       from .tf_formatter import TFFormatter

       _register_formatter(TFFormatter, "tensorflow", aliases=["tf"])
else:
       UpperCamelCase__  :      Dict			=    ValueError("Tensorflow needs to be installed to be able to return Tensorflow tensors.")
       _register_unavailable_formatter(_tf_error, "tensorflow", aliases=["tf"])

if config.JAX_AVAILABLE:
       from .jax_formatter import JaxFormatter

       _register_formatter(JaxFormatter, "jax", aliases=[])
else:
       UpperCamelCase__  :      Union[str, Any]			=    ValueError("JAX needs to be installed to be able to return JAX arrays.")
       _register_unavailable_formatter(_jax_error, "jax", aliases=[])


def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		Optional[str]       ):





    """simple docstring"""


    if format_type in _FORMAT_TYPES_ALIASES:
        return _FORMAT_TYPES_ALIASES[format_type]
    else:
        return format_type





def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		Optional[str] ,   **_SCREAMING_SNAKE_CASE					:		Optional[int]       ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						get_format_type_from_alias(_SCREAMING_SNAKE_CASE       )
    if format_type in _FORMAT_TYPES:
        return _FORMAT_TYPES[format_type](**_SCREAMING_SNAKE_CASE       )
    if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE:
        raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type]
    else:
        raise ValueError(
            f"""Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None       )}, but got '{format_type}'"""       )





import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


UpperCamelCase__  :      int			=    "\nHugging 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.\n\nIn March 2021, Hugging Face raised $40 million in a Series B funding round.[3]\n\nOn 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]\n"



class       __snake_case  (    unittest.TestCase     , lowerCAmelCase__       ):

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						load_tool('text-question-answering')
      self.tool.setup()
      SCREAMING_SNAKE_CASE_									=						load_tool('text-question-answering'						,		remote=_A)

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.tool(_A						,		'What did Hugging Face do in April 2021?')
      self.assertEqual(_A						,		'launched the BigScience Research Workshop')

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.remote_tool(_A						,		'What did Hugging Face do in April 2021?')
      self.assertEqual(_A						,		'launched the BigScience Research Workshop')

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.tool(text=_A						,		question='What did Hugging Face do in April 2021?')
      self.assertEqual(_A						,		'launched the BigScience Research Workshop')


  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.remote_tool(text=_A						,		question='What did Hugging Face do in April 2021?')
      self.assertEqual(_A						,		'launched the BigScience Research Workshop')


