





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


_lowerCamelCase   				=			get_tests_dir('fixtures')




class   UpperCamelCase_       (     unittest.TestCase    ):


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



									"""simple docstring"""



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

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


							def      _snake_case  (							self    :Dict		)   ->   List[str]:



									"""simple docstring"""



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


							def      _snake_case  (							self    :List[Any]		)   ->   Optional[int]:



									"""simple docstring"""



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

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

									self.assertIsNotNone(__A		)




@is_staging_test
class   UpperCamelCase_       (     unittest.TestCase    ):


							@classmethod
							def      _snake_case  (							cls    :int		)   ->   str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      TOKEN
									HfFolder.save_token(__A		)


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



									"""simple docstring"""



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

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

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


							def      _snake_case  (							self    :int		)   ->   Optional[int]:



									"""simple docstring"""



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

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

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


							def      _snake_case  (							self    :Optional[Any]		)   ->   int:



									"""simple docstring"""



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

									SCREAMING_SNAKE_CASE__			=      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_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


_lowerCamelCase   				=			{
    'configuration_layoutlmv3': [
        'LAYOUTLMV3_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'LayoutLMv3Config',
        'LayoutLMv3OnnxConfig',
    ],
    'processing_layoutlmv3': ['LayoutLMv3Processor'],
    'tokenization_layoutlmv3': ['LayoutLMv3Tokenizer'],
}

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_lowerCamelCase   				=			['LayoutLMv3TokenizerFast']

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_lowerCamelCase   				=			[
	    'LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'LayoutLMv3ForQuestionAnswering',
	    'LayoutLMv3ForSequenceClassification',
	    'LayoutLMv3ForTokenClassification',
	    'LayoutLMv3Model',
	    'LayoutLMv3PreTrainedModel',
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_lowerCamelCase   				=			[
	    'TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'TFLayoutLMv3ForQuestionAnswering',
	    'TFLayoutLMv3ForSequenceClassification',
	    'TFLayoutLMv3ForTokenClassification',
	    'TFLayoutLMv3Model',
	    'TFLayoutLMv3PreTrainedModel',
	]

try:
	if not is_vision_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_lowerCamelCase   				=			['LayoutLMv3FeatureExtractor']
	_lowerCamelCase   				=			['LayoutLMv3ImageProcessor']


if TYPE_CHECKING:
	from .configuration_layoutlmva import (
	    LAYOUTLMV3_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    LayoutLMvaConfig,
	    LayoutLMvaOnnxConfig,
	)
	from .processing_layoutlmva import LayoutLMvaProcessor
	from .tokenization_layoutlmva import LayoutLMvaTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_layoutlmva_fast import LayoutLMvaTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_layoutlmva import (
		    LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
		    LayoutLMvaForQuestionAnswering,
		    LayoutLMvaForSequenceClassification,
		    LayoutLMvaForTokenClassification,
		    LayoutLMvaModel,
		    LayoutLMvaPreTrainedModel,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_layoutlmva import (
		    TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFLayoutLMvaForQuestionAnswering,
		    TFLayoutLMvaForSequenceClassification,
		    TFLayoutLMvaForTokenClassification,
		    TFLayoutLMvaModel,
		    TFLayoutLMvaPreTrainedModel,
		)

	try:
		if not is_vision_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .feature_extraction_layoutlmva import LayoutLMvaFeatureExtractor
		from .image_processing_layoutlmva import LayoutLMvaImageProcessor

else:
	import sys

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