





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


_UpperCAmelCase       : Dict						     =       get_tests_dir("""fixtures""")

class      lowerCAmelCase							(      unittest.TestCase    ):
 def   A_			(   self						:   Optional[Any]			)    ->			Optional[Any]:
     # A mock response for an HTTP head request to emulate server down
     lowerCamelCase__					:   Dict      				=	mock.Mock()
     lowerCamelCase__					:   List[Any]      				=	500
     lowerCamelCase__					:   Any      				=	{}
     lowerCamelCase__					:   Dict      				=	HTTPError
     lowerCamelCase__					:   str      				=	{}

     # Download this model to make sure it's in the cache.
     lowerCamelCase__					:   Optional[Any]      				=	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__					:   Optional[Any]      				=	ViTImageProcessor.from_pretrained('hf-internal-testing/tiny-random-vit'			)
         # This check we did call the fake head request
         mock_head.assert_called()
 def   A_			(   self						:   Tuple			)    ->			List[str]:
     # This test is for deprecated behavior and can be removed in v5
     lowerCamelCase__					:   int      				=	ViTImageProcessor.from_pretrained(
         'https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json'			)







 def   A_			(   self						:   str			)    ->			str:
     with self.assertRaises(_A			):
         # config is in subfolder, the following should not work without specifying the subfolder
         lowerCamelCase__					:   int      				=	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      lowerCAmelCase							(      unittest.TestCase    ):
 @classmethod
 def   A_			(   cls						:   Optional[int]			)    ->			Optional[Any]:
     lowerCamelCase__					:   str      				=	TOKEN
     HfFolder.save_token(_A			)
 @classmethod
 def   A_			(   cls						:   Optional[int]			)    ->			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   A_			(   self						:   int			)    ->			str:
     lowerCamelCase__					:   Any      				=	ViTImageProcessor.from_pretrained(_A			)
     image_processor.push_to_hub('test-image-processor'    ,  use_auth_token=self._token			)

     lowerCamelCase__					:   Optional[int]      				=	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__					:   Union[str, Any]      				=	ViTImageProcessor.from_pretrained(F"""{USER}/test-image-processor"""			)
     for k, v in image_processor.__dict__.items():
         self.assertEqual(_A    ,  getattr(_A    ,  _A			)			)
 def   A_			(   self						:   Dict			)    ->			Optional[int]:
     lowerCamelCase__					:   Optional[int]      				=	ViTImageProcessor.from_pretrained(_A			)
     image_processor.push_to_hub('valid_org/test-image-processor'    ,  use_auth_token=self._token			)

     lowerCamelCase__					:   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__					:   str      				=	ViTImageProcessor.from_pretrained('valid_org/test-image-processor-org'			)
     for k, v in image_processor.__dict__.items():
         self.assertEqual(_A    ,  getattr(_A    ,  _A			)			)







 def   A_			(   self						:   List[Any]			)    ->			Any:
     CustomImageProcessor.register_for_auto_class()
     lowerCamelCase__					:   List[Any]      				=	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__					:   str      				=	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 ...configuration_utils import PretrainedConfig
from ...utils import logging


_UpperCAmelCase       : Dict			     =       logging.get_logger(__name__)

_UpperCAmelCase       : Union[str, Any]			     =       {
    """naver-clova-ix/donut-base""": """https://huggingface.co/naver-clova-ix/donut-base/resolve/main/config.json""",
    # See all Donut models at https://huggingface.co/models?filter=donut-swin
}

class      lowerCAmelCase							(      __UpperCamelCase    ):
 UpperCAmelCase__									=	"""donut-swin"""

 UpperCAmelCase__									=	{
     """num_attention_heads""": """num_heads""",
     """num_hidden_layers""": """num_layers""",
 }
 def __init__(   self						:   Tuple    ,  UpperCAmelCase						:   List[str]=224    ,  UpperCAmelCase						:   Optional[Any]=4    ,  UpperCAmelCase						:   Union[str, Any]=3    ,  UpperCAmelCase						:   Union[str, Any]=96    ,  UpperCAmelCase						:   int=[2, 2, 6, 2]    ,  UpperCAmelCase						:   Dict=[3, 6, 12, 24]    ,  UpperCAmelCase						:   Any=7    ,  UpperCAmelCase						:   Optional[int]=4.0    ,  UpperCAmelCase						:   List[Any]=True    ,  UpperCAmelCase						:   Any=0.0    ,  UpperCAmelCase						:   Optional[Any]=0.0    ,  UpperCAmelCase						:   int=0.1    ,  UpperCAmelCase						:   List[str]="gelu"    ,  UpperCAmelCase						:   List[str]=False    ,  UpperCAmelCase						:   str=0.0_2    ,  UpperCAmelCase						:   str=1e-5    ,  **UpperCAmelCase						:   Tuple    ,  )    ->			int:
     super().__init__(**UpperCAmelCase			)

     lowerCamelCase__					:   Optional[Any]      				=	image_size
     lowerCamelCase__					:   Optional[int]      				=	patch_size
     lowerCamelCase__					:   int      				=	num_channels
     lowerCamelCase__					:   int      				=	embed_dim
     lowerCamelCase__					:   Optional[Any]      				=	depths
     lowerCamelCase__					:   Optional[int]      				=	len(UpperCAmelCase			)
     lowerCamelCase__					:   Optional[int]      				=	num_heads
     lowerCamelCase__					:   Tuple      				=	window_size
     lowerCamelCase__					:   Dict      				=	mlp_ratio
     lowerCamelCase__					:   str      				=	qkv_bias
     lowerCamelCase__					:   Tuple      				=	hidden_dropout_prob
     lowerCamelCase__					:   str      				=	attention_probs_dropout_prob
     lowerCamelCase__					:   str      				=	drop_path_rate
     lowerCamelCase__					:   int      				=	hidden_act
     lowerCamelCase__					:   str      				=	use_absolute_embeddings
     lowerCamelCase__					:   List[Any]      				=	layer_norm_eps
     lowerCamelCase__					:   Optional[Any]      				=	initializer_range
     # we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
     # this indicates the channel dimension after the last stage of the model
     lowerCamelCase__					:   Optional[int]      				=	int(embed_dim * 2 ** (len(UpperCAmelCase			) - 1)			)





