



'''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__       :	List[str]    = get_tests_dir('''fixtures/test_sentencepiece.model''')


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

UpperCamelCase__       :	Dict    = 25_60_47
UpperCamelCase__       :	List[Any]    = 25_61_45






@require_sentencepiece
@require_tokenizers
class 						_UpperCamelCase  (							lowerCamelCase__    ,					unittest.TestCase    ):


			'''simple docstring'''

			_A      :		Any			    =		NllbTokenizer
			_A      :		List[str]			    =		NllbTokenizerFast
			_A      :		Optional[Any]			    =		True
			_A      :		List[str]			    =		True
			_A      :		Any			    =		{}

			def UpperCamelCase__					(							self     : int						):





					"""simple docstring"""






					super().setUp()

					# We have a SentencePiece fixture for testing
					__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		NllbTokenizer(lowerCAmelCase__							,     keep_accents=lowerCAmelCase__						)
					tokenizer.save_pretrained(self.tmpdirname						)

			def UpperCamelCase__					(							self     : List[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		NllbTokenizer(lowerCAmelCase__							,     keep_accents=lowerCAmelCase__						)

					__SCREAMING_SNAKE_CASE       :		Optional[int]           =		tokenizer.tokenize("""This is a test"""						)
					self.assertListEqual(lowerCAmelCase__							,     ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]						)

					self.assertListEqual(
					    tokenizer.convert_tokens_to_ids(lowerCAmelCase__						)							,     [value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]]							,     )

					__SCREAMING_SNAKE_CASE       :		List[str]           =		tokenizer.tokenize("""I was born in 92000, and this is falsé."""						)
					self.assertListEqual(
					    lowerCAmelCase__							,     [
					        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""",
					        """é""",
					        """.""",
					    ]							,     )
					__SCREAMING_SNAKE_CASE       :		List[Any]           =		tokenizer.convert_tokens_to_ids(lowerCAmelCase__						)
					self.assertListEqual(
					    lowerCAmelCase__							,     [
					        value + tokenizer.fairseq_offset
					        for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
					    ]							,     )

					__SCREAMING_SNAKE_CASE       :		Optional[int]           =		tokenizer.convert_ids_to_tokens(lowerCAmelCase__						)
					self.assertListEqual(
					    lowerCAmelCase__							,     [
					        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     : Dict						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		List[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})"						):
									__SCREAMING_SNAKE_CASE       :		List[str]           =		self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__							,     **lowerCAmelCase__						)
									__SCREAMING_SNAKE_CASE       :		Tuple           =		self.tokenizer_class.from_pretrained(lowerCAmelCase__							,     **lowerCAmelCase__						)

									__SCREAMING_SNAKE_CASE       :		List[Any]           =		tempfile.mkdtemp()

									__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		tokenizer_r.save_pretrained(lowerCAmelCase__						)
									__SCREAMING_SNAKE_CASE       :		Any           =		tokenizer_p.save_pretrained(lowerCAmelCase__						)

									# 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						)						)
									__SCREAMING_SNAKE_CASE       :		List[str]           =		tuple(f for f in tokenizer_r_files if """tokenizer.json""" not in f						)
									self.assertSequenceEqual(lowerCAmelCase__							,     lowerCAmelCase__						)

									# Checks everything loads correctly in the same way
									__SCREAMING_SNAKE_CASE       :		Dict           =		tokenizer_r.from_pretrained(lowerCAmelCase__						)
									__SCREAMING_SNAKE_CASE       :		List[Any]           =		tokenizer_p.from_pretrained(lowerCAmelCase__						)

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

									shutil.rmtree(lowerCAmelCase__						)

									# Save tokenizer rust, legacy_format=True
									__SCREAMING_SNAKE_CASE       :		Dict           =		tempfile.mkdtemp()

									__SCREAMING_SNAKE_CASE       :		str           =		tokenizer_r.save_pretrained(lowerCAmelCase__							,     legacy_format=lowerCAmelCase__						)
									__SCREAMING_SNAKE_CASE       :		str           =		tokenizer_p.save_pretrained(lowerCAmelCase__						)

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

									# Checks everything loads correctly in the same way
									__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		tokenizer_r.from_pretrained(lowerCAmelCase__						)
									__SCREAMING_SNAKE_CASE       :		Tuple           =		tokenizer_p.from_pretrained(lowerCAmelCase__						)

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

									shutil.rmtree(lowerCAmelCase__						)

									# Save tokenizer rust, legacy_format=False
									__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		tempfile.mkdtemp()

									__SCREAMING_SNAKE_CASE       :		List[str]           =		tokenizer_r.save_pretrained(lowerCAmelCase__							,     legacy_format=lowerCAmelCase__						)
									__SCREAMING_SNAKE_CASE       :		Tuple           =		tokenizer_p.save_pretrained(lowerCAmelCase__						)

									# 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
									__SCREAMING_SNAKE_CASE       :		List[Any]           =		tokenizer_r.from_pretrained(lowerCAmelCase__						)
									__SCREAMING_SNAKE_CASE       :		int           =		tokenizer_p.from_pretrained(lowerCAmelCase__						)

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

									shutil.rmtree(lowerCAmelCase__						)

			@require_torch
			def UpperCamelCase__					(							self     : Any						):





					"""simple docstring"""






					if not self.test_seqaseq:
							return

					__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		self.get_tokenizers()
					for tokenizer in tokenizers:
							with self.subTest(F"{tokenizer.__class__.__name__}"						):
									# Longer text that will definitely require truncation.
									__SCREAMING_SNAKE_CASE       :		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       :		Optional[Any]           =		[
									    """Ş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:
											__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		tokenizer.prepare_seqaseq_batch(
											    src_texts=lowerCAmelCase__							,     tgt_texts=lowerCAmelCase__							,     max_length=3							,     max_target_length=1_0							,     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]							,     1_0						)
									# max_target_length will default to max_length if not specified
									__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		tokenizer.prepare_seqaseq_batch(
									    lowerCAmelCase__							,     tgt_texts=lowerCAmelCase__							,     max_length=3							,     return_tensors="""pt"""						)
									self.assertEqual(batch.input_ids.shape[1]							,     3						)
									self.assertEqual(batch.labels.shape[1]							,     3						)

									__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		tokenizer.prepare_seqaseq_batch(
									    src_texts=lowerCAmelCase__							,     max_length=3							,     max_target_length=1_0							,     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"""							,     lowerCAmelCase__						)

			@unittest.skip("""Unfortunately way too slow to build a BPE with SentencePiece."""						)
			def UpperCamelCase__					(							self     : List[Any]						):





					"""simple docstring"""






					pass



			def UpperCamelCase__					(							self     : List[str]						):





					"""simple docstring"""






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

									__SCREAMING_SNAKE_CASE       :		List[Any]           =		self.rust_tokenizer_class.from_pretrained(
									    lowerCAmelCase__							,     additional_special_tokens=lowerCAmelCase__							,     **lowerCAmelCase__						)
									__SCREAMING_SNAKE_CASE       :		Tuple           =		tokenizer_r.encode("""Hey this is a <special> token"""						)

									__SCREAMING_SNAKE_CASE       :		Any           =		tokenizer_r.encode("""<special>"""							,     add_special_tokens=lowerCAmelCase__						)[0]

									self.assertTrue(special_token_id in r_output						)

									if self.test_slow_tokenizer:
											__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		self.rust_tokenizer_class.from_pretrained(
											    lowerCAmelCase__							,     additional_special_tokens=lowerCAmelCase__							,     **lowerCAmelCase__							,     )
											__SCREAMING_SNAKE_CASE       :		Dict           =		self.tokenizer_class.from_pretrained(
											    lowerCAmelCase__							,     additional_special_tokens=lowerCAmelCase__							,     **lowerCAmelCase__						)

											__SCREAMING_SNAKE_CASE       :		List[Any]           =		tokenizer_p.encode("""Hey this is a <special> token"""						)

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

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






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


			'''simple docstring'''

			_A      :		Optional[Any]			    =		'''facebook/nllb-200-distilled-600M'''
			_A      :		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      :		Optional[int]			    =		[
			    '''Ş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[str]			    =		[
			    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     : Union[str, Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		NllbTokenizer           =		NllbTokenizer.from_pretrained(
					    cls.checkpoint_name							,     src_lang="""eng_Latn"""							,     tgt_lang="""ron_Latn"""						)
					__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		1
					return cls

			def UpperCamelCase__					(							self     : Tuple						):





					"""simple docstring"""






					self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Arab"""]							,     2_5_6_0_0_1						)
					self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Latn"""]							,     2_5_6_0_0_2						)
					self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""fra_Latn"""]							,     2_5_6_0_5_7						)

			def UpperCamelCase__					(							self     : int						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		List[str]           =		self.tokenizer.batch_encode_plus(self.src_text						).input_ids[0]
					self.assertListEqual(self.expected_src_tokens							,     lowerCAmelCase__						)

			def UpperCamelCase__					(							self     : List[str]						):





					"""simple docstring"""






					self.assertIn(lowerCAmelCase__							,     self.tokenizer.all_special_ids						)
					# fmt: off
					__SCREAMING_SNAKE_CASE       :		List[str]           =		[RO_CODE, 4_2_5_4, 9_8_0_6_8, 1_1_2_9_2_3, 3_9_0_7_2, 3_9_0_9, 7_1_3, 1_0_2_7_6_7, 2_6, 1_7_3_1_4, 3_5_6_4_2, 1_4_6_8_3, 3_3_1_1_8, 2_0_2_2, 6_6_9_8_7, 2, 2_5_6_0_4_7]
					# fmt: on

					__SCREAMING_SNAKE_CASE       :		Tuple           =		self.tokenizer.decode(lowerCAmelCase__							,     skip_special_tokens=lowerCAmelCase__						)
					__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		self.tokenizer.decode(generated_ids[1:]							,     skip_special_tokens=lowerCAmelCase__						)
					self.assertEqual(lowerCAmelCase__							,     lowerCAmelCase__						)
					self.assertNotIn(self.tokenizer.eos_token							,     lowerCAmelCase__						)

			def UpperCamelCase__					(							self     : Optional[int]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		str           =		["""this is gunna be a long sentence """ * 2_0]
					assert isinstance(src_text[0]							,     lowerCAmelCase__						)
					__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		1_0
					__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		self.tokenizer(lowerCAmelCase__							,     max_length=lowerCAmelCase__							,     truncation=lowerCAmelCase__						).input_ids[0]
					self.assertEqual(ids[-1]							,     2						)
					self.assertEqual(ids[0]							,     lowerCAmelCase__						)
					self.assertEqual(len(lowerCAmelCase__						)							,     lowerCAmelCase__						)

			def UpperCamelCase__					(							self     : List[str]						):





					"""simple docstring"""






					self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """ar_AR"""]						)							,     [2_5_6_2_0_3, 3]						)

			def UpperCamelCase__					(							self     : Tuple						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Dict           =		tempfile.mkdtemp()
					__SCREAMING_SNAKE_CASE       :		str           =		self.tokenizer.fairseq_tokens_to_ids
					self.tokenizer.save_pretrained(lowerCAmelCase__						)
					__SCREAMING_SNAKE_CASE       :		int           =		NllbTokenizer.from_pretrained(lowerCAmelCase__						)
					self.assertDictEqual(new_tok.fairseq_tokens_to_ids							,     lowerCAmelCase__						)

			@require_torch
			def UpperCamelCase__					(							self     : Union[str, Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Optional[int]           =		self.tokenizer(
					    self.src_text							,     text_target=self.tgt_text							,     padding=lowerCAmelCase__							,     truncation=lowerCAmelCase__							,     max_length=len(self.expected_src_tokens						)							,     return_tensors="""pt"""							,     )
					__SCREAMING_SNAKE_CASE       :		List[str]           =		shift_tokens_right(
					    batch["""labels"""]							,     self.tokenizer.pad_token_id							,     self.tokenizer.lang_code_to_id["""ron_Latn"""]						)

					self.assertIsInstance(lowerCAmelCase__							,     lowerCAmelCase__						)

					self.assertEqual((2, 1_5)							,     batch.input_ids.shape						)
					self.assertEqual((2, 1_5)							,     batch.attention_mask.shape						)
					__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		batch.input_ids.tolist()[0]
					self.assertListEqual(self.expected_src_tokens							,     lowerCAmelCase__						)
					self.assertEqual(lowerCAmelCase__							,     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     : Dict						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		List[str]           =		self.tokenizer(self.src_text							,     padding=lowerCAmelCase__							,     truncation=lowerCAmelCase__							,     max_length=3							,     return_tensors="""pt"""						)
					__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		self.tokenizer(
					    text_target=self.tgt_text							,     padding=lowerCAmelCase__							,     truncation=lowerCAmelCase__							,     max_length=1_0							,     return_tensors="""pt"""						)
					__SCREAMING_SNAKE_CASE       :		List[Any]           =		targets["""input_ids"""]
					__SCREAMING_SNAKE_CASE       :		Tuple           =		shift_tokens_right(
					    lowerCAmelCase__							,     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]							,     1_0						)

			@require_torch
			def UpperCamelCase__					(							self     : List[str]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		str           =		self.tokenizer._build_translation_inputs(
					    """A test"""							,     return_tensors="""pt"""							,     src_lang="""eng_Latn"""							,     tgt_lang="""fra_Latn"""						)

					self.assertEqual(
					    nested_simplify(lowerCAmelCase__						)							,     {
					        # A, test, EOS, en_XX
					        """input_ids""": [[2_5_6_0_4_7, 7_0, 7_3_5_6, 2]],
					        """attention_mask""": [[1, 1, 1, 1]],
					        # ar_AR
					        """forced_bos_token_id""": 2_5_6_0_5_7,
					    }							,     )



			@require_torch
			def UpperCamelCase__					(							self     : Tuple						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		List[Any]           =		True
					__SCREAMING_SNAKE_CASE       :		Optional[int]           =		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_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2, 2_5_6_0_4_7]						)

					__SCREAMING_SNAKE_CASE       :		str           =		False
					__SCREAMING_SNAKE_CASE       :		List[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							,     [2_5_6_0_4_7, 1_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2]						)




'''simple docstring'''




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  :


									'''simple docstring'''

									@staticmethod
									def UpperCamelCase__					(							*lowerCAmelCase__     : Any							,     **lowerCAmelCase__     : Any						):





											"""simple docstring"""






											pass






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


			'''simple docstring'''

			_A      :		Optional[int]			    =		MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING

			def UpperCamelCase__					(							self     : str							,     lowerCAmelCase__     : Dict							,     lowerCAmelCase__     : Tuple							,     lowerCAmelCase__     : Optional[Any]						):





					"""simple docstring"""






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

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

			def UpperCamelCase__					(							self     : int							,     lowerCAmelCase__     : Optional[Any]							,     lowerCAmelCase__     : List[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Optional[int]           =		object_detector(examples[0]							,     threshold=0.0						)

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

			@require_tf
			@unittest.skip("""Zero Shot Object Detection not implemented in TF"""						)
			def UpperCamelCase__					(							self     : Optional[int]						):





					"""simple docstring"""






					pass

			@require_torch
			def UpperCamelCase__					(							self     : Optional[int]						):





					"""simple docstring"""






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

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

					self.assertEqual(
					    nested_simplify(lowerCAmelCase__							,     decimals=4						)							,     [
					        {"""score""": 0.72_35, """label""": """cat""", """box""": {"""xmin""": 2_0_4, """ymin""": 1_6_7, """xmax""": 2_3_2, """ymax""": 1_9_0}},
					        {"""score""": 0.72_18, """label""": """remote""", """box""": {"""xmin""": 2_0_4, """ymin""": 1_6_7, """xmax""": 2_3_2, """ymax""": 1_9_0}},
					        {"""score""": 0.71_84, """label""": """couch""", """box""": {"""xmin""": 2_0_4, """ymin""": 1_6_7, """xmax""": 2_3_2, """ymax""": 1_9_0}},
					        {"""score""": 0.67_48, """label""": """remote""", """box""": {"""xmin""": 5_7_1, """ymin""": 8_3, """xmax""": 5_9_8, """ymax""": 1_0_3}},
					        {"""score""": 0.66_56, """label""": """cat""", """box""": {"""xmin""": 5_7_1, """ymin""": 8_3, """xmax""": 5_9_8, """ymax""": 1_0_3}},
					        {"""score""": 0.66_14, """label""": """couch""", """box""": {"""xmin""": 5_7_1, """ymin""": 8_3, """xmax""": 5_9_8, """ymax""": 1_0_3}},
					        {"""score""": 0.64_56, """label""": """remote""", """box""": {"""xmin""": 4_9_4, """ymin""": 1_0_5, """xmax""": 5_2_1, """ymax""": 1_2_7}},
					        {"""score""": 0.6_42, """label""": """remote""", """box""": {"""xmin""": 6_7, """ymin""": 2_7_4, """xmax""": 9_3, """ymax""": 2_9_7}},
					        {"""score""": 0.64_19, """label""": """cat""", """box""": {"""xmin""": 4_9_4, """ymin""": 1_0_5, """xmax""": 5_2_1, """ymax""": 1_2_7}},
					    ]							,     )

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

					self.assertEqual(
					    nested_simplify(lowerCAmelCase__							,     decimals=4						)							,     [
					        [
					            {"""score""": 0.72_35, """label""": """cat""", """box""": {"""xmin""": 2_0_4, """ymin""": 1_6_7, """xmax""": 2_3_2, """ymax""": 1_9_0}},
					            {"""score""": 0.72_18, """label""": """remote""", """box""": {"""xmin""": 2_0_4, """ymin""": 1_6_7, """xmax""": 2_3_2, """ymax""": 1_9_0}},
					            {"""score""": 0.71_84, """label""": """couch""", """box""": {"""xmin""": 2_0_4, """ymin""": 1_6_7, """xmax""": 2_3_2, """ymax""": 1_9_0}},
					            {"""score""": 0.67_48, """label""": """remote""", """box""": {"""xmin""": 5_7_1, """ymin""": 8_3, """xmax""": 5_9_8, """ymax""": 1_0_3}},
					            {"""score""": 0.66_56, """label""": """cat""", """box""": {"""xmin""": 5_7_1, """ymin""": 8_3, """xmax""": 5_9_8, """ymax""": 1_0_3}},
					            {"""score""": 0.66_14, """label""": """couch""", """box""": {"""xmin""": 5_7_1, """ymin""": 8_3, """xmax""": 5_9_8, """ymax""": 1_0_3}},
					            {"""score""": 0.64_56, """label""": """remote""", """box""": {"""xmin""": 4_9_4, """ymin""": 1_0_5, """xmax""": 5_2_1, """ymax""": 1_2_7}},
					            {"""score""": 0.6_42, """label""": """remote""", """box""": {"""xmin""": 6_7, """ymin""": 2_7_4, """xmax""": 9_3, """ymax""": 2_9_7}},
					            {"""score""": 0.64_19, """label""": """cat""", """box""": {"""xmin""": 4_9_4, """ymin""": 1_0_5, """xmax""": 5_2_1, """ymax""": 1_2_7}},
					        ]
					    ]							,     )

			@require_torch
			@slow
			def UpperCamelCase__					(							self     : str						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Any           =		pipeline("""zero-shot-object-detection"""						)

					__SCREAMING_SNAKE_CASE       :		List[str]           =		object_detector(
					    """http://images.cocodataset.org/val2017/000000039769.jpg"""							,     candidate_labels=["""cat""", """remote""", """couch"""]							,     )
					self.assertEqual(
					    nested_simplify(lowerCAmelCase__							,     decimals=4						)							,     [
					        {"""score""": 0.28_68, """label""": """cat""", """box""": {"""xmin""": 3_2_4, """ymin""": 2_0, """xmax""": 6_4_0, """ymax""": 3_7_3}},
					        {"""score""": 0.2_77, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_2, """xmax""": 1_7_7, """ymax""": 1_1_5}},
					        {"""score""": 0.25_37, """label""": """cat""", """box""": {"""xmin""": 1, """ymin""": 5_5, """xmax""": 3_1_5, """ymax""": 4_7_2}},
					        {"""score""": 0.14_74, """label""": """remote""", """box""": {"""xmin""": 3_3_5, """ymin""": 7_4, """xmax""": 3_7_1, """ymax""": 1_8_7}},
					        {"""score""": 0.12_08, """label""": """couch""", """box""": {"""xmin""": 4, """ymin""": 0, """xmax""": 6_4_2, """ymax""": 4_7_6}},
					    ]							,     )

					__SCREAMING_SNAKE_CASE       :		Dict           =		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(lowerCAmelCase__							,     decimals=4						)							,     [
					        [
					            {"""score""": 0.28_68, """label""": """cat""", """box""": {"""xmin""": 3_2_4, """ymin""": 2_0, """xmax""": 6_4_0, """ymax""": 3_7_3}},
					            {"""score""": 0.2_77, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_2, """xmax""": 1_7_7, """ymax""": 1_1_5}},
					            {"""score""": 0.25_37, """label""": """cat""", """box""": {"""xmin""": 1, """ymin""": 5_5, """xmax""": 3_1_5, """ymax""": 4_7_2}},
					            {"""score""": 0.14_74, """label""": """remote""", """box""": {"""xmin""": 3_3_5, """ymin""": 7_4, """xmax""": 3_7_1, """ymax""": 1_8_7}},
					            {"""score""": 0.12_08, """label""": """couch""", """box""": {"""xmin""": 4, """ymin""": 0, """xmax""": 6_4_2, """ymax""": 4_7_6}},
					        ],
					        [
					            {"""score""": 0.28_68, """label""": """cat""", """box""": {"""xmin""": 3_2_4, """ymin""": 2_0, """xmax""": 6_4_0, """ymax""": 3_7_3}},
					            {"""score""": 0.2_77, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_2, """xmax""": 1_7_7, """ymax""": 1_1_5}},
					            {"""score""": 0.25_37, """label""": """cat""", """box""": {"""xmin""": 1, """ymin""": 5_5, """xmax""": 3_1_5, """ymax""": 4_7_2}},
					            {"""score""": 0.14_74, """label""": """remote""", """box""": {"""xmin""": 3_3_5, """ymin""": 7_4, """xmax""": 3_7_1, """ymax""": 1_8_7}},
					            {"""score""": 0.12_08, """label""": """couch""", """box""": {"""xmin""": 4, """ymin""": 0, """xmax""": 6_4_2, """ymax""": 4_7_6}},
					        ],
					    ]							,     )

			@require_tf
			@unittest.skip("""Zero Shot Object Detection not implemented in TF"""						)
			def UpperCamelCase__					(							self     : Any						):





					"""simple docstring"""






					pass

			@require_torch
			@slow
			def UpperCamelCase__					(							self     : List[str]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Dict           =		0.2
					__SCREAMING_SNAKE_CASE       :		Dict           =		pipeline("""zero-shot-object-detection"""						)

					__SCREAMING_SNAKE_CASE       :		Any           =		object_detector(
					    """http://images.cocodataset.org/val2017/000000039769.jpg"""							,     candidate_labels=["""cat""", """remote""", """couch"""]							,     threshold=lowerCAmelCase__							,     )
					self.assertEqual(
					    nested_simplify(lowerCAmelCase__							,     decimals=4						)							,     [
					        {"""score""": 0.28_68, """label""": """cat""", """box""": {"""xmin""": 3_2_4, """ymin""": 2_0, """xmax""": 6_4_0, """ymax""": 3_7_3}},
					        {"""score""": 0.2_77, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_2, """xmax""": 1_7_7, """ymax""": 1_1_5}},
					        {"""score""": 0.25_37, """label""": """cat""", """box""": {"""xmin""": 1, """ymin""": 5_5, """xmax""": 3_1_5, """ymax""": 4_7_2}},
					    ]							,     )



			@require_torch
			@slow
			def UpperCamelCase__					(							self     : int						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		str           =		2
					__SCREAMING_SNAKE_CASE       :		int           =		pipeline("""zero-shot-object-detection"""						)

					__SCREAMING_SNAKE_CASE       :		int           =		object_detector(
					    """http://images.cocodataset.org/val2017/000000039769.jpg"""							,     candidate_labels=["""cat""", """remote""", """couch"""]							,     top_k=lowerCAmelCase__							,     )
					self.assertEqual(
					    nested_simplify(lowerCAmelCase__							,     decimals=4						)							,     [
					        {"""score""": 0.28_68, """label""": """cat""", """box""": {"""xmin""": 3_2_4, """ymin""": 2_0, """xmax""": 6_4_0, """ymax""": 3_7_3}},
					        {"""score""": 0.2_77, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_2, """xmax""": 1_7_7, """ymax""": 1_1_5}},
					    ]							,     )