





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


snake_case_							=			get_tests_dir('''fixtures''')
class        snake_case_		(			unittest.TestCase):







		def 			__lowercase   (		self   )				->   Optional[Any]:
				lowerCamelCase   : Optional[Any]								=mock.Mock()
				lowerCamelCase   : List[Any]								=5_0_0
				lowerCamelCase   : List[str]								={}
				lowerCamelCase   : List[Any]								=HTTPError
				lowerCamelCase   : Optional[int]								={}

				# Download this model to make sure it's in the cache.
				lowerCamelCase   : Optional[int]								=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=a_   ) as mock_head:
						lowerCamelCase   : str								=ViTImageProcessor.from_pretrained('''hf-internal-testing/tiny-random-vit'''   )
						# This check we did call the fake head request
						mock_head.assert_called()







		def 			__lowercase   (		self   )				->   List[str]:
				lowerCamelCase   : Optional[int]								=ViTImageProcessor.from_pretrained(
				    '''https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json'''   )







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



				with self.assertRaises(a_   ):
						# config is in subfolder, the following should not work without specifying the subfolder
						lowerCamelCase   : Union[str, Any]								=AutoImageProcessor.from_pretrained('''hf-internal-testing/stable-diffusion-all-variants'''   )

				lowerCamelCase   : Optional[Any]								=AutoImageProcessor.from_pretrained(
				    '''hf-internal-testing/stable-diffusion-all-variants'''			,     subfolder='''feature_extractor'''   )

				self.assertIsNotNone(a_   )

@is_staging_test
class        snake_case_		(			unittest.TestCase):







		@classmethod
		def 			__lowercase   (		cls   )				->   int:
				lowerCamelCase   : Union[str, Any]								=TOKEN
				HfFolder.save_token(a_   )







		@classmethod
		def 			__lowercase   (		cls   )				->   Any:



				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 			__lowercase   (		self   )				->   List[str]:
				lowerCamelCase   : Union[str, Any]								=ViTImageProcessor.from_pretrained(a_   )
				image_processor.push_to_hub('''test-image-processor'''			,     use_auth_token=self._token   )

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

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

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







		def 			__lowercase   (		self   )				->   List[Any]:
				lowerCamelCase   : Optional[int]								=ViTImageProcessor.from_pretrained(a_   )
				image_processor.push_to_hub('''valid_org/test-image-processor'''			,     use_auth_token=self._token   )

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

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

				lowerCamelCase   : List[Any]								=ViTImageProcessor.from_pretrained('''valid_org/test-image-processor-org'''   )
				for k, v in image_processor.__dict__.items():
						self.assertEqual(a_			,     getattr(a_			,     a_   )   )







		def 			__lowercase   (		self   )				->   Optional[int]:
				CustomImageProcessor.register_for_auto_class()
				lowerCamelCase   : List[str]								=CustomImageProcessor.from_pretrained(a_   )

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

				lowerCamelCase   : Optional[int]								=AutoImageProcessor.from_pretrained(
				    F"{USER}/test-dynamic-image-processor"			,     trust_remote_code=a_   )
				# 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'''   )








from typing import TYPE_CHECKING

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


snake_case_							=			{'''configuration_swin''': ['''SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''SwinConfig''', '''SwinOnnxConfig''']}


try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				snake_case_							=			[
				    '''SWIN_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''SwinForImageClassification''',
				    '''SwinForMaskedImageModeling''',
				    '''SwinModel''',
				    '''SwinPreTrainedModel''',
				    '''SwinBackbone''',
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				snake_case_							=			[
				    '''TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''TFSwinForImageClassification''',
				    '''TFSwinForMaskedImageModeling''',
				    '''TFSwinModel''',
				    '''TFSwinPreTrainedModel''',
				]

if TYPE_CHECKING:
				from .configuration_swin import SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinConfig, SwinOnnxConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_swin import (
								    SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
								    SwinBackbone,
								    SwinForImageClassification,
								    SwinForMaskedImageModeling,
								    SwinModel,
								    SwinPreTrainedModel,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_swin import (
								    TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFSwinForImageClassification,
								    TFSwinForMaskedImageModeling,
								    TFSwinModel,
								    TFSwinPreTrainedModel,
								)

else:
				import sys

				snake_case_							=			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

