






import json
import os
import unittest

from transformers.models.roc_bert.tokenization_roc_bert import (
    VOCAB_FILES_NAMES,
    RoCBertBasicTokenizer,
    RoCBertTokenizer,
    RoCBertWordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english




@require_tokenizers
class 							_lowerCAmelCase(			UpperCAmelCase_				,      unittest.TestCase   ):





       """simple docstring"""







       a							:						Optional[Any]										=RoCBertTokenizer
       a							:						List[Any]										=None
       a							:						Tuple										=False
       a							:						str										=True
       a							:						Optional[Any]										=filter_non_english





       def      _a       (   self				):
         super().setUp()

         UpperCamelCase_:   Union[str, Any]        =							['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', '你', '好', '是', '谁', 'a', 'b', 'c', 'd']
         UpperCamelCase_:   str        =							{}
         UpperCamelCase_:   Dict        =							{}
         for i, value in enumerate(_lowercase				):
           UpperCamelCase_:   Union[str, Any]        =							i
           UpperCamelCase_:   Tuple        =							i
         UpperCamelCase_:   str        =							os.path.join(self.tmpdirname    ,     VOCAB_FILES_NAMES['vocab_file']				)
         UpperCamelCase_:   str        =							os.path.join(self.tmpdirname    ,     VOCAB_FILES_NAMES['word_shape_file']				)
         UpperCamelCase_:   Optional[int]        =							os.path.join(self.tmpdirname    ,     VOCAB_FILES_NAMES['word_pronunciation_file']				)
         with open(self.vocab_file    ,     'w'    ,     encoding='utf-8'				) as vocab_writer:
           vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]				)				)
         with open(self.word_shape_file    ,     'w'    ,     encoding='utf-8'				) as word_shape_writer:
           json.dump(_lowercase    ,     _lowercase    ,     ensure_ascii=_lowercase				)
         with open(self.word_pronunciation_file    ,     'w'    ,     encoding='utf-8'				) as word_pronunciation_writer:
           json.dump(_lowercase    ,     _lowercase    ,     ensure_ascii=_lowercase				)





       def      _a       (   self				):
         UpperCamelCase_:   Optional[Any]        =							self.tokenizer_class(self.vocab_file    ,     self.word_shape_file    ,     self.word_pronunciation_file				)

         UpperCamelCase_:   int        =							tokenizer.tokenize('你好[SEP]你是谁'				)
         self.assertListEqual(_lowercase    ,     ['你', '好', '[SEP]', '你', '是', '谁']				)
         self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowercase				)    ,     [5, 6, 2, 5, 7, 8]				)
         self.assertListEqual(tokenizer.convert_tokens_to_shape_ids(_lowercase				)    ,     [5, 6, 2, 5, 7, 8]				)
         self.assertListEqual(tokenizer.convert_tokens_to_pronunciation_ids(_lowercase				)    ,     [5, 6, 2, 5, 7, 8]				)





       def      _a       (   self				):
         UpperCamelCase_:   Tuple        =							RoCBertBasicTokenizer()

         self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'				)    ,     ['ah', '\u535A', '\u63A8', 'zz']				)





       def      _a       (   self				):
         UpperCamelCase_:   str        =							RoCBertBasicTokenizer(do_lower_case=_lowercase				)

         self.assertListEqual(
             tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '				)    ,     ['hello', '!', 'how', 'are', 'you', '?']				)
         self.assertListEqual(tokenizer.tokenize('H\u00E9llo'				)    ,     ['hello']				)





       def      _a       (   self				):
         UpperCamelCase_:   Optional[Any]        =							RoCBertBasicTokenizer(do_lower_case=_lowercase    ,     strip_accents=_lowercase				)

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '				)    ,     ['hällo', '!', 'how', 'are', 'you', '?']				)
         self.assertListEqual(tokenizer.tokenize('H\u00E9llo'				)    ,     ['h\u00E9llo']				)





       def      _a       (   self				):
         UpperCamelCase_:   Tuple        =							RoCBertBasicTokenizer(do_lower_case=_lowercase    ,     strip_accents=_lowercase				)

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '				)    ,     ['hallo', '!', 'how', 'are', 'you', '?']				)
         self.assertListEqual(tokenizer.tokenize('H\u00E9llo'				)    ,     ['hello']				)





       def      _a       (   self				):
         UpperCamelCase_:   Dict        =							RoCBertBasicTokenizer(do_lower_case=_lowercase				)

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '				)    ,     ['hallo', '!', 'how', 'are', 'you', '?']				)
         self.assertListEqual(tokenizer.tokenize('H\u00E9llo'				)    ,     ['hello']				)





       def      _a       (   self				):
         UpperCamelCase_:   str        =							RoCBertBasicTokenizer(do_lower_case=_lowercase				)

         self.assertListEqual(
             tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '				)    ,     ['HeLLo', '!', 'how', 'Are', 'yoU', '?']				)





       def      _a       (   self				):
         UpperCamelCase_:   str        =							RoCBertBasicTokenizer(do_lower_case=_lowercase    ,     strip_accents=_lowercase				)

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '				)    ,     ['HäLLo', '!', 'how', 'Are', 'yoU', '?']				)





       def      _a       (   self				):
         UpperCamelCase_:   Tuple        =							RoCBertBasicTokenizer(do_lower_case=_lowercase    ,     strip_accents=_lowercase				)

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '				)    ,     ['HaLLo', '!', 'how', 'Are', 'yoU', '?']				)





       def      _a       (   self				):
         UpperCamelCase_:   List[Any]        =							RoCBertBasicTokenizer(do_lower_case=_lowercase    ,     never_split=['[UNK]']				)

         self.assertListEqual(
             tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'				)    ,     ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']				)





       def      _a       (   self				):
         UpperCamelCase_:   Dict        =							['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

         UpperCamelCase_:   Tuple        =							{}
         for i, token in enumerate(_lowercase				):
           UpperCamelCase_:   List[str]        =							i
         UpperCamelCase_:   Dict        =							RoCBertWordpieceTokenizer(vocab=_lowercase    ,     unk_token='[UNK]'				)

         self.assertListEqual(tokenizer.tokenize(''				)    ,     []				)

         self.assertListEqual(tokenizer.tokenize('unwanted running'				)    ,     ['un', '##want', '##ed', 'runn', '##ing']				)

         self.assertListEqual(tokenizer.tokenize('unwantedX running'				)    ,     ['[UNK]', 'runn', '##ing']				)





       def      _a       (   self				):
         self.assertTrue(_is_whitespace(' '				)				)
         self.assertTrue(_is_whitespace('\t'				)				)
         self.assertTrue(_is_whitespace('\r'				)				)
         self.assertTrue(_is_whitespace('\n'				)				)
         self.assertTrue(_is_whitespace('\u00A0'				)				)

         self.assertFalse(_is_whitespace('A'				)				)
         self.assertFalse(_is_whitespace('-'				)				)





       def      _a       (   self				):
         self.assertTrue(_is_control('\u0005'				)				)

         self.assertFalse(_is_control('A'				)				)
         self.assertFalse(_is_control(' '				)				)
         self.assertFalse(_is_control('\t'				)				)
         self.assertFalse(_is_control('\r'				)				)





       def      _a       (   self				):
         self.assertTrue(_is_punctuation('-'				)				)
         self.assertTrue(_is_punctuation('$'				)				)
         self.assertTrue(_is_punctuation('`'				)				)
         self.assertTrue(_is_punctuation('.'				)				)

         self.assertFalse(_is_punctuation('A'				)				)
         self.assertFalse(_is_punctuation(' '				)				)





       def      _a       (   self				):
         UpperCamelCase_:   List[str]        =							self.get_tokenizer()

         # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
         self.assertListEqual([tokenizer.tokenize(_lowercase				) for t in ['Test', '\xad', 'test']]    ,     [['[UNK]'], [], ['[UNK]']]				)

         if self.test_rust_tokenizer:
           UpperCamelCase_:   str        =							self.get_rust_tokenizer()
           self.assertListEqual(
               [rust_tokenizer.tokenize(_lowercase				) for t in ['Test', '\xad', 'test']]    ,     [['[UNK]'], [], ['[UNK]']]				)





       def      _a       (   self				):
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''				):
             UpperCamelCase_:   List[str]        =							self.rust_tokenizer_class.from_pretrained(_lowercase    ,     **_lowercase				)

             UpperCamelCase_:   Tuple        =							f'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
             UpperCamelCase_:   List[str]        =							tokenizer_r.encode_plus(
                 _lowercase    ,     return_attention_mask=_lowercase    ,     return_token_type_ids=_lowercase    ,     return_offsets_mapping=_lowercase    ,     add_special_tokens=_lowercase    ,     )

             UpperCamelCase_:   Optional[int]        =							tokenizer_r.do_lower_case if hasattr(_lowercase    ,     'do_lower_case'				) else False
             UpperCamelCase_:   int        =							(
                 [
                     ((0, 0), tokenizer_r.cls_token),
                     ((0, 1), 'A'),
                     ((1, 2), ','),
                     ((3, 5), 'na'),
                     ((5, 6), '##ï'),
                     ((6, 8), '##ve'),
                     ((9, 1_5), tokenizer_r.mask_token),
                     ((1_6, 2_1), 'Allen'),
                     ((2_1, 2_3), '##NL'),
                     ((2_3, 2_4), '##P'),
                     ((2_5, 3_3), 'sentence'),
                     ((3_3, 3_4), '.'),
                     ((0, 0), tokenizer_r.sep_token),
                 ]
                 if not do_lower_case
                 else [
                     ((0, 0), tokenizer_r.cls_token),
                     ((0, 1), 'a'),
                     ((1, 2), ','),
                     ((3, 8), 'naive'),
                     ((9, 1_5), tokenizer_r.mask_token),
                     ((1_6, 2_1), 'allen'),
                     ((2_1, 2_3), '##nl'),
                     ((2_3, 2_4), '##p'),
                     ((2_5, 3_3), 'sentence'),
                     ((3_3, 3_4), '.'),
                     ((0, 0), tokenizer_r.sep_token),
                 ]
             )

             self.assertEqual(
                 [e[1] for e in expected_results]    ,     tokenizer_r.convert_ids_to_tokens(tokens['input_ids']				)				)
             self.assertEqual([e[0] for e in expected_results]    ,     tokens['offset_mapping']				)





       def      _a       (   self				):
         UpperCamelCase_:   List[str]        =							['的', '人', '有']
         UpperCamelCase_:   Optional[Any]        =							''.join(_lowercase				)
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''				):
             UpperCamelCase_:   Tuple        =							True
             UpperCamelCase_:   Union[str, Any]        =							self.tokenizer_class.from_pretrained(_lowercase    ,     **_lowercase				)
             UpperCamelCase_:   Union[str, Any]        =							self.rust_tokenizer_class.from_pretrained(_lowercase    ,     **_lowercase				)

             UpperCamelCase_:   Optional[int]        =							tokenizer_p.encode(_lowercase    ,     add_special_tokens=_lowercase				)
             UpperCamelCase_:   List[str]        =							tokenizer_r.encode(_lowercase    ,     add_special_tokens=_lowercase				)

             UpperCamelCase_:   str        =							tokenizer_r.convert_ids_to_tokens(_lowercase				)
             UpperCamelCase_:   str        =							tokenizer_p.convert_ids_to_tokens(_lowercase				)

             # it is expected that each Chinese character is not preceded by "##"
             self.assertListEqual(_lowercase    ,     _lowercase				)
             self.assertListEqual(_lowercase    ,     _lowercase				)

             UpperCamelCase_:   Optional[Any]        =							False
             UpperCamelCase_:   Any        =							self.rust_tokenizer_class.from_pretrained(_lowercase    ,     **_lowercase				)
             UpperCamelCase_:   Optional[Any]        =							self.tokenizer_class.from_pretrained(_lowercase    ,     **_lowercase				)

             UpperCamelCase_:   Any        =							tokenizer_r.encode(_lowercase    ,     add_special_tokens=_lowercase				)
             UpperCamelCase_:   int        =							tokenizer_p.encode(_lowercase    ,     add_special_tokens=_lowercase				)

             UpperCamelCase_:   int        =							tokenizer_r.convert_ids_to_tokens(_lowercase				)
             UpperCamelCase_:   Optional[int]        =							tokenizer_p.convert_ids_to_tokens(_lowercase				)

             # it is expected that only the first Chinese character is not preceded by "##".
             UpperCamelCase_:   Tuple        =							[
                 f'''##{token}''' if idx != 0 else token for idx, token in enumerate(_lowercase				)
             ]
             self.assertListEqual(_lowercase    ,     _lowercase				)
             self.assertListEqual(_lowercase    ,     _lowercase				)





       @slow
       def      _a       (   self				):
         UpperCamelCase_:   List[Any]        =							self.tokenizer_class(self.vocab_file    ,     self.word_shape_file    ,     self.word_pronunciation_file				)

         UpperCamelCase_:   List[str]        =							tokenizer.encode('你好'    ,     add_special_tokens=_lowercase				)
         UpperCamelCase_:   Any        =							tokenizer.encode('你是谁'    ,     add_special_tokens=_lowercase				)

         UpperCamelCase_:   int        =							tokenizer.build_inputs_with_special_tokens(_lowercase				)
         UpperCamelCase_:   Dict        =							tokenizer.build_inputs_with_special_tokens(_lowercase    ,     _lowercase				)

         assert encoded_sentence == [1] + text + [2]
         assert encoded_pair == [1] + text + [2] + text_a + [2]





       def      _a       (   self				):
         UpperCamelCase_:   Dict        =							self.get_tokenizers(do_lower_case=_lowercase				)
         for tokenizer in tokenizers:
           with self.subTest(f'''{tokenizer.__class__.__name__}'''				):
             UpperCamelCase_:   Any        =							'你好，你是谁'
             UpperCamelCase_:   int        =							tokenizer.tokenize(_lowercase				)
             UpperCamelCase_:   Dict        =							tokenizer.convert_tokens_to_ids(_lowercase				)
             UpperCamelCase_:   str        =							tokenizer.convert_tokens_to_shape_ids(_lowercase				)
             UpperCamelCase_:   Any        =							tokenizer.convert_tokens_to_pronunciation_ids(_lowercase				)
             UpperCamelCase_:   List[Any]        =							tokenizer.prepare_for_model(
                 _lowercase    ,     _lowercase    ,     _lowercase    ,     add_special_tokens=_lowercase				)

             UpperCamelCase_:   Optional[int]        =							tokenizer.encode_plus(_lowercase    ,     add_special_tokens=_lowercase				)

             self.assertEqual(_lowercase    ,     _lowercase				)


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 						__magic_name__					:






      @staticmethod
      def 	UpperCAmelCase_				(				*_lowercase		,						**_lowercase	)->     Optional[int]:
          pass






@is_pipeline_test
@require_vision
@require_torch
class 						__magic_name__					(							unittest.TestCase				):
     UpperCamelCase_	:Optional[Any]										=      MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING






     def 	UpperCAmelCase_				(				self		,						_lowercase		,						_lowercase		,						_lowercase	)->     Union[str, Any]:
         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 	UpperCAmelCase_				(				self		,						_lowercase		,						_lowercase	)->     Union[str, Any]:
         UpperCamelCase_			  =						object_detector(examples[0]		,						threshold=0.0	)

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






     @require_tf
     @unittest.skip("Zero Shot Object Detection not implemented in TF"	)
     def 	UpperCAmelCase_				(				self	)->     str:
         pass






     @require_torch
     def 	UpperCAmelCase_				(				self	)->     List[Any]:
         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(_lowercase		,						decimals=4	)		,						[
                 {"score": 0.7_235, "label": "cat", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                 {"score": 0.7_218, "label": "remote", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                 {"score": 0.7_184, "label": "couch", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                 {"score": 0.6_748, "label": "remote", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                 {"score": 0.6_656, "label": "cat", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                 {"score": 0.6_614, "label": "couch", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                 {"score": 0.6_456, "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.6_419, "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(_lowercase		,						decimals=4	)		,						[
                 [
                     {"score": 0.7_235, "label": "cat", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                     {"score": 0.7_218, "label": "remote", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                     {"score": 0.7_184, "label": "couch", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                     {"score": 0.6_748, "label": "remote", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                     {"score": 0.6_656, "label": "cat", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                     {"score": 0.6_614, "label": "couch", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                     {"score": 0.6_456, "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.6_419, "label": "cat", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
                 ]
             ]		,						)






     @require_torch
     @slow
     def 	UpperCAmelCase_				(				self	)->     Any:
         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(_lowercase		,						decimals=4	)		,						[
                 {"score": 0.2_868, "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.2_537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                 {"score": 0.1_474, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                 {"score": 0.1_208, "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(_lowercase		,						decimals=4	)		,						[
                 [
                     {"score": 0.2_868, "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.2_537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                     {"score": 0.1_474, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                     {"score": 0.1_208, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
                 ],
                 [
                     {"score": 0.2_868, "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.2_537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                     {"score": 0.1_474, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                     {"score": 0.1_208, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
                 ],
             ]		,						)






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






     @require_torch
     @slow
     def 	UpperCAmelCase_				(				self	)->     Optional[Any]:
         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=_lowercase		,						)
         self.assertEqual(
             nested_simplify(_lowercase		,						decimals=4	)		,						[
                 {"score": 0.2_868, "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.2_537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
             ]		,						)






     @require_torch
     @slow
     def 	UpperCAmelCase_				(				self	)->     Optional[int]:
         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=_lowercase		,						)
         self.assertEqual(
             nested_simplify(_lowercase		,						decimals=4	)		,						[
                 {"score": 0.2_868, "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}},
             ]		,						)
