

# 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     __snake_case    :
       """simple docstring"""







       def __init__(		self      , _UpperCamelCase=False      , _UpperCamelCase=False      , _UpperCamelCase=6.0      , _UpperCamelCase=None      , _UpperCamelCase=False      , _UpperCamelCase=False      , _UpperCamelCase=None      , _UpperCamelCase="fp4"      , _UpperCamelCase=False      , **_UpperCamelCase      , )      ->							int:






              """simple docstring"""


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

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

              self.post_init()


       def 			a		(		self   )      ->							Union[str, Any]:






              """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 			a		(		self   )      ->							int:






              """simple docstring"""


              return self.load_in_abit or self.load_in_abit


       def 			a		(		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 			a		(		cls      , _UpperCamelCase      , _UpperCamelCase      , **_UpperCamelCase   )      ->							Union[str, Any]:






              """simple docstring"""


              __snake_case       	=							cls(**_UpperCamelCase   )

              __snake_case       	=							[]
              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 			a		(		self      , _UpperCamelCase   )      ->							int:






              """simple docstring"""


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

                     writer.write(_UpperCamelCase   )


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






              """simple docstring"""


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

              return output


       def __repr__(		self   )      ->							Dict:






              """simple docstring"""


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


       def 			a		(		self      , _UpperCamelCase = True   )      ->							str:






              """simple docstring"""


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






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






              """simple docstring"""


              __snake_case       	=							self.to_dict()

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

              __snake_case       	=							{}

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

              return serializable_config_dict




from argparse import ArgumentParser

from . import BaseTransformersCLICommand







def 						lowerCamelCase__      ( __A    :Optional[int]		):


       """simple docstring"""




       return DownloadCommand(args.model	,args.cache_dir	,args.force	,args.trust_remote_code		)




class     __snake_case    (				snake_case__  ):
       """simple docstring"""







       @staticmethod
       def 			a		(		_UpperCamelCase   )      ->							Any:






              """simple docstring"""


              __snake_case       	=							parser.add_parser("""download"""   )
              download_parser.add_argument(
                  """--cache-dir"""      , type=_UpperCamelCase      , default=_UpperCamelCase      , help="""Path to location to store the models"""   )
              download_parser.add_argument(
                  """--force"""      , action="""store_true"""      , help="""Force the model to be download even if already in cache-dir"""   )
              download_parser.add_argument(
                  """--trust-remote-code"""      , action="""store_true"""      , help="""Whether or not to allow for custom models defined on the Hub in their own modeling files. Use only if you've reviewed the code as it will execute on your local machine"""      , )
              download_parser.add_argument("""model"""      , type=_UpperCamelCase      , help="""Name of the model to download"""   )
              download_parser.set_defaults(func=_UpperCamelCase   )


       def __init__(		self      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase   )      ->							Any:






              """simple docstring"""


              __snake_case       	=							model
              __snake_case       	=							cache
              __snake_case       	=							force
              __snake_case       	=							trust_remote_code






       def 			a		(		self   )      ->							List[Any]:






              """simple docstring"""


              from ..models.auto import AutoModel, AutoTokenizer

              AutoModel.from_pretrained(
                  self._model      , cache_dir=self._cache      , force_download=self._force      , trust_remote_code=self._trust_remote_code   )
              AutoTokenizer.from_pretrained(
                  self._model      , cache_dir=self._cache      , force_download=self._force      , trust_remote_code=self._trust_remote_code   )

