






"""simple docstring"""







import os
import sys
import warnings
from dataclasses import dataclass, field
from io import BytesIO
from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union

import numpy as np
import pyarrow as pa

from .. import config
from ..download.streaming_download_manager import xopen
from ..table import array_cast
from ..utils.file_utils import is_local_path
from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict


if TYPE_CHECKING:
			import PIL.Image

			from .features import FeatureType


a			:    Optional[List[str]]				 =		None
a			:    Any				 =		"""<""" if sys.byteorder == """little""" else """>"""
# Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image
a			:    str				 =		[
    np.dtype("""|b1"""),
    np.dtype("""|u1"""),
    np.dtype("""<u2"""),
    np.dtype(""">u2"""),
    np.dtype("""<i2"""),
    np.dtype(""">i2"""),
    np.dtype("""<u4"""),
    np.dtype(""">u4"""),
    np.dtype("""<i4"""),
    np.dtype(""">i4"""),
    np.dtype("""<f4"""),
    np.dtype(""">f4"""),
    np.dtype("""<f8"""),
    np.dtype(""">f8"""),
]


@dataclass
class    __UpperCAmelCase:




						"""simple docstring"""




						__lowerCamelCase    	= True
						__lowerCamelCase    	= None
						# Automatically constructed
						__lowerCamelCase    	= "PIL.Image.Image"
						__lowerCamelCase    	= pa.struct({"bytes": pa.binary(), "path": pa.string()}							)
						__lowerCamelCase    	= field(default="Image"  ,  init=SCREAMING_SNAKE_CASE__  ,  repr=SCREAMING_SNAKE_CASE__							)




						def __call__(       self      ):
												'''simple docstring'''
												return self.pa_type




						def 		UpperCAmelCase_	(       self	,  snake_case__      ):
												'''simple docstring'''
												if config.PIL_AVAILABLE:
																		import PIL.Image
												else:
																		raise ImportError("To support encoding images, please install 'Pillow'."      )

												if isinstance(snake_case__	,  snake_case__      ):
																		lowercase__    :				int=	np.array(snake_case__      )

												if isinstance(snake_case__	,  snake_case__      ):
																		return {"path": value, "bytes": None}
												elif isinstance(snake_case__	,  snake_case__      ):
																		return {"path": None, "bytes": value}
												elif isinstance(snake_case__	,  np.ndarray      ):
																		# convert the image array to PNG/TIFF bytes
																		return encode_np_array(snake_case__      )
												elif isinstance(snake_case__	,  PIL.Image.Image      ):
																		# convert the PIL image to bytes (default format is PNG/TIFF)
																		return encode_pil_image(snake_case__      )
												elif value.get("path"      ) is not None and os.path.isfile(value["path"]      ):
																		# we set "bytes": None to not duplicate the data if they're already available locally
																		return {"bytes": None, "path": value.get("path"      )}
												elif value.get("bytes"      ) is not None or value.get("path"      ) is not None:
																		# store the image bytes, and path is used to infer the image format using the file extension
																		return {"bytes": value.get("bytes"      ), "path": value.get("path"      )}
												else:
																		raise ValueError(
																		    F'''An image sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.'''      )




						def 		UpperCAmelCase_	(       self	,  snake_case__	,  snake_case__=None      ):
												'''simple docstring'''
												if not self.decode:
																		raise RuntimeError("Decoding is disabled for this feature. Please use Image(decode=True) instead."      )

												if config.PIL_AVAILABLE:
																		import PIL.Image
												else:
																		raise ImportError("To support decoding images, please install 'Pillow'."      )

												if token_per_repo_id is None:
																		lowercase__    :				Optional[Any]=	{}

												lowercase__,     lowercase__    :				Union[str, Any]=	value["path"], value["bytes"]
												if bytes_ is None:
																		if path is None:
																								raise ValueError(F'''An image should have one of \'path\' or \'bytes\' but both are None in {value}.'''      )
																		else:
																								if is_local_path(snake_case__      ):
																														lowercase__    :				List[Any]=	PIL.Image.open(snake_case__      )
																								else:
																														lowercase__    :				str=	path.split("::"      )[-1]
																														try:
																																				lowercase__    :				Optional[int]=	string_to_dict(snake_case__	,  config.HUB_DATASETS_URL      )["repo_id"]
																																				lowercase__    :				Tuple=	token_per_repo_id.get(snake_case__      )
																														except ValueError:
																																				lowercase__    :				List[str]=	None
																														with xopen(snake_case__	,  "rb"	,  use_auth_token=snake_case__      ) as f:
																																				lowercase__    :				Optional[int]=	BytesIO(f.read()      )
																														lowercase__    :				str=	PIL.Image.open(bytes_      )
												else:
																		lowercase__    :				List[str]=	PIL.Image.open(BytesIO(bytes_      )      )
												image.load()  # to avoid "Too many open files" errors
												return image




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												from .features import Value

												return (
												    self
												    if self.decode
												    else {
												        "bytes": Value("binary"      ),
												        "path": Value("string"      ),
												    }
												)




						def 		UpperCAmelCase_	(       self	,  snake_case__      ):
												'''simple docstring'''
												if pa.types.is_string(storage.type      ):
																		lowercase__    :				List[Any]=	pa.array([None] * len(snake_case__      )	,  type=pa.binary()      )
																		lowercase__    :				Optional[Any]=	pa.StructArray.from_arrays([bytes_array, storage]	,  ["bytes", "path"]	,  mask=storage.is_null()      )
												elif pa.types.is_binary(storage.type      ):
																		lowercase__    :				int=	pa.array([None] * len(snake_case__      )	,  type=pa.string()      )
																		lowercase__    :				Optional[int]=	pa.StructArray.from_arrays([storage, path_array]	,  ["bytes", "path"]	,  mask=storage.is_null()      )
												elif pa.types.is_struct(storage.type      ):
																		if storage.type.get_field_index("bytes"      ) >= 0:
																								lowercase__    :				int=	storage.field("bytes"      )
																		else:
																								lowercase__    :				Optional[int]=	pa.array([None] * len(snake_case__      )	,  type=pa.binary()      )
																		if storage.type.get_field_index("path"      ) >= 0:
																								lowercase__    :				List[str]=	storage.field("path"      )
																		else:
																								lowercase__    :				Any=	pa.array([None] * len(snake_case__      )	,  type=pa.string()      )
																		lowercase__    :				Tuple=	pa.StructArray.from_arrays([bytes_array, path_array]	,  ["bytes", "path"]	,  mask=storage.is_null()      )
												elif pa.types.is_list(storage.type      ):
																		lowercase__    :				Union[str, Any]=	pa.array(
																		    [encode_np_array(np.array(snake_case__      )      )["bytes"] if arr is not None else None for arr in storage.to_pylist()]	,  type=pa.binary()	,  )
																		lowercase__    :				Tuple=	pa.array([None] * len(snake_case__      )	,  type=pa.string()      )
																		lowercase__    :				List[Any]=	pa.StructArray.from_arrays(
																		    [bytes_array, path_array]	,  ["bytes", "path"]	,  mask=bytes_array.is_null()      )
												return array_cast(snake_case__	,  self.pa_type      )




						def 		UpperCAmelCase_	(       self	,  snake_case__      ):
												'''simple docstring'''

												@no_op_if_value_is_null
												def path_to_bytes(snake_case__      ):
																		with xopen(snake_case__	,  "rb"      ) as f:
																								lowercase__    :				str=	f.read()
																		return bytes_

												lowercase__    :				Optional[int]=	pa.array(
												    [
												        (path_to_bytes(x["path"]      ) if x["bytes"] is None else x["bytes"]) if x is not None else None
												        for x in storage.to_pylist()
												    ]	,  type=pa.binary()	,  )
												lowercase__    :				Any=	pa.array(
												    [os.path.basename(snake_case__      ) if path is not None else None for path in storage.field("path"      ).to_pylist()]	,  type=pa.string()	,  )
												lowercase__    :				int=	pa.StructArray.from_arrays([bytes_array, path_array]	,  ["bytes", "path"]	,  mask=bytes_array.is_null()      )
												return array_cast(snake_case__	,  self.pa_type      )





def 						lowercase__()    ->List[str]:




						"""simple docstring"""



						if config.PIL_AVAILABLE:
												import PIL.Image
						else:
												raise ImportError("To support encoding images, please install 'Pillow'."						)

						global _IMAGE_COMPRESSION_FORMATS
						if _IMAGE_COMPRESSION_FORMATS is None:
												PIL.Image.init()
												lowercase__    :				List[Any]=	list(set(PIL.Image.OPEN.keys()						) & set(PIL.Image.SAVE.keys()						)						)
						return _IMAGE_COMPRESSION_FORMATS





def 						lowercase__(A						)    ->bytes:




						"""simple docstring"""



						lowercase__    :				List[str]=	BytesIO()
						if image.format in list_image_compression_formats():
												lowercase__    :				Optional[Any]=	image.format
						else:
												lowercase__    :				List[Any]=	"PNG" if image.mode in ["1", "L", "LA", "RGB", "RGBA"] else "TIFF"
						image.save(A ,		format=A						)
						return buffer.getvalue()





def 						lowercase__(A						)    ->dict:




						"""simple docstring"""



						if hasattr(A ,		"filename"						) and image.filename != "":
												return {"path": image.filename, "bytes": None}
						else:
												return {"path": None, "bytes": image_to_bytes(A						)}





def 						lowercase__(A						)    ->dict:




						"""simple docstring"""



						if config.PIL_AVAILABLE:
												import PIL.Image
						else:
												raise ImportError("To support encoding images, please install 'Pillow'."						)

						lowercase__    :				List[Any]=	array.dtype
						lowercase__    :				List[Any]=	dtype.byteorder if dtype.byteorder != "=" else _NATIVE_BYTEORDER
						lowercase__    :				int=	dtype.kind
						lowercase__    :				Optional[int]=	dtype.itemsize

						lowercase__    :				Optional[int]=	None

						# Multi-channel array case (only np.dtype("|u1") is allowed)
						if array.shape[2:]:
												lowercase__    :				List[Any]=	np.dtype("|u1"						)
												if dtype_kind not in ["u", "i"]:
																		raise TypeError(
																		    f'''Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays.'''						)
												if dtype is not dest_dtype:
																		warnings.warn(f'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\''''						)
    # Exact match
						elif dtype in _VALID_IMAGE_ARRAY_DTPYES:
												lowercase__    :				List[Any]=	dtype
						else:  # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually)
												while dtype_itemsize >= 1:
																		lowercase__    :				int=	dtype_byteorder + dtype_kind + str(A						)
																		lowercase__    :				List[str]=	np.dtype(A						)
																		if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES:
																								warnings.warn(f'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\''''						)
																								break
																		else:
																								dtype_itemsize //= 2

						if dest_dtype is None:
												raise TypeError(
												    f'''Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}'''						)
						lowercase__    :				List[Any]=	PIL.Image.fromarray(array.astype(A						)						)
						return {"path": None, "bytes": image_to_bytes(A						)}







def 						lowercase__(A						)    ->List[dict]:




						"""simple docstring"""



						if config.PIL_AVAILABLE:
												import PIL.Image
						else:
												raise ImportError("To support encoding images, please install 'Pillow'."						)

						if objs:
												lowercase__,     lowercase__    :				Any=	first_non_null_value(A						)
												if isinstance(A ,		A						):
																		return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs]
												if isinstance(A ,		np.ndarray						):
																		lowercase__    :				Optional[int]=	no_op_if_value_is_null(A						)
																		return [obj_to_image_dict_func(A						) for obj in objs]
												elif isinstance(A ,		PIL.Image.Image						):
																		lowercase__    :				Optional[int]=	no_op_if_value_is_null(A						)
																		return [obj_to_image_dict_func(A						) for obj in objs]
												else:
																		return objs
						else:
												return objs














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


a			:    List[str]				 =		{
    """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    __UpperCAmelCase(       unittest.TestCase							):




						"""simple docstring"""




						@classmethod
						def 		UpperCAmelCase_	(       cls      ):
												'''simple docstring'''
												lowercase__    :				Union[str, Any]=	TOKEN
												HfFolder.save_token(snake_case__      )




						@classmethod
						def 		UpperCAmelCase_	(       cls      ):
												'''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 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				Union[str, Any]=	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      )

												lowercase__    :				List[Any]=	BertConfig.from_pretrained(F'''{USER}/test-config'''      )
												for k, v in config.to_dict().items():
																		if k != "transformers_version":
																								self.assertEqual(snake_case__	,  getattr(snake_case__	,  snake_case__      )      )

        # 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(snake_case__	,  repo_id="test-config"	,  push_to_hub=snake_case__	,  use_auth_token=self._token      )

												lowercase__    :				int=	BertConfig.from_pretrained(F'''{USER}/test-config'''      )
												for k, v in config.to_dict().items():
																		if k != "transformers_version":
																								self.assertEqual(snake_case__	,  getattr(snake_case__	,  snake_case__      )      )




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				Optional[int]=	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      )

												lowercase__    :				Optional[Any]=	BertConfig.from_pretrained("valid_org/test-config-org"      )
												for k, v in config.to_dict().items():
																		if k != "transformers_version":
																								self.assertEqual(snake_case__	,  getattr(snake_case__	,  snake_case__      )      )

        # 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(
																		    snake_case__	,  repo_id="valid_org/test-config-org"	,  push_to_hub=snake_case__	,  use_auth_token=self._token      )

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




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												CustomConfig.register_for_auto_class()
												lowercase__    :				Union[str, Any]=	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"}      )

												lowercase__    :				List[str]=	AutoConfig.from_pretrained(F'''{USER}/test-dynamic-config'''	,  trust_remote_code=snake_case__      )
												# 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    __UpperCAmelCase(       unittest.TestCase							):




						"""simple docstring"""




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				Dict=	GPTaConfig()

												# attempt to modify each of int/float/bool/str config records and verify they were updated
												lowercase__    :				str=	c.n_embd + 1  # int
												lowercase__    :				Tuple=	c.resid_pdrop + 1.0  # float
												lowercase__    :				Union[str, Any]=	not c.scale_attn_weights  # bool
												lowercase__    :				Optional[Any]=	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(snake_case__	,  c.n_embd	,  "mismatch for key: n_embd"      )
												self.assertEqual(snake_case__	,  c.resid_pdrop	,  "mismatch for key: resid_pdrop"      )
												self.assertEqual(snake_case__	,  c.scale_attn_weights	,  "mismatch for key: scale_attn_weights"      )
												self.assertEqual(snake_case__	,  c.summary_type	,  "mismatch for key: summary_type"      )




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				Optional[Any]=	PretrainedConfig()
												lowercase__    :				List[str]=	[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(
												    snake_case__	,  ["is_encoder_decoder", "_name_or_path", "_commit_hash", "transformers_version"]      )
												lowercase__    :				Tuple=	[key for key, value in config_common_kwargs.items() if value == getattr(snake_case__	,  snake_case__      )]
												if len(snake_case__      ) > 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(snake_case__      )}.'''      )




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												with self.assertRaises(snake_case__      ):
																		# config is in subfolder, the following should not work without specifying the subfolder
																		lowercase__    :				Optional[int]=	BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder"      )

												lowercase__    :				Optional[Any]=	BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder"	,  subfolder="bert"      )

												self.assertIsNotNone(snake_case__      )




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												# A mock response for an HTTP head request to emulate server down
												lowercase__    :				str=	mock.Mock()
												lowercase__    :				Optional[Any]=	500
												lowercase__    :				Any=	{}
												lowercase__    :				Tuple=	HTTPError
												lowercase__    :				List[Any]=	{}

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




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												# This test is for deprecated behavior and can be removed in v5
												lowercase__    :				Optional[Any]=	BertConfig.from_pretrained(
												    "https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json"      )




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				int=	AutoConfig.from_pretrained("bert-base-cased"      )
												lowercase__    :				Optional[int]=	["config.4.0.0.json"]

												with tempfile.TemporaryDirectory() as tmp_dir:
																		configuration.save_pretrained(snake_case__      )
																		lowercase__    :				List[Any]=	2
																		json.dump(configuration.to_dict()	,  open(os.path.join(snake_case__	,  "config.4.0.0.json"      )	,  "w"      )      )

																		# This should pick the new configuration file as the version of Transformers is > 4.0.0
																		lowercase__    :				int=	AutoConfig.from_pretrained(snake_case__      )
																		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
																		lowercase__    :				Optional[int]=	["config.42.0.0.json"]
																		lowercase__    :				int=	768
																		configuration.save_pretrained(snake_case__      )
																		shutil.move(os.path.join(snake_case__	,  "config.4.0.0.json"      )	,  os.path.join(snake_case__	,  "config.42.0.0.json"      )      )
																		lowercase__    :				Optional[Any]=	AutoConfig.from_pretrained(snake_case__      )
																		self.assertEqual(new_configuration.hidden_size	,  768      )




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												# This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
												lowercase__    :				Optional[Any]=	"hf-internal-testing/test-two-configs"

												import transformers as new_transformers

												lowercase__    :				Optional[Any]=	"v4.0.0"
												lowercase__,     lowercase__    :				str=	new_transformers.models.auto.AutoConfig.from_pretrained(
												    snake_case__	,  return_unused_kwargs=snake_case__      )
												self.assertEqual(new_configuration.hidden_size	,  2      )
												# This checks `_configuration_file` ia not kept in the kwargs by mistake.
												self.assertDictEqual(snake_case__	,  {}      )

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

												lowercase__    :				Dict=	"v3.0.0"
												lowercase__    :				Tuple=	old_transformers.models.auto.AutoConfig.from_pretrained(snake_case__      )
												self.assertEqual(old_configuration.hidden_size	,  768      )






