
"""simple docstring"""


import io
import math
from typing import Dict, Optional, Union

import numpy as np
from huggingface_hub import hf_hub_download

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import convert_to_rgb, normalize, to_channel_dimension_format, to_pil_image
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    get_image_size,
    infer_channel_dimension_format,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_vision_available, logging
from ...utils.import_utils import requires_backends


if is_vision_available():
      import textwrap

      from PIL import Image, ImageDraw, ImageFont

if is_torch_available():
      import torch

      from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
else:
      SCREAMING_SNAKE_CASE			  =  False


SCREAMING_SNAKE_CASE			  =  logging.get_logger(__name__)
SCREAMING_SNAKE_CASE			  =  """ybelkada/fonts"""



def 						lowerCamelCase__      (				)->				List[Any]:







       """simple docstring"""
       if is_torch_available() and not is_torch_greater_or_equal_than_1_11:
              raise ImportError(
                  F"You are using torch=={torch.__version__}, but torch>=1.11.0 is required to use "
                  "Pix2StructImageProcessor. Please upgrade torch."					)



def 						lowerCamelCase__      (				UpperCAmelCase_		,   UpperCAmelCase_		,   UpperCAmelCase_					)->				str:







       """simple docstring"""
       requires_backends(UpperCAmelCase_		,   ["torch"]					)
       _check_torch_version()

       UpperCamelCase       			=		image_tensor.unsqueeze(0					)
       UpperCamelCase       			=		torch.nn.functional.unfold(UpperCAmelCase_		,   (patch_height, patch_width)		,   stride=(patch_height, patch_width)					)
       UpperCamelCase       			=		patches.reshape(image_tensor.size(0					)		,   image_tensor.size(1					)		,   UpperCAmelCase_		,   UpperCAmelCase_		,   -1					)
       UpperCamelCase       			=		patches.permute(0		,   4		,   2		,   3		,   1					).reshape(
           image_tensor.size(2					) // patch_height		,   image_tensor.size(3					) // patch_width		,   image_tensor.size(1					) * patch_height * patch_width		,   )
       return patches.unsqueeze(0					)



def 						lowerCamelCase__      (				UpperCAmelCase_		,   UpperCAmelCase_ = 36		,   UpperCAmelCase_ = "black"		,   UpperCAmelCase_ = "white"		,   UpperCAmelCase_ = 5		,   UpperCAmelCase_ = 5		,   UpperCAmelCase_ = 5		,   UpperCAmelCase_ = 5		,   UpperCAmelCase_ = None		,   UpperCAmelCase_ = None		,   )->				Image.Image:







       """simple docstring"""
       requires_backends(UpperCAmelCase_		,   "vision"					)
       # Add new lines so that each line is no more than 80 characters.

       UpperCamelCase       			=		textwrap.TextWrapper(width=80					)
       UpperCamelCase       			=		wrapper.wrap(text=UpperCAmelCase_					)
       UpperCamelCase       			=		"\n".join(UpperCAmelCase_					)

       if font_bytes is not None and font_path is None:
              UpperCamelCase       			=		io.BytesIO(UpperCAmelCase_					)
       elif font_path is not None:
              UpperCamelCase       			=		font_path
       else:
              UpperCamelCase       			=		hf_hub_download(UpperCAmelCase_		,   "Arial.TTF"					)
       UpperCamelCase       			=		ImageFont.truetype(UpperCAmelCase_		,   encoding="UTF-8"		,   size=UpperCAmelCase_					)

       # Use a temporary canvas to determine the width and height in pixels when
       # rendering the text.
       UpperCamelCase       			=		ImageDraw.Draw(Image.new("RGB"		,   (1, 1)		,   UpperCAmelCase_					)					)
       UpperCamelCase			,							UpperCamelCase			,							UpperCamelCase			,							UpperCamelCase       			=		temp_draw.textbbox((0, 0)		,   UpperCAmelCase_		,   UpperCAmelCase_					)

       # Create the actual image with a bit of padding around the text.
       UpperCamelCase       			=		text_width + left_padding + right_padding
       UpperCamelCase       			=		text_height + top_padding + bottom_padding
       UpperCamelCase       			=		Image.new("RGB"		,   (image_width, image_height)		,   UpperCAmelCase_					)
       UpperCamelCase       			=		ImageDraw.Draw(UpperCAmelCase_					)
       draw.text(xy=(left_padding, top_padding)		,   text=UpperCAmelCase_		,   fill=UpperCAmelCase_		,   font=UpperCAmelCase_					)
       return image



def 						lowerCamelCase__      (				UpperCAmelCase_		,   UpperCAmelCase_		,   **UpperCAmelCase_					)->				List[str]:







       """simple docstring"""
       requires_backends(UpperCAmelCase_		,   "vision"					)

       # Convert to PIL image if necessary
       UpperCamelCase       			=		to_pil_image(UpperCAmelCase_					)

       UpperCamelCase       			=		render_text(UpperCAmelCase_		,   **UpperCAmelCase_					)
       UpperCamelCase       			=		max(header_image.width		,   image.width					)

       UpperCamelCase       			=		int(image.height * (new_width / image.width)					)
       UpperCamelCase       			=		int(header_image.height * (new_width / header_image.width)					)

       UpperCamelCase       			=		Image.new("RGB"		,   (new_width, new_height + new_header_height)		,   "white"					)
       new_image.paste(header_image.resize((new_width, new_header_height)					)		,   (0, 0)					)
       new_image.paste(image.resize((new_width, new_height)					)		,   (0, new_header_height)					)

       # Convert back to the original framework if necessary
       UpperCamelCase       			=		to_numpy_array(UpperCAmelCase_					)

       if infer_channel_dimension_format(UpperCAmelCase_					) == ChannelDimension.LAST:
              UpperCamelCase       			=		to_channel_dimension_format(UpperCAmelCase_		,   ChannelDimension.LAST					)

       return new_image



class 	__a	(   _lowerCAmelCase						):
       UpperCamelCase_		:       int				=      ['''flattened_patches''']






       def __init__(	self			:				List[str]							,   UpperCAmelCase_			:				bool = True							,   UpperCAmelCase_			:				bool = True							,   UpperCAmelCase_			:				Dict[str, int] = None							,   UpperCAmelCase_			:				int = 2_048							,   UpperCAmelCase_			:				bool = False							,   **UpperCAmelCase_			:				Any							,   )->	None:







              """simple docstring"""
              super().__init__(**UpperCAmelCase_      )
              UpperCamelCase       			=		patch_size if patch_size is not None else {"height": 16, "width": 16}
              UpperCamelCase       			=		do_normalize
              UpperCamelCase       			=		do_convert_rgb
              UpperCamelCase       			=		max_patches
              UpperCamelCase       			=		is_vqa






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Optional[Any]							,   UpperCAmelCase_			:				np.ndarray							,   UpperCAmelCase_			:				int							,   UpperCAmelCase_			:				dict							,   **UpperCAmelCase_			:				Optional[Any]      )->	np.ndarray:







              """simple docstring"""
              requires_backends(self.extract_flattened_patches							,   "torch"      )
              _check_torch_version()

              # convert to torch
              UpperCamelCase       			=		to_channel_dimension_format(UpperCAmelCase_							,   ChannelDimension.FIRST      )
              UpperCamelCase       			=		torch.from_numpy(UpperCAmelCase_      )

              UpperCamelCase			,							UpperCamelCase       			=		patch_size["height"], patch_size["width"]
              UpperCamelCase			,							UpperCamelCase       			=		get_image_size(UpperCAmelCase_      )

              # maximize scale s.t.
              UpperCamelCase       			=		math.sqrt(max_patches * (patch_height / image_height) * (patch_width / image_width)      )
              UpperCamelCase       			=		max(min(math.floor(scale * image_height / patch_height      )							,   UpperCAmelCase_      )							,   1      )
              UpperCamelCase       			=		max(min(math.floor(scale * image_width / patch_width      )							,   UpperCAmelCase_      )							,   1      )
              UpperCamelCase       			=		max(num_feasible_rows * patch_height							,   1      )
              UpperCamelCase       			=		max(num_feasible_cols * patch_width							,   1      )

              UpperCamelCase       			=		torch.nn.functional.interpolate(
                  image.unsqueeze(0      )							,   size=(resized_height, resized_width)							,   mode="bilinear"							,   align_corners=UpperCAmelCase_							,   antialias=UpperCAmelCase_							,   ).squeeze(0      )

              # [1, rows, columns, patch_height * patch_width * image_channels]
              UpperCamelCase       			=		torch_extract_patches(UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_      )

              UpperCamelCase       			=		patches.shape
              UpperCamelCase       			=		patches_shape[1]
              UpperCamelCase       			=		patches_shape[2]
              UpperCamelCase       			=		patches_shape[3]

              # [rows * columns, patch_height * patch_width * image_channels]
              UpperCamelCase       			=		patches.reshape([rows * columns, depth]      )

              # [rows * columns, 1]
              UpperCamelCase       			=		torch.arange(UpperCAmelCase_      ).reshape([rows, 1]      ).repeat(1							,   UpperCAmelCase_      ).reshape([rows * columns, 1]      )
              UpperCamelCase       			=		torch.arange(UpperCAmelCase_      ).reshape([1, columns]      ).repeat(UpperCAmelCase_							,   1      ).reshape([rows * columns, 1]      )

              # Offset by 1 so the ids do not contain zeros, which represent padding.
              row_ids += 1
              col_ids += 1

              # Prepare additional patch features.
              # [rows * columns, 1]
              UpperCamelCase       			=		row_ids.to(torch.floataa      )
              UpperCamelCase       			=		col_ids.to(torch.floataa      )

              # [rows * columns, 2 + patch_height * patch_width * image_channels]
              UpperCamelCase       			=		torch.cat([row_ids, col_ids, patches]							,   -1      )

              # [max_patches, 2 + patch_height * patch_width * image_channels]
              UpperCamelCase       			=		torch.nn.functional.pad(UpperCAmelCase_							,   [0, 0, 0, max_patches - (rows * columns)]      ).float()

              UpperCamelCase       			=		to_numpy_array(UpperCAmelCase_      )

              return result






       def 						_SCREAMING_SNAKE_CASE							(	self			:				str							,   UpperCAmelCase_			:				np.ndarray							,   UpperCAmelCase_			:				Optional[Union[str, ChannelDimension]] = None							,   **UpperCAmelCase_			:				Any      )->	np.ndarray:







              """simple docstring"""
              if image.dtype == np.uinta:
                     UpperCamelCase       			=		image.astype(np.floataa      )

              # take mean across the whole `image`
              UpperCamelCase       			=		np.mean(UpperCAmelCase_      )
              UpperCamelCase       			=		np.std(UpperCAmelCase_      )
              UpperCamelCase       			=		max(UpperCAmelCase_							,   1.0 / math.sqrt(np.prod(image.shape      )      )      )

              return normalize(UpperCAmelCase_							,   mean=UpperCAmelCase_							,   std=UpperCAmelCase_							,   **UpperCAmelCase_      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				str							,   UpperCAmelCase_			:				ImageInput							,   UpperCAmelCase_			:				Optional[str] = None							,   UpperCAmelCase_			:				bool = None							,   UpperCAmelCase_			:				Optional[bool] = None							,   UpperCAmelCase_			:				Optional[int] = None							,   UpperCAmelCase_			:				Optional[Dict[str, int]] = None							,   UpperCAmelCase_			:				Optional[Union[str, TensorType]] = None							,   UpperCAmelCase_			:				ChannelDimension = ChannelDimension.FIRST							,   **UpperCAmelCase_			:				Optional[Any]							,   )->	ImageInput:







              """simple docstring"""
              UpperCamelCase       			=		do_normalize if do_normalize is not None else self.do_normalize
              UpperCamelCase       			=		do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb
              UpperCamelCase       			=		patch_size if patch_size is not None else self.patch_size
              UpperCamelCase       			=		max_patches if max_patches is not None else self.max_patches
              UpperCamelCase       			=		self.is_vqa

              if kwargs.get("data_format"							,   UpperCAmelCase_      ) is not None:
                     raise ValueError("data_format is not an accepted input as the outputs are "      )

              UpperCamelCase       			=		make_list_of_images(UpperCAmelCase_      )

              if not valid_images(UpperCAmelCase_      ):
                     raise ValueError(
                         "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
                         "torch.Tensor, tf.Tensor or jax.ndarray."      )

              # PIL RGBA images are converted to RGB
              if do_convert_rgb:
                     UpperCamelCase       			=		[convert_to_rgb(UpperCAmelCase_      ) for image in images]

              # All transformations expect numpy arrays.
              UpperCamelCase       			=		[to_numpy_array(UpperCAmelCase_      ) for image in images]

              if is_vqa:
                     if header_text is None:
                            raise ValueError("A header text must be provided for VQA models."      )
                     UpperCamelCase       			=		kwargs.pop("font_bytes"							,   UpperCAmelCase_      )
                     UpperCamelCase       			=		kwargs.pop("font_path"							,   UpperCAmelCase_      )

                     if isinstance(UpperCAmelCase_							,   UpperCAmelCase_      ):
                            UpperCamelCase       			=		[header_text] * len(UpperCAmelCase_      )

                     UpperCamelCase       			=		[
                         render_header(UpperCAmelCase_							,   header_text[i]							,   font_bytes=UpperCAmelCase_							,   font_path=UpperCAmelCase_      )
                         for i, image in enumerate(UpperCAmelCase_      )
                     ]

              if do_normalize:
                     UpperCamelCase       			=		[self.normalize(image=UpperCAmelCase_      ) for image in images]

              # convert to torch tensor and permute
              UpperCamelCase       			=		[
                  self.extract_flattened_patches(image=UpperCAmelCase_							,   max_patches=UpperCAmelCase_							,   patch_size=UpperCAmelCase_      )
                  for image in images
              ]

              # create attention mask in numpy
              UpperCamelCase       			=		[(image.sum(axis=-1      ) != 0).astype(np.floataa      ) for image in images]

              UpperCamelCase       			=		BatchFeature(
                  data={"flattened_patches": images, "attention_mask": attention_masks}							,   tensor_type=UpperCAmelCase_      )

              return encoded_outputs







"""simple docstring"""


import json
import os
import shutil
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 AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / """utils"""))

from test_module.custom_configuration import CustomConfig  # noqa E402


SCREAMING_SNAKE_CASE			  =  {
    """return_dict""": False,
    """output_hidden_states""": True,
    """output_attentions""": True,
    """torchscript""": True,
    """torch_dtype""": """float16""",
    """use_bfloat16""": True,
    """tf_legacy_loss""": True,
    """pruned_heads""": {"""a""": 1},
    """tie_word_embeddings""": False,
    """is_decoder""": True,
    """cross_attention_hidden_size""": 128,
    """add_cross_attention""": True,
    """tie_encoder_decoder""": True,
    """max_length""": 50,
    """min_length""": 3,
    """do_sample""": True,
    """early_stopping""": True,
    """num_beams""": 3,
    """num_beam_groups""": 3,
    """diversity_penalty""": 0.5,
    """temperature""": 2.0,
    """top_k""": 10,
    """top_p""": 0.7,
    """typical_p""": 0.2,
    """repetition_penalty""": 0.8,
    """length_penalty""": 0.8,
    """no_repeat_ngram_size""": 5,
    """encoder_no_repeat_ngram_size""": 5,
    """bad_words_ids""": [1, 2, 3],
    """num_return_sequences""": 3,
    """chunk_size_feed_forward""": 5,
    """output_scores""": True,
    """return_dict_in_generate""": True,
    """forced_bos_token_id""": 2,
    """forced_eos_token_id""": 3,
    """remove_invalid_values""": True,
    """architectures""": ["""BertModel"""],
    """finetuning_task""": """translation""",
    """id2label""": {0: """label"""},
    """label2id""": {"""label""": """0"""},
    """tokenizer_class""": """BertTokenizerFast""",
    """prefix""": """prefix""",
    """bos_token_id""": 6,
    """pad_token_id""": 7,
    """eos_token_id""": 8,
    """sep_token_id""": 9,
    """decoder_start_token_id""": 10,
    """exponential_decay_length_penalty""": (5, 1.01),
    """suppress_tokens""": [0, 1],
    """begin_suppress_tokens""": 2,
    """task_specific_params""": {"""translation""": """some_params"""},
    """problem_type""": """regression""",
}



@is_staging_test
class 	__a	(   unittest.TestCase						):






       @classmethod
       def 						_SCREAMING_SNAKE_CASE							(	cls			:				Union[str, Any]      )->	List[Any]:







              """simple docstring"""
              UpperCamelCase       			=		TOKEN
              HfFolder.save_token(UpperCAmelCase_      )






       @classmethod
       def 						_SCREAMING_SNAKE_CASE							(	cls			:				str      )->	Dict:







              """simple docstring"""
              try:
                     delete_repo(token=cls._token							,   repo_id="test-config"      )
              except HTTPError:
                     pass

              try:
                     delete_repo(token=cls._token							,   repo_id="valid_org/test-config-org"      )
              except HTTPError:
                     pass

              try:
                     delete_repo(token=cls._token							,   repo_id="test-dynamic-config"      )
              except HTTPError:
                     pass






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







              """simple docstring"""
              UpperCamelCase       			=		BertConfig(
                  vocab_size=99							,   hidden_size=32							,   num_hidden_layers=5							,   num_attention_heads=4							,   intermediate_size=37      )
              config.push_to_hub("test-config"							,   use_auth_token=self._token      )

              UpperCamelCase       			=		BertConfig.from_pretrained(f"{USER}/test-config"      )
              for k, v in config.to_dict().items():
                     if k != "transformers_version":
                            self.assertEqual(UpperCAmelCase_							,   getattr(UpperCAmelCase_							,   UpperCAmelCase_      )      )

        # Reset repo
              delete_repo(token=self._token							,   repo_id="test-config"      )

              # Push to hub via save_pretrained
              with tempfile.TemporaryDirectory() as tmp_dir:
                     config.save_pretrained(UpperCAmelCase_							,   repo_id="test-config"							,   push_to_hub=UpperCAmelCase_							,   use_auth_token=self._token      )

              UpperCamelCase       			=		BertConfig.from_pretrained(f"{USER}/test-config"      )
              for k, v in config.to_dict().items():
                     if k != "transformers_version":
                            self.assertEqual(UpperCAmelCase_							,   getattr(UpperCAmelCase_							,   UpperCAmelCase_      )      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Tuple      )->	List[str]:







              """simple docstring"""
              UpperCamelCase       			=		BertConfig(
                  vocab_size=99							,   hidden_size=32							,   num_hidden_layers=5							,   num_attention_heads=4							,   intermediate_size=37      )
              config.push_to_hub("valid_org/test-config-org"							,   use_auth_token=self._token      )

              UpperCamelCase       			=		BertConfig.from_pretrained("valid_org/test-config-org"      )
              for k, v in config.to_dict().items():
                     if k != "transformers_version":
                            self.assertEqual(UpperCAmelCase_							,   getattr(UpperCAmelCase_							,   UpperCAmelCase_      )      )

        # Reset repo
              delete_repo(token=self._token							,   repo_id="valid_org/test-config-org"      )

              # Push to hub via save_pretrained
              with tempfile.TemporaryDirectory() as tmp_dir:
                     config.save_pretrained(
                         UpperCAmelCase_							,   repo_id="valid_org/test-config-org"							,   push_to_hub=UpperCAmelCase_							,   use_auth_token=self._token      )

              UpperCamelCase       			=		BertConfig.from_pretrained("valid_org/test-config-org"      )
              for k, v in config.to_dict().items():
                     if k != "transformers_version":
                            self.assertEqual(UpperCAmelCase_							,   getattr(UpperCAmelCase_							,   UpperCAmelCase_      )      )






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







              """simple docstring"""
              CustomConfig.register_for_auto_class()
              UpperCamelCase       			=		CustomConfig(attribute=42      )

              config.push_to_hub("test-dynamic-config"							,   use_auth_token=self._token      )

              # This has added the proper auto_map field to the config
              self.assertDictEqual(config.auto_map							,   {"AutoConfig": "custom_configuration.CustomConfig"}      )

              UpperCamelCase       			=		AutoConfig.from_pretrained(f"{USER}/test-dynamic-config"							,   trust_remote_code=UpperCAmelCase_      )
              # Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
              self.assertEqual(new_config.__class__.__name__							,   "CustomConfig"      )
              self.assertEqual(new_config.attribute							,   42      )





class 	__a	(   unittest.TestCase						):






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Any      )->	Any:







              """simple docstring"""
              UpperCamelCase       			=		GPTaConfig()

              # attempt to modify each of int/float/bool/str config records and verify they were updated
              UpperCamelCase       			=		c.n_embd + 1  # int
              UpperCamelCase       			=		c.resid_pdrop + 1.0  # float
              UpperCamelCase       			=		not c.scale_attn_weights  # bool
              UpperCamelCase       			=		c.summary_type + "foo"  # str
              c.update_from_string(
                  f"n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}"      )
              self.assertEqual(UpperCAmelCase_							,   c.n_embd							,   "mismatch for key: n_embd"      )
              self.assertEqual(UpperCAmelCase_							,   c.resid_pdrop							,   "mismatch for key: resid_pdrop"      )
              self.assertEqual(UpperCAmelCase_							,   c.scale_attn_weights							,   "mismatch for key: scale_attn_weights"      )
              self.assertEqual(UpperCAmelCase_							,   c.summary_type							,   "mismatch for key: summary_type"      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Any      )->	List[str]:







              """simple docstring"""
              UpperCamelCase       			=		PretrainedConfig()
              UpperCamelCase       			=		[key for key in base_config.__dict__ if key not in config_common_kwargs]
              # If this part of the test fails, you have arguments to addin config_common_kwargs above.
              self.assertListEqual(
                  UpperCAmelCase_							,   ["is_encoder_decoder", "_name_or_path", "_commit_hash", "transformers_version"]      )
              UpperCamelCase       			=		[key for key, value in config_common_kwargs.items() if value == getattr(UpperCAmelCase_							,   UpperCAmelCase_      )]
              if len(UpperCAmelCase_      ) > 0:
                     raise ValueError(
                         "The following keys are set with the default values in"
                         " `test_configuration_common.config_common_kwargs` pick another value for them:"
                         f" {', '.join(UpperCAmelCase_      )}."      )






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







              """simple docstring"""
              with self.assertRaises(UpperCAmelCase_      ):
                     # config is in subfolder, the following should not work without specifying the subfolder
                     UpperCamelCase       			=		BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder"      )

              UpperCamelCase       			=		BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder"							,   subfolder="bert"      )

              self.assertIsNotNone(UpperCAmelCase_      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Any      )->	Any:







              """simple docstring"""
              # A mock response for an HTTP head request to emulate server down
              UpperCamelCase       			=		mock.Mock()
              UpperCamelCase       			=		500
              UpperCamelCase       			=		{}
              UpperCamelCase       			=		HTTPError
              UpperCamelCase       			=		{}

              # Download this model to make sure it's in the cache.
              UpperCamelCase       			=		BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert"      )

              # 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       			=		BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert"      )
                     # This check we did call the fake head request
                     mock_head.assert_called()






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Tuple      )->	int:







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






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Union[str, Any]      )->	Optional[int]:







              """simple docstring"""
              UpperCamelCase       			=		AutoConfig.from_pretrained("bert-base-cased"      )
              UpperCamelCase       			=		["config.4.0.0.json"]

              with tempfile.TemporaryDirectory() as tmp_dir:
                     configuration.save_pretrained(UpperCAmelCase_      )
                     UpperCamelCase       			=		2
                     json.dump(configuration.to_dict()							,   open(os.path.join(UpperCAmelCase_							,   "config.4.0.0.json"      )							,   "w"      )      )

                     # This should pick the new configuration file as the version of Transformers is > 4.0.0
                     UpperCamelCase       			=		AutoConfig.from_pretrained(UpperCAmelCase_      )
                     self.assertEqual(new_configuration.hidden_size							,   2      )

                     # Will need to be adjusted if we reach v42 and this test is still here.
                     # Should pick the old configuration file as the version of Transformers is < 4.42.0
                     UpperCamelCase       			=		["config.42.0.0.json"]
                     UpperCamelCase       			=		768
                     configuration.save_pretrained(UpperCAmelCase_      )
                     shutil.move(os.path.join(UpperCAmelCase_							,   "config.4.0.0.json"      )							,   os.path.join(UpperCAmelCase_							,   "config.42.0.0.json"      )      )
                     UpperCamelCase       			=		AutoConfig.from_pretrained(UpperCAmelCase_      )
                     self.assertEqual(new_configuration.hidden_size							,   768      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Optional[Any]      )->	Dict:







              """simple docstring"""
              # This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
              UpperCamelCase       			=		"hf-internal-testing/test-two-configs"

              import transformers as new_transformers

              UpperCamelCase       			=		"v4.0.0"
              UpperCamelCase			,							UpperCamelCase       			=		new_transformers.models.auto.AutoConfig.from_pretrained(
                  UpperCAmelCase_							,   return_unused_kwargs=UpperCAmelCase_      )
              self.assertEqual(new_configuration.hidden_size							,   2      )
              # This checks `_configuration_file` ia not kept in the kwargs by mistake.
              self.assertDictEqual(UpperCAmelCase_							,   {}      )

              # Testing an older version by monkey-patching the version in the module it's used.
              import transformers as old_transformers

              UpperCamelCase       			=		"v3.0.0"
              UpperCamelCase       			=		old_transformers.models.auto.AutoConfig.from_pretrained(UpperCAmelCase_      )
              self.assertEqual(old_configuration.hidden_size							,   768      )





