




'''simple docstring'''


from __future__ import annotations

import unittest

from transformers import RoFormerConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers import (
        TFRoFormerForCausalLM,
        TFRoFormerForMaskedLM,
        TFRoFormerForMultipleChoice,
        TFRoFormerForQuestionAnswering,
        TFRoFormerForSequenceClassification,
        TFRoFormerForTokenClassification,
        TFRoFormerModel,
    )
    from transformers.models.roformer.modeling_tf_roformer import (
        TFRoFormerSelfAttention,
        TFRoFormerSinusoidalPositionalEmbedding,
    )

class     A					:







       def __init__(						self :						Union[str, Any]							,    lowerCAmelCase_ :						Tuple							,    lowerCAmelCase_ :						Optional[int]=13							,    lowerCAmelCase_ :						Any=7							,    lowerCAmelCase_ :						Optional[int]=True							,    lowerCAmelCase_ :						Optional[int]=True							,    lowerCAmelCase_ :						Optional[int]=True							,    lowerCAmelCase_ :						str=True							,    lowerCAmelCase_ :						Dict=99							,    lowerCAmelCase_ :						List[Any]=32							,    lowerCAmelCase_ :						Tuple=2							,    lowerCAmelCase_ :						List[str]=4							,    lowerCAmelCase_ :						int=37							,    lowerCAmelCase_ :						Union[str, Any]="gelu"							,    lowerCAmelCase_ :						List[str]=0.1							,    lowerCAmelCase_ :						List[Any]=0.1							,    lowerCAmelCase_ :						List[Any]=5_12							,    lowerCAmelCase_ :						List[str]=16							,    lowerCAmelCase_ :						Optional[Any]=2							,    lowerCAmelCase_ :						Tuple=0.0_2							,    lowerCAmelCase_ :						str=3							,    lowerCAmelCase_ :						Optional[int]=4							,    lowerCAmelCase_ :						Any=None							,    )    ->							Union[str, Any]:


              """simple docstring"""


              _a			  =       parent
              _a			  =       13
              _a			  =       7
              _a			  =       True
              _a			  =       True
              _a			  =       True
              _a			  =       True
              _a			  =       99
              _a			  =       32
              _a			  =       2
              _a			  =       4
              _a			  =       37
              _a			  =       'gelu'
              _a			  =       0.1
              _a			  =       0.1
              _a			  =       5_12
              _a			  =       16
              _a			  =       2
              _a			  =       0.0_2
              _a			  =       3
              _a			  =       4
              _a			  =       None







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


              """simple docstring"""


              _a			  =       ids_tensor([self.batch_size, self.seq_length]							,    self.vocab_size      )

              _a			  =       None
              if self.use_input_mask:
                     _a			  =       random_attention_mask([self.batch_size, self.seq_length]      )

              _a			  =       None
              if self.use_token_type_ids:
                     _a			  =       ids_tensor([self.batch_size, self.seq_length]							,    self.type_vocab_size      )

              _a			  =       None
              _a			  =       None
              _a			  =       None
              if self.use_labels:
                     _a			  =       ids_tensor([self.batch_size]							,    self.type_sequence_label_size      )
                     _a			  =       ids_tensor([self.batch_size, self.seq_length]							,    self.num_labels      )
                     _a			  =       ids_tensor([self.batch_size]							,    self.num_choices      )

              _a			  =       RoFormerConfig(
                  vocab_size=self.vocab_size							,    hidden_size=self.hidden_size							,    num_hidden_layers=self.num_hidden_layers							,    num_attention_heads=self.num_attention_heads							,    intermediate_size=self.intermediate_size							,    hidden_act=self.hidden_act							,    hidden_dropout_prob=self.hidden_dropout_prob							,    attention_probs_dropout_prob=self.attention_probs_dropout_prob							,    max_position_embeddings=self.max_position_embeddings							,    type_vocab_size=self.type_vocab_size							,    initializer_range=self.initializer_range							,    return_dict=lowerCAmelCase_							,    )

              return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels







       def      __lowerCAmelCase    (						self :						Tuple							,    lowerCAmelCase_ :						int							,    lowerCAmelCase_ :						str							,    lowerCAmelCase_ :						int							,    lowerCAmelCase_ :						Optional[int]							,    lowerCAmelCase_ :						List[Any]							,    lowerCAmelCase_ :						Tuple							,    lowerCAmelCase_ :						int      )    ->							Tuple:


              """simple docstring"""


              _a			  =       TFRoFormerModel(config=lowerCAmelCase_      )
              _a			  =       {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

              _a			  =       [input_ids, input_mask]
              _a			  =       model(lowerCAmelCase_      )

              _a			  =       model(lowerCAmelCase_      )

              self.parent.assertEqual(result.last_hidden_state.shape							,    (self.batch_size, self.seq_length, self.hidden_size)      )







       def      __lowerCAmelCase    (						self :						Optional[int]							,    lowerCAmelCase_ :						Optional[Any]							,    lowerCAmelCase_ :						List[Any]							,    lowerCAmelCase_ :						int							,    lowerCAmelCase_ :						Tuple							,    lowerCAmelCase_ :						Optional[int]							,    lowerCAmelCase_ :						List[Any]							,    lowerCAmelCase_ :						Dict      )    ->							Dict:


              """simple docstring"""


              _a			  =       True
              _a			  =       TFRoFormerForCausalLM(config=lowerCAmelCase_      )
              _a			  =       {
                  'input_ids': input_ids,
                  'attention_mask': input_mask,
                  'token_type_ids': token_type_ids,
              }
              _a			  =       model(lowerCAmelCase_      )['logits']
              self.parent.assertListEqual(
                  list(prediction_scores.numpy().shape      )							,    [self.batch_size, self.seq_length, self.vocab_size]      )







       def      __lowerCAmelCase    (						self :						Any							,    lowerCAmelCase_ :						int							,    lowerCAmelCase_ :						str							,    lowerCAmelCase_ :						int							,    lowerCAmelCase_ :						List[str]							,    lowerCAmelCase_ :						str							,    lowerCAmelCase_ :						str							,    lowerCAmelCase_ :						int      )    ->							Union[str, Any]:


              """simple docstring"""


              _a			  =       TFRoFormerForMaskedLM(config=lowerCAmelCase_      )
              _a			  =       {
                  'input_ids': input_ids,
                  'attention_mask': input_mask,
                  'token_type_ids': token_type_ids,
              }
              _a			  =       model(lowerCAmelCase_      )
              self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.seq_length, self.vocab_size)      )







       def      __lowerCAmelCase    (						self :						Optional[Any]							,    lowerCAmelCase_ :						Tuple							,    lowerCAmelCase_ :						int							,    lowerCAmelCase_ :						List[str]							,    lowerCAmelCase_ :						Dict							,    lowerCAmelCase_ :						Optional[Any]							,    lowerCAmelCase_ :						Optional[int]							,    lowerCAmelCase_ :						Optional[int]      )    ->							Optional[int]:


              """simple docstring"""


              _a			  =       self.num_labels
              _a			  =       TFRoFormerForSequenceClassification(config=lowerCAmelCase_      )
              _a			  =       {
                  'input_ids': input_ids,
                  'attention_mask': input_mask,
                  'token_type_ids': token_type_ids,
              }

              _a			  =       model(lowerCAmelCase_      )
              self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.num_labels)      )







       def      __lowerCAmelCase    (						self :						Union[str, Any]							,    lowerCAmelCase_ :						Optional[Any]							,    lowerCAmelCase_ :						Optional[Any]							,    lowerCAmelCase_ :						Tuple							,    lowerCAmelCase_ :						Union[str, Any]							,    lowerCAmelCase_ :						Tuple							,    lowerCAmelCase_ :						Tuple							,    lowerCAmelCase_ :						int      )    ->							str:


              """simple docstring"""


              _a			  =       self.num_choices
              _a			  =       TFRoFormerForMultipleChoice(config=lowerCAmelCase_      )
              _a			  =       tf.tile(tf.expand_dims(lowerCAmelCase_							,    1      )							,    (1, self.num_choices, 1)      )
              _a			  =       tf.tile(tf.expand_dims(lowerCAmelCase_							,    1      )							,    (1, self.num_choices, 1)      )
              _a			  =       tf.tile(tf.expand_dims(lowerCAmelCase_							,    1      )							,    (1, self.num_choices, 1)      )
              _a			  =       {
                  'input_ids': multiple_choice_inputs_ids,
                  'attention_mask': multiple_choice_input_mask,
                  'token_type_ids': multiple_choice_token_type_ids,
              }
              _a			  =       model(lowerCAmelCase_      )
              self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.num_choices)      )







       def      __lowerCAmelCase    (						self :						Optional[Any]							,    lowerCAmelCase_ :						Tuple							,    lowerCAmelCase_ :						Union[str, Any]							,    lowerCAmelCase_ :						List[Any]							,    lowerCAmelCase_ :						Union[str, Any]							,    lowerCAmelCase_ :						Any							,    lowerCAmelCase_ :						int							,    lowerCAmelCase_ :						List[Any]      )    ->							Union[str, Any]:


              """simple docstring"""


              _a			  =       self.num_labels
              _a			  =       TFRoFormerForTokenClassification(config=lowerCAmelCase_      )
              _a			  =       {
                  'input_ids': input_ids,
                  'attention_mask': input_mask,
                  'token_type_ids': token_type_ids,
              }
              _a			  =       model(lowerCAmelCase_      )
              self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.seq_length, self.num_labels)      )







       def      __lowerCAmelCase    (						self :						Any							,    lowerCAmelCase_ :						Any							,    lowerCAmelCase_ :						Optional[int]							,    lowerCAmelCase_ :						Union[str, Any]							,    lowerCAmelCase_ :						Optional[Any]							,    lowerCAmelCase_ :						Union[str, Any]							,    lowerCAmelCase_ :						Optional[int]							,    lowerCAmelCase_ :						List[Any]      )    ->							Union[str, Any]:


              """simple docstring"""


              _a			  =       TFRoFormerForQuestionAnswering(config=lowerCAmelCase_      )
              _a			  =       {
                  'input_ids': input_ids,
                  'attention_mask': input_mask,
                  'token_type_ids': token_type_ids,
              }

              _a			  =       model(lowerCAmelCase_      )
              self.parent.assertEqual(result.start_logits.shape							,    (self.batch_size, self.seq_length)      )
              self.parent.assertEqual(result.end_logits.shape							,    (self.batch_size, self.seq_length)      )







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


              """simple docstring"""


              _a			  =       self.prepare_config_and_inputs()
              (
                  _a       
              )			  =       config_and_inputs
              _a			  =       {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
              return config, inputs_dict



@require_tf
class     A					(	_a  ,_a  ,unittest.TestCase					):
       lowercase_           =       (
           (
               TFRoFormerModel,
               TFRoFormerForCausalLM,
               TFRoFormerForMaskedLM,
               TFRoFormerForQuestionAnswering,
               TFRoFormerForSequenceClassification,
               TFRoFormerForTokenClassification,
               TFRoFormerForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       lowercase_           =       (
           {
               'feature-extraction': TFRoFormerModel,
               'fill-mask': TFRoFormerForMaskedLM,
               'question-answering': TFRoFormerForQuestionAnswering,
               'text-classification': TFRoFormerForSequenceClassification,
               'text-generation': TFRoFormerForCausalLM,
               'token-classification': TFRoFormerForTokenClassification,
               'zero-shot': TFRoFormerForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )

       lowercase_           =       False
       lowercase_           =       False







       def      __lowerCAmelCase    (						self :						Optional[Any]							,    lowerCAmelCase_ :						Optional[int]							,    lowerCAmelCase_ :						List[str]							,    lowerCAmelCase_ :						str							,    lowerCAmelCase_ :						Optional[int]							,    lowerCAmelCase_ :						List[Any]      )    ->							Dict:


              """simple docstring"""


              if pipeline_test_casse_name == "TextGenerationPipelineTests":
                     return True

              return False







       def      __lowerCAmelCase    (						self :						Dict      )    ->							Optional[int]:


              """simple docstring"""


              _a			  =       TFRoFormerModelTester(self      )
              _a			  =       ConfigTester(self							,    config_class=lowerCAmelCase_							,    hidden_size=37      )







       def      __lowerCAmelCase    (						self :						int      )    ->							Union[str, Any]:


              """simple docstring"""


              self.config_tester.run_common_tests()







       def      __lowerCAmelCase    (						self :						str      )    ->							Any:


              """simple docstring"""


              _a			  =       self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_model(*lowerCAmelCase_      )







       def      __lowerCAmelCase    (						self :						Optional[int]      )    ->							Dict:


              """simple docstring"""


              _a			  =       self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase_      )







       def      __lowerCAmelCase    (						self :						Optional[Any]      )    ->							Tuple:


              """simple docstring"""


              _a			  =       self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_lm_head(*lowerCAmelCase_      )







       def      __lowerCAmelCase    (						self :						Optional[int]      )    ->							Optional[int]:


              """simple docstring"""


              _a			  =       self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_multiple_choice(*lowerCAmelCase_      )







       def      __lowerCAmelCase    (						self :						str      )    ->							Optional[int]:


              """simple docstring"""


              _a			  =       self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase_      )







       def      __lowerCAmelCase    (						self :						str      )    ->							Optional[int]:


              """simple docstring"""


              _a			  =       self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase_      )







       def      __lowerCAmelCase    (						self :						Tuple      )    ->							List[Any]:


              """simple docstring"""


              _a			  =       self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase_      )







       @slow
       def      __lowerCAmelCase    (						self :						Tuple      )    ->							List[str]:


              """simple docstring"""


              _a			  =       TFRoFormerModel.from_pretrained('''junnyu/roformer_chinese_base'''      )
              self.assertIsNotNone(lowerCAmelCase_      )



@require_tf
class     A					(	unittest.TestCase					):







       @slow
       def      __lowerCAmelCase    (						self :						Tuple      )    ->							List[str]:


              """simple docstring"""


              _a			  =       TFRoFormerForMaskedLM.from_pretrained('''junnyu/roformer_chinese_base'''      )
              _a			  =       tf.constant([[0, 1, 2, 3, 4, 5]]      )
              _a			  =       model(lowerCAmelCase_      )[0]

              # TODO Replace vocab size
              _a			  =       5_00_00

              _a			  =       [1, 6, vocab_size]
              self.assertEqual(output.shape							,    lowerCAmelCase_      )

              print(output[:, :3, :3]      )

              # TODO Replace values below with what was printed above.
              _a			  =       tf.constant(
                  [
                      [
                          [-0.1_2_0_5_3_3_4_1, -1.0_2_6_4_9_0_1, 0.2_9_2_2_1_9_4_6],
                          [-1.5_1_3_3_7_8_3, 0.1_9_7_4_3_3, 0.1_5_1_9_0_6_0_7],
                          [-5.0_1_3_5_4_0_3, -3.9_0_0_2_5_6, -0.8_4_0_3_8_7_6_4],
                      ]
                  ]      )
              tf.debugging.assert_near(output[:, :3, :3]							,    lowerCAmelCase_							,    atol=1e-4      )



@require_tf
class     A					(	unittest.TestCase					):
       lowercase_           =       1e-4







       def      __lowerCAmelCase    (						self :						Any      )    ->							Dict:


              """simple docstring"""


              _a			  =       tf.constant([[4, 10]]      )
              _a			  =       TFRoFormerSinusoidalPositionalEmbedding(num_positions=6							,    embedding_dim=6      )

              _a			  =       emba(input_ids.shape      )
              _a			  =       tf.constant(
                  [[0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 1.0_0_0_0, 1.0_0_0_0, 1.0_0_0_0], [0.8_4_1_5, 0.0_4_6_4, 0.0_0_2_2, 0.5_4_0_3, 0.9_9_8_9, 1.0_0_0_0]]      )

              tf.debugging.assert_near(lowerCAmelCase_							,    lowerCAmelCase_							,    atol=self.tolerance      )







       def      __lowerCAmelCase    (						self :						int      )    ->							int:


              """simple docstring"""


              _a			  =       tf.constant(
                  [
                      [0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0],
                      [0.8_4_1_5, 0.8_2_1_9, 0.8_0_2_0, 0.7_8_1_9, 0.7_6_1_7],
                      [0.9_0_9_3, 0.9_3_6_4, 0.9_5_8_1, 0.9_7_4_9, 0.9_8_7_0],
                  ]      )
              _a			  =       TFRoFormerSinusoidalPositionalEmbedding(num_positions=5_12							,    embedding_dim=5_12      )
              emba([2, 16, 5_12]      )
              _a			  =       emba.weight[:3, :5]

              tf.debugging.assert_near(lowerCAmelCase_							,    lowerCAmelCase_							,    atol=self.tolerance      )



@require_tf
class     A					(	unittest.TestCase					):
       lowercase_           =       1e-4







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


              """simple docstring"""


              _a			  =       tf.reshape(tf.range(2 * 12 * 16 * 64							,    dtype=tf.floataa      )							,    shape=(2, 12, 16, 64)      ) / 1_00

              _a			  =       -tf.reshape(tf.range(2 * 12 * 16 * 64							,    dtype=tf.floataa      )							,    shape=(2, 12, 16, 64)      ) / 1_00

              _a			  =       TFRoFormerSinusoidalPositionalEmbedding(num_positions=32							,    embedding_dim=64      )
              _a			  =       embed_positions([2, 16, 7_68]      )[None, None, :, :]

              _a			  =       TFRoFormerSelfAttention.apply_rotary_position_embeddings(
                  lowerCAmelCase_							,    lowerCAmelCase_							,    lowerCAmelCase_      )

              _a			  =       tf.constant(
                  [
                      [0.0_0_0_0, 0.0_1_0_0, 0.0_2_0_0, 0.0_3_0_0, 0.0_4_0_0, 0.0_5_0_0, 0.0_6_0_0, 0.0_7_0_0],
                      [-0.2_0_1_2, 0.8_8_9_7, 0.0_2_6_3, 0.9_4_0_1, 0.2_0_7_4, 0.9_4_6_3, 0.3_4_8_1, 0.9_3_4_3],
                      [-1.7_0_5_7, 0.6_2_7_1, -1.2_1_4_5, 1.3_8_9_7, -0.6_3_0_3, 1.7_6_4_7, -0.1_1_7_3, 1.8_9_8_5],
                      [-2.1_7_3_1, -1.6_3_9_7, -2.7_3_5_8, 0.2_8_5_4, -2.1_8_4_0, 1.7_1_8_3, -1.3_0_1_8, 2.4_8_7_1],
                      [0.2_7_1_7, -3.6_1_7_3, -2.9_2_0_6, -2.1_9_8_8, -3.6_6_3_8, 0.3_8_5_8, -2.9_1_5_5, 2.2_9_8_0],
                      [3.9_8_5_9, -2.1_5_8_0, -0.7_9_8_4, -4.4_9_0_4, -4.1_1_8_1, -2.0_2_5_2, -4.4_7_8_2, 1.1_2_5_3],
                  ]      )
              _a			  =       tf.constant(
                  [
                      [0.0_0_0_0, -0.0_1_0_0, -0.0_2_0_0, -0.0_3_0_0, -0.0_4_0_0, -0.0_5_0_0, -0.0_6_0_0, -0.0_7_0_0],
                      [0.2_0_1_2, -0.8_8_9_7, -0.0_2_6_3, -0.9_4_0_1, -0.2_0_7_4, -0.9_4_6_3, -0.3_4_8_1, -0.9_3_4_3],
                      [1.7_0_5_7, -0.6_2_7_1, 1.2_1_4_5, -1.3_8_9_7, 0.6_3_0_3, -1.7_6_4_7, 0.1_1_7_3, -1.8_9_8_5],
                      [2.1_7_3_1, 1.6_3_9_7, 2.7_3_5_8, -0.2_8_5_4, 2.1_8_4_0, -1.7_1_8_3, 1.3_0_1_8, -2.4_8_7_1],
                      [-0.2_7_1_7, 3.6_1_7_3, 2.9_2_0_6, 2.1_9_8_8, 3.6_6_3_8, -0.3_8_5_8, 2.9_1_5_5, -2.2_9_8_0],
                      [-3.9_8_5_9, 2.1_5_8_0, 0.7_9_8_4, 4.4_9_0_4, 4.1_1_8_1, 2.0_2_5_2, 4.4_7_8_2, -1.1_2_5_3],
                  ]      )

              tf.debugging.assert_near(query_layer[0, 0, :6, :8]							,    lowerCAmelCase_							,    atol=self.tolerance      )
              tf.debugging.assert_near(key_layer[0, 0, :6, :8]							,    lowerCAmelCase_							,    atol=self.tolerance      )







'''simple docstring'''


import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


_snake_case   :   str     							=	'\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     A					(	unittest.TestCase  ,_a					):







							def      __lowerCAmelCase    (						self :						Any      )    ->							Dict:


														"""simple docstring"""


														_a			  =       load_tool('''text-question-answering'''      )
														self.tool.setup()
														_a			  =       load_tool('''text-question-answering'''							,    remote=lowerCAmelCase_      )







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


														"""simple docstring"""


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







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


														"""simple docstring"""


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







							def      __lowerCAmelCase    (						self :						List[Any]      )    ->							List[str]:


														"""simple docstring"""


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







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


														"""simple docstring"""


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

