





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


_UpperCamelCase							=			get_tests_dir('''fixtures''')




class 					_lowerCamelCase			(     unittest.TestCase     ):



      """simple docstring"""






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






        '''simple docstring'''






        __snake_case :					Any          =							mock.Mock()
        __snake_case :					List[str]          =							500
        __snake_case :					Optional[Any]          =							{}
        __snake_case :					List[str]          =							HTTPError
        __snake_case :					List[str]          =							{}

        # Download this model to make sure it's in the cache.
        __snake_case :					Dict          =							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=__lowercase ) as mock_head:
          __snake_case :					Tuple          =							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 )							-> int:






        '''simple docstring'''






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







      def     UpperCAmelCase		(			self )							-> str:






        '''simple docstring'''






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

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

        self.assertIsNotNone(__lowercase )




@is_staging_test
class 					_lowerCamelCase			(     unittest.TestCase     ):



      """simple docstring"""






      @classmethod
      def     UpperCAmelCase		(			cls )							-> str:






        '''simple docstring'''






        __snake_case :					Any          =							TOKEN
        HfFolder.save_token(__lowercase )







      @classmethod
      def     UpperCAmelCase		(			cls )							-> 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'''






        __snake_case :					Dict          =							ViTImageProcessor.from_pretrained(__lowercase )
        image_processor.push_to_hub("test-image-processor"					,    use_auth_token=self._token )

        __snake_case :					Optional[Any]          =							ViTImageProcessor.from_pretrained(F"""{USER}/test-image-processor""" )
        for k, v in image_processor.__dict__.items():
          self.assertEqual(__lowercase					,    getattr(__lowercase					,    __lowercase ) )

        # 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(
              __lowercase					,    repo_id="test-image-processor"					,    push_to_hub=__lowercase					,    use_auth_token=self._token )

        __snake_case :					Tuple          =							ViTImageProcessor.from_pretrained(F"""{USER}/test-image-processor""" )
        for k, v in image_processor.__dict__.items():
          self.assertEqual(__lowercase					,    getattr(__lowercase					,    __lowercase ) )







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






        '''simple docstring'''






        __snake_case :					Tuple          =							ViTImageProcessor.from_pretrained(__lowercase )
        image_processor.push_to_hub("valid_org/test-image-processor"					,    use_auth_token=self._token )

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

        # 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(
              __lowercase					,    repo_id="valid_org/test-image-processor-org"					,    push_to_hub=__lowercase					,    use_auth_token=self._token )

        __snake_case :					Union[str, Any]          =							ViTImageProcessor.from_pretrained("valid_org/test-image-processor-org" )
        for k, v in image_processor.__dict__.items():
          self.assertEqual(__lowercase					,    getattr(__lowercase					,    __lowercase ) )







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






        '''simple docstring'''






        CustomImageProcessor.register_for_auto_class()
        __snake_case :					Dict          =							CustomImageProcessor.from_pretrained(__lowercase )

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

        __snake_case :					Tuple          =							AutoImageProcessor.from_pretrained(
            F"""{USER}/test-dynamic-image-processor"""					,    trust_remote_code=__lowercase )
        # 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'''
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


UpperCAmelCase_			:  Any										=   {
    'configuration_maskformer': ['MASKFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MaskFormerConfig'],
    'configuration_maskformer_swin': ['MaskFormerSwinConfig'],
}

try:
 if not is_vision_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase_			:  Tuple										=   ['MaskFormerFeatureExtractor']
 UpperCAmelCase_			:  List[str]										=   ['MaskFormerImageProcessor']


try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase_			:  Optional[Any]										=   [
     'MASKFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
     'MaskFormerForInstanceSegmentation',
     'MaskFormerModel',
     'MaskFormerPreTrainedModel',
 ]
 UpperCAmelCase_			:  Optional[int]										=   [
     'MaskFormerSwinBackbone',
     'MaskFormerSwinModel',
     'MaskFormerSwinPreTrainedModel',
 ]

if TYPE_CHECKING:
 from .configuration_maskformer import MASKFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, MaskFormerConfig
 from .configuration_maskformer_swin import MaskFormerSwinConfig

 try:
  if not is_vision_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .feature_extraction_maskformer import MaskFormerFeatureExtractor
  from .image_processing_maskformer import MaskFormerImageProcessor
 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_maskformer import (
      MASKFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
      MaskFormerForInstanceSegmentation,
      MaskFormerModel,
      MaskFormerPreTrainedModel,
  )
  from .modeling_maskformer_swin import (
      MaskFormerSwinBackbone,
      MaskFormerSwinModel,
      MaskFormerSwinPreTrainedModel,
  )


else:
 import sys

 UpperCAmelCase_			:  Union[str, Any]										=   _LazyModule(__name__, globals()['__file__'], _import_structure)






