





import json
import os
import sys
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from huggingface_hub import HfFolder, Repository, create_repo, delete_repo
from requests.exceptions import HTTPError

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoProcessor,
    AutoTokenizer,
    BertTokenizer,
    ProcessorMixin,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
)
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test
from transformers.tokenization_utils import TOKENIZER_CONFIG_FILE
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_tokenizers_available


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402
from test_module.custom_processing import CustomProcessor  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


_UpperCAmelCase        =				get_tests_dir('fixtures/dummy_feature_extractor_config.json')
_UpperCAmelCase        =				get_tests_dir('fixtures/vocab.json')
_UpperCAmelCase        =				get_tests_dir('fixtures')



class 							_UpperCamelCase					(	unittest.TestCase     ):
       _UpperCamelCase				:					Tuple         =   ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''bla''', '''blou''']

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




              """simple docstring"""


              UpperCamelCase_          =  0

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




              """simple docstring"""


              UpperCamelCase_          =  AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h"		)
              self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: Any		)       -> Dict:




              """simple docstring"""


              with tempfile.TemporaryDirectory() as tmpdirname:
                     UpperCamelCase_          =  WavaVecaConfig()
                     UpperCamelCase_          =  AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h"		)

                     # save in new folder
                     model_config.save_pretrained(_SCREAMING_SNAKE_CASE		)
                     processor.save_pretrained(_SCREAMING_SNAKE_CASE		)

                     UpperCamelCase_          =  AutoProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

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




              """simple docstring"""


              with tempfile.TemporaryDirectory() as tmpdirname:
                     # copy relevant files
                     copyfile(_SCREAMING_SNAKE_CASE					,   os.path.join(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)		)
                     copyfile(_SCREAMING_SNAKE_CASE					,   os.path.join(_SCREAMING_SNAKE_CASE					,   "vocab.json"		)		)

                     UpperCamelCase_          =  AutoProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: Any		)       -> str:




              """simple docstring"""


              with tempfile.TemporaryDirectory() as tmpdirname:
                     UpperCamelCase_          =  WavaVecaFeatureExtractor()
                     UpperCamelCase_          =  AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h"		)

                     UpperCamelCase_          =  WavaVecaProcessor(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

                     # save in new folder
                     processor.save_pretrained(_SCREAMING_SNAKE_CASE		)

                     # drop `processor_class` in tokenizer
                     with open(os.path.join(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)					,   "r"		) as f:
                            UpperCamelCase_          =  json.load(_SCREAMING_SNAKE_CASE		)
                            config_dict.pop("processor_class"		)

                     with open(os.path.join(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)					,   "w"		) as f:
                            f.write(json.dumps(_SCREAMING_SNAKE_CASE		)		)

                     UpperCamelCase_          =  AutoProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: int		)       -> Any:




              """simple docstring"""


              with tempfile.TemporaryDirectory() as tmpdirname:
                     UpperCamelCase_          =  WavaVecaFeatureExtractor()
                     UpperCamelCase_          =  AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h"		)

                     UpperCamelCase_          =  WavaVecaProcessor(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

                     # save in new folder
                     processor.save_pretrained(_SCREAMING_SNAKE_CASE		)

                     # drop `processor_class` in feature extractor
                     with open(os.path.join(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)					,   "r"		) as f:
                            UpperCamelCase_          =  json.load(_SCREAMING_SNAKE_CASE		)
                            config_dict.pop("processor_class"		)

                     with open(os.path.join(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)					,   "w"		) as f:
                            f.write(json.dumps(_SCREAMING_SNAKE_CASE		)		)

                     UpperCamelCase_          =  AutoProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

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




              """simple docstring"""


              with tempfile.TemporaryDirectory() as tmpdirname:
                     UpperCamelCase_          =  WavaVecaConfig(processor_class="Wav2Vec2Processor"		)
                     model_config.save_pretrained(_SCREAMING_SNAKE_CASE		)
                     # copy relevant files
                     copyfile(_SCREAMING_SNAKE_CASE					,   os.path.join(_SCREAMING_SNAKE_CASE					,   "vocab.json"		)		)
                     # create emtpy sample processor
                     with open(os.path.join(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)					,   "w"		) as f:
                            f.write("{}"		)

                     UpperCamelCase_          =  AutoProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: Optional[int]		)       -> Dict:




              """simple docstring"""


              with self.assertRaises(_SCREAMING_SNAKE_CASE		):
                     UpperCamelCase_          =  AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor"		)
              # If remote code is disabled, we can't load this config.
              with self.assertRaises(_SCREAMING_SNAKE_CASE		):
                     UpperCamelCase_          =  AutoProcessor.from_pretrained(
                         "hf-internal-testing/test_dynamic_processor"					,   trust_remote_code=_SCREAMING_SNAKE_CASE		)

              UpperCamelCase_          =  AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor"					,   trust_remote_code=_SCREAMING_SNAKE_CASE		)
              self.assertTrue(processor.special_attribute_present		)
              self.assertEqual(processor.__class__.__name__					,   "NewProcessor"		)

              UpperCamelCase_          =  processor.feature_extractor
              self.assertTrue(feature_extractor.special_attribute_present		)
              self.assertEqual(feature_extractor.__class__.__name__					,   "NewFeatureExtractor"		)

              UpperCamelCase_          =  processor.tokenizer
              self.assertTrue(tokenizer.special_attribute_present		)
              if is_tokenizers_available():
                     self.assertEqual(tokenizer.__class__.__name__					,   "NewTokenizerFast"		)

                     # Test we can also load the slow version
                     UpperCamelCase_          =  AutoProcessor.from_pretrained(
                         "hf-internal-testing/test_dynamic_processor"					,   trust_remote_code=_SCREAMING_SNAKE_CASE					,   use_fast=_SCREAMING_SNAKE_CASE		)
                     UpperCamelCase_          =  new_processor.tokenizer
                     self.assertTrue(new_tokenizer.special_attribute_present		)
                     self.assertEqual(new_tokenizer.__class__.__name__					,   "NewTokenizer"		)
              else:
                     self.assertEqual(tokenizer.__class__.__name__					,   "NewTokenizer"		)

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




              """simple docstring"""


              try:
                     AutoConfig.register("custom"					,   _SCREAMING_SNAKE_CASE		)
                     AutoFeatureExtractor.register(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)
                     AutoTokenizer.register(_SCREAMING_SNAKE_CASE					,   slow_tokenizer_class=_SCREAMING_SNAKE_CASE		)
                     AutoProcessor.register(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)
                     # Trying to register something existing in the Transformers library will raise an error
                     with self.assertRaises(_SCREAMING_SNAKE_CASE		):
                            AutoProcessor.register(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

                     # Now that the config is registered, it can be used as any other config with the auto-API
                     UpperCamelCase_          =  CustomFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE		)

                     with tempfile.TemporaryDirectory() as tmp_dir:
                            UpperCamelCase_          =  os.path.join(_SCREAMING_SNAKE_CASE					,   "vocab.txt"		)
                            with open(_SCREAMING_SNAKE_CASE					,   "w"					,   encoding="utf-8"		) as vocab_writer:
                                   vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]		)		)
                            UpperCamelCase_          =  CustomTokenizer(_SCREAMING_SNAKE_CASE		)

                     UpperCamelCase_          =  CustomProcessor(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

                     with tempfile.TemporaryDirectory() as tmp_dir:
                            processor.save_pretrained(_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  AutoProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)
                            self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

              finally:
                     if "custom" in CONFIG_MAPPING._extra_content:
                            del CONFIG_MAPPING._extra_content["custom"]
                     if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
                            del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
                     if CustomConfig in TOKENIZER_MAPPING._extra_content:
                            del TOKENIZER_MAPPING._extra_content[CustomConfig]
                     if CustomConfig in PROCESSOR_MAPPING._extra_content:
                            del PROCESSOR_MAPPING._extra_content[CustomConfig]

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




              """simple docstring"""


              class 							_UpperCamelCase					(	lowerCAmelCase_     ):
                     _UpperCamelCase				:					List[Any]         =   False



              class 							_UpperCamelCase					(	lowerCAmelCase_     ):
                     _UpperCamelCase				:					Union[str, Any]         =   False



              class 							_UpperCamelCase					(	lowerCAmelCase_     ):
                     _UpperCamelCase				:					List[str]         =   '''AutoFeatureExtractor'''
                     _UpperCamelCase				:					Dict         =   '''AutoTokenizer'''
                     _UpperCamelCase				:					Optional[Any]         =   False

              try:
                     AutoConfig.register("custom"					,   _SCREAMING_SNAKE_CASE		)
                     AutoFeatureExtractor.register(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)
                     AutoTokenizer.register(_SCREAMING_SNAKE_CASE					,   slow_tokenizer_class=_SCREAMING_SNAKE_CASE		)
                     AutoProcessor.register(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)
                     # If remote code is not set, the default is to use local classes.
                     UpperCamelCase_          =  AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor"		)
                     self.assertEqual(processor.__class__.__name__					,   "NewProcessor"		)
                     self.assertFalse(processor.special_attribute_present		)
                     self.assertFalse(processor.feature_extractor.special_attribute_present		)
                     self.assertFalse(processor.tokenizer.special_attribute_present		)

                     # If remote code is disabled, we load the local ones.
                     UpperCamelCase_          =  AutoProcessor.from_pretrained(
                         "hf-internal-testing/test_dynamic_processor"					,   trust_remote_code=_SCREAMING_SNAKE_CASE		)
                     self.assertEqual(processor.__class__.__name__					,   "NewProcessor"		)
                     self.assertFalse(processor.special_attribute_present		)
                     self.assertFalse(processor.feature_extractor.special_attribute_present		)
                     self.assertFalse(processor.tokenizer.special_attribute_present		)

                     # If remote is enabled, we load from the Hub.
                     UpperCamelCase_          =  AutoProcessor.from_pretrained(
                         "hf-internal-testing/test_dynamic_processor"					,   trust_remote_code=_SCREAMING_SNAKE_CASE		)
                     self.assertEqual(processor.__class__.__name__					,   "NewProcessor"		)
                     self.assertTrue(processor.special_attribute_present		)
                     self.assertTrue(processor.feature_extractor.special_attribute_present		)
                     self.assertTrue(processor.tokenizer.special_attribute_present		)

              finally:
                     if "custom" in CONFIG_MAPPING._extra_content:
                            del CONFIG_MAPPING._extra_content["custom"]
                     if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
                            del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
                     if CustomConfig in TOKENIZER_MAPPING._extra_content:
                            del TOKENIZER_MAPPING._extra_content[CustomConfig]
                     if CustomConfig in PROCESSOR_MAPPING._extra_content:
                            del PROCESSOR_MAPPING._extra_content[CustomConfig]

       def lowercase (		self: Any		)       -> Dict:




              """simple docstring"""


              UpperCamelCase_          =  AutoProcessor.from_pretrained("hf-internal-testing/tiny-random-bert"		)
              self.assertEqual(processor.__class__.__name__					,   "BertTokenizerFast"		)



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




              """simple docstring"""


              UpperCamelCase_          =  AutoProcessor.from_pretrained("hf-internal-testing/tiny-random-convnext"		)
              self.assertEqual(processor.__class__.__name__					,   "ConvNextImageProcessor"		)



@is_staging_test
class 							_UpperCamelCase					(	unittest.TestCase     ):
       _UpperCamelCase				:					Dict         =   ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''bla''', '''blou''']

       @classmethod
       def lowercase (		cls: List[Any]		)       -> Optional[int]:




              """simple docstring"""


              UpperCamelCase_          =  TOKEN
              HfFolder.save_token(_SCREAMING_SNAKE_CASE		)

       @classmethod
       def lowercase (		cls: Tuple		)       -> List[str]:




              """simple docstring"""


              try:
                     delete_repo(token=cls._token					,   repo_id="test-processor"		)
              except HTTPError:
                     pass

              try:
                     delete_repo(token=cls._token					,   repo_id="valid_org/test-processor-org"		)
              except HTTPError:
                     pass

              try:
                     delete_repo(token=cls._token					,   repo_id="test-dynamic-processor"		)
              except HTTPError:
                     pass

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




              """simple docstring"""


              UpperCamelCase_          =  WavaVecaProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)
              with tempfile.TemporaryDirectory() as tmp_dir:
                     processor.save_pretrained(
                         os.path.join(_SCREAMING_SNAKE_CASE					,   "test-processor"		)					,   push_to_hub=_SCREAMING_SNAKE_CASE					,   use_auth_token=self._token		)

                     UpperCamelCase_          =  WavaVecaProcessor.from_pretrained(f'''{USER}/test-processor'''		)
                     for k, v in processor.feature_extractor.__dict__.items():
                            self.assertEqual(_SCREAMING_SNAKE_CASE					,   getattr(new_processor.feature_extractor					,   _SCREAMING_SNAKE_CASE		)		)
                     self.assertDictEqual(new_processor.tokenizer.get_vocab()					,   processor.tokenizer.get_vocab()		)

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




              """simple docstring"""


              UpperCamelCase_          =  WavaVecaProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              with tempfile.TemporaryDirectory() as tmp_dir:
                     processor.save_pretrained(
                         os.path.join(_SCREAMING_SNAKE_CASE					,   "test-processor-org"		)					,   push_to_hub=_SCREAMING_SNAKE_CASE					,   use_auth_token=self._token					,   organization="valid_org"					,   )

                     UpperCamelCase_          =  WavaVecaProcessor.from_pretrained("valid_org/test-processor-org"		)
                     for k, v in processor.feature_extractor.__dict__.items():
                            self.assertEqual(_SCREAMING_SNAKE_CASE					,   getattr(new_processor.feature_extractor					,   _SCREAMING_SNAKE_CASE		)		)
                     self.assertDictEqual(new_processor.tokenizer.get_vocab()					,   processor.tokenizer.get_vocab()		)



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




              """simple docstring"""


              CustomFeatureExtractor.register_for_auto_class()
              CustomTokenizer.register_for_auto_class()
              CustomProcessor.register_for_auto_class()

              UpperCamelCase_          =  CustomFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              with tempfile.TemporaryDirectory() as tmp_dir:
                     UpperCamelCase_          =  os.path.join(_SCREAMING_SNAKE_CASE					,   "vocab.txt"		)
                     with open(_SCREAMING_SNAKE_CASE					,   "w"					,   encoding="utf-8"		) as vocab_writer:
                            vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]		)		)
                     UpperCamelCase_          =  CustomTokenizer(_SCREAMING_SNAKE_CASE		)

              UpperCamelCase_          =  CustomProcessor(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

              with tempfile.TemporaryDirectory() as tmp_dir:
                     create_repo(f'''{USER}/test-dynamic-processor'''					,   token=self._token		)
                     UpperCamelCase_          =  Repository(_SCREAMING_SNAKE_CASE					,   clone_from=f'''{USER}/test-dynamic-processor'''					,   token=self._token		)
                     processor.save_pretrained(_SCREAMING_SNAKE_CASE		)

                     # This has added the proper auto_map field to the feature extractor config
                     self.assertDictEqual(
                         processor.feature_extractor.auto_map					,   {
                             "AutoFeatureExtractor": "custom_feature_extraction.CustomFeatureExtractor",
                             "AutoProcessor": "custom_processing.CustomProcessor",
                         }					,   )

                     # This has added the proper auto_map field to the tokenizer config
                     with open(os.path.join(_SCREAMING_SNAKE_CASE					,   "tokenizer_config.json"		)		) as f:
                            UpperCamelCase_          =  json.load(_SCREAMING_SNAKE_CASE		)
                     self.assertDictEqual(
                         tokenizer_config["auto_map"]					,   {
                             "AutoTokenizer": ["custom_tokenization.CustomTokenizer", None],
                             "AutoProcessor": "custom_processing.CustomProcessor",
                         }					,   )

                     # The code has been copied from fixtures
                     self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE					,   "custom_feature_extraction.py"		)		)		)
                     self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE					,   "custom_tokenization.py"		)		)		)
                     self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE					,   "custom_processing.py"		)		)		)

                     repo.push_to_hub()

              UpperCamelCase_          =  AutoProcessor.from_pretrained(f'''{USER}/test-dynamic-processor'''					,   trust_remote_code=_SCREAMING_SNAKE_CASE		)
              # Can't make an isinstance check because the new_processor is from the CustomProcessor class of a dynamic module
              self.assertEqual(new_processor.__class__.__name__					,   "CustomProcessor"		)








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}},
                  ]					,   )

