



# 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


lowercase_	       =			logging.get_logger(__name__)






@dataclass
class 						__a :



	def __init__(						self							:    Dict				,	snake_case_							:    str=False				,	snake_case_							:    int=False				,	snake_case_							:    List[Any]=6.0				,	snake_case_							:    int=None				,	snake_case_							:    Any=False				,	snake_case_							:    Optional[Any]=False				,	snake_case_							:    Optional[Any]=None				,	snake_case_							:    Any="fp4"				,	snake_case_							:    Optional[int]=False				,	**snake_case_							:    Any				,	)->							Any:
						__lowerCAmelCase	   =load_in_abit
						__lowerCAmelCase	   =load_in_abit
						__lowerCAmelCase	   =llm_inta_threshold
						__lowerCAmelCase	   =llm_inta_skip_modules
						__lowerCAmelCase	   =llm_inta_enable_fpaa_cpu_offload
						__lowerCAmelCase	   =llm_inta_has_fpaa_weight
						__lowerCAmelCase	   =bnb_abit_quant_type
						__lowerCAmelCase	   =bnb_abit_use_double_quant

						if bnb_abit_compute_dtype is None:
											__lowerCAmelCase	   =torch.floataa
						elif isinstance(snake_case_				,	snake_case_):
											__lowerCAmelCase	   =getattr(snake_case_				,	snake_case_)
						elif isinstance(snake_case_				,	torch.dtype):
											__lowerCAmelCase	   =bnb_abit_compute_dtype
						else:
											raise ValueError("""bnb_4bit_compute_dtype must be a string or a torch.dtype""")

						self.post_init()



	def 		UpperCamelCase							(						self							:    Optional[Any])->							List[Any]:
						if not isinstance(self.llm_inta_threshold				,	snake_case_):
											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				,	snake_case_):
											raise ValueError("""llm_int8_skip_modules must be a list of strings""")
						if not isinstance(self.llm_inta_enable_fpaa_cpu_offload				,	snake_case_):
											raise ValueError("""llm_int8_enable_fp32_cpu_offload must be a boolean""")

						if not isinstance(self.llm_inta_has_fpaa_weight				,	snake_case_):
											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				,	snake_case_):
											raise ValueError("""bnb_4bit_quant_type must be a string""")

						if not isinstance(self.bnb_abit_use_double_quant				,	snake_case_):
											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 		UpperCamelCase							(						self							:    Optional[Any])->							int:
						return self.load_in_abit or self.load_in_abit



	def 		UpperCamelCase							(						self							:    Tuple)->							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 		UpperCamelCase							(						cls							:    Optional[int]				,	snake_case_							:    Dict				,	snake_case_							:    List[Any]				,	**snake_case_							:    Tuple)->							Optional[int]:
						__lowerCAmelCase	   =cls(**snake_case_)

						__lowerCAmelCase	   =[]
						for key, value in kwargs.items():
											if hasattr(snake_case_				,	snake_case_):
																setattr(snake_case_				,	snake_case_				,	snake_case_)
																to_remove.append(snake_case_)
						for key in to_remove:
											kwargs.pop(snake_case_				,	snake_case_)

						if return_unused_kwargs:
											return config, kwargs
						else:
											return config



	def 		UpperCamelCase							(						self							:    List[Any]				,	snake_case_							:    Union[str, os.PathLike])->							int:
						with open(snake_case_				,	"""w"""				,	encoding="""utf-8""") as writer:
											__lowerCAmelCase	   =self.to_dict()
											__lowerCAmelCase	   =json.dumps(snake_case_				,	indent=2				,	sort_keys=snake_case_) + """\n"""

											writer.write(snake_case_)



	def 		UpperCamelCase							(						self							:    int)->							Dict[str, Any]:
						__lowerCAmelCase	   =copy.deepcopy(self.__dict__)
						__lowerCAmelCase	   =str(output["""bnb_4bit_compute_dtype"""]).split(""".""")[1]

						return output



	def __repr__(						self							:    Optional[Any])->							Dict:
						return F"""{self.__class__.__name__} {self.to_json_string()}"""



	def 		UpperCamelCase							(						self							:    Tuple				,	snake_case_							:    bool = True)->							str:
						if use_diff is True:
											__lowerCAmelCase	   =self.to_diff_dict()
						else:
											__lowerCAmelCase	   =self.to_dict()
						return json.dumps(snake_case_				,	indent=2				,	sort_keys=snake_case_) + "\n"



	def 		UpperCamelCase							(						self							:    Optional[Any])->							Dict[str, Any]:
						__lowerCAmelCase	   =self.to_dict()

						# get the default config dict
						__lowerCAmelCase	   =BitsAndBytesConfig().to_dict()

						__lowerCAmelCase	   ={}

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

						return serializable_config_dict









def 					__lowerCAmelCase		(  )  ->						Tuple:
					__lowerCAmelCase	   =[]
					__lowerCAmelCase	   =1

					while len(__lowerCamelCase	) < 1E6:
										constant.append(str(__lowerCamelCase	)	)
										i += 1

					__lowerCAmelCase	   ="""""".join(__lowerCamelCase	)

					return (
					    int(constant[0]	)
					    * int(constant[9]	)
					    * int(constant[99]	)
					    * int(constant[999]	)
					    * int(constant[9999]	)
					    * int(constant[99999]	)
					    * int(constant[999999]	)
					)


if __name__ == "__main__":
				print(solution())




