






'''simple docstring'''

import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


UpperCamelCase      					=get_tests_dir("fixtures/test_sentencepiece.model")


if is_torch_available():
      from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

UpperCamelCase      					=25_6047
UpperCamelCase      					=25_6145




@require_sentencepiece
@require_tokenizers
class      A     (   UpperCAmelCase_, unittest.TestCase    ):






 """simple docstring"""





 __a      :    int			  =    NllbTokenizer
 __a      :    Optional[int]			  =    NllbTokenizerFast
 __a      :    Optional[int]			  =    True
 __a      :    Tuple			  =    True
 __a      :    Optional[int]			  =    {}
 def 	_UpperCAmelCase							(				self			):
       super().setUp()

       # We have a SentencePiece fixture for testing
       UpperCamelCase_					: Optional[int]            =				NllbTokenizer(_snake_case      ,  keep_accents=_snake_case			)
       tokenizer.save_pretrained(self.tmpdirname			)
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Any            =				NllbTokenizer(_snake_case      ,  keep_accents=_snake_case			)

       UpperCamelCase_					: Dict            =				tokenizer.tokenize("""This is a test"""			)
       self.assertListEqual(_snake_case      ,  ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]			)

       self.assertListEqual(
           tokenizer.convert_tokens_to_ids(_snake_case			)      ,  [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]]      ,  )

       UpperCamelCase_					: int            =				tokenizer.tokenize("""I was born in 92000, and this is falsé."""			)
       self.assertListEqual(
           _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""",
               """é""",
               """.""",
           ]      ,  )
       UpperCamelCase_					: str            =				tokenizer.convert_tokens_to_ids(_snake_case			)
       self.assertListEqual(
           _snake_case      ,  [
               value + tokenizer.fairseq_offset
               for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4]
           ]      ,  )

       UpperCamelCase_					: Tuple            =				tokenizer.convert_ids_to_tokens(_snake_case			)
       self.assertListEqual(
           _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>""",
               """.""",
           ]      ,  )
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Union[str, Any]            =				(self.rust_tokenizer_class, """hf-internal-testing/tiny-random-nllb""", {})
       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"			):
                   UpperCamelCase_					: str            =				self.rust_tokenizer_class.from_pretrained(_snake_case      ,  **_snake_case			)
                   UpperCamelCase_					: str            =				self.tokenizer_class.from_pretrained(_snake_case      ,  **_snake_case			)

                   UpperCamelCase_					: List[str]            =				tempfile.mkdtemp()

                   UpperCamelCase_					: List[Any]            =				tokenizer_r.save_pretrained(_snake_case			)
                   UpperCamelCase_					: Union[str, Any]            =				tokenizer_p.save_pretrained(_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			)			)
                   UpperCamelCase_					: Optional[Any]            =				tuple(f for f in tokenizer_r_files if """tokenizer.json""" not in f			)
                   self.assertSequenceEqual(_snake_case      ,  _snake_case			)

                   # Checks everything loads correctly in the same way
                   UpperCamelCase_					: Optional[int]            =				tokenizer_r.from_pretrained(_snake_case			)
                   UpperCamelCase_					: Optional[int]            =				tokenizer_p.from_pretrained(_snake_case			)

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

                   shutil.rmtree(_snake_case			)

                   # Save tokenizer rust, legacy_format=True
                   UpperCamelCase_					: int            =				tempfile.mkdtemp()

                   UpperCamelCase_					: Tuple            =				tokenizer_r.save_pretrained(_snake_case      ,  legacy_format=_snake_case			)
                   UpperCamelCase_					: Optional[Any]            =				tokenizer_p.save_pretrained(_snake_case			)

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

                   # Checks everything loads correctly in the same way
                   UpperCamelCase_					: Optional[int]            =				tokenizer_r.from_pretrained(_snake_case			)
                   UpperCamelCase_					: List[Any]            =				tokenizer_p.from_pretrained(_snake_case			)

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

                   shutil.rmtree(_snake_case			)

                   # Save tokenizer rust, legacy_format=False
                   UpperCamelCase_					: Dict            =				tempfile.mkdtemp()

                   UpperCamelCase_					: List[Any]            =				tokenizer_r.save_pretrained(_snake_case      ,  legacy_format=_snake_case			)
                   UpperCamelCase_					: Any            =				tokenizer_p.save_pretrained(_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
                   UpperCamelCase_					: str            =				tokenizer_r.from_pretrained(_snake_case			)
                   UpperCamelCase_					: str            =				tokenizer_p.from_pretrained(_snake_case			)

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

                   shutil.rmtree(_snake_case			)
 @require_torch
 def 	_UpperCAmelCase							(				self			):


       if not self.test_seqaseq:
             return

       UpperCamelCase_					: int            =				self.get_tokenizers()
       for tokenizer in tokenizers:
             with self.subTest(F"{tokenizer.__class__.__name__}"			):
                   # Longer text that will definitely require truncation.
                   UpperCamelCase_					: Tuple            =				[
                       """ 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.""",
                   ]
                   UpperCamelCase_					: Dict            =				[
                       """Ş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.""",
                   ]
                   try:
                         UpperCamelCase_					: Union[str, Any]            =				tokenizer.prepare_seqaseq_batch(
                             src_texts=_snake_case      ,  tgt_texts=_snake_case      ,  max_length=3      ,  max_target_length=10      ,  return_tensors="""pt"""      ,  src_lang="""eng_Latn"""      ,  tgt_lang="""ron_Latn"""      ,  )
                   except NotImplementedError:
                         return
                   self.assertEqual(batch.input_ids.shape[1]      ,  3			)
                   self.assertEqual(batch.labels.shape[1]      ,  10			)
                   # max_target_length will default to max_length if not specified
                   UpperCamelCase_					: Dict            =				tokenizer.prepare_seqaseq_batch(
                       _snake_case      ,  tgt_texts=_snake_case      ,  max_length=3      ,  return_tensors="""pt"""			)
                   self.assertEqual(batch.input_ids.shape[1]      ,  3			)
                   self.assertEqual(batch.labels.shape[1]      ,  3			)

                   UpperCamelCase_					: List[str]            =				tokenizer.prepare_seqaseq_batch(
                       src_texts=_snake_case      ,  max_length=3      ,  max_target_length=10      ,  return_tensors="""pt"""			)
                   self.assertEqual(batch_encoder_only.input_ids.shape[1]      ,  3			)
                   self.assertEqual(batch_encoder_only.attention_mask.shape[1]      ,  3			)
                   self.assertNotIn("""decoder_input_ids"""      ,  _snake_case			)
 @unittest.skip("""Unfortunately way too slow to build a BPE with SentencePiece."""			)
 def 	_UpperCAmelCase							(				self			):
       pass





 def 	_UpperCAmelCase							(				self			):


       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"			):
                   UpperCamelCase_					: Tuple            =				[AddedToken("""<special>"""      ,  lstrip=_snake_case			)]

                   UpperCamelCase_					: str            =				self.rust_tokenizer_class.from_pretrained(
                       _snake_case      ,  additional_special_tokens=_snake_case      ,  **_snake_case			)
                   UpperCamelCase_					: Optional[int]            =				tokenizer_r.encode("""Hey this is a <special> token"""			)

                   UpperCamelCase_					: List[str]            =				tokenizer_r.encode("""<special>"""      ,  add_special_tokens=_snake_case			)[0]

                   self.assertTrue(special_token_id in r_output			)

                   if self.test_slow_tokenizer:
                         UpperCamelCase_					: Dict            =				self.rust_tokenizer_class.from_pretrained(
                             _snake_case      ,  additional_special_tokens=_snake_case      ,  **_snake_case      ,  )
                         UpperCamelCase_					: Optional[int]            =				self.tokenizer_class.from_pretrained(
                             _snake_case      ,  additional_special_tokens=_snake_case      ,  **_snake_case			)

                         UpperCamelCase_					: Tuple            =				tokenizer_p.encode("""Hey this is a <special> token"""			)

                         UpperCamelCase_					: Any            =				tokenizer_cr.encode("""Hey this is a <special> token"""			)

                         self.assertEqual(_snake_case      ,  _snake_case			)
                         self.assertEqual(_snake_case      ,  _snake_case			)
                         self.assertTrue(special_token_id in p_output			)
                         self.assertTrue(special_token_id in cr_output			)






@require_torch
@require_sentencepiece
@require_tokenizers
class      A     (   unittest.TestCase    ):






 """simple docstring"""





 __a      :    int			  =    "facebook/nllb-200-distilled-600M"
 __a      :    List[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.",
 ]
 __a      :    Dict			  =    [
     "Ş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.",
 ]
 __a      :    List[Any]			  =    [
     25_6047,
     1_6297,
     13_4408,
     8165,
     24_8066,
     1_4734,
     950,
     1135,
     10_5721,
     3573,
     83,
     2_7352,
     108,
     4_9486,
     2,
 ]
 @classmethod
 def 	_UpperCAmelCase							(				cls			):
       UpperCamelCase_					: List[Any]            =				NllbTokenizer.from_pretrained(
           cls.checkpoint_name      ,  src_lang="""eng_Latn"""      ,  tgt_lang="""ron_Latn"""			)
       UpperCamelCase_					: Tuple            =				1
       return cls
 def 	_UpperCAmelCase							(				self			):
       self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Arab"""]      ,  25_60_01			)
       self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Latn"""]      ,  25_60_02			)
       self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""fra_Latn"""]      ,  25_60_57			)
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: List[str]            =				self.tokenizer.batch_encode_plus(self.src_text			).input_ids[0]
       self.assertListEqual(self.expected_src_tokens      ,  _snake_case			)
 def 	_UpperCAmelCase							(				self			):
       self.assertIn(_snake_case      ,  self.tokenizer.all_special_ids			)
       # fmt: off
       UpperCamelCase_					: Tuple            =				[RO_CODE, 42_54, 9_80_68, 11_29_23, 3_90_72, 39_09, 7_13, 10_27_67, 26, 1_73_14, 3_56_42, 1_46_83, 3_31_18, 20_22, 6_69_87, 2, 25_60_47]
       # fmt: on

       UpperCamelCase_					: Optional[Any]            =				self.tokenizer.decode(_snake_case      ,  skip_special_tokens=_snake_case			)
       UpperCamelCase_					: str            =				self.tokenizer.decode(generated_ids[1:]      ,  skip_special_tokens=_snake_case			)
       self.assertEqual(_snake_case      ,  _snake_case			)
       self.assertNotIn(self.tokenizer.eos_token      ,  _snake_case			)
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: List[Any]            =				["""this is gunna be a long sentence """ * 20]
       assert isinstance(src_text[0]      ,  _snake_case			)
       UpperCamelCase_					: List[str]            =				10
       UpperCamelCase_					: Optional[Any]            =				self.tokenizer(_snake_case      ,  max_length=_snake_case      ,  truncation=_snake_case			).input_ids[0]
       self.assertEqual(ids[-1]      ,  2			)
       self.assertEqual(ids[0]      ,  _snake_case			)
       self.assertEqual(len(_snake_case			)      ,  _snake_case			)
 def 	_UpperCAmelCase							(				self			):
       self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """ar_AR"""]			)      ,  [25_62_03, 3]			)
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Dict            =				tempfile.mkdtemp()
       UpperCamelCase_					: Optional[int]            =				self.tokenizer.fairseq_tokens_to_ids
       self.tokenizer.save_pretrained(_snake_case			)
       UpperCamelCase_					: Optional[Any]            =				NllbTokenizer.from_pretrained(_snake_case			)
       self.assertDictEqual(new_tok.fairseq_tokens_to_ids      ,  _snake_case			)
 @require_torch
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: str            =				self.tokenizer(
           self.src_text      ,  text_target=self.tgt_text      ,  padding=_snake_case      ,  truncation=_snake_case      ,  max_length=len(self.expected_src_tokens			)      ,  return_tensors="""pt"""      ,  )
       UpperCamelCase_					: Optional[int]            =				shift_tokens_right(
           batch["""labels"""]      ,  self.tokenizer.pad_token_id      ,  self.tokenizer.lang_code_to_id["""ron_Latn"""]			)

       self.assertIsInstance(_snake_case      ,  _snake_case			)

       self.assertEqual((2, 15)      ,  batch.input_ids.shape			)
       self.assertEqual((2, 15)      ,  batch.attention_mask.shape			)
       UpperCamelCase_					: Dict            =				batch.input_ids.tolist()[0]
       self.assertListEqual(self.expected_src_tokens      ,  _snake_case			)
       self.assertEqual(_snake_case      ,  batch.decoder_input_ids[0, 0]			)  # EOS
       # 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			):
       UpperCamelCase_					: Dict            =				self.tokenizer(self.src_text      ,  padding=_snake_case      ,  truncation=_snake_case      ,  max_length=3      ,  return_tensors="""pt"""			)
       UpperCamelCase_					: Tuple            =				self.tokenizer(
           text_target=self.tgt_text      ,  padding=_snake_case      ,  truncation=_snake_case      ,  max_length=10      ,  return_tensors="""pt"""			)
       UpperCamelCase_					: Any            =				targets["""input_ids"""]
       UpperCamelCase_					: List[str]            =				shift_tokens_right(
           _snake_case      ,  self.tokenizer.pad_token_id      ,  decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]      ,  )

       self.assertEqual(batch.input_ids.shape[1]      ,  3			)
       self.assertEqual(batch.decoder_input_ids.shape[1]      ,  10			)
 @require_torch
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Any            =				self.tokenizer._build_translation_inputs(
           """A test"""      ,  return_tensors="""pt"""      ,  src_lang="""eng_Latn"""      ,  tgt_lang="""fra_Latn"""			)

       self.assertEqual(
           nested_simplify(_snake_case			)      ,  {
               # A, test, EOS, en_XX
               """input_ids""": [[25_60_47, 70, 73_56, 2]],
               """attention_mask""": [[1, 1, 1, 1]],
               # ar_AR
               """forced_bos_token_id""": 25_60_57,
           }      ,  )





 @require_torch
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: int            =				True
       UpperCamelCase_					: Optional[Any]            =				self.tokenizer(
           """UN Chief says there is no military solution in Syria"""      ,  src_lang="""eng_Latn"""      ,  tgt_lang="""fra_Latn"""			)
       self.assertEqual(
           inputs.input_ids      ,  [1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2, 25_60_47]			)

       UpperCamelCase_					: str            =				False
       UpperCamelCase_					: Tuple            =				self.tokenizer(
           """UN Chief says there is no military solution in Syria"""      ,  src_lang="""eng_Latn"""      ,  tgt_lang="""fra_Latn"""			)
       self.assertEqual(
           inputs.input_ids      ,  [25_60_47, 1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2]			)











import unittest

from transformers import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING, is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
							from PIL import Image
else:


							class   __lowerCAmelCase  :
												"""simple docstring"""






												@staticmethod
												def      _a				(  *_snake_case       :							Any					,       **_snake_case       :							Optional[int]       ):






															"""simple docstring"""


															pass


@is_pipeline_test
@require_torch
@require_vision
class   __lowerCAmelCase  (		unittest.TestCase   ):
					"""simple docstring"""






					A__					:		Union[str, Any]      							=     MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING



					def      _a				(  self       :							List[Any]					,       _snake_case       :							Union[str, Any]					,       _snake_case       :							Tuple					,       _snake_case       :							Union[str, Any]       ):






								"""simple docstring"""


								A__	  =     pipeline('visual-question-answering'					,       model='hf-internal-testing/tiny-vilt-random-vqa'       )
								A__	  =     [
								    {
								        'image': Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'       ),
								        'question': 'How many cats are there?',
								    },
								    {
								        'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
								        'question': 'How many cats are there?',
								    },
								]
								return vqa_pipeline, examples



					def      _a				(  self       :							Optional[Any]					,       _snake_case       :							Union[str, Any]					,       _snake_case       :							List[str]       ):






								"""simple docstring"""


								A__	  =     vqa_pipeline(_snake_case					,       top_k=1       )
								self.assertEqual(
								    _snake_case					,       [
								        [{'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}],
								        [{'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}],
								    ]					,       )



					@require_torch
					def      _a				(  self       :							Any       ):






								"""simple docstring"""


								A__	  =     pipeline('visual-question-answering'					,       model='hf-internal-testing/tiny-vilt-random-vqa'       )
								A__	  =     './tests/fixtures/tests_samples/COCO/000000039769.png'
								A__	  =     'How many cats are there?'

								A__	  =     vqa_pipeline(image=_snake_case					,       question='How many cats are there?'					,       top_k=2       )
								self.assertEqual(
								    _snake_case					,       [{'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}, {'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}]       )

								A__	  =     vqa_pipeline({'image': image, 'question': question}					,       top_k=2       )
								self.assertEqual(
								    _snake_case					,       [{'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}, {'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}]       )



					@slow
					@require_torch
					def      _a				(  self       :							Any       ):






								"""simple docstring"""


								A__	  =     pipeline('visual-question-answering'					,       model='dandelin/vilt-b32-finetuned-vqa'       )
								A__	  =     './tests/fixtures/tests_samples/COCO/000000039769.png'
								A__	  =     'How many cats are there?'

								A__	  =     vqa_pipeline(image=_snake_case					,       question=_snake_case					,       top_k=2       )
								self.assertEqual(
								    nested_simplify(_snake_case					,       decimals=4       )					,       [{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]       )

								A__	  =     vqa_pipeline({'image': image, 'question': question}					,       top_k=2       )
								self.assertEqual(
								    nested_simplify(_snake_case					,       decimals=4       )					,       [{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]       )

								A__	  =     vqa_pipeline(
								    [{'image': image, 'question': question}, {'image': image, 'question': question}]					,       top_k=2       )
								self.assertEqual(
								    nested_simplify(_snake_case					,       decimals=4       )					,       [[{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]] * 2					,       )



					@require_tf
					@unittest.skip('Visual question answering not implemented in TF'       )
					def      _a				(  self       :							Dict       ):






								"""simple docstring"""


								pass




