






import copy
import tempfile
import unittest

from huggingface_hub import HfFolder, delete_repo
from parameterized import parameterized
from requests.exceptions import HTTPError

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test




class 							_lowerCAmelCase(			unittest.TestCase   ):





       """simple docstring"""







       @parameterized.expand([(None,), ('foo.json',)]				)
       def      _a       (   self    ,     _lowerCamelCase				):
         UpperCamelCase_:   Any        =							GenerationConfig(
             do_sample=_lowercase    ,     temperature=0.7    ,     length_penalty=1.0    ,     bad_words_ids=[[1, 2, 3], [4, 5]]    ,     )
         with tempfile.TemporaryDirectory() as tmp_dir:
           config.save_pretrained(_lowercase    ,     config_name=_lowercase				)
           UpperCamelCase_:   str        =							GenerationConfig.from_pretrained(_lowercase    ,     config_name=_lowercase				)

         # Checks parameters that were specified
         self.assertEqual(loaded_config.do_sample    ,     _lowercase				)
         self.assertEqual(loaded_config.temperature    ,     0.7				)
         self.assertEqual(loaded_config.length_penalty    ,     1.0				)
         self.assertEqual(loaded_config.bad_words_ids    ,     [[1, 2, 3], [4, 5]]				)

         # Checks parameters that were not specified (defaults)
         self.assertEqual(loaded_config.top_k    ,     5_0				)
         self.assertEqual(loaded_config.max_length    ,     2_0				)
         self.assertEqual(loaded_config.max_time    ,     _lowercase				)





       def      _a       (   self				):
         UpperCamelCase_:   List[Any]        =							AutoConfig.from_pretrained('gpt2'				)
         UpperCamelCase_:   List[Any]        =							GenerationConfig.from_model_config(_lowercase				)
         UpperCamelCase_:   int        =							GenerationConfig()

         # The generation config has loaded a few non-default parameters from the model config
         self.assertNotEqual(_lowercase    ,     _lowercase				)

         # One of those parameters is eos_token_id -- check if it matches
         self.assertNotEqual(generation_config_from_model.eos_token_id    ,     default_generation_config.eos_token_id				)
         self.assertEqual(generation_config_from_model.eos_token_id    ,     model_config.eos_token_id				)





       def      _a       (   self				):
         UpperCamelCase_:   List[Any]        =							GenerationConfig()
         UpperCamelCase_:   str        =							{
             'max_new_tokens': 1_0_2_4,
             'foo': 'bar',
         }
         UpperCamelCase_:   int        =							copy.deepcopy(_lowercase				)
         UpperCamelCase_:   int        =							generation_config.update(**_lowercase				)

         # update_kwargs was not modified (no side effects)
         self.assertEqual(_lowercase    ,     _lowercase				)

         # update_kwargs was used to update the config on valid attributes
         self.assertEqual(generation_config.max_new_tokens    ,     1_0_2_4				)

         # `.update()` returns a dictionary of unused kwargs
         self.assertEqual(_lowercase    ,     {'foo': 'bar'}				)





       def      _a       (   self				):
         UpperCamelCase_:   Optional[Any]        =							GenerationConfig()
         UpperCamelCase_:   str        =							'bar'

         with tempfile.TemporaryDirectory('test-generation-config'				) as tmp_dir:
           generation_config.save_pretrained(_lowercase				)

           UpperCamelCase_:   Any        =							GenerationConfig.from_pretrained(_lowercase				)
         # update_kwargs was used to update the config on valid attributes
         self.assertEqual(new_config.foo    ,     'bar'				)

         UpperCamelCase_:   Dict        =							GenerationConfig.from_model_config(_lowercase				)
         assert not hasattr(_lowercase    ,     'foo'				)  # no new kwargs should be initialized if from config





       def      _a       (   self				):
         UpperCamelCase_:   List[Any]        =							GenerationConfig()
         self.assertEqual(default_config.temperature    ,     1.0				)
         self.assertEqual(default_config.do_sample    ,     _lowercase				)
         self.assertEqual(default_config.num_beams    ,     1				)

         UpperCamelCase_:   List[Any]        =							GenerationConfig(
             do_sample=_lowercase    ,     temperature=0.7    ,     length_penalty=1.0    ,     bad_words_ids=[[1, 2, 3], [4, 5]]    ,     )
         self.assertEqual(config.temperature    ,     0.7				)
         self.assertEqual(config.do_sample    ,     _lowercase				)
         self.assertEqual(config.num_beams    ,     1				)

         with tempfile.TemporaryDirectory() as tmp_dir:
           config.save_pretrained(_lowercase				)
           UpperCamelCase_:   Optional[Any]        =							GenerationConfig.from_pretrained(_lowercase    ,     temperature=1.0				)

         self.assertEqual(loaded_config.temperature    ,     1.0				)
         self.assertEqual(loaded_config.do_sample    ,     _lowercase				)
         self.assertEqual(loaded_config.num_beams    ,     1				)  # default value







@is_staging_test
class 							_lowerCAmelCase(			unittest.TestCase   ):





       """simple docstring"""







       @classmethod
       def      _a       (   cls				):
         UpperCamelCase_:   Optional[Any]        =							TOKEN
         HfFolder.save_token(_lowercase				)





       @classmethod
       def      _a       (   cls				):
         try:
           delete_repo(token=cls._token    ,     repo_id='test-generation-config'				)
         except HTTPError:
           pass

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





       def      _a       (   self				):
         UpperCamelCase_:   List[str]        =							GenerationConfig(
             do_sample=_lowercase    ,     temperature=0.7    ,     length_penalty=1.0    ,     )
         config.push_to_hub('test-generation-config'    ,     use_auth_token=self._token				)

         UpperCamelCase_:   Optional[int]        =							GenerationConfig.from_pretrained(f'''{USER}/test-generation-config'''				)
         for k, v in config.to_dict().items():
           if k != "transformers_version":
             self.assertEqual(_lowercase    ,     getattr(_lowercase    ,     _lowercase				)				)

        # Reset repo
         delete_repo(token=self._token    ,     repo_id='test-generation-config'				)

         # Push to hub via save_pretrained
         with tempfile.TemporaryDirectory() as tmp_dir:
           config.save_pretrained(
               _lowercase    ,     repo_id='test-generation-config'    ,     push_to_hub=_lowercase    ,     use_auth_token=self._token				)

         UpperCamelCase_:   str        =							GenerationConfig.from_pretrained(f'''{USER}/test-generation-config'''				)
         for k, v in config.to_dict().items():
           if k != "transformers_version":
             self.assertEqual(_lowercase    ,     getattr(_lowercase    ,     _lowercase				)				)





       def      _a       (   self				):
         UpperCamelCase_:   Optional[Any]        =							GenerationConfig(
             do_sample=_lowercase    ,     temperature=0.7    ,     length_penalty=1.0    ,     )
         config.push_to_hub('valid_org/test-generation-config-org'    ,     use_auth_token=self._token				)

         UpperCamelCase_:   Dict        =							GenerationConfig.from_pretrained('valid_org/test-generation-config-org'				)
         for k, v in config.to_dict().items():
           if k != "transformers_version":
             self.assertEqual(_lowercase    ,     getattr(_lowercase    ,     _lowercase				)				)

        # Reset repo
         delete_repo(token=self._token    ,     repo_id='valid_org/test-generation-config-org'				)

         # Push to hub via save_pretrained
         with tempfile.TemporaryDirectory() as tmp_dir:
           config.save_pretrained(
               _lowercase    ,     repo_id='valid_org/test-generation-config-org'    ,     push_to_hub=_lowercase    ,     use_auth_token=self._token				)

         UpperCamelCase_:   Union[str, Any]        =							GenerationConfig.from_pretrained('valid_org/test-generation-config-org'				)
         for k, v in config.to_dict().items():
           if k != "transformers_version":
             self.assertEqual(_lowercase    ,     getattr(_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}},
             ]		,						)
