





'''simple docstring'''






import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
      import torch


__lowerCamelCase    :			Optional[int]		= random.Random()


def        _a (__SCREAMING_SNAKE_CASE	,   __SCREAMING_SNAKE_CASE=1.0	,   __SCREAMING_SNAKE_CASE=None	,   __SCREAMING_SNAKE_CASE=None ):


  """simple docstring"""

  if rng is None:
    _UpperCamelCase							      =global_rng

  _UpperCamelCase							      =[]
  for batch_idx in range(shape[0] ):
    values.append([] )
    for _ in range(shape[1] ):
      values[-1].append(rng.random() * scale )

  return values







@require_torch
class 		UpperCAmelCase (					unittest.TestCase):


  """simple docstring"""







  def __init__(					self     :       Optional[Any]				,						UpperCamelCase__     :       List[Any]				,						UpperCamelCase__     :       Optional[Any]=7				,						UpperCamelCase__     :       str=400				,						UpperCamelCase__     :       List[str]=2000				,						UpperCamelCase__     :       int=1				,						UpperCamelCase__     :       int=0.0				,						UpperCamelCase__     :       Dict=1_6000				,						UpperCamelCase__     :       Optional[Any]=True				,						UpperCamelCase__     :       Tuple=80				,						UpperCamelCase__     :       Any=16				,						UpperCamelCase__     :       Optional[int]=64				,						UpperCamelCase__     :       Optional[int]="hann_window"				,						UpperCamelCase__     :       Optional[int]=80				,						UpperCamelCase__     :       List[Any]=7600				,						UpperCamelCase__     :       Union[str, Any]=1E-10				,						UpperCamelCase__     :       Union[str, Any]=True				,						)  ->    Optional[Any]:
    _UpperCamelCase							      =parent
    _UpperCamelCase							      =batch_size
    _UpperCamelCase							      =min_seq_length
    _UpperCamelCase							      =max_seq_length
    _UpperCamelCase							      =(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
    _UpperCamelCase							      =feature_size
    _UpperCamelCase							      =padding_value
    _UpperCamelCase							      =sampling_rate
    _UpperCamelCase							      =do_normalize
    _UpperCamelCase							      =num_mel_bins
    _UpperCamelCase							      =hop_length
    _UpperCamelCase							      =win_length
    _UpperCamelCase							      =win_function
    _UpperCamelCase							      =fmin
    _UpperCamelCase							      =fmax
    _UpperCamelCase							      =mel_floor
    _UpperCamelCase							      =return_attention_mask


  def 	UpperCamelCase__   (					self     :       Union[str, Any]	)  ->    Tuple:
    return {
        "feature_size": self.feature_size,
        "padding_value": self.padding_value,
        "sampling_rate": self.sampling_rate,
        "do_normalize": self.do_normalize,
        "num_mel_bins": self.num_mel_bins,
        "hop_length": self.hop_length,
        "win_length": self.win_length,
        "win_function": self.win_function,
        "fmin": self.fmin,
        "fmax": self.fmax,
        "mel_floor": self.mel_floor,
        "return_attention_mask": self.return_attention_mask,
    }


  def 	UpperCamelCase__   (					self     :       Tuple				,						UpperCamelCase__     :       List[str]=False				,						UpperCamelCase__     :       Dict=False	)  ->    List[Any]:






    def _flatten(UpperCamelCase__     :       Any	):
      return list(itertools.chain(*UpperCamelCase__	)	)

    if equal_length:
      _UpperCamelCase							      =floats_list((self.batch_size, self.max_seq_length)	)
    else:
      # make sure that inputs increase in size
      _UpperCamelCase							      =[
          _flatten(floats_list((x, self.feature_size)	)	)
          for x in range(self.min_seq_length				,						self.max_seq_length				,						self.seq_length_diff	)
      ]

    if numpify:
      _UpperCamelCase							      =[np.asarray(UpperCamelCase__	) for x in speech_inputs]

    return speech_inputs




  def 	UpperCamelCase__   (					self     :       Optional[Any]				,						UpperCamelCase__     :       List[Any]=False				,						UpperCamelCase__     :       List[Any]=False	)  ->    Any:






    if equal_length:
      _UpperCamelCase							      =[floats_list((self.max_seq_length, self.num_mel_bins)	) for _ in range(self.batch_size	)]
    else:
      # make sure that inputs increase in size
      _UpperCamelCase							      =[
          floats_list((x, self.num_mel_bins)	)
          for x in range(self.min_seq_length				,						self.max_seq_length				,						self.seq_length_diff	)
      ]

    if numpify:
      _UpperCamelCase							      =[np.asarray(UpperCamelCase__	) for x in speech_inputs]

    return speech_inputs







@require_torch
class 		UpperCAmelCase (					lowercase_ ,  unittest.TestCase):


  """simple docstring"""







  lowerCAmelCase_											=					SpeechTaFeatureExtractor


  def 	UpperCamelCase__   (					self     :       Optional[Any]	)  ->    Union[str, Any]:
    _UpperCamelCase							      =SpeechTaFeatureExtractionTester(self	)


  def 	UpperCamelCase__   (					self     :       Optional[int]				,						UpperCamelCase__     :       Optional[Any]	)  ->    int:
    self.assertTrue(np.all(np.mean(UpperCamelCase__				,						axis=0	) < 1E-3	)	)
    self.assertTrue(np.all(np.abs(np.var(UpperCamelCase__				,						axis=0	) - 1	) < 1E-3	)	)


  def 	UpperCamelCase__   (					self     :       Optional[int]	)  ->    Optional[int]:
    _UpperCamelCase							      =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
    # create three inputs of length 800, 1000, and 1200
    _UpperCamelCase							      =[floats_list((1, x)	)[0] for x in range(800				,						1400				,						200	)]
    _UpperCamelCase							      =[np.asarray(UpperCamelCase__	) for speech_input in speech_inputs]

    # Test not batched input
    _UpperCamelCase							      =feat_extract(speech_inputs[0]				,						return_tensors='''np'''	).input_values
    _UpperCamelCase							      =feat_extract(np_speech_inputs[0]				,						return_tensors='''np'''	).input_values
    self.assertTrue(np.allclose(UpperCamelCase__				,						UpperCamelCase__				,						atol=1E-3	)	)

    # Test batched
    _UpperCamelCase							      =feat_extract(UpperCamelCase__				,						return_tensors='''np'''	).input_values
    _UpperCamelCase							      =feat_extract(UpperCamelCase__				,						return_tensors='''np'''	).input_values
    for enc_seq_a, enc_seq_a in zip(UpperCamelCase__				,						UpperCamelCase__	):
      self.assertTrue(np.allclose(UpperCamelCase__				,						UpperCamelCase__				,						atol=1E-3	)	)


  def 	UpperCamelCase__   (					self     :       Any	)  ->    Any:
    _UpperCamelCase							      =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
    _UpperCamelCase							      =[floats_list((1, x)	)[0] for x in range(800				,						1400				,						200	)]

    _UpperCamelCase							      =['''longest''', '''max_length''', '''do_not_pad''']
    _UpperCamelCase							      =[None, 1600, None]
    for max_length, padding in zip(UpperCamelCase__				,						UpperCamelCase__	):
      _UpperCamelCase							      =feat_extract(UpperCamelCase__				,						padding=UpperCamelCase__				,						max_length=UpperCamelCase__				,						return_tensors='''np'''	)
      _UpperCamelCase							      =processed.input_values

      self._check_zero_mean_unit_variance(input_values[0][:800]	)
      self.assertTrue(input_values[0][800:].sum() < 1E-6	)
      self._check_zero_mean_unit_variance(input_values[1][:1000]	)
      self.assertTrue(input_values[0][1000:].sum() < 1E-6	)
      self._check_zero_mean_unit_variance(input_values[2][:1200]	)


  def 	UpperCamelCase__   (					self     :       Any	)  ->    Dict:
    _UpperCamelCase							      =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
    _UpperCamelCase							      =range(800				,						1400				,						200	)
    _UpperCamelCase							      =[floats_list((1, x)	)[0] for x in lengths]

    _UpperCamelCase							      =['''longest''', '''max_length''', '''do_not_pad''']
    _UpperCamelCase							      =[None, 1600, None]

    for max_length, padding in zip(UpperCamelCase__				,						UpperCamelCase__	):
      _UpperCamelCase							      =feat_extract(UpperCamelCase__				,						max_length=UpperCamelCase__				,						padding=UpperCamelCase__	)
      _UpperCamelCase							      =processed.input_values

      self._check_zero_mean_unit_variance(input_values[0][:800]	)
      self._check_zero_mean_unit_variance(input_values[1][:1000]	)
      self._check_zero_mean_unit_variance(input_values[2][:1200]	)


  def 	UpperCamelCase__   (					self     :       Dict	)  ->    Union[str, Any]:
    _UpperCamelCase							      =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
    _UpperCamelCase							      =[floats_list((1, x)	)[0] for x in range(800				,						1400				,						200	)]
    _UpperCamelCase							      =feat_extract(
        UpperCamelCase__				,						truncation=UpperCamelCase__				,						max_length=1000				,						padding='''max_length'''				,						return_tensors='''np'''	)
    _UpperCamelCase							      =processed.input_values

    self._check_zero_mean_unit_variance(input_values[0, :800]	)
    self._check_zero_mean_unit_variance(input_values[1]	)
    self._check_zero_mean_unit_variance(input_values[2]	)


  def 	UpperCamelCase__   (					self     :       int	)  ->    Tuple:
    _UpperCamelCase							      =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
    _UpperCamelCase							      =[floats_list((1, x)	)[0] for x in range(800				,						1400				,						200	)]
    _UpperCamelCase							      =feat_extract(
        UpperCamelCase__				,						truncation=UpperCamelCase__				,						max_length=1000				,						padding='''longest'''				,						return_tensors='''np'''	)
    _UpperCamelCase							      =processed.input_values

    self._check_zero_mean_unit_variance(input_values[0, :800]	)
    self._check_zero_mean_unit_variance(input_values[1, :1000]	)
    self._check_zero_mean_unit_variance(input_values[2]	)

    # make sure that if max_length < longest -> then pad to max_length
    self.assertTrue(input_values.shape == (3, 1000)	)

    _UpperCamelCase							      =[floats_list((1, x)	)[0] for x in range(800				,						1400				,						200	)]
    _UpperCamelCase							      =feat_extract(
        UpperCamelCase__				,						truncation=UpperCamelCase__				,						max_length=2000				,						padding='''longest'''				,						return_tensors='''np'''	)
    _UpperCamelCase							      =processed.input_values

    self._check_zero_mean_unit_variance(input_values[0, :800]	)
    self._check_zero_mean_unit_variance(input_values[1, :1000]	)
    self._check_zero_mean_unit_variance(input_values[2]	)

    # make sure that if max_length > longest -> then pad to longest
    self.assertTrue(input_values.shape == (3, 1200)	)


  def 	UpperCamelCase__   (					self     :       Optional[Any]	)  ->    int:
    _UpperCamelCase							      =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
    _UpperCamelCase							      =np.random.rand(100	).astype(np.floataa	)
    _UpperCamelCase							      =np_speech_inputs.tolist()

    for inputs in [py_speech_inputs, np_speech_inputs]:
      _UpperCamelCase							      =feature_extractor.pad([{'''input_values''': inputs}]				,						return_tensors='''np'''	)
      self.assertTrue(np_processed.input_values.dtype == np.floataa	)
      _UpperCamelCase							      =feature_extractor.pad([{'''input_values''': inputs}]				,						return_tensors='''pt'''	)
      self.assertTrue(pt_processed.input_values.dtype == torch.floataa	)


  def 	UpperCamelCase__   (					self     :       Tuple	)  ->    Any:
    _UpperCamelCase							      =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
    # create three inputs of length 800, 1000, and 1200
    _UpperCamelCase							      =[floats_list((1, x)	)[0] for x in range(800				,						1400				,						200	)]
    _UpperCamelCase							      =[np.asarray(UpperCamelCase__	) for speech_input in speech_inputs]

    # Test feature size
    _UpperCamelCase							      =feature_extractor(audio_target=UpperCamelCase__				,						padding=UpperCamelCase__				,						return_tensors='''np'''	).input_values
    self.assertTrue(input_values.ndim == 3	)
    self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins	)

    # Test not batched input
    _UpperCamelCase							      =feature_extractor(speech_inputs[0]				,						return_tensors='''np'''	).input_values
    _UpperCamelCase							      =feature_extractor(np_speech_inputs[0]				,						return_tensors='''np'''	).input_values
    self.assertTrue(np.allclose(UpperCamelCase__				,						UpperCamelCase__				,						atol=1E-3	)	)

    # Test batched
    _UpperCamelCase							      =feature_extractor(UpperCamelCase__				,						return_tensors='''np'''	).input_values
    _UpperCamelCase							      =feature_extractor(UpperCamelCase__				,						return_tensors='''np'''	).input_values
    for enc_seq_a, enc_seq_a in zip(UpperCamelCase__				,						UpperCamelCase__	):
      self.assertTrue(np.allclose(UpperCamelCase__				,						UpperCamelCase__				,						atol=1E-3	)	)

    # Test 2-D numpy arrays are batched.
    _UpperCamelCase							      =[floats_list((1, x)	)[0] for x in (800, 800, 800)]
    _UpperCamelCase							      =np.asarray(UpperCamelCase__	)
    _UpperCamelCase							      =feature_extractor(UpperCamelCase__				,						return_tensors='''np'''	).input_values
    _UpperCamelCase							      =feature_extractor(UpperCamelCase__				,						return_tensors='''np'''	).input_values
    for enc_seq_a, enc_seq_a in zip(UpperCamelCase__				,						UpperCamelCase__	):
      self.assertTrue(np.allclose(UpperCamelCase__				,						UpperCamelCase__				,						atol=1E-3	)	)


  def 	UpperCamelCase__   (					self     :       List[str]	)  ->    Optional[int]:
    _UpperCamelCase							      =self.feat_extract_tester.prepare_inputs_for_target()
    _UpperCamelCase							      =self.feature_extraction_class(**self.feat_extract_dict	)
    _UpperCamelCase							      =feat_extract.model_input_names[0]

    _UpperCamelCase							      =BatchFeature({input_name: speech_inputs}	)

    self.assertTrue(all(len(UpperCamelCase__	) == len(UpperCamelCase__	) for x, y in zip(UpperCamelCase__				,						processed_features[input_name]	)	)	)

    _UpperCamelCase							      =self.feat_extract_tester.prepare_inputs_for_target(equal_length=UpperCamelCase__	)
    _UpperCamelCase							      =BatchFeature({input_name: speech_inputs}				,						tensor_type='''np'''	)

    _UpperCamelCase							      =processed_features[input_name]

    if len(batch_features_input.shape	) < 3:
      _UpperCamelCase							      =batch_features_input[:, :, None]

    self.assertTrue(
        batch_features_input.shape
        == (self.feat_extract_tester.batch_size, len(speech_inputs[0]	), self.feat_extract_tester.num_mel_bins)	)


  @require_torch
  def 	UpperCamelCase__   (					self     :       Dict	)  ->    Any:
    _UpperCamelCase							      =self.feat_extract_tester.prepare_inputs_for_target(equal_length=UpperCamelCase__	)
    _UpperCamelCase							      =self.feature_extraction_class(**self.feat_extract_dict	)
    _UpperCamelCase							      =feat_extract.model_input_names[0]

    _UpperCamelCase							      =BatchFeature({input_name: speech_inputs}				,						tensor_type='''pt'''	)

    _UpperCamelCase							      =processed_features[input_name]

    if len(batch_features_input.shape	) < 3:
      _UpperCamelCase							      =batch_features_input[:, :, None]

    self.assertTrue(
        batch_features_input.shape
        == (self.feat_extract_tester.batch_size, len(speech_inputs[0]	), self.feat_extract_tester.num_mel_bins)	)


  @require_torch
  def 	UpperCamelCase__   (					self     :       Union[str, Any]	)  ->    Tuple:
    _UpperCamelCase							      =self.feature_extraction_class(**self.feat_extract_dict	)
    _UpperCamelCase							      =self.feat_extract_tester.prepare_inputs_for_target()
    _UpperCamelCase							      =feat_extract.model_input_names[0]

    _UpperCamelCase							      =BatchFeature({input_name: speech_inputs}	)

    _UpperCamelCase							      =feat_extract.num_mel_bins  # hack!

    _UpperCamelCase							      =feat_extract.pad(UpperCamelCase__				,						padding='''longest'''				,						return_tensors='''np'''	)[input_name]
    _UpperCamelCase							      =feat_extract.pad(UpperCamelCase__				,						padding='''longest'''				,						return_tensors='''pt'''	)[input_name]

    self.assertTrue(abs(input_np.astype(np.floataa	).sum() - input_pt.numpy().astype(np.floataa	).sum()	) < 1E-2	)


  def 	UpperCamelCase__   (					self     :       int	)  ->    List[str]:
    _UpperCamelCase							      =self.feat_extract_dict
    _UpperCamelCase							      =True
    _UpperCamelCase							      =self.feature_extraction_class(**UpperCamelCase__	)
    _UpperCamelCase							      =self.feat_extract_tester.prepare_inputs_for_target()
    _UpperCamelCase							      =[len(UpperCamelCase__	) for x in speech_inputs]
    _UpperCamelCase							      =feat_extract.model_input_names[0]

    _UpperCamelCase							      =BatchFeature({input_name: speech_inputs}	)

    _UpperCamelCase							      =feat_extract.num_mel_bins  # hack!

    _UpperCamelCase							      =feat_extract.pad(UpperCamelCase__				,						padding='''longest'''				,						return_tensors='''np'''	)
    self.assertIn('''attention_mask'''				,						UpperCamelCase__	)
    self.assertListEqual(list(processed.attention_mask.shape	)				,						list(processed[input_name].shape[:2]	)	)
    self.assertListEqual(processed.attention_mask.sum(-1	).tolist()				,						UpperCamelCase__	)


  def 	UpperCamelCase__   (					self     :       Dict	)  ->    Optional[Any]:
    _UpperCamelCase							      =self.feat_extract_dict
    _UpperCamelCase							      =True
    _UpperCamelCase							      =self.feature_extraction_class(**UpperCamelCase__	)
    _UpperCamelCase							      =self.feat_extract_tester.prepare_inputs_for_target()
    _UpperCamelCase							      =[len(UpperCamelCase__	) for x in speech_inputs]
    _UpperCamelCase							      =feat_extract.model_input_names[0]

    _UpperCamelCase							      =BatchFeature({input_name: speech_inputs}	)
    _UpperCamelCase							      =min(UpperCamelCase__	)

    _UpperCamelCase							      =feat_extract.num_mel_bins  # hack!

    _UpperCamelCase							      =feat_extract.pad(
        UpperCamelCase__				,						padding='''max_length'''				,						max_length=UpperCamelCase__				,						truncation=UpperCamelCase__				,						return_tensors='''np'''	)
    self.assertIn('''attention_mask'''				,						UpperCamelCase__	)
    self.assertListEqual(
        list(processed_pad.attention_mask.shape	)				,						[processed_pad[input_name].shape[0], max_length]	)
    self.assertListEqual(
        processed_pad.attention_mask[:, :max_length].sum(-1	).tolist()				,						[max_length for x in speech_inputs]	)


  def 	UpperCamelCase__   (					self     :       str				,						UpperCamelCase__     :       Tuple	)  ->    Union[str, Any]:
    from datasets import load_dataset

    _UpperCamelCase							      =load_dataset('''hf-internal-testing/librispeech_asr_dummy'''				,						'''clean'''				,						split='''validation'''	)
    # automatic decoding with librispeech
    _UpperCamelCase							      =ds.sort('''id'''	).select(range(UpperCamelCase__	)	)[:num_samples]['''audio''']

    return [x["array"] for x in speech_samples]


  def 	UpperCamelCase__   (					self     :       Tuple	)  ->    Optional[Any]:
    _UpperCamelCase							      =torch.tensor(
        [2.3804E-03, 2.0752E-03, 1.9836E-03, 2.1057E-03, 1.6174E-03,
         3.0518E-04, 9.1553E-05, 3.3569E-04, 9.7656E-04, 1.8311E-03,
         2.0142E-03, 2.1057E-03, 1.7395E-03, 4.5776E-04, -3.9673E-04,
         4.5776E-04, 1.0071E-03, 9.1553E-05, 4.8828E-04, 1.1597E-03,
         7.3242E-04, 9.4604E-04, 1.8005E-03, 1.8311E-03, 8.8501E-04,
         4.2725E-04, 4.8828E-04, 7.3242E-04, 1.0986E-03, 2.1057E-03]	)
    # fmt: on

    _UpperCamelCase							      =self._load_datasamples(1	)
    _UpperCamelCase							      =SpeechTaFeatureExtractor()
    _UpperCamelCase							      =feature_extractor(UpperCamelCase__				,						return_tensors='''pt'''	).input_values
    self.assertEquals(input_values.shape				,						(1, 9_3680)	)
    self.assertTrue(torch.allclose(input_values[0, :30]				,						UpperCamelCase__				,						atol=1E-6	)	)




  def 	UpperCamelCase__   (					self     :       Optional[Any]	)  ->    Union[str, Any]:
    _UpperCamelCase							      =torch.tensor(
        [-2.6870, -3.0104, -3.1356, -3.5352, -3.0044, -3.0353, -3.4719, -3.6777,
         -3.1520, -2.9435, -2.6553, -2.8795, -2.9944, -2.5921, -3.0279, -3.0386,
         -3.0864, -3.1291, -3.2353, -2.7444, -2.6831, -2.7287, -3.1761, -3.1571,
         -3.2726, -3.0582, -3.1007, -3.4533, -3.4695, -3.0998]	)
    # fmt: on

    _UpperCamelCase							      =self._load_datasamples(1	)
    _UpperCamelCase							      =SpeechTaFeatureExtractor()
    _UpperCamelCase							      =feature_extractor(audio_target=UpperCamelCase__				,						return_tensors='''pt'''	).input_values
    self.assertEquals(input_values.shape				,						(1, 366, 80)	)
    self.assertTrue(torch.allclose(input_values[0, 0, :30]				,						UpperCamelCase__				,						atol=1E-4	)	)









import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


lowercase_   							=  '\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 					__lowerCAmelCase	(   unittest.TestCase     ,     SCREAMING_SNAKE_CASE				):




  def     A__	(							self   )    ->					Union[str, Any]:
        '''simple docstring'''






        _lowercase      			=load_tool('text-question-answering'   )
        self.tool.setup()
        _lowercase      			=load_tool('text-question-answering'				,  remote=lowerCAmelCase   )




  def     A__	(							self   )    ->					Dict:
        '''simple docstring'''






        _lowercase      			=self.tool(lowerCAmelCase				,  'What did Hugging Face do in April 2021?'   )
        self.assertEqual(lowerCAmelCase				,  'launched the BigScience Research Workshop'   )




  def     A__	(							self   )    ->					Optional[Any]:
        '''simple docstring'''






        _lowercase      			=self.remote_tool(lowerCAmelCase				,  'What did Hugging Face do in April 2021?'   )
        self.assertEqual(lowerCAmelCase				,  'launched the BigScience Research Workshop'   )




  def     A__	(							self   )    ->					Any:
        '''simple docstring'''






        _lowercase      			=self.tool(text=lowerCAmelCase				,  question='What did Hugging Face do in April 2021?'   )
        self.assertEqual(lowerCAmelCase				,  'launched the BigScience Research Workshop'   )




  def     A__	(							self   )    ->					Optional[int]:
        '''simple docstring'''






        _lowercase      			=self.remote_tool(text=lowerCAmelCase				,  question='What did Hugging Face do in April 2021?'   )
        self.assertEqual(lowerCAmelCase				,  'launched the BigScience Research Workshop'   )


