'''simple docstring'''




# 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


__UpperCAmelCase     							=logging.get_logger(__name__)




@dataclass
class     a__      :






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





         """simple docstring"""



         __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(a  ,				a    ):
             __lowerCamelCase		=  getattr(a  ,				a    )
         elif isinstance(a  ,				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    SCREAMING_SNAKE_CASE__   ( self		:		int    ):





         """simple docstring"""



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

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

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





         """simple docstring"""



         return self.load_in_abit or self.load_in_abit






     def    SCREAMING_SNAKE_CASE__   ( self		:		Optional[Any]    ):





         """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		:		List[Any]  ,				a		:		Dict  ,				a		:		Optional[int]  ,				**a		:		int    ):





         """simple docstring"""



         __lowerCamelCase		=  cls(**a    )

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

         if return_unused_kwargs:
             return config, kwargs
         else:
             return config






     def    SCREAMING_SNAKE_CASE__   ( self		:		Union[str, Any]  ,				a		:		Union[str, os.PathLike]    ):





         """simple docstring"""



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

             writer.write(a    )






     def    SCREAMING_SNAKE_CASE__   ( self		:		List[str]    ):





         """simple docstring"""



         __lowerCamelCase		=  copy.deepcopy(self.__dict__    )
         __lowerCamelCase		=  str(output['''bnb_4bit_compute_dtype''']    ).split('''.'''    )[1]

         return output






     def __repr__( self		:		List[Any]    ):





         """simple docstring"""



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






     def    SCREAMING_SNAKE_CASE__   ( self		:		Union[str, Any]  ,				a		:		bool = True    ):





         """simple docstring"""



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






     def    SCREAMING_SNAKE_CASE__   ( self		:		Dict    ):





         """simple docstring"""



         __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

"""simple docstring"""




_a      :		List[str]           =   {
    'Pillow': 'Pillow',
    'accelerate': 'accelerate>=0.11.0',
    'compel': 'compel==0.1.8',
    'black': 'black~=23.1',
    'datasets': 'datasets',
    'filelock': 'filelock',
    'flax': 'flax>=0.4.1',
    'hf-doc-builder': 'hf-doc-builder>=0.3.0',
    'huggingface-hub': 'huggingface-hub>=0.13.2',
    'requests-mock': 'requests-mock==1.10.0',
    'importlib_metadata': 'importlib_metadata',
    'invisible-watermark': 'invisible-watermark',
    'isort': 'isort>=5.5.4',
    'jax': 'jax>=0.2.8,!=0.3.2',
    'jaxlib': 'jaxlib>=0.1.65',
    'Jinja2': 'Jinja2',
    'k-diffusion': 'k-diffusion>=0.0.12',
    'torchsde': 'torchsde',
    'note_seq': 'note_seq',
    'librosa': 'librosa',
    'numpy': 'numpy',
    'omegaconf': 'omegaconf',
    'parameterized': 'parameterized',
    'protobuf': 'protobuf>=3.20.3,<4',
    'pytest': 'pytest',
    'pytest-timeout': 'pytest-timeout',
    'pytest-xdist': 'pytest-xdist',
    'ruff': 'ruff>=0.0.241',
    'safetensors': 'safetensors',
    'sentencepiece': 'sentencepiece>=0.1.91,!=0.1.92',
    'scipy': 'scipy',
    'onnx': 'onnx',
    'regex': 'regex!=2019.12.17',
    'requests': 'requests',
    'tensorboard': 'tensorboard',
    'torch': 'torch>=1.4',
    'torchvision': 'torchvision',
    'transformers': 'transformers>=4.25.1',
    'urllib3': 'urllib3<=2.0.0',
}




