






"""simple docstring"""





import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
)

from ...test_tokenization_common import TokenizerTesterMixin


_SCREAMING_SNAKE_CASE					:				Tuple					    =						get_tests_dir('''fixtures/test_sentencepiece.model''')

if is_torch_available():
  from transformers.models.mbart.modeling_mbart import shift_tokens_right

_SCREAMING_SNAKE_CASE					:				Tuple					    =						25_0004
_SCREAMING_SNAKE_CASE					:				Optional[Any]					    =						25_0020






@require_sentencepiece
@require_tokenizers
class      a						(					__snake_case  ,      unittest.TestCase		):
    SCREAMING_SNAKE_CASE						:     List[Any]						= MBartaaTokenizer
    SCREAMING_SNAKE_CASE						:     List[str]						= MBartaaTokenizerFast
    SCREAMING_SNAKE_CASE						:     List[str]						= True
    SCREAMING_SNAKE_CASE						:     List[Any]						= True






    def    UpperCamelCase       (       self     :							Optional[int]					)     ->		Optional[int]:
      super().setUp()

      # We have a SentencePiece fixture for testing
      lowerCamelCase_         =						MBartaaTokenizer(__SCREAMING_SNAKE_CASE       ,						src_lang='en_XX'       ,						tgt_lang='ro_RO'       ,						keep_accents=__SCREAMING_SNAKE_CASE					)
      tokenizer.save_pretrained(self.tmpdirname					)






    def    UpperCamelCase       (       self     :							Optional[Any]					)     ->		Optional[Any]:
      lowerCamelCase_         =						'<s>'
      lowerCamelCase_         =						0

      self.assertEqual(self.get_tokenizer()._convert_token_to_id(__SCREAMING_SNAKE_CASE					)       ,						__SCREAMING_SNAKE_CASE					)
      self.assertEqual(self.get_tokenizer()._convert_id_to_token(__SCREAMING_SNAKE_CASE					)       ,						__SCREAMING_SNAKE_CASE					)






    def    UpperCamelCase       (       self     :							Tuple					)     ->		List[Any]:
      lowerCamelCase_         =						list(self.get_tokenizer().get_vocab().keys()					)

      self.assertEqual(vocab_keys[0]       ,						'<s>'					)
      self.assertEqual(vocab_keys[1]       ,						'<pad>'					)
      self.assertEqual(vocab_keys[-1]       ,						'<mask>'					)
      self.assertEqual(len(__SCREAMING_SNAKE_CASE					)       ,						1054					)






    def    UpperCamelCase       (       self     :							str					)     ->		int:
      self.assertEqual(self.get_tokenizer().vocab_size       ,						1054					)






    def    UpperCamelCase       (       self     :							Optional[int]					)     ->		Tuple:
      lowerCamelCase_         =						MBartaaTokenizer(__SCREAMING_SNAKE_CASE       ,						src_lang='en_XX'       ,						tgt_lang='ro_RO'       ,						keep_accents=__SCREAMING_SNAKE_CASE					)

      lowerCamelCase_         =						tokenizer.tokenize('This is a test'					)
      self.assertListEqual(__SCREAMING_SNAKE_CASE       ,						['▁This', '▁is', '▁a', '▁t', 'est']					)

      self.assertListEqual(
          tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE					)       ,						[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]       ,						)

      lowerCamelCase_         =						tokenizer.tokenize('I was born in 92000, and this is falsé.'					)
      self.assertListEqual(
          __SCREAMING_SNAKE_CASE       ,						[SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '9', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', 'é', '.']       ,						)
      lowerCamelCase_         =						tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE					)
      self.assertListEqual(
          __SCREAMING_SNAKE_CASE       ,						[
              value + tokenizer.fairseq_offset
              for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
          ]       ,						)

      lowerCamelCase_         =						tokenizer.convert_ids_to_tokens(__SCREAMING_SNAKE_CASE					)
      self.assertListEqual(
          __SCREAMING_SNAKE_CASE       ,						[SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '<unk>', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', '<unk>', '.']       ,						)






    @slow
    def    UpperCamelCase       (       self     :							Any					)     ->		Tuple:
      # fmt: off
      lowerCamelCase_         =						{'input_ids': [[250004, 11062, 82772, 7, 15, 82772, 538, 51529, 237, 17198, 1290, 206, 9, 215175, 1314, 136, 17198, 1290, 206, 9, 56359, 42, 122009, 9, 16466, 16, 87344, 4537, 9, 4717, 78381, 6, 159958, 7, 15, 24480, 618, 4, 527, 22693, 5428, 4, 2777, 24480, 9874, 4, 43523, 594, 4, 803, 18392, 33189, 18, 4, 43523, 24447, 12399, 100, 24955, 83658, 9626, 144057, 15, 839, 22335, 16, 136, 24955, 83658, 83479, 15, 39102, 724, 16, 678, 645, 2789, 1328, 4589, 42, 122009, 115774, 23, 805, 1328, 46876, 7, 136, 53894, 1940, 42227, 41159, 17721, 823, 425, 4, 27512, 98722, 206, 136, 5531, 4970, 919, 17336, 5, 2], [250004, 20080, 618, 83, 82775, 47, 479, 9, 1517, 73, 53894, 333, 80581, 110117, 18811, 5256, 1295, 51, 152526, 297, 7986, 390, 124416, 538, 35431, 214, 98, 15044, 25737, 136, 7108, 43701, 23, 756, 135355, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [250004, 581, 63773, 119455, 6, 147797, 88203, 7, 645, 70, 21, 3285, 10269, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
      # fmt: on

      self.tokenizer_integration_test_util(
          expected_encoding=__SCREAMING_SNAKE_CASE       ,						model_name='facebook/mbart-large-50'       ,						revision='d3913889c59cd5c9e456b269c376325eabad57e2'       ,						)






    def    UpperCamelCase       (       self     :							List[str]					)     ->		Dict:
      if not self.test_slow_tokenizer:
        # as we don't have a slow version, we can't compare the outputs between slow and fast versions
        return

      lowerCamelCase_         =						(self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-mbart50', {})
      for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
        with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''					):
          lowerCamelCase_         =						self.rust_tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE       ,						**__SCREAMING_SNAKE_CASE					)
          lowerCamelCase_         =						self.tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE       ,						**__SCREAMING_SNAKE_CASE					)

          lowerCamelCase_         =						tempfile.mkdtemp()

          lowerCamelCase_         =						tokenizer_r.save_pretrained(__SCREAMING_SNAKE_CASE					)
          lowerCamelCase_         =						tokenizer_p.save_pretrained(__SCREAMING_SNAKE_CASE					)

          # Checks it save with the same files + the tokenizer.json file for the fast one
          self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files					)					)
          lowerCamelCase_         =						tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f					)
          self.assertSequenceEqual(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					)

          # Checks everything loads correctly in the same way
          lowerCamelCase_         =						tokenizer_r.from_pretrained(__SCREAMING_SNAKE_CASE					)
          lowerCamelCase_         =						tokenizer_p.from_pretrained(__SCREAMING_SNAKE_CASE					)

          # Check special tokens are set accordingly on Rust and Python
          for key in tokenizer_pp.special_tokens_map:
            self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					)					)
            # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
            # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

          shutil.rmtree(__SCREAMING_SNAKE_CASE					)

          # Save tokenizer rust, legacy_format=True
          lowerCamelCase_         =						tempfile.mkdtemp()

          lowerCamelCase_         =						tokenizer_r.save_pretrained(__SCREAMING_SNAKE_CASE       ,						legacy_format=__SCREAMING_SNAKE_CASE					)
          lowerCamelCase_         =						tokenizer_p.save_pretrained(__SCREAMING_SNAKE_CASE					)

          # Checks it save with the same files
          self.assertSequenceEqual(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					)

          # Checks everything loads correctly in the same way
          lowerCamelCase_         =						tokenizer_r.from_pretrained(__SCREAMING_SNAKE_CASE					)
          lowerCamelCase_         =						tokenizer_p.from_pretrained(__SCREAMING_SNAKE_CASE					)

          # Check special tokens are set accordingly on Rust and Python
          for key in tokenizer_pp.special_tokens_map:
            self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					)					)

          shutil.rmtree(__SCREAMING_SNAKE_CASE					)

          # Save tokenizer rust, legacy_format=False
          lowerCamelCase_         =						tempfile.mkdtemp()

          lowerCamelCase_         =						tokenizer_r.save_pretrained(__SCREAMING_SNAKE_CASE       ,						legacy_format=__SCREAMING_SNAKE_CASE					)
          lowerCamelCase_         =						tokenizer_p.save_pretrained(__SCREAMING_SNAKE_CASE					)

          # Checks it saved the tokenizer.json file
          self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files					)					)

          # Checks everything loads correctly in the same way
          lowerCamelCase_         =						tokenizer_r.from_pretrained(__SCREAMING_SNAKE_CASE					)
          lowerCamelCase_         =						tokenizer_p.from_pretrained(__SCREAMING_SNAKE_CASE					)

          # Check special tokens are set accordingly on Rust and Python
          for key in tokenizer_pp.special_tokens_map:
            self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					)					)

          shutil.rmtree(__SCREAMING_SNAKE_CASE					)






@require_torch
@require_sentencepiece
@require_tokenizers
class      a						(					unittest.TestCase		):
    SCREAMING_SNAKE_CASE						:     Optional[int]						= """facebook/mbart-large-50-one-to-many-mmt"""
    SCREAMING_SNAKE_CASE						:     Optional[Any]						= [
        """ UN Chief Says There Is No Military Solution in Syria""",
        """ Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.""",
    ]
    SCREAMING_SNAKE_CASE						:     List[str]						= [
        """Şeful ONU declară că nu există o soluţie militară în Siria""",
        """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"""
        """ pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"""
        """ face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""",
    ]
    SCREAMING_SNAKE_CASE						:     List[str]						= [EN_CODE, 8_2_7_4, 1_2_7_8_7_3, 2_5_9_1_6, 7, 8_6_2_2, 2_0_7_1, 4_3_8, 6_7_4_8_5, 5_3, 1_8_7_8_9_5, 2_3, 5_1_7_1_2, 2]






    @classmethod
    def    UpperCamelCase       (       cls     :							Any					)     ->		Dict:
      lowerCamelCase_         =						MBartaaTokenizer.from_pretrained(
          cls.checkpoint_name       ,						src_lang='en_XX'       ,						tgt_lang='ro_RO'					)
      lowerCamelCase_         =						1
      return cls






    def    UpperCamelCase       (       self     :							Optional[Any]					)     ->		List[Any]:
      self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ar_AR']       ,						250001					)
      self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['en_EN']       ,						250004					)
      self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ro_RO']       ,						250020					)
      self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['mr_IN']       ,						250038					)






    def    UpperCamelCase       (       self     :							str					)     ->		Optional[Any]:
      lowerCamelCase_         =						self.tokenizer.batch_encode_plus(self.src_text					).input_ids[0]
      self.assertListEqual(self.expected_src_tokens       ,						__SCREAMING_SNAKE_CASE					)






    def    UpperCamelCase       (       self     :							Dict					)     ->		Optional[int]:
      self.assertIn(__SCREAMING_SNAKE_CASE       ,						self.tokenizer.all_special_ids					)
      lowerCamelCase_         =						[RO_CODE, 884, 9019, 96, 9, 916, 86792, 36, 18743, 15596, 5, 2]
      lowerCamelCase_         =						self.tokenizer.decode(__SCREAMING_SNAKE_CASE       ,						skip_special_tokens=__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						self.tokenizer.decode(generated_ids[1:]       ,						skip_special_tokens=__SCREAMING_SNAKE_CASE					)
      self.assertEqual(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					)
      self.assertNotIn(self.tokenizer.eos_token       ,						__SCREAMING_SNAKE_CASE					)






    def    UpperCamelCase       (       self     :							Tuple					)     ->		Union[str, Any]:
      lowerCamelCase_         =						['this is gunna be a long sentence ' * 20]
      assert isinstance(src_text[0]       ,						__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						10
      lowerCamelCase_         =						self.tokenizer(__SCREAMING_SNAKE_CASE       ,						max_length=__SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE					).input_ids[0]
      self.assertEqual(ids[0]       ,						__SCREAMING_SNAKE_CASE					)
      self.assertEqual(ids[-1]       ,						2					)
      self.assertEqual(len(__SCREAMING_SNAKE_CASE					)       ,						__SCREAMING_SNAKE_CASE					)






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		Any:
      self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR']					)       ,						[250053, 250001]					)






    def    UpperCamelCase       (       self     :							List[str]					)     ->		List[str]:
      lowerCamelCase_         =						tempfile.mkdtemp()
      lowerCamelCase_         =						self.tokenizer.fairseq_tokens_to_ids
      self.tokenizer.save_pretrained(__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						MBartaaTokenizer.from_pretrained(__SCREAMING_SNAKE_CASE					)
      self.assertDictEqual(new_tok.fairseq_tokens_to_ids       ,						__SCREAMING_SNAKE_CASE					)






    @require_torch
    def    UpperCamelCase       (       self     :							int					)     ->		Optional[int]:
      lowerCamelCase_         =						self.tokenizer(self.src_text       ,						text_target=self.tgt_text       ,						padding=__SCREAMING_SNAKE_CASE       ,						return_tensors='pt'					)
      lowerCamelCase_         =						shift_tokens_right(batch['labels']       ,						self.tokenizer.pad_token_id					)

      # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
      assert batch.input_ids[1][0] == EN_CODE
      assert batch.input_ids[1][-1] == 2
      assert batch.labels[1][0] == RO_CODE
      assert batch.labels[1][-1] == 2
      assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE]






    @require_torch
    def    UpperCamelCase       (       self     :							Optional[Any]					)     ->		List[Any]:
      lowerCamelCase_         =						self.tokenizer(
          self.src_text       ,						text_target=self.tgt_text       ,						padding=__SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						max_length=len(self.expected_src_tokens					)       ,						return_tensors='pt'       ,						)
      lowerCamelCase_         =						shift_tokens_right(batch['labels']       ,						self.tokenizer.pad_token_id					)

      self.assertIsInstance(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					)

      self.assertEqual((2, 14)       ,						batch.input_ids.shape					)
      self.assertEqual((2, 14)       ,						batch.attention_mask.shape					)
      lowerCamelCase_         =						batch.input_ids.tolist()[0]
      self.assertListEqual(self.expected_src_tokens       ,						__SCREAMING_SNAKE_CASE					)
      self.assertEqual(2       ,						batch.decoder_input_ids[0, 0]					)  # decoder_start_token_id
      # Test that special tokens are reset
      self.assertEqual(self.tokenizer.prefix_tokens       ,						[EN_CODE]					)
      self.assertEqual(self.tokenizer.suffix_tokens       ,						[self.tokenizer.eos_token_id]					)






    def    UpperCamelCase       (       self     :							str					)     ->		Optional[Any]:
      lowerCamelCase_         =						self.tokenizer(self.src_text       ,						padding=__SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						max_length=3       ,						return_tensors='pt'					)
      lowerCamelCase_         =						self.tokenizer(
          text_target=self.tgt_text       ,						padding=__SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						max_length=10       ,						return_tensors='pt'					)
      lowerCamelCase_         =						targets['input_ids']
      lowerCamelCase_         =						shift_tokens_right(__SCREAMING_SNAKE_CASE       ,						self.tokenizer.pad_token_id					)

      self.assertEqual(batch.input_ids.shape[1]       ,						3					)
      self.assertEqual(batch.decoder_input_ids.shape[1]       ,						10					)






    @require_torch
    def    UpperCamelCase       (       self     :							Tuple					)     ->		Optional[int]:
      lowerCamelCase_         =						self.tokenizer._build_translation_inputs(
          'A test'       ,						return_tensors='pt'       ,						src_lang='en_XX'       ,						tgt_lang='ar_AR'					)

      self.assertEqual(
          nested_simplify(__SCREAMING_SNAKE_CASE					)       ,						{
              # en_XX, A, test, EOS
              'input_ids': [[250004, 62, 3034, 2]],
              'attention_mask': [[1, 1, 1, 1]],
              # ar_AR
              'forced_bos_token_id': 250001,
          }       ,						)












"""simple docstring"""





import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


_SCREAMING_SNAKE_CASE					:				Optional[int]					    =						'''
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  ,      __snake_case		):






    def    UpperCamelCase       (       self     :							int					)     ->		Optional[int]:
      lowerCamelCase_         =						load_tool('text-question-answering'					)
      self.tool.setup()
      lowerCamelCase_         =						load_tool('text-question-answering'       ,						remote=__SCREAMING_SNAKE_CASE					)






    def    UpperCamelCase       (       self     :							Dict					)     ->		Tuple:
      lowerCamelCase_         =						self.tool(__SCREAMING_SNAKE_CASE       ,						'What did Hugging Face do in April 2021?'					)
      self.assertEqual(__SCREAMING_SNAKE_CASE       ,						'launched the BigScience Research Workshop'					)






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		Optional[int]:
      lowerCamelCase_         =						self.remote_tool(__SCREAMING_SNAKE_CASE       ,						'What did Hugging Face do in April 2021?'					)
      self.assertEqual(__SCREAMING_SNAKE_CASE       ,						'launched the BigScience Research Workshop'					)






    def    UpperCamelCase       (       self     :							List[str]					)     ->		Optional[int]:
      lowerCamelCase_         =						self.tool(text=__SCREAMING_SNAKE_CASE       ,						question='What did Hugging Face do in April 2021?'					)
      self.assertEqual(__SCREAMING_SNAKE_CASE       ,						'launched the BigScience Research Workshop'					)






    def    UpperCamelCase       (       self     :							Union[str, Any]					)     ->		int:
      lowerCamelCase_         =						self.remote_tool(text=__SCREAMING_SNAKE_CASE       ,						question='What did Hugging Face do in April 2021?'					)
      self.assertEqual(__SCREAMING_SNAKE_CASE       ,						'launched the BigScience Research Workshop'					)




