






# 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      :       int    =						logging.get_logger(__name__)



@dataclass
class 				_UpperCamelCase      :


      def __init__(						self       ,    __UpperCamelCase=False       ,    __UpperCamelCase=False       ,    __UpperCamelCase=6.0       ,    __UpperCamelCase=None       ,    __UpperCamelCase=False       ,    __UpperCamelCase=False       ,    __UpperCamelCase=None       ,    __UpperCamelCase="fp4"       ,    __UpperCamelCase=False       ,    **__UpperCamelCase       ,    )->						str:
           __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(__UpperCamelCase       ,    __UpperCamelCase						):
                __lowerCAmelCase             =       getattr(__UpperCamelCase       ,    __UpperCamelCase						)
           elif isinstance(__UpperCamelCase       ,    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						)->						List[Any]:
           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 			__UpperCAmelCase		(						self						)->						Optional[Any]:
           return self.load_in_abit or self.load_in_abit


      def 			__UpperCAmelCase		(						self						)->						Any:
           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       ,    __UpperCamelCase       ,    __UpperCamelCase       ,    **__UpperCamelCase						)->						List[str]:
           __lowerCAmelCase             =       cls(**__UpperCamelCase						)

           __lowerCAmelCase             =       []
           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 			__UpperCAmelCase		(						self       ,    __UpperCamelCase						)->						Dict:
           with open(__UpperCamelCase       ,    "w"       ,    encoding="utf-8"						) as writer:
                __lowerCAmelCase             =       self.to_dict()
                __lowerCAmelCase             =       json.dumps(__UpperCamelCase       ,    indent=2       ,    sort_keys=__UpperCamelCase						) + "\n"

                writer.write(__UpperCamelCase						)


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

           return output


      def __repr__(						self						)->						Tuple:
           return F"""{self.__class__.__name__} {self.to_json_string()}"""


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


      def 			__UpperCAmelCase		(						self						)->						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














lowerCamelCase      :       List[Any]    =						{
    '''meter''': '''m''',
    '''kilometer''': '''km''',
    '''megametre''': '''Mm''',
    '''gigametre''': '''Gm''',
    '''terametre''': '''Tm''',
    '''petametre''': '''Pm''',
    '''exametre''': '''Em''',
    '''zettametre''': '''Zm''',
    '''yottametre''': '''Ym''',
}
# Exponent of the factor(meter)
lowerCamelCase      :       Union[str, Any]    =						{
    '''m''': 0,
    '''km''': 3,
    '''Mm''': 6,
    '''Gm''': 9,
    '''Tm''': 12,
    '''Pm''': 15,
    '''Em''': 18,
    '''Zm''': 21,
    '''Ym''': 24,
}





def    __lowerCAmelCase   (    __snake_case       ,			__snake_case       ,			__snake_case							):
     __lowerCAmelCase             =       from_type.lower().strip("s"							)
     __lowerCAmelCase             =       to_type.lower().strip("s"							)

     __lowerCAmelCase             =       UNIT_SYMBOL.get(__snake_case       ,			__snake_case							)
     __lowerCAmelCase             =       UNIT_SYMBOL.get(__snake_case       ,			__snake_case							)

     if from_sanitized not in METRIC_CONVERSION:
          __lowerCAmelCase             =       (
              F"""Invalid 'from_type' value: {from_type!r}.\n"""
              F"""Conversion abbreviations are: {", ".join(__snake_case							)}"""
          )
          raise ValueError(__snake_case							)
     if to_sanitized not in METRIC_CONVERSION:
          __lowerCAmelCase             =       (
              F"""Invalid 'to_type' value: {to_type!r}.\n"""
              F"""Conversion abbreviations are: {", ".join(__snake_case							)}"""
          )
          raise ValueError(__snake_case							)
     __lowerCAmelCase             =       METRIC_CONVERSION[from_sanitized]
     __lowerCAmelCase             =       METRIC_CONVERSION[to_sanitized]
     __lowerCAmelCase             =       1

     if from_exponent > to_exponent:
          __lowerCAmelCase             =       from_exponent - to_exponent
     else:
          __lowerCAmelCase             =       -(to_exponent - from_exponent)

     return value * pow(10       ,			__snake_case							)


if __name__ == "__main__":
 from doctest import testmod

 testmod()






