



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


lowercase					=       get_tests_dir('''fixtures''')




class       lowercase__      (   unittest.TestCase     ):
							'''simple docstring'''







							def 							lowerCamelCase_ (	self    )      ->				Tuple:
									_UpperCAmelCase							=		mock.Mock()
									_UpperCAmelCase							=		500
									_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=__UpperCamelCase    ) 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 							lowerCamelCase_ (	self    )      ->				Tuple:
									_UpperCAmelCase							=		ViTImageProcessor.from_pretrained(
									    'https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json'    )






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


									with self.assertRaises(__UpperCamelCase    ):
											# 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(__UpperCamelCase    )







@is_staging_test
class       lowercase__      (   unittest.TestCase     ):
							'''simple docstring'''







							@classmethod
							def 							lowerCamelCase_ (	cls    )      ->				List[str]:
									_UpperCAmelCase							=		TOKEN
									HfFolder.save_token(__UpperCamelCase    )






							@classmethod
							def 							lowerCamelCase_ (	cls    )      ->				List[str]:


									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 							lowerCamelCase_ (	self    )      ->				str:
									_UpperCAmelCase							=		ViTImageProcessor.from_pretrained(__UpperCamelCase    )
									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(__UpperCamelCase						,							getattr(__UpperCamelCase						,							__UpperCamelCase    )    )

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

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






							def 							lowerCamelCase_ (	self    )      ->				Union[str, Any]:
									_UpperCAmelCase							=		ViTImageProcessor.from_pretrained(__UpperCamelCase    )
									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(__UpperCamelCase						,							getattr(__UpperCamelCase						,							__UpperCamelCase    )    )

									# 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(
											    __UpperCamelCase						,							repo_id='valid_org/test-image-processor-org'						,							push_to_hub=__UpperCamelCase						,							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(__UpperCamelCase						,							getattr(__UpperCamelCase						,							__UpperCamelCase    )    )






							def 							lowerCamelCase_ (	self    )      ->				int:
									CustomImageProcessor.register_for_auto_class()
									_UpperCAmelCase							=		CustomImageProcessor.from_pretrained(__UpperCamelCase    )

									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=__UpperCamelCase    )
									# 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_sentencepiece_available,
    is_speech_available,
    is_tf_available,
    is_torch_available,
)


A									=  {
    'configuration_speech_to_text': ['SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Speech2TextConfig'],
    'processing_speech_to_text': ['Speech2TextProcessor'],
}

try:
		if not is_sentencepiece_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		A									=  ['Speech2TextTokenizer']

try:
		if not is_speech_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		A									=  ['Speech2TextFeatureExtractor']

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		A									=  [
		    'TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'TFSpeech2TextForConditionalGeneration',
		    'TFSpeech2TextModel',
		    'TFSpeech2TextPreTrainedModel',
		]

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		A									=  [
		    'SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'Speech2TextForConditionalGeneration',
		    'Speech2TextModel',
		    'Speech2TextPreTrainedModel',
		]


if TYPE_CHECKING:
		from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig
		from .processing_speech_to_text import SpeechaTextProcessor

		try:
				if not is_sentencepiece_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tokenization_speech_to_text import SpeechaTextTokenizer

		try:
				if not is_speech_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_speech_to_text import (
				    TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFSpeechaTextForConditionalGeneration,
				    TFSpeechaTextModel,
				    TFSpeechaTextPreTrainedModel,
				)

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_speech_to_text import (
				    SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    SpeechaTextForConditionalGeneration,
				    SpeechaTextModel,
				    SpeechaTextPreTrainedModel,
				)

else:
		import sys

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