

# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import copy
import importlib.metadata
import json
import os
from dataclasses import dataclass
from typing import Any, Dict, Union

from packaging import version

from ..utils import is_torch_available, logging


if is_torch_available():
						import torch


lowerCAmelCase							:  Union[str, Any]            =						logging.get_logger(__name__)



@dataclass
class   __lowercase    :




			"""simple docstring"""







			def __init__(			self  :					Dict       ,						lowerCAmelCase__  :					Tuple=False       ,						lowerCAmelCase__  :					Union[str, Any]=False       ,						lowerCAmelCase__  :					Any=6.0       ,						lowerCAmelCase__  :					Optional[int]=None       ,						lowerCAmelCase__  :					List[Any]=False       ,						lowerCAmelCase__  :					Tuple=False       ,						lowerCAmelCase__  :					Optional[Any]=None       ,						lowerCAmelCase__  :					Optional[Any]="fp4"       ,						lowerCAmelCase__  :					Optional[Any]=False       ,						**lowerCAmelCase__  :					Dict       ,						):
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	load_in_abit
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	load_in_abit
									SCREAMING_SNAKE_CASE_:			Tuple  		=	llm_inta_threshold
									SCREAMING_SNAKE_CASE_:			str  		=	llm_inta_skip_modules
									SCREAMING_SNAKE_CASE_:			List[str]  		=	llm_inta_enable_fpaa_cpu_offload
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	llm_inta_has_fpaa_weight
									SCREAMING_SNAKE_CASE_:			Any  		=	bnb_abit_quant_type
									SCREAMING_SNAKE_CASE_:			str  		=	bnb_abit_use_double_quant

									if bnb_abit_compute_dtype is None:
															SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	torch.floataa
									elif isinstance(lowerCAmelCase__       ,						lowerCAmelCase__):
															SCREAMING_SNAKE_CASE_:			Optional[int]  		=	getattr(lowerCAmelCase__       ,						lowerCAmelCase__)
									elif isinstance(lowerCAmelCase__       ,						torch.dtype):
															SCREAMING_SNAKE_CASE_:			Optional[int]  		=	bnb_abit_compute_dtype
									else:
															raise ValueError("bnb_4bit_compute_dtype must be a string or a torch.dtype")

									self.post_init()



			def 	_SCREAMING_SNAKE_CASE      (			self  :					int):
									if not isinstance(self.llm_inta_threshold       ,						lowerCAmelCase__):
															raise ValueError("llm_int8_threshold must be a float")

									if self.llm_inta_skip_modules is not None and not isinstance(self.llm_inta_skip_modules       ,						lowerCAmelCase__):
															raise ValueError("llm_int8_skip_modules must be a list of strings")
									if not isinstance(self.llm_inta_enable_fpaa_cpu_offload       ,						lowerCAmelCase__):
															raise ValueError("llm_int8_enable_fp32_cpu_offload must be a boolean")

									if not isinstance(self.llm_inta_has_fpaa_weight       ,						lowerCAmelCase__):
															raise ValueError("llm_int8_has_fp16_weight must be a boolean")

									if self.bnb_abit_compute_dtype is not None and not isinstance(self.bnb_abit_compute_dtype       ,						torch.dtype):
															raise ValueError("bnb_4bit_compute_dtype must be torch.dtype")

									if not isinstance(self.bnb_abit_quant_type       ,						lowerCAmelCase__):
															raise ValueError("bnb_4bit_quant_type must be a string")

									if not isinstance(self.bnb_abit_use_double_quant       ,						lowerCAmelCase__):
															raise ValueError("bnb_4bit_use_double_quant must be a boolean")

									if self.load_in_abit and not version.parse(importlib.metadata.version("bitsandbytes")) >= version.parse(
									    "0.39.0"):
															raise ValueError(
															    "4 bit quantization requires bitsandbytes>=0.39.0 - please upgrade your bitsandbytes version")



			def 	_SCREAMING_SNAKE_CASE      (			self  :					str):
									return self.load_in_abit or self.load_in_abit



			def 	_SCREAMING_SNAKE_CASE      (			self  :					str):
									if self.load_in_abit:
															return "llm_int8"
									elif self.load_in_abit and self.bnb_abit_quant_type == "fp4":
															return "fp4"
									elif self.load_in_abit and self.bnb_abit_quant_type == "nf4":
															return "nf4"
									else:
															return None



			@classmethod
			def 	_SCREAMING_SNAKE_CASE      (			cls  :					Dict       ,						lowerCAmelCase__  :					Any       ,						lowerCAmelCase__  :					List[str]       ,						**lowerCAmelCase__  :					str):
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	cls(**lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_:			List[str]  		=	[]
									for key, value in kwargs.items():
															if hasattr(lowerCAmelCase__       ,						lowerCAmelCase__):
																					setattr(lowerCAmelCase__       ,						lowerCAmelCase__       ,						lowerCAmelCase__)
																					to_remove.append(lowerCAmelCase__)
									for key in to_remove:
															kwargs.pop(lowerCAmelCase__       ,						lowerCAmelCase__)

									if return_unused_kwargs:
															return config, kwargs
									else:
															return config



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Dict       ,						lowerCAmelCase__  :					Union[str, os.PathLike]):
									with open(lowerCAmelCase__       ,						"w"       ,						encoding="utf-8") as writer:
															SCREAMING_SNAKE_CASE_:			Any  		=	self.to_dict()
															SCREAMING_SNAKE_CASE_:			List[Any]  		=	json.dumps(lowerCAmelCase__       ,						indent=2       ,						sort_keys=lowerCAmelCase__) + "\n"

															writer.write(lowerCAmelCase__)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[Any]):
									SCREAMING_SNAKE_CASE_:			Dict  		=	copy.deepcopy(self.__dict__)
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	str(output["bnb_4bit_compute_dtype"]).split(".")[1]

									return output



			def __repr__(			self  :					str):
									return F"{self.__class__.__name__} {self.to_json_string()}"



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Tuple       ,						lowerCAmelCase__  :					bool = True):
									if use_diff is True:
															SCREAMING_SNAKE_CASE_:			List[Any]  		=	self.to_diff_dict()
									else:
															SCREAMING_SNAKE_CASE_:			Dict  		=	self.to_dict()
									return json.dumps(lowerCAmelCase__       ,						indent=2       ,						sort_keys=lowerCAmelCase__) + "\n"




			def 	_SCREAMING_SNAKE_CASE      (			self  :					Any):
									SCREAMING_SNAKE_CASE_:			Dict  		=	self.to_dict()

									# get the default config dict
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	BitsAndBytesConfig().to_dict()

									SCREAMING_SNAKE_CASE_:			int  		=	{}

									# only serialize values that differ from the default config
									for key, value in config_dict.items():
															if value != default_config_dict[key]:
																					SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	value

									return serializable_config_dict









import importlib
import json
import os
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
import transformers.models.auto
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.bert.configuration_bert import BertConfig
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir


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

from test_module.custom_configuration import CustomConfig  # noqa E402


lowerCAmelCase							:  Union[str, Any]            =						get_tests_dir("""fixtures/dummy-config.json""")



class   __lowercase    (			unittest.TestCase     ):




			"""simple docstring"""







			def 	_SCREAMING_SNAKE_CASE      (			self  :					Tuple):
									SCREAMING_SNAKE_CASE_:			Dict  		=	0



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Any):
									self.assertIsNotNone(transformers.models.auto.__spec__)
									self.assertIsNotNone(importlib.util.find_spec("transformers.models.auto"))



			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[Any]):
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	AutoConfig.from_pretrained("bert-base-uncased")
									self.assertIsInstance(lowerCAmelCase__       ,						lowerCAmelCase__)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					str):
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	AutoConfig.from_pretrained(lowerCAmelCase__)
									self.assertIsInstance(lowerCAmelCase__       ,						lowerCAmelCase__)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					int):
									SCREAMING_SNAKE_CASE_:			Tuple  		=	AutoConfig.from_pretrained(lowerCAmelCase__)
									self.assertIsInstance(lowerCAmelCase__       ,						lowerCAmelCase__)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Union[str, Any]):
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	AutoConfig.for_model("roberta")
									self.assertIsInstance(lowerCAmelCase__       ,						lowerCAmelCase__)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[Any]):
									with tempfile.TemporaryDirectory() as tmp_dir:
															# This model name contains bert and roberta, but roberta ends up being picked.
															SCREAMING_SNAKE_CASE_:			int  		=	os.path.join(lowerCAmelCase__       ,						"fake-roberta")
															os.makedirs(lowerCAmelCase__       ,						exist_ok=lowerCAmelCase__)
															with open(os.path.join(lowerCAmelCase__       ,						"config.json")       ,						"w") as f:
																					f.write(json.dumps({}))
															SCREAMING_SNAKE_CASE_:			Any  		=	AutoConfig.from_pretrained(lowerCAmelCase__)
															self.assertEqual(type(lowerCAmelCase__)       ,						lowerCAmelCase__)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Optional[int]):
									try:
															AutoConfig.register("custom"       ,						lowerCAmelCase__)
															# Wrong model type will raise an error
															with self.assertRaises(lowerCAmelCase__):
																					AutoConfig.register("model"       ,						lowerCAmelCase__)
															# Trying to register something existing in the Transformers library will raise an error
															with self.assertRaises(lowerCAmelCase__):
																					AutoConfig.register("bert"       ,						lowerCAmelCase__)

															# Now that the config is registered, it can be used as any other config with the auto-API
															SCREAMING_SNAKE_CASE_:			List[Any]  		=	CustomConfig()
															with tempfile.TemporaryDirectory() as tmp_dir:
																					config.save_pretrained(lowerCAmelCase__)
																					SCREAMING_SNAKE_CASE_:			Tuple  		=	AutoConfig.from_pretrained(lowerCAmelCase__)
																					self.assertIsInstance(lowerCAmelCase__       ,						lowerCAmelCase__)

									finally:
															if "custom" in CONFIG_MAPPING._extra_content:
																					del CONFIG_MAPPING._extra_content["custom"]



			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[str]):
									with self.assertRaisesRegex(
									    lowerCAmelCase__       ,						"bert-base is not a local folder and is not a valid model identifier"):
															SCREAMING_SNAKE_CASE_:			List[str]  		=	AutoConfig.from_pretrained("bert-base")



			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[Any]):
									with self.assertRaisesRegex(
									    lowerCAmelCase__       ,						R"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"):
															SCREAMING_SNAKE_CASE_:			str  		=	AutoConfig.from_pretrained(lowerCAmelCase__       ,						revision="aaaaaa")



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Optional[int]):
									with self.assertRaisesRegex(
									    lowerCAmelCase__       ,						"hf-internal-testing/no-config-test-repo does not appear to have a file named config.json."       ,						):
															SCREAMING_SNAKE_CASE_:			int  		=	AutoConfig.from_pretrained("hf-internal-testing/no-config-test-repo")



			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[str]):
									# If remote code is not set, we will time out when asking whether to load the model.
									with self.assertRaises(lowerCAmelCase__):
															SCREAMING_SNAKE_CASE_:			str  		=	AutoConfig.from_pretrained("hf-internal-testing/test_dynamic_model")
									# If remote code is disabled, we can't load this config.
									with self.assertRaises(lowerCAmelCase__):
															SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	AutoConfig.from_pretrained("hf-internal-testing/test_dynamic_model"       ,						trust_remote_code=lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_:			str  		=	AutoConfig.from_pretrained("hf-internal-testing/test_dynamic_model"       ,						trust_remote_code=lowerCAmelCase__)
									self.assertEqual(config.__class__.__name__       ,						"NewModelConfig")

									# Test config can be reloaded.
									with tempfile.TemporaryDirectory() as tmp_dir:
															config.save_pretrained(lowerCAmelCase__)
															SCREAMING_SNAKE_CASE_:			Any  		=	AutoConfig.from_pretrained(lowerCAmelCase__       ,						trust_remote_code=lowerCAmelCase__)
									self.assertEqual(reloaded_config.__class__.__name__       ,						"NewModelConfig")




			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[Any]):



									class   __lowercase    (			UpperCAmelCase_     ):




												"""simple docstring"""







												_UpperCAmelCase       :							int      							=					'''new-model'''

									try:
															AutoConfig.register("new-model"       ,						lowerCAmelCase__)
															# If remote code is not set, the default is to use local
															SCREAMING_SNAKE_CASE_:			int  		=	AutoConfig.from_pretrained("hf-internal-testing/test_dynamic_model")
															self.assertEqual(config.__class__.__name__       ,						"NewModelConfigLocal")

															# If remote code is disabled, we load the local one.
															SCREAMING_SNAKE_CASE_:			Optional[int]  		=	AutoConfig.from_pretrained("hf-internal-testing/test_dynamic_model"       ,						trust_remote_code=lowerCAmelCase__)
															self.assertEqual(config.__class__.__name__       ,						"NewModelConfigLocal")

															# If remote is enabled, we load from the Hub
															SCREAMING_SNAKE_CASE_:			int  		=	AutoConfig.from_pretrained("hf-internal-testing/test_dynamic_model"       ,						trust_remote_code=lowerCAmelCase__)
															self.assertEqual(config.__class__.__name__       ,						"NewModelConfig")

									finally:
															if "new-model" in CONFIG_MAPPING._extra_content:
																					del CONFIG_MAPPING._extra_content["new-model"]






