






"""simple docstring"""







import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

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

from transformers import AutoImageProcessor, ViTImageProcessor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


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

from test_module.custom_image_processing import CustomImageProcessor  # noqa E402


lowerCAmelCase_						:     Tuple							  =   get_tests_dir('''fixtures''')





class 	UpperCamelCase_			(							unittest.TestCase	):



  def 		UpperCamelCase_					(   self					)      ->      Optional[Any]:



         """simple docstring"""





         UpperCAmelCase						     =      mock.Mock()
         UpperCAmelCase						     =      5_00
         UpperCAmelCase						     =      {}
         UpperCAmelCase						     =      HTTPError
         UpperCAmelCase						     =      {}

         # Download this model to make sure it's in the cache.
         UpperCAmelCase						     =      ViTImageProcessor.from_pretrained("""hf-internal-testing/tiny-random-vit"""					)
         # Under the mock environment we get a 500 error when trying to reach the model.
         with mock.patch("""requests.Session.request"""			,		return_value=snake_case__					) as mock_head:
                UpperCAmelCase						     =      ViTImageProcessor.from_pretrained("""hf-internal-testing/tiny-random-vit"""					)
                # This check we did call the fake head request
                mock_head.assert_called()



  def 		UpperCamelCase_					(   self					)      ->      Tuple:



         """simple docstring"""





         UpperCAmelCase						     =      ViTImageProcessor.from_pretrained(
             """https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json"""					)



  def 		UpperCamelCase_					(   self					)      ->      Optional[Any]:



         """simple docstring"""





         with self.assertRaises(snake_case__					):
                # config is in subfolder, the following should not work without specifying the subfolder
                UpperCAmelCase						     =      AutoImageProcessor.from_pretrained("""hf-internal-testing/stable-diffusion-all-variants"""					)

         UpperCAmelCase						     =      AutoImageProcessor.from_pretrained(
             """hf-internal-testing/stable-diffusion-all-variants"""			,		subfolder="""feature_extractor"""					)

         self.assertIsNotNone(snake_case__					)





@is_staging_test
class 	UpperCamelCase_			(							unittest.TestCase	):



  @classmethod
  def 		UpperCamelCase_					(   cls					)      ->      Optional[int]:



         """simple docstring"""





         UpperCAmelCase						     =      TOKEN
         HfFolder.save_token(snake_case__					)



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



         """simple docstring"""





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

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

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



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



         """simple docstring"""





         UpperCAmelCase						     =      ViTImageProcessor.from_pretrained(snake_case__					)
         image_processor.push_to_hub("""test-image-processor"""			,		use_auth_token=self._token					)

         UpperCAmelCase						     =      ViTImageProcessor.from_pretrained(f'''{USER}/test-image-processor'''					)
         for k, v in image_processor.__dict__.items():
                self.assertEqual(snake_case__			,		getattr(snake_case__			,		snake_case__					)					)

         # Reset repo
         delete_repo(token=self._token			,		repo_id="""test-image-processor"""					)

         # Push to hub via save_pretrained
         with tempfile.TemporaryDirectory() as tmp_dir:
                image_processor.save_pretrained(
                    snake_case__			,		repo_id="""test-image-processor"""			,		push_to_hub=snake_case__			,		use_auth_token=self._token					)

         UpperCAmelCase						     =      ViTImageProcessor.from_pretrained(f'''{USER}/test-image-processor'''					)
         for k, v in image_processor.__dict__.items():
                self.assertEqual(snake_case__			,		getattr(snake_case__			,		snake_case__					)					)



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



         """simple docstring"""





         UpperCAmelCase						     =      ViTImageProcessor.from_pretrained(snake_case__					)
         image_processor.push_to_hub("""valid_org/test-image-processor"""			,		use_auth_token=self._token					)

         UpperCAmelCase						     =      ViTImageProcessor.from_pretrained("""valid_org/test-image-processor"""					)
         for k, v in image_processor.__dict__.items():
                self.assertEqual(snake_case__			,		getattr(snake_case__			,		snake_case__					)					)

         # Reset repo
         delete_repo(token=self._token			,		repo_id="""valid_org/test-image-processor"""					)

         # Push to hub via save_pretrained
         with tempfile.TemporaryDirectory() as tmp_dir:
                image_processor.save_pretrained(
                    snake_case__			,		repo_id="""valid_org/test-image-processor-org"""			,		push_to_hub=snake_case__			,		use_auth_token=self._token					)

         UpperCAmelCase						     =      ViTImageProcessor.from_pretrained("""valid_org/test-image-processor-org"""					)
         for k, v in image_processor.__dict__.items():
                self.assertEqual(snake_case__			,		getattr(snake_case__			,		snake_case__					)					)



  def 		UpperCamelCase_					(   self					)      ->      List[Any]:



         """simple docstring"""





         CustomImageProcessor.register_for_auto_class()
         UpperCAmelCase						     =      CustomImageProcessor.from_pretrained(snake_case__					)

         image_processor.push_to_hub("""test-dynamic-image-processor"""			,		use_auth_token=self._token					)

         # This has added the proper auto_map field to the config
         self.assertDictEqual(
             image_processor.auto_map			,		{"""AutoImageProcessor""": """custom_image_processing.CustomImageProcessor"""}			,		)

         UpperCAmelCase						     =      AutoImageProcessor.from_pretrained(
             f'''{USER}/test-dynamic-image-processor'''			,		trust_remote_code=snake_case__					)
         # Can't make an isinstance check because the new_image_processor is from the CustomImageProcessor class of a dynamic module
         self.assertEqual(new_image_processor.__class__.__name__			,		"""CustomImageProcessor"""					)






'''simple docstring'''


import inspect
import os
import unittest

import torch

import accelerate
from accelerate import debug_launcher
from accelerate.test_utils import (
    execute_subprocess_async,
    require_cpu,
    require_huggingface_suite,
    require_multi_gpu,
    require_single_gpu,
)
from accelerate.utils import patch_environment





@require_huggingface_suite
class  __lowercase    (	unittest.TestCase			):







   def 		UpperCamelCase__      (						self   )					->     Tuple:
     __a								=       inspect.getfile(accelerate.test_utils   )
     __a								=       os.path.sep.join(
         mod_file.split(os.path.sep   )[:-1] + ['scripts', 'external_deps', 'test_metrics.py']   )

     from accelerate.test_utils.scripts.external_deps import test_metrics  # noqa: F401

     __a								=       test_metrics







   @require_cpu
   def 		UpperCamelCase__      (						self   )					->     Tuple:
     debug_launcher(self.test_metrics.main   ,				num_processes=1   )







   @require_cpu
   def 		UpperCamelCase__      (						self   )					->     str:
     debug_launcher(self.test_metrics.main   )







   @require_single_gpu
   def 		UpperCamelCase__      (						self   )					->     Dict:
     self.test_metrics.main()







   @require_multi_gpu
   def 		UpperCamelCase__      (						self   )					->     int:
     print(f"Found {torch.cuda.device_count()} devices."   )
     __a								=       ['torchrun', f"--nproc_per_node={torch.cuda.device_count()}", self.test_file_path]
     with patch_environment(omp_num_threads=1   ):
       execute_subprocess_async(UpperCamelCase   ,				env=os.environ.copy()   )



