

# 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









from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase							:  Optional[int]            =						{
    """configuration_nllb_moe""": [
        """NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """NllbMoeConfig""",
    ]
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase							:  Optional[int]            =						[
						    """NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """NllbMoeForConditionalGeneration""",
						    """NllbMoeModel""",
						    """NllbMoePreTrainedModel""",
						    """NllbMoeTop2Router""",
						    """NllbMoeSparseMLP""",
						]


if TYPE_CHECKING:
						from .configuration_nllb_moe import (
						    NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    NllbMoeConfig,
						)

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_nllb_moe import (
												    NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST,
												    NllbMoeForConditionalGeneration,
												    NllbMoeModel,
												    NllbMoePreTrainedModel,
												    NllbMoeSparseMLP,
												    NllbMoeTopaRouter,
												)


else:
						import sys

						lowerCAmelCase							:  Any            =						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






