






# 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







import argparse
import os
import re

import packaging.version


lowerCamelCase     :							Optional[Any]    ='''examples/'''
lowerCamelCase     :							List[Any]    ={
    '''examples''': (re.compile(R'''^check_min_version\("[^"]+"\)\s*$''', re.MULTILINE), '''check_min_version("VERSION")\n'''),
    '''init''': (re.compile(R'''^__version__\s+=\s+"([^"]+)"\s*$''', re.MULTILINE), '''__version__ = "VERSION"\n'''),
    '''setup''': (re.compile(R'''^(\s*)version\s*=\s*"[^"]+",''', re.MULTILINE), R'''\1version="VERSION",'''),
    '''doc''': (re.compile(R'''^(\s*)release\s*=\s*"[^"]+"$''', re.MULTILINE), '''release = "VERSION"\n'''),
}
lowerCamelCase     :							List[str]    ={
    '''init''': '''src/transformers/__init__.py''',
    '''setup''': '''setup.py''',
}
lowerCamelCase     :							int    ='''README.md'''







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )			->     Optional[Any]:
     with open(__lowerCAmelCase ,   "r" ,   encoding="utf-8" ,   newline="\n"      ) as f:
          UpperCamelCase__      :       List[Any]	    =  f.read()
     UpperCamelCase__    ,					UpperCamelCase__      :       List[str]	    =  REPLACE_PATTERNS[pattern]
     UpperCamelCase__      :       Union[str, Any]	    =  replace.replace("VERSION" ,   __lowerCAmelCase      )
     UpperCamelCase__      :       Tuple	    =  re_pattern.sub(__lowerCAmelCase ,   __lowerCAmelCase      )
     with open(__lowerCAmelCase ,   "w" ,   encoding="utf-8" ,   newline="\n"      ) as f:
          f.write(__lowerCAmelCase      )







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     Union[str, Any]:
     for folder, directories, fnames in os.walk(__lowerCAmelCase      ):
          # Removing some of the folders with non-actively maintained examples from the walk
          if "research_projects" in directories:
               directories.remove("research_projects"      )
          if "legacy" in directories:
               directories.remove("legacy"      )
          for fname in fnames:
               if fname.endswith(".py"      ):
                    update_version_in_file(os.path.join(__lowerCAmelCase ,   __lowerCAmelCase      ) ,   __lowerCAmelCase ,   pattern="examples"      )







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase=False      )			->     Optional[int]:
     for pattern, fname in REPLACE_FILES.items():
          update_version_in_file(__lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )
     if not patch:
          update_version_in_examples(__lowerCAmelCase      )







def 		SCREAMING_SNAKE_CASE							( )			->     Optional[Any]:
     UpperCamelCase__      :       Tuple	    =  "🤗 Transformers currently provides the following architectures"
     UpperCamelCase__      :       Tuple	    =  "1. Want to contribute a new model?"
     with open(__lowerCAmelCase ,   "r" ,   encoding="utf-8" ,   newline="\n"      ) as f:
          UpperCamelCase__      :       Optional[int]	    =  f.readlines()

     # Find the start of the list.
     UpperCamelCase__      :       List[Any]	    =  0
     while not lines[start_index].startswith(_start_prompt      ):
          start_index += 1
     start_index += 1

     UpperCamelCase__      :       Dict	    =  start_index
     # Update the lines in the model list.
     while not lines[index].startswith(_end_prompt      ):
          if lines[index].startswith("1."      ):
               UpperCamelCase__      :       str	    =  lines[index].replace(
                   "https://huggingface.co/docs/transformers/main/model_doc" ,   "https://huggingface.co/docs/transformers/model_doc" ,   )
          index += 1

     with open(__lowerCAmelCase ,   "w" ,   encoding="utf-8" ,   newline="\n"      ) as f:
          f.writelines(__lowerCAmelCase      )







def 		SCREAMING_SNAKE_CASE							( )			->     Tuple:
     with open(REPLACE_FILES["init"] ,   "r"      ) as f:
          UpperCamelCase__      :       str	    =  f.read()
     UpperCamelCase__      :       Dict	    =  REPLACE_PATTERNS["init"][0].search(__lowerCAmelCase      ).groups()[0]
     return packaging.version.parse(__lowerCAmelCase      )







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase=False      )			->     Optional[int]:
     UpperCamelCase__      :       Dict	    =  get_version()
     if patch and default_version.is_devrelease:
          raise ValueError("Can't create a patch version from the dev branch, checkout a released version!"      )
     if default_version.is_devrelease:
          UpperCamelCase__      :       List[str]	    =  default_version.base_version
     elif patch:
          UpperCamelCase__      :       int	    =  f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}'
     else:
          UpperCamelCase__      :       Tuple	    =  f'{default_version.major}.{default_version.minor + 1}.0'

     # Now let's ask nicely if that's the right one.
     UpperCamelCase__      :       Tuple	    =  input(f'Which version are you releasing? [{default_version}]'      )
     if len(__lowerCAmelCase      ) == 0:
          UpperCamelCase__      :       Any	    =  default_version

     print(f'Updating version to {version}.'      )
     global_version_update(__lowerCAmelCase ,   patch=__lowerCAmelCase      )
     if not patch:
          print("Cleaning main README, don't forget to run `make fix-copies`."      )
          clean_main_ref_in_model_list()







def 		SCREAMING_SNAKE_CASE							( )			->     int:
     UpperCamelCase__      :       str	    =  get_version()
     UpperCamelCase__      :       Dict	    =  f'{current_version.major}.{current_version.minor + 1}.0.dev0'
     UpperCamelCase__      :       int	    =  current_version.base_version

     # Check with the user we got that right.
     UpperCamelCase__      :       List[str]	    =  input(f'Which version are we developing now? [{dev_version}]'      )
     if len(__lowerCAmelCase      ) == 0:
          UpperCamelCase__      :       Optional[Any]	    =  dev_version

     print(f'Updating version to {version}.'      )
     global_version_update(__lowerCAmelCase      )
     print("Cleaning main README, don't forget to run `make fix-copies`."      )
     clean_main_ref_in_model_list()


if __name__ == "__main__":
 lowerCamelCase     :							List[Any]    =argparse.ArgumentParser()
 parser.add_argument('''--post_release''', action='''store_true''', help='''Whether this is pre or post release.''')
 parser.add_argument('''--patch''', action='''store_true''', help='''Whether or not this is a patch release.''')
 lowerCamelCase     :							Optional[Any]    =parser.parse_args()
 if not args.post_release:
  pre_release_work(patch=args.patch)
 elif args.patch:
  print('''Nothing to do after a patch :-)''')
 else:
  post_release_work()