




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


lowerCamelCase_			=						get_tests_dir('fixtures')







class 		lowercase_   (			unittest.TestCase       ):


   """simple docstring"""

   def 							lowerCAmelCase_      (   self :     str   ):

      """simple docstring"""
      # A mock response for an HTTP head request to emulate server down
      _SCREAMING_SNAKE_CASE	=				mock.Mock()
      _SCREAMING_SNAKE_CASE	=				5_0_0
      _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=SCREAMING_SNAKE_CASE_   ) 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 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      # This test is for deprecated behavior and can be removed in v5
      _SCREAMING_SNAKE_CASE	=				ViTImageProcessor.from_pretrained(
          "https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json"   )



   def 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      with self.assertRaises(SCREAMING_SNAKE_CASE_   ):
         # 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(SCREAMING_SNAKE_CASE_   )







@is_staging_test
class 		lowercase_   (			unittest.TestCase       ):


   """simple docstring"""

   @classmethod
   def 							lowerCAmelCase_      (   cls :     List[Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				TOKEN
      HfFolder.save_token(SCREAMING_SNAKE_CASE_   )



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

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				ViTImageProcessor.from_pretrained(SCREAMING_SNAKE_CASE_   )
      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(SCREAMING_SNAKE_CASE_  ,				getattr(SCREAMING_SNAKE_CASE_  ,				SCREAMING_SNAKE_CASE_   )   )

      # 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(
             SCREAMING_SNAKE_CASE_  ,				repo_id="test-image-processor"  ,				push_to_hub=SCREAMING_SNAKE_CASE_  ,				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(SCREAMING_SNAKE_CASE_  ,				getattr(SCREAMING_SNAKE_CASE_  ,				SCREAMING_SNAKE_CASE_   )   )



   def 							lowerCAmelCase_      (   self :     Tuple   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				ViTImageProcessor.from_pretrained(SCREAMING_SNAKE_CASE_   )
      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(SCREAMING_SNAKE_CASE_  ,				getattr(SCREAMING_SNAKE_CASE_  ,				SCREAMING_SNAKE_CASE_   )   )

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



   def 							lowerCAmelCase_      (   self :     Dict   ):

      """simple docstring"""
      CustomImageProcessor.register_for_auto_class()
      _SCREAMING_SNAKE_CASE	=				CustomImageProcessor.from_pretrained(SCREAMING_SNAKE_CASE_   )

      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=SCREAMING_SNAKE_CASE_   )
      # 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 collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


if TYPE_CHECKING:
 from ... import FeatureExtractionMixin, PreTrainedTokenizerBase, TensorType


lowerCamelCase_			=						logging.get_logger(__name__)

lowerCamelCase_			=						{
    'microsoft/deberta-v2-xlarge': 'https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/config.json',
    'microsoft/deberta-v2-xxlarge': 'https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/config.json',
    'microsoft/deberta-v2-xlarge-mnli': (
        'https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/config.json'
    ),
    'microsoft/deberta-v2-xxlarge-mnli': (
        'https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/config.json'
    ),
}







class 		lowercase_   (			A       ):


   """simple docstring"""

   lowerCamelCase_      =						'''deberta-v2'''



   def __init__(   self :     str  ,				__lowerCamelCase :     Union[str, Any]=1_2_8_1_0_0  ,				__lowerCamelCase :     Optional[int]=1_5_3_6  ,				__lowerCamelCase :     Optional[int]=2_4  ,				__lowerCamelCase :     Optional[int]=2_4  ,				__lowerCamelCase :     Tuple=6_1_4_4  ,				__lowerCamelCase :     List[str]="gelu"  ,				__lowerCamelCase :     int=0.1  ,				__lowerCamelCase :     Optional[Any]=0.1  ,				__lowerCamelCase :     Union[str, Any]=5_1_2  ,				__lowerCamelCase :     Optional[Any]=0  ,				__lowerCamelCase :     str=0.0_2  ,				__lowerCamelCase :     int=1e-7  ,				__lowerCamelCase :     Any=False  ,				__lowerCamelCase :     Any=-1  ,				__lowerCamelCase :     Tuple=0  ,				__lowerCamelCase :     str=True  ,				__lowerCamelCase :     List[Any]=None  ,				__lowerCamelCase :     Optional[int]=0  ,				__lowerCamelCase :     Any="gelu"  ,				**__lowerCamelCase :     Union[str, Any]  ,				):

      """simple docstring"""
      super().__init__(**__lowerCamelCase   )

      _SCREAMING_SNAKE_CASE	=				hidden_size
      _SCREAMING_SNAKE_CASE	=				num_hidden_layers
      _SCREAMING_SNAKE_CASE	=				num_attention_heads
      _SCREAMING_SNAKE_CASE	=				intermediate_size
      _SCREAMING_SNAKE_CASE	=				hidden_act
      _SCREAMING_SNAKE_CASE	=				hidden_dropout_prob
      _SCREAMING_SNAKE_CASE	=				attention_probs_dropout_prob
      _SCREAMING_SNAKE_CASE	=				max_position_embeddings
      _SCREAMING_SNAKE_CASE	=				type_vocab_size
      _SCREAMING_SNAKE_CASE	=				initializer_range
      _SCREAMING_SNAKE_CASE	=				relative_attention
      _SCREAMING_SNAKE_CASE	=				max_relative_positions
      _SCREAMING_SNAKE_CASE	=				pad_token_id
      _SCREAMING_SNAKE_CASE	=				position_biased_input

      # Backwards compatibility
      if type(__lowerCamelCase   ) == str:
         _SCREAMING_SNAKE_CASE	=				[x.strip() for x in pos_att_type.lower().split("|"   )]

      _SCREAMING_SNAKE_CASE	=				pos_att_type
      _SCREAMING_SNAKE_CASE	=				vocab_size
      _SCREAMING_SNAKE_CASE	=				layer_norm_eps

      _SCREAMING_SNAKE_CASE	=				kwargs.get("pooler_hidden_size"  ,				__lowerCamelCase   )
      _SCREAMING_SNAKE_CASE	=				pooler_dropout
      _SCREAMING_SNAKE_CASE	=				pooler_hidden_act







class 		lowercase_   (			A       ):


   """simple docstring"""

   @property
   def 							lowerCAmelCase_      (   self :     List[Any]   ):

      """simple docstring"""
      if self.task == "multiple-choice":
         _SCREAMING_SNAKE_CASE	=				{0: "batch", 1: "choice", 2: "sequence"}
      else:
         _SCREAMING_SNAKE_CASE	=				{0: "batch", 1: "sequence"}
      if self._config.type_vocab_size > 0:
         return OrderedDict(
             [("input_ids", dynamic_axis), ("attention_mask", dynamic_axis), ("token_type_ids", dynamic_axis)]   )
      else:
         return OrderedDict([("input_ids", dynamic_axis), ("attention_mask", dynamic_axis)]   )



   @property
   def 							lowerCAmelCase_      (   self :     List[str]   ):

      """simple docstring"""
      return 1_2



   def 							lowerCAmelCase_      (   self :     List[str]  ,				__lowerCamelCase :     Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]  ,				__lowerCamelCase :     int = -1  ,				__lowerCamelCase :     int = -1  ,				__lowerCamelCase :     int = -1  ,				__lowerCamelCase :     bool = False  ,				__lowerCamelCase :     Optional["TensorType"] = None  ,				__lowerCamelCase :     int = 3  ,				__lowerCamelCase :     int = 4_0  ,				__lowerCamelCase :     int = 4_0  ,				__lowerCamelCase :     "PreTrainedTokenizerBase" = None  ,				):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				super().generate_dummy_inputs(preprocessor=__lowerCamelCase  ,				framework=__lowerCamelCase   )
      if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
         del dummy_inputs["token_type_ids"]
      return dummy_inputs

