



"""simple docstring"""





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       	=						logging.get_logger(__name__)
@dataclass
class 				lowercase__       :



       def __init__(							self      :  Dict		,    _UpperCAmelCase      :  Any=False		,    _UpperCAmelCase      :  Optional[Any]=False		,    _UpperCAmelCase      :  int=6.0		,    _UpperCAmelCase      :  Any=None		,    _UpperCAmelCase      :  List[Any]=False		,    _UpperCAmelCase      :  Any=False		,    _UpperCAmelCase      :  Dict=None		,    _UpperCAmelCase      :  Dict="fp4"		,    _UpperCAmelCase      :  Dict=False		,    **_UpperCAmelCase      :  int		,    )			->						List[Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							load_in_abit
             UpperCAmelCase_      			=							load_in_abit
             UpperCAmelCase_      			=							llm_inta_threshold
             UpperCAmelCase_      			=							llm_inta_skip_modules
             UpperCAmelCase_      			=							llm_inta_enable_fpaa_cpu_offload
             UpperCAmelCase_      			=							llm_inta_has_fpaa_weight
             UpperCAmelCase_      			=							bnb_abit_quant_type
             UpperCAmelCase_      			=							bnb_abit_use_double_quant

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

             self.post_init()



       def 					lowercase__    (							self      :  str   )			->						Optional[int]:


             '''simple docstring'''




             if not isinstance(self.llm_inta_threshold		,    _UpperCAmelCase   ):
                   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		,    _UpperCAmelCase   ):
                   raise ValueError("llm_int8_skip_modules must be a list of strings"   )
             if not isinstance(self.llm_inta_enable_fpaa_cpu_offload		,    _UpperCAmelCase   ):
                   raise ValueError("llm_int8_enable_fp32_cpu_offload must be a boolean"   )

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

             if not isinstance(self.bnb_abit_use_double_quant		,    _UpperCAmelCase   ):
                   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 					lowercase__    (							self      :  Dict   )			->						int:


             '''simple docstring'''




             return self.load_in_abit or self.load_in_abit



       def 					lowercase__    (							self      :  Dict   )			->						int:


             '''simple docstring'''




             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 					lowercase__    (							cls      :  str		,    _UpperCAmelCase      :  int		,    _UpperCAmelCase      :  Tuple		,    **_UpperCAmelCase      :  List[str]   )			->						List[Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							cls(**_UpperCAmelCase   )

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

             if return_unused_kwargs:
                   return config, kwargs
             else:
                   return config



       def 					lowercase__    (							self      :  Union[str, Any]		,    _UpperCAmelCase      :  Union[str, os.PathLike]   )			->						Any:


             '''simple docstring'''




             with open(_UpperCAmelCase		,    "w"		,    encoding="utf-8"   ) as writer:
                   UpperCAmelCase_      			=							self.to_dict()
                   UpperCAmelCase_      			=							json.dumps(_UpperCAmelCase		,    indent=2		,    sort_keys=_UpperCAmelCase   ) + '\n'

                   writer.write(_UpperCAmelCase   )



       def 					lowercase__    (							self      :  Optional[Any]   )			->						Dict[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							copy.deepcopy(self.__dict__   )
             UpperCAmelCase_      			=							str(output["bnb_4bit_compute_dtype"]   ).split("."   )[1]

             return output



       def __repr__(							self      :  Any   )			->						Tuple:


             '''simple docstring'''




             return F"""{self.__class__.__name__} {self.to_json_string()}"""



       def 					lowercase__    (							self      :  Dict		,    _UpperCAmelCase      :  bool = True   )			->						str:


             '''simple docstring'''




             if use_diff is True:
                   UpperCAmelCase_      			=							self.to_diff_dict()
             else:
                   UpperCAmelCase_      			=							self.to_dict()
             return json.dumps(_UpperCAmelCase		,    indent=2		,    sort_keys=_UpperCAmelCase   ) + "\n"







       def 					lowercase__    (							self      :  Optional[Any]   )			->						Dict[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							self.to_dict()

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

             UpperCAmelCase_      			=							{}

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

             return serializable_config_dict









"""simple docstring"""





from .configuration_bert_masked import MaskedBertConfig
from .modeling_bert_masked import (
    MaskedBertForMultipleChoice,
    MaskedBertForQuestionAnswering,
    MaskedBertForSequenceClassification,
    MaskedBertForTokenClassification,
    MaskedBertModel,
)
from .modules import *




