



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


snake_case_			:     str  	=  get_tests_dir('fixtures')






class 							lowercase__     (							unittest.TestCase       ):





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







							'''simple docstring'''
							# A mock response for an HTTP head request to emulate server down
							_UpperCamelCase :		List[Any]			    =       mock.Mock()
							_UpperCamelCase :		Tuple			    =       500
							_UpperCamelCase :		Tuple			    =       {}
							_UpperCamelCase :		Dict			    =       HTTPError
							_UpperCamelCase :		Dict			    =       {}

							# Download this model to make sure it's in the cache.
							_UpperCamelCase :		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=lowerCamelCase__			) as mock_head:
													_UpperCamelCase :		Any			    =       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'''
							# This test is for deprecated behavior and can be removed in v5
							_UpperCamelCase :		str			    =       ViTImageProcessor.from_pretrained(
							    'https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json'			)





	def      UpperCamelCase_  (			self :    Dict			):







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

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

							self.assertIsNotNone(lowerCamelCase__			)






@is_staging_test
class 							lowercase__     (							unittest.TestCase       ):





	@classmethod
	def      UpperCamelCase_  (			cls :    Any			):







							'''simple docstring'''
							_UpperCamelCase :		int			    =       TOKEN
							HfFolder.save_token(lowerCamelCase__			)





	@classmethod
	def      UpperCamelCase_  (			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      UpperCamelCase_  (			self :    Any			):







							'''simple docstring'''
							_UpperCamelCase :		str			    =       ViTImageProcessor.from_pretrained(lowerCamelCase__			)
							image_processor.push_to_hub('test-image-processor'			,use_auth_token=self._token			)

							_UpperCamelCase :		List[str]			    =       ViTImageProcessor.from_pretrained(F'{USER}/test-image-processor'			)
							for k, v in image_processor.__dict__.items():
													self.assertEqual(lowerCamelCase__			,getattr(lowerCamelCase__			,lowerCamelCase__			)			)

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

							_UpperCamelCase :		Union[str, Any]			    =       ViTImageProcessor.from_pretrained(F'{USER}/test-image-processor'			)
							for k, v in image_processor.__dict__.items():
													self.assertEqual(lowerCamelCase__			,getattr(lowerCamelCase__			,lowerCamelCase__			)			)





	def      UpperCamelCase_  (			self :    List[str]			):







							'''simple docstring'''
							_UpperCamelCase :		Tuple			    =       ViTImageProcessor.from_pretrained(lowerCamelCase__			)
							image_processor.push_to_hub('valid_org/test-image-processor'			,use_auth_token=self._token			)

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

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

							_UpperCamelCase :		Any			    =       ViTImageProcessor.from_pretrained('valid_org/test-image-processor-org'			)
							for k, v in image_processor.__dict__.items():
													self.assertEqual(lowerCamelCase__			,getattr(lowerCamelCase__			,lowerCamelCase__			)			)





	def      UpperCamelCase_  (			self :    Any			):







							'''simple docstring'''
							CustomImageProcessor.register_for_auto_class()
							_UpperCamelCase :		str			    =       CustomImageProcessor.from_pretrained(lowerCamelCase__			)

							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 :		Optional[int]			    =       AutoImageProcessor.from_pretrained(
							    F'{USER}/test-dynamic-image-processor'			,trust_remote_code=lowerCamelCase__			)
							# 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_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


snake_case_			:     Optional[Any]  	=  {
    'configuration_clip': [
        'CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'CLIPConfig',
        'CLIPOnnxConfig',
        'CLIPTextConfig',
        'CLIPVisionConfig',
    ],
    'processing_clip': ['CLIPProcessor'],
    'tokenization_clip': ['CLIPTokenizer'],
}

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_			:     Optional[int]  	=  ['CLIPTokenizerFast']

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_			:     Optional[int]  	=  ['CLIPFeatureExtractor']
					snake_case_			:     Dict  	=  ['CLIPImageProcessor']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_			:     Tuple  	=  [
					    'CLIP_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'CLIPModel',
					    'CLIPPreTrainedModel',
					    'CLIPTextModel',
					    'CLIPTextModelWithProjection',
					    'CLIPVisionModel',
					    'CLIPVisionModelWithProjection',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_			:     List[Any]  	=  [
					    'TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'TFCLIPModel',
					    'TFCLIPPreTrainedModel',
					    'TFCLIPTextModel',
					    'TFCLIPVisionModel',
					]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_			:     Optional[int]  	=  [
					    'FlaxCLIPModel',
					    'FlaxCLIPPreTrainedModel',
					    'FlaxCLIPTextModel',
					    'FlaxCLIPTextPreTrainedModel',
					    'FlaxCLIPVisionModel',
					    'FlaxCLIPVisionPreTrainedModel',
					]


if TYPE_CHECKING:
					from .configuration_clip import (
					    CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    CLIPConfig,
					    CLIPOnnxConfig,
					    CLIPTextConfig,
					    CLIPVisionConfig,
					)
					from .processing_clip import CLIPProcessor
					from .tokenization_clip import CLIPTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_clip_fast import CLIPTokenizerFast

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .feature_extraction_clip import CLIPFeatureExtractor
										from .image_processing_clip import CLIPImageProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_clip import (
										    CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
										    CLIPModel,
										    CLIPPreTrainedModel,
										    CLIPTextModel,
										    CLIPTextModelWithProjection,
										    CLIPVisionModel,
										    CLIPVisionModelWithProjection,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_clip import (
										    TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFCLIPModel,
										    TFCLIPPreTrainedModel,
										    TFCLIPTextModel,
										    TFCLIPVisionModel,
										)

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_clip import (
										    FlaxCLIPModel,
										    FlaxCLIPPreTrainedModel,
										    FlaxCLIPTextModel,
										    FlaxCLIPTextPreTrainedModel,
										    FlaxCLIPVisionModel,
										    FlaxCLIPVisionPreTrainedModel,
										)


else:
					import sys

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


