






"""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


UpperCAmelCase_     :				str        =				logging.get_logger(__name__)




@dataclass
class 							lowerCAmelCase__       :






      '''simple docstring'''

      def __init__(		self  :						Dict		,			lowercase_  :						List[Any]=False		,			lowercase_  :						List[Any]=False		,			lowercase_  :						Dict=6.0		,			lowercase_  :						Optional[Any]=None		,			lowercase_  :						Optional[int]=False		,			lowercase_  :						List[str]=False		,			lowercase_  :						Tuple=None		,			lowercase_  :						List[Any]="fp4"		,			lowercase_  :						List[Any]=False		,			**lowercase_  :						Any		,			):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						str							=	load_in_abit
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	load_in_abit
          SCREAMING_SNAKE_CASE_   :						str							=	llm_inta_threshold
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	llm_inta_skip_modules
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	llm_inta_enable_fpaa_cpu_offload
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	llm_inta_has_fpaa_weight
          SCREAMING_SNAKE_CASE_   :						str							=	bnb_abit_quant_type
          SCREAMING_SNAKE_CASE_   :						Dict							=	bnb_abit_use_double_quant

          if bnb_abit_compute_dtype is None:
              SCREAMING_SNAKE_CASE_   :						int							=	torch.floataa
          elif isinstance(lowercase_		,			lowercase_):
              SCREAMING_SNAKE_CASE_   :						Optional[int]							=	getattr(lowercase_		,			lowercase_)
          elif isinstance(lowercase_		,			torch.dtype):
              SCREAMING_SNAKE_CASE_   :						List[Any]							=	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  :						List[str]):




          '''simple docstring'''


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

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

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




          '''simple docstring'''


          return self.load_in_abit or self.load_in_abit
      def _SCREAMING_SNAKE_CASE				(		self  :						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 _SCREAMING_SNAKE_CASE				(		cls  :						Union[str, Any]		,			lowercase_  :						Any		,			lowercase_  :						Optional[int]		,			**lowercase_  :						Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[str]							=	cls(**lowercase_)

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

          if return_unused_kwargs:
              return config, kwargs
          else:
              return config
      def _SCREAMING_SNAKE_CASE				(		self  :						List[str]		,			lowercase_  :						Dict):




          '''simple docstring'''


          with open(lowercase_		,			'''w'''		,			encoding='''utf-8''') as writer:
              SCREAMING_SNAKE_CASE_   :						List[Any]							=	self.to_dict()
              SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	json.dumps(lowercase_		,			indent=2		,			sort_keys=lowercase_) + '''\n'''

              writer.write(lowercase_)
      def _SCREAMING_SNAKE_CASE				(		self  :						Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	copy.deepcopy(self.__dict__)
          SCREAMING_SNAKE_CASE_   :						List[str]							=	str(output['''bnb_4bit_compute_dtype''']).split('''.''')[1]

          return output
      def __repr__(		self  :						int):




          '''simple docstring'''


          return F'{self.__class__.__name__} {self.to_json_string()}'
      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[Any]		,			lowercase_  :						str = True):




          '''simple docstring'''


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



      def _SCREAMING_SNAKE_CASE				(		self  :						List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Dict							=	self.to_dict()

          # get the default config dict
          SCREAMING_SNAKE_CASE_   :						Any							=	BitsAndBytesConfig().to_dict()

          SCREAMING_SNAKE_CASE_   :						str							=	{}

          # 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_   :						int							=	value

          return serializable_config_dict










"""simple docstring"""






def       _A    (__a = 1_00							)				-> int:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						int							=	(n * (n + 1) // 2) ** 2
    SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	n * (n + 1) * (2 * n + 1) // 6
    return sum_cubes - sum_squares


if __name__ == "__main__":
  print(f'''{solution() = }''')


