






"""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


__a       :	str             = get_tests_dir('fixtures')







class        _SCREAMING_SNAKE_CASE						(  unittest.TestCase							):





							"""simple docstring"""





							def  lowercase		(   self:     Tuple    ):

												'''simple docstring'''

												a__          =  mock.Mock()
												a__          =  500
												a__          =  {}
												a__          =  HTTPError
												a__          =  {}

												# Download this model to make sure it's in the cache.
												a__          =  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:
																	a__          =  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[Any]    ):

												'''simple docstring'''

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





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

												'''simple docstring'''

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

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

												self.assertIsNotNone(__A    )







@is_staging_test
class        _SCREAMING_SNAKE_CASE						(  unittest.TestCase							):





							"""simple docstring"""





							@classmethod
							def  lowercase		(   cls:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  TOKEN
												HfFolder.save_token(__A    )




							@classmethod
							def  lowercase		(   cls:     List[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  lowercase		(   self:     Optional[int]    ):

												'''simple docstring'''

												a__          =  ViTImageProcessor.from_pretrained(__A    )
												image_processor.push_to_hub('''test-image-processor'''				,		use_auth_token=self._token    )

												a__          =  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    )

												a__          =  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:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  ViTImageProcessor.from_pretrained(__A    )
												image_processor.push_to_hub('''valid_org/test-image-processor'''				,		use_auth_token=self._token    )

												a__          =  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    )

												a__          =  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[Any]    ):

												'''simple docstring'''

												CustomImageProcessor.register_for_auto_class()
												a__          =  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'''}				,		)

												a__          =  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'''    )










"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__a       :	str             = {
    'configuration_swiftformer': [
        'SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'SwiftFormerConfig',
        'SwiftFormerOnnxConfig',
    ]
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__a       :	int             = [
	    'SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'SwiftFormerForImageClassification',
	    'SwiftFormerModel',
	    'SwiftFormerPreTrainedModel',
	]

if TYPE_CHECKING:
	from .configuration_swiftformer import (
	    SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    SwiftFormerConfig,
	    SwiftFormerOnnxConfig,
	)

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_swiftformer import (
		    SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    SwiftFormerForImageClassification,
		    SwiftFormerModel,
		    SwiftFormerPreTrainedModel,
		)

else:
	import sys

	__a       :	Dict             = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


