





import inspect
import os
import unittest
from pathlib import Path

import torch

import accelerate
from accelerate.test_utils import execute_subprocess_async
from accelerate.test_utils.testing import run_command



class 							_UpperCamelCase					(	unittest.TestCase     ):
       _UpperCamelCase				:					Optional[int]         =   inspect.getfile(accelerate.test_utils     )
       _UpperCamelCase				:					Optional[int]         =   os.path.sep.join(mod_file.split(os.path.sep     )[:-1] + ['''scripts''', '''test_cli.py''']     )

       _UpperCamelCase				:					Tuple         =   ['''accelerate''', '''launch''']
       _UpperCamelCase				:					Any         =   Path.home() / '''.cache/huggingface/accelerate'''
       _UpperCamelCase				:					List[str]         =   '''default_config.yaml'''
       _UpperCamelCase				:					int         =   config_folder / config_file
       _UpperCamelCase				:					Any         =   config_folder / '''_default_config.yaml'''

       _UpperCamelCase				:					Optional[Any]         =   Path('''tests/test_configs'''     )

       @classmethod
       def lowercase (		cls: Union[str, Any]		)       -> Union[str, Any]:




              """simple docstring"""


              if cls.config_path.is_file():
                     cls.config_path.rename(cls.changed_path		)

       @classmethod
       def lowercase (		cls: Any		)       -> Dict:




              """simple docstring"""


              if cls.changed_path.is_file():
                     cls.changed_path.rename(cls.config_path		)

       def lowercase (		self: Any		)       -> int:




              """simple docstring"""


              UpperCamelCase_          =  self.base_cmd
              if torch.cuda.is_available() and (torch.cuda.device_count() > 1):
                     cmd += ["--multi_gpu"]
              execute_subprocess_async(cmd + [self.test_file_path]					,   env=os.environ.copy()		)

       def lowercase (		self: Dict		)       -> str:




              """simple docstring"""


              for config in sorted(self.test_config_path.glob("**/*.yaml"		)		):
                     with self.subTest(config_file=_SCREAMING_SNAKE_CASE		):
                            execute_subprocess_async(
                                self.base_cmd + ["--config_file", str(_SCREAMING_SNAKE_CASE		), self.test_file_path]					,   env=os.environ.copy()		)



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




              """simple docstring"""


              execute_subprocess_async(["accelerate", "test"]					,   env=os.environ.copy()		)



class 							_UpperCamelCase					(	unittest.TestCase     ):
       _UpperCamelCase				:					int         =   '''test-tpu'''
       _UpperCamelCase				:					Union[str, Any]         =   '''us-central1-a'''
       _UpperCamelCase				:					List[Any]         =   '''ls'''
       _UpperCamelCase				:					Tuple         =   ['''accelerate''', '''tpu-config''']
       _UpperCamelCase				:					int         =   '''cd /usr/share'''
       _UpperCamelCase				:					Optional[int]         =   '''tests/test_samples/test_command_file.sh'''
       _UpperCamelCase				:					Any         =   '''Running gcloud compute tpus tpu-vm ssh'''

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




              """simple docstring"""


              UpperCamelCase_          =  run_command(
                  self.cmd
                  + ["--command", self.command, "--tpu_zone", self.tpu_zone, "--tpu_name", self.tpu_name, "--debug"]					,   return_stdout=_SCREAMING_SNAKE_CASE					,   )
              self.assertIn(
                  f'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all'''					,   _SCREAMING_SNAKE_CASE					,   )

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




              """simple docstring"""


              UpperCamelCase_          =  run_command(
                  self.cmd
                  + [
                      "--config_file",
                      "tests/test_configs/0_12_0.yaml",
                      "--command",
                      self.command,
                      "--tpu_zone",
                      self.tpu_zone,
                      "--tpu_name",
                      self.tpu_name,
                      "--debug",
                  ]					,   return_stdout=_SCREAMING_SNAKE_CASE					,   )
              self.assertIn(
                  f'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all'''					,   _SCREAMING_SNAKE_CASE					,   )

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




              """simple docstring"""


              UpperCamelCase_          =  run_command(
                  self.cmd + ["--config_file", "tests/test_configs/latest.yaml", "--debug"]					,   return_stdout=_SCREAMING_SNAKE_CASE		)
              self.assertIn(
                  f'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo "hello world"; echo "this is a second command" --worker all'''					,   _SCREAMING_SNAKE_CASE					,   )

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




              """simple docstring"""


              UpperCamelCase_          =  run_command(
                  self.cmd + ["--config_file", "tests/test_configs/latest.yaml", "--command", self.command, "--debug"]					,   return_stdout=_SCREAMING_SNAKE_CASE					,   )
              self.assertIn(
                  f'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all'''					,   _SCREAMING_SNAKE_CASE					,   )

       def lowercase (		self: str		)       -> Tuple:




              """simple docstring"""


              UpperCamelCase_          =  run_command(
                  self.cmd
                  + [
                      "--config_file",
                      "tests/test_configs/latest.yaml",
                      "--command",
                      self.command,
                      "--command",
                      "echo \"Hello World\"",
                      "--debug",
                  ]					,   return_stdout=_SCREAMING_SNAKE_CASE					,   )
              self.assertIn(
                  f'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls; echo "Hello World" --worker all'''					,   _SCREAMING_SNAKE_CASE					,   )

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




              """simple docstring"""


              UpperCamelCase_          =  run_command(
                  self.cmd
                  + ["--config_file", "tests/test_configs/latest.yaml", "--command_file", self.command_file, "--debug"]					,   return_stdout=_SCREAMING_SNAKE_CASE					,   )
              self.assertIn(
                  f'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo "hello world"; echo "this is a second command" --worker all'''					,   _SCREAMING_SNAKE_CASE					,   )

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




              """simple docstring"""


              UpperCamelCase_          =  run_command(
                  self.cmd
                  + [
                      "--config_file",
                      "tests/test_configs/0_12_0.yaml",
                      "--command_file",
                      self.command_file,
                      "--tpu_zone",
                      self.tpu_zone,
                      "--tpu_name",
                      self.tpu_name,
                      "--debug",
                  ]					,   return_stdout=_SCREAMING_SNAKE_CASE					,   )
              self.assertIn(
                  f'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo "hello world"; echo "this is a second command" --worker all'''					,   _SCREAMING_SNAKE_CASE					,   )

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




              """simple docstring"""


              UpperCamelCase_          =  run_command(
                  self.cmd + ["--config_file", "tests/test_configs/latest.yaml", "--install_accelerate", "--debug"]					,   return_stdout=_SCREAMING_SNAKE_CASE					,   )
              self.assertIn(
                  f'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; pip install accelerate -U; echo "hello world"; echo "this is a second command" --worker all'''					,   _SCREAMING_SNAKE_CASE					,   )



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




              """simple docstring"""


              UpperCamelCase_          =  run_command(
                  self.cmd
                  + [
                      "--config_file",
                      "tests/test_configs/latest.yaml",
                      "--install_accelerate",
                      "--accelerate_version",
                      "12.0.0",
                      "--debug",
                  ]					,   return_stdout=_SCREAMING_SNAKE_CASE					,   )
              self.assertIn(
                  f'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; pip install accelerate==12.0.0; echo "hello world"; echo "this is a second command" --worker all'''					,   _SCREAMING_SNAKE_CASE					,   )








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

