





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


_UpperCAmelCase        =				get_tests_dir('fixtures/test_sentencepiece.model')

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

_UpperCAmelCase        =				2_5_0_0_0_4
_UpperCAmelCase        =				2_5_0_0_2_0



@require_sentencepiece
@require_tokenizers
class 							_UpperCamelCase					(	lowerCAmelCase_  ,						unittest.TestCase     ):
       _UpperCamelCase				:					List[Any]         =   MBartaaTokenizer
       _UpperCamelCase				:					Optional[int]         =   MBartaaTokenizerFast
       _UpperCamelCase				:					Tuple         =   True
       _UpperCamelCase				:					Optional[Any]         =   True

       def lowercase (		self: Dict		)       -> Any:




              """simple docstring"""


              super().setUp()

              # We have a SentencePiece fixture for testing
              UpperCamelCase_          =  MBartaaTokenizer(_SCREAMING_SNAKE_CASE					,   src_lang="en_XX"					,   tgt_lang="ro_RO"					,   keep_accents=_SCREAMING_SNAKE_CASE		)
              tokenizer.save_pretrained(self.tmpdirname		)

       def lowercase (		self: str		)       -> Tuple:




              """simple docstring"""


              UpperCamelCase_          =  "<s>"
              UpperCamelCase_          =  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 lowercase (		self: Dict		)       -> Dict:




              """simple docstring"""


              UpperCamelCase_          =  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 lowercase (		self: str		)       -> Any:




              """simple docstring"""


              self.assertEqual(self.get_tokenizer().vocab_size					,   1054		)

       def lowercase (		self: str		)       -> Any:




              """simple docstring"""


              UpperCamelCase_          =  MBartaaTokenizer(_SCREAMING_SNAKE_CASE					,   src_lang="en_XX"					,   tgt_lang="ro_RO"					,   keep_accents=_SCREAMING_SNAKE_CASE		)

              UpperCamelCase_          =  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]]					,   )

              UpperCamelCase_          =  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", "é", "."]					,   )
              UpperCamelCase_          =  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]
                  ]					,   )

              UpperCamelCase_          =  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 lowercase (		self: Optional[int]		)       -> Dict:




              """simple docstring"""


              UpperCamelCase_          =  {"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 lowercase (		self: Optional[int]		)       -> Tuple:




              """simple docstring"""


              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

              UpperCamelCase_          =  (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})'''		):
                            UpperCamelCase_          =  self.rust_tokenizer_class.from_pretrained(_SCREAMING_SNAKE_CASE					,   **_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  self.tokenizer_class.from_pretrained(_SCREAMING_SNAKE_CASE					,   **_SCREAMING_SNAKE_CASE		)

                            UpperCamelCase_          =  tempfile.mkdtemp()

                            UpperCamelCase_          =  tokenizer_r.save_pretrained(_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  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		)		)
                            UpperCamelCase_          =  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
                            UpperCamelCase_          =  tokenizer_r.from_pretrained(_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  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
                            UpperCamelCase_          =  tempfile.mkdtemp()

                            UpperCamelCase_          =  tokenizer_r.save_pretrained(_SCREAMING_SNAKE_CASE					,   legacy_format=_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  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
                            UpperCamelCase_          =  tokenizer_r.from_pretrained(_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  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
                            UpperCamelCase_          =  tempfile.mkdtemp()

                            UpperCamelCase_          =  tokenizer_r.save_pretrained(_SCREAMING_SNAKE_CASE					,   legacy_format=_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  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
                            UpperCamelCase_          =  tokenizer_r.from_pretrained(_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  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 							_UpperCamelCase					(	unittest.TestCase     ):
       _UpperCamelCase				:					Dict         =   '''facebook/mbart-large-50-one-to-many-mmt'''
       _UpperCamelCase				:					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.''',
       ]
       _UpperCamelCase				:					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.''',
       ]
       _UpperCamelCase				:					Union[str, Any]         =   [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 lowercase (		cls: Union[str, Any]		)       -> List[str]:




              """simple docstring"""


              UpperCamelCase_          =  MBartaaTokenizer.from_pretrained(
                  cls.checkpoint_name					,   src_lang="en_XX"					,   tgt_lang="ro_RO"		)
              UpperCamelCase_          =  1
              return cls

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




              """simple docstring"""


              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 lowercase (		self: List[Any]		)       -> str:




              """simple docstring"""


              UpperCamelCase_          =  self.tokenizer.batch_encode_plus(self.src_text		).input_ids[0]
              self.assertListEqual(self.expected_src_tokens					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: int		)       -> Tuple:




              """simple docstring"""


              self.assertIn(_SCREAMING_SNAKE_CASE					,   self.tokenizer.all_special_ids		)
              UpperCamelCase_          =  [RO_CODE, 884, 9019, 96, 9, 916, 86792, 36, 18743, 15596, 5, 2]
              UpperCamelCase_          =  self.tokenizer.decode(_SCREAMING_SNAKE_CASE					,   skip_special_tokens=_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  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 lowercase (		self: Any		)       -> Union[str, Any]:




              """simple docstring"""


              UpperCamelCase_          =  ["this is gunna be a long sentence " * 20]
              assert isinstance(src_text[0]					,   _SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  10
              UpperCamelCase_          =  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 lowercase (		self: Any		)       -> List[Any]:




              """simple docstring"""


              self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "ar_AR"]		)					,   [250053, 250001]		)

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




              """simple docstring"""


              UpperCamelCase_          =  tempfile.mkdtemp()
              UpperCamelCase_          =  self.tokenizer.fairseq_tokens_to_ids
              self.tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  MBartaaTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE		)
              self.assertDictEqual(new_tok.fairseq_tokens_to_ids					,   _SCREAMING_SNAKE_CASE		)

       @require_torch
       def lowercase (		self: Dict		)       -> str:




              """simple docstring"""


              UpperCamelCase_          =  self.tokenizer(self.src_text					,   text_target=self.tgt_text					,   padding=_SCREAMING_SNAKE_CASE					,   return_tensors="pt"		)
              UpperCamelCase_          =  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 lowercase (		self: Any		)       -> Tuple:




              """simple docstring"""


              UpperCamelCase_          =  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"					,   )
              UpperCamelCase_          =  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		)
              UpperCamelCase_          =  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 lowercase (		self: List[str]		)       -> str:




              """simple docstring"""


              UpperCamelCase_          =  self.tokenizer(self.src_text					,   padding=_SCREAMING_SNAKE_CASE					,   truncation=_SCREAMING_SNAKE_CASE					,   max_length=3					,   return_tensors="pt"		)
              UpperCamelCase_          =  self.tokenizer(
                  text_target=self.tgt_text					,   padding=_SCREAMING_SNAKE_CASE					,   truncation=_SCREAMING_SNAKE_CASE					,   max_length=10					,   return_tensors="pt"		)
              UpperCamelCase_          =  targets["input_ids"]
              UpperCamelCase_          =  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 lowercase (		self: Optional[Any]		)       -> Tuple:




              """simple docstring"""


              UpperCamelCase_          =  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,
                  }					,   )








import unittest

from transformers import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING, is_vision_available, 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 							_UpperCamelCase					:

            @staticmethod
            def lowercase (		*_SCREAMING_SNAKE_CASE: Optional[int]					,   **_SCREAMING_SNAKE_CASE: Dict		)       -> Union[str, Any]:




                   """simple docstring"""


                   pass



@is_pipeline_test
@require_vision
@require_torch
class 							_UpperCamelCase					(	unittest.TestCase     ):
       _UpperCamelCase				:					str         =   MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING

       def lowercase (		self: int					,   _SCREAMING_SNAKE_CASE: str					,   _SCREAMING_SNAKE_CASE: int					,   _SCREAMING_SNAKE_CASE: Optional[Any]		)       -> Any:




              """simple docstring"""


              UpperCamelCase_          =  pipeline(
                  "zero-shot-object-detection"					,   model="hf-internal-testing/tiny-random-owlvit-object-detection"		)

              UpperCamelCase_          =  [
                  {
                      "image": "./tests/fixtures/tests_samples/COCO/000000039769.png",
                      "candidate_labels": ["cat", "remote", "couch"],
                  }
              ]
              return object_detector, examples

       def lowercase (		self: Optional[Any]					,   _SCREAMING_SNAKE_CASE: Tuple					,   _SCREAMING_SNAKE_CASE: Tuple		)       -> Optional[int]:




              """simple docstring"""


              UpperCamelCase_          =  object_detector(examples[0]					,   threshold=0.0		)

              UpperCamelCase_          =  len(_SCREAMING_SNAKE_CASE		)
              self.assertGreater(_SCREAMING_SNAKE_CASE					,   0		)
              self.assertEqual(
                  _SCREAMING_SNAKE_CASE					,   [
                      {
                          "score": ANY(_SCREAMING_SNAKE_CASE		),
                          "label": ANY(_SCREAMING_SNAKE_CASE		),
                          "box": {"xmin": ANY(_SCREAMING_SNAKE_CASE		), "ymin": ANY(_SCREAMING_SNAKE_CASE		), "xmax": ANY(_SCREAMING_SNAKE_CASE		), "ymax": ANY(_SCREAMING_SNAKE_CASE		)},
                      }
                      for i in range(_SCREAMING_SNAKE_CASE		)
                  ]					,   )

       @require_tf
       @unittest.skip("Zero Shot Object Detection not implemented in TF"		)
       def lowercase (		self: Tuple		)       -> List[str]:




              """simple docstring"""


              pass

       @require_torch
       def lowercase (		self: Union[str, Any]		)       -> str:




              """simple docstring"""


              UpperCamelCase_          =  pipeline(
                  "zero-shot-object-detection"					,   model="hf-internal-testing/tiny-random-owlvit-object-detection"		)

              UpperCamelCase_          =  object_detector(
                  "./tests/fixtures/tests_samples/COCO/000000039769.png"					,   candidate_labels=["cat", "remote", "couch"]					,   threshold=0.64					,   )

              self.assertEqual(
                  nested_simplify(_SCREAMING_SNAKE_CASE					,   decimals=4		)					,   [
                      {"score": 0.72_35, "label": "cat", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                      {"score": 0.72_18, "label": "remote", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                      {"score": 0.71_84, "label": "couch", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                      {"score": 0.67_48, "label": "remote", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                      {"score": 0.66_56, "label": "cat", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                      {"score": 0.66_14, "label": "couch", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                      {"score": 0.64_56, "label": "remote", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
                      {"score": 0.6_42, "label": "remote", "box": {"xmin": 67, "ymin": 274, "xmax": 93, "ymax": 297}},
                      {"score": 0.64_19, "label": "cat", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
                  ]					,   )

              UpperCamelCase_          =  object_detector(
                  [
                      {
                          "image": "./tests/fixtures/tests_samples/COCO/000000039769.png",
                          "candidate_labels": ["cat", "remote", "couch"],
                      }
                  ]					,   threshold=0.64					,   )

              self.assertEqual(
                  nested_simplify(_SCREAMING_SNAKE_CASE					,   decimals=4		)					,   [
                      [
                          {"score": 0.72_35, "label": "cat", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                          {"score": 0.72_18, "label": "remote", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                          {"score": 0.71_84, "label": "couch", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                          {"score": 0.67_48, "label": "remote", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                          {"score": 0.66_56, "label": "cat", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                          {"score": 0.66_14, "label": "couch", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                          {"score": 0.64_56, "label": "remote", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
                          {"score": 0.6_42, "label": "remote", "box": {"xmin": 67, "ymin": 274, "xmax": 93, "ymax": 297}},
                          {"score": 0.64_19, "label": "cat", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
                      ]
                  ]					,   )

       @require_torch
       @slow
       def lowercase (		self: List[str]		)       -> List[str]:




              """simple docstring"""


              UpperCamelCase_          =  pipeline("zero-shot-object-detection"		)

              UpperCamelCase_          =  object_detector(
                  "http://images.cocodataset.org/val2017/000000039769.jpg"					,   candidate_labels=["cat", "remote", "couch"]					,   )
              self.assertEqual(
                  nested_simplify(_SCREAMING_SNAKE_CASE					,   decimals=4		)					,   [
                      {"score": 0.28_68, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                      {"score": 0.2_77, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                      {"score": 0.25_37, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                      {"score": 0.14_74, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                      {"score": 0.12_08, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
                  ]					,   )

              UpperCamelCase_          =  object_detector(
                  [
                      {
                          "image": "http://images.cocodataset.org/val2017/000000039769.jpg",
                          "candidate_labels": ["cat", "remote", "couch"],
                      },
                      {
                          "image": "http://images.cocodataset.org/val2017/000000039769.jpg",
                          "candidate_labels": ["cat", "remote", "couch"],
                      },
                  ]					,   )
              self.assertEqual(
                  nested_simplify(_SCREAMING_SNAKE_CASE					,   decimals=4		)					,   [
                      [
                          {"score": 0.28_68, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                          {"score": 0.2_77, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                          {"score": 0.25_37, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                          {"score": 0.14_74, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                          {"score": 0.12_08, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
                      ],
                      [
                          {"score": 0.28_68, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                          {"score": 0.2_77, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                          {"score": 0.25_37, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                          {"score": 0.14_74, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                          {"score": 0.12_08, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
                      ],
                  ]					,   )

       @require_tf
       @unittest.skip("Zero Shot Object Detection not implemented in TF"		)
       def lowercase (		self: List[Any]		)       -> str:




              """simple docstring"""


              pass

       @require_torch
       @slow
       def lowercase (		self: Any		)       -> int:




              """simple docstring"""


              UpperCamelCase_          =  0.2
              UpperCamelCase_          =  pipeline("zero-shot-object-detection"		)

              UpperCamelCase_          =  object_detector(
                  "http://images.cocodataset.org/val2017/000000039769.jpg"					,   candidate_labels=["cat", "remote", "couch"]					,   threshold=_SCREAMING_SNAKE_CASE					,   )
              self.assertEqual(
                  nested_simplify(_SCREAMING_SNAKE_CASE					,   decimals=4		)					,   [
                      {"score": 0.28_68, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                      {"score": 0.2_77, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                      {"score": 0.25_37, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                  ]					,   )



       @require_torch
       @slow
       def lowercase (		self: Dict		)       -> Tuple:




              """simple docstring"""


              UpperCamelCase_          =  2
              UpperCamelCase_          =  pipeline("zero-shot-object-detection"		)

              UpperCamelCase_          =  object_detector(
                  "http://images.cocodataset.org/val2017/000000039769.jpg"					,   candidate_labels=["cat", "remote", "couch"]					,   top_k=_SCREAMING_SNAKE_CASE					,   )
              self.assertEqual(
                  nested_simplify(_SCREAMING_SNAKE_CASE					,   decimals=4		)					,   [
                      {"score": 0.28_68, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                      {"score": 0.2_77, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                  ]					,   )

