






# 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       __a  :







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


      '''simple docstring'''






      UpperCamelCase__      :       Any	    =  load_in_abit
      UpperCamelCase__      :       Any	    =  load_in_abit
      UpperCamelCase__      :       Any	    =  llm_inta_threshold
      UpperCamelCase__      :       List[Any]	    =  llm_inta_skip_modules
      UpperCamelCase__      :       int	    =  llm_inta_enable_fpaa_cpu_offload
      UpperCamelCase__      :       int	    =  llm_inta_has_fpaa_weight
      UpperCamelCase__      :       Any	    =  bnb_abit_quant_type
      UpperCamelCase__      :       str	    =  bnb_abit_use_double_quant

      if bnb_abit_compute_dtype is None:
           UpperCamelCase__      :       Dict	    =  torch.floataa
      elif isinstance(SCREAMING_SNAKE_CASE							,       SCREAMING_SNAKE_CASE						):
           UpperCamelCase__      :       Any	    =  getattr(SCREAMING_SNAKE_CASE							,       SCREAMING_SNAKE_CASE						)
      elif isinstance(SCREAMING_SNAKE_CASE							,       torch.dtype						):
           UpperCamelCase__      :       Dict	    =  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 :       List[Any]						):


      '''simple docstring'''






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

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

      if not isinstance(self.bnb_abit_use_double_quant							,       SCREAMING_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  __lowercase (		self :       List[str]						):


      '''simple docstring'''






      return self.load_in_abit or self.load_in_abit







 def  __lowercase (		self :       Tuple						):


      '''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 :       Optional[int]							,       SCREAMING_SNAKE_CASE :       str							,       SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      UpperCamelCase__      :       Tuple	    =  cls(**SCREAMING_SNAKE_CASE						)

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

      if return_unused_kwargs:
           return config, kwargs
      else:
           return config







 def  __lowercase (		self :       Optional[int]							,       SCREAMING_SNAKE_CASE :       Union[str, os.PathLike]						):


      '''simple docstring'''






      with open(SCREAMING_SNAKE_CASE							,       "w"							,       encoding="utf-8"						) as writer:
           UpperCamelCase__      :       Dict	    =  self.to_dict()
           UpperCamelCase__      :       Optional[int]	    =  json.dumps(SCREAMING_SNAKE_CASE							,       indent=2							,       sort_keys=SCREAMING_SNAKE_CASE						) + "\n"

           writer.write(SCREAMING_SNAKE_CASE						)







 def  __lowercase (		self :       Tuple						):


      '''simple docstring'''






      UpperCamelCase__      :       Optional[Any]	    =  copy.deepcopy(self.__dict__						)
      UpperCamelCase__      :       Union[str, Any]	    =  str(output["bnb_4bit_compute_dtype"]						).split("."						)[1]

      return output







 def __repr__(		self :       str						):


      '''simple docstring'''






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







 def  __lowercase (		self :       int							,       SCREAMING_SNAKE_CASE :       bool = True						):


      '''simple docstring'''






      if use_diff is True:
           UpperCamelCase__      :       Union[str, Any]	    =  self.to_diff_dict()
      else:
           UpperCamelCase__      :       str	    =  self.to_dict()
      return json.dumps(SCREAMING_SNAKE_CASE							,       indent=2							,       sort_keys=SCREAMING_SNAKE_CASE						) + "\n"







 def  __lowercase (		self :       Optional[Any]						):


      '''simple docstring'''






      UpperCamelCase__      :       List[Any]	    =  self.to_dict()

      # get the default config dict
      UpperCamelCase__      :       int	    =  BitsAndBytesConfig().to_dict()

      UpperCamelCase__      :       Optional[Any]	    =  {}

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

      return serializable_config_dict







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     int:
     assert isinstance(__lowerCAmelCase ,   __lowerCAmelCase      ), f'The input value of [n={number}] is not an integer'

     if number == 1:
          return 2
     elif number < 1:
          UpperCamelCase__      :       List[Any]	    =  f'The input value of [n={number}] has to be > 0'
          raise ValueError(__lowerCAmelCase      )
     else:
          UpperCamelCase__      :       Optional[Any]	    =  sylvester(number - 1      )
          UpperCamelCase__      :       str	    =  num - 1
          UpperCamelCase__      :       int	    =  num
          return lower * upper + 1


if __name__ == "__main__":
 print(F"""The 8th number in Sylvester's sequence: {sylvester(8)}""")