


"""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 				SCREAMING_SNAKE_CASE__    :
												"""simple docstring"""


												@staticmethod
												def 	lowercase__							(						*snake_case__		,					**snake_case__						):






														"""simple docstring"""





														pass


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


							a  :    Optional[Any]       =MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING

							def 	lowercase__							(						self		,					snake_case__		,					snake_case__		,					snake_case__						):






									"""simple docstring"""





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

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

							def 	lowercase__							(						self		,					snake_case__		,					snake_case__						):






									"""simple docstring"""





									lowerCAmelCase					:					Optional[Any]								=							object_detector(examples[0]		,					threshold=0.0						)

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

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






									"""simple docstring"""





									pass

							@require_torch
							def 	lowercase__							(						self						):






									"""simple docstring"""





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

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

									self.assertEqual(
									    nested_simplify(snake_case__		,					decimals=4						)		,					[
									        {"score": 0.7235, "label": "cat", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
									        {"score": 0.7218, "label": "remote", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
									        {"score": 0.7184, "label": "couch", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
									        {"score": 0.6748, "label": "remote", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
									        {"score": 0.6656, "label": "cat", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
									        {"score": 0.6614, "label": "couch", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
									        {"score": 0.6456, "label": "remote", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
									        {"score": 0.642, "label": "remote", "box": {"xmin": 67, "ymin": 274, "xmax": 93, "ymax": 297}},
									        {"score": 0.6419, "label": "cat", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
									    ]		,					)

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

									self.assertEqual(
									    nested_simplify(snake_case__		,					decimals=4						)		,					[
									        [
									            {"score": 0.7235, "label": "cat", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
									            {"score": 0.7218, "label": "remote", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
									            {"score": 0.7184, "label": "couch", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
									            {"score": 0.6748, "label": "remote", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
									            {"score": 0.6656, "label": "cat", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
									            {"score": 0.6614, "label": "couch", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
									            {"score": 0.6456, "label": "remote", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
									            {"score": 0.642, "label": "remote", "box": {"xmin": 67, "ymin": 274, "xmax": 93, "ymax": 297}},
									            {"score": 0.6419, "label": "cat", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
									        ]
									    ]		,					)

							@require_torch
							@slow
							def 	lowercase__							(						self						):






									"""simple docstring"""





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

									lowerCAmelCase					:					Dict								=							object_detector(
									    "http://images.cocodataset.org/val2017/000000039769.jpg"		,					candidate_labels=["cat", "remote", "couch"]		,					)
									self.assertEqual(
									    nested_simplify(snake_case__		,					decimals=4						)		,					[
									        {"score": 0.2868, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
									        {"score": 0.277, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
									        {"score": 0.2537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
									        {"score": 0.1474, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
									        {"score": 0.1208, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
									    ]		,					)

									lowerCAmelCase					:					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(snake_case__		,					decimals=4						)		,					[
									        [
									            {"score": 0.2868, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
									            {"score": 0.277, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
									            {"score": 0.2537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
									            {"score": 0.1474, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
									            {"score": 0.1208, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
									        ],
									        [
									            {"score": 0.2868, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
									            {"score": 0.277, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
									            {"score": 0.2537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
									            {"score": 0.1474, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
									            {"score": 0.1208, "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						):






									"""simple docstring"""





									pass

							@require_torch
							@slow
							def 	lowercase__							(						self						):






									"""simple docstring"""





									lowerCAmelCase					:					Dict								=							0.2
									lowerCAmelCase					:					List[Any]								=							pipeline("zero-shot-object-detection"						)

									lowerCAmelCase					:					Union[str, Any]								=							object_detector(
									    "http://images.cocodataset.org/val2017/000000039769.jpg"		,					candidate_labels=["cat", "remote", "couch"]		,					threshold=snake_case__		,					)
									self.assertEqual(
									    nested_simplify(snake_case__		,					decimals=4						)		,					[
									        {"score": 0.2868, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
									        {"score": 0.277, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
									        {"score": 0.2537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
									    ]		,					)







							@require_torch
							@slow
							def 	lowercase__							(						self						):






									"""simple docstring"""





									lowerCAmelCase					:					int								=							2
									lowerCAmelCase					:					Any								=							pipeline("zero-shot-object-detection"						)

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









"""simple docstring"""







import unittest

from datasets import load_dataset

from transformers import BloomTokenizerFast
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin


@require_tokenizers
class 				SCREAMING_SNAKE_CASE__    (		lowercase       ,   unittest.TestCase    ):
       """simple docstring"""


       a  :    List[str]       =None
       a  :    List[Any]       =BloomTokenizerFast
       a  :    Optional[int]       =BloomTokenizerFast
       a  :    Optional[Any]       =True
       a  :    Dict       =False
       a  :    Optional[Any]       ="tokenizer_file"
       a  :    Optional[int]       ={"bos_token": "<s>", "eos_token": "</s>", "unk_token": "<unk>", "pad_token": "<pad>"}

       def 	lowercase__							(						self						):






         """simple docstring"""





         super().setUp()
         lowerCAmelCase					:					Tuple								=							BloomTokenizerFast.from_pretrained("bigscience/tokenizer"						)
         tokenizer.save_pretrained(self.tmpdirname						)

       def 	lowercase__							(						self		,					**snake_case__						):






         """simple docstring"""





         kwargs.update(self.special_tokens_map						)
         return BloomTokenizerFast.from_pretrained(self.tmpdirname		,					**snake_case__						)

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					int								=							self.get_rust_tokenizer()

         lowerCAmelCase					:					List[Any]								=							["The quick brown fox</s>", "jumps over the lazy dog</s>"]
         lowerCAmelCase					:					str								=							[[2_175, 23_714, 73_173, 144_252, 2], [77, 132_619, 3_478, 368, 109_586, 35_433, 2]]

         lowerCAmelCase					:					Optional[int]								=							tokenizer.batch_encode_plus(snake_case__						)["input_ids"]
         self.assertListEqual(snake_case__		,					snake_case__						)

         lowerCAmelCase					:					Optional[int]								=							tokenizer.batch_decode(snake_case__						)
         self.assertListEqual(snake_case__		,					snake_case__						)

       def 	lowercase__							(						self		,					snake_case__=6						):






         """simple docstring"""





         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""						):
             lowerCAmelCase					:					Tuple								=							self.rust_tokenizer_class.from_pretrained(snake_case__		,					**snake_case__						)
             # tokenizer_r.pad_token = None # Hotfixing padding = None
             # Simple input
             lowerCAmelCase					:					str								=							"This is a simple input"
             lowerCAmelCase					:					Tuple								=							["This is a simple input 1", "This is a simple input 2"]
             lowerCAmelCase					:					Any								=							("This is a simple input", "This is a pair")
             lowerCAmelCase					:					Tuple								=							[
                 ("This is a simple input 1", "This is a simple input 2"),
                 ("This is a simple pair 1", "This is a simple pair 2"),
             ]

             # Simple input tests
             try:
               tokenizer_r.encode(snake_case__		,					max_length=snake_case__						)
               tokenizer_r.encode_plus(snake_case__		,					max_length=snake_case__						)

               tokenizer_r.batch_encode_plus(snake_case__		,					max_length=snake_case__						)
               tokenizer_r.encode(snake_case__		,					max_length=snake_case__						)
               tokenizer_r.batch_encode_plus(snake_case__		,					max_length=snake_case__						)
             except ValueError:
               self.fail("Bloom Tokenizer should be able to deal with padding"						)

             lowerCAmelCase					:					Tuple								=							None  # Hotfixing padding = None
             self.assertRaises(snake_case__		,					tokenizer_r.encode		,					snake_case__		,					max_length=snake_case__		,					padding="max_length"						)

             # Simple input
             self.assertRaises(snake_case__		,					tokenizer_r.encode_plus		,					snake_case__		,					max_length=snake_case__		,					padding="max_length"						)

             # Simple input
             self.assertRaises(
                 snake_case__		,					tokenizer_r.batch_encode_plus		,					snake_case__		,					max_length=snake_case__		,					padding="max_length"		,					)

             # Pair input
             self.assertRaises(snake_case__		,					tokenizer_r.encode		,					snake_case__		,					max_length=snake_case__		,					padding="max_length"						)

             # Pair input
             self.assertRaises(snake_case__		,					tokenizer_r.encode_plus		,					snake_case__		,					max_length=snake_case__		,					padding="max_length"						)

             # Pair input
             self.assertRaises(
                 snake_case__		,					tokenizer_r.batch_encode_plus		,					snake_case__		,					max_length=snake_case__		,					padding="max_length"		,					)

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					int								=							self.get_rust_tokenizer()
         lowerCAmelCase					:					int								=							load_dataset("xnli"		,					"all_languages"		,					split="test"		,					streaming=snake_case__						)

         lowerCAmelCase					:					Tuple								=							next(iter(snake_case__						)						)["premise"]  # pick up one data
         lowerCAmelCase					:					Optional[Any]								=							list(sample_data.values()						)

         lowerCAmelCase					:					int								=							list(map(tokenizer.encode		,					snake_case__						)						)
         lowerCAmelCase					:					List[Any]								=							[tokenizer.decode(snake_case__		,					clean_up_tokenization_spaces=snake_case__						) for x in output_tokens]
         self.assertListEqual(snake_case__		,					snake_case__						)







       def 	lowercase__							(						self						):






         """simple docstring"""





         self.assertGreaterEqual(len(self.tokenizer_class.pretrained_vocab_files_map						)		,					1						)
         self.assertGreaterEqual(len(list(self.tokenizer_class.pretrained_vocab_files_map.values()						)[0]						)		,					1						)





