





# 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_        =							logging.get_logger(__name__)



@dataclass
class    __lowerCAmelCase			:






			def __init__(self   ,				__magic_name__=False   ,				__magic_name__=False   ,				__magic_name__=6.0   ,				__magic_name__=None   ,				__magic_name__=False   ,				__magic_name__=False   ,				__magic_name__=None   ,				__magic_name__="fp4"   ,				__magic_name__=False   ,				**__magic_name__   ,				)	->  List[str]:


							'''simple docstring'''



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

							if bnb_abit_compute_dtype is None:
											snake_case_		:       Any           =    torch.floataa
							elif isinstance(a__   ,				a__       ):
											snake_case_		:       Optional[int]           =    getattr(a__   ,				a__       )
							elif isinstance(a__   ,				torch.dtype       ):
											snake_case_		:       Optional[Any]           =    bnb_abit_compute_dtype
							else:
											raise ValueError('''bnb_4bit_compute_dtype must be a string or a torch.dtype'''       )

							self.post_init()






			def      lowerCamelCase    (self       )	->  str:


							'''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      lowerCamelCase    (self       )	->  Union[str, Any]:


							'''simple docstring'''



							return self.load_in_abit or self.load_in_abit






			def      lowerCamelCase    (self       )	->  Dict:


							'''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      lowerCamelCase    (cls   ,				__magic_name__   ,				__magic_name__   ,				**__magic_name__       )	->  int:


							'''simple docstring'''



							snake_case_		:       int           =    cls(**a__       )

							snake_case_		:       Tuple           =    []
							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      lowerCamelCase    (self   ,				__magic_name__       )	->  int:


							'''simple docstring'''



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

											writer.write(a__       )






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


							'''simple docstring'''



							snake_case_		:       int           =    copy.deepcopy(self.__dict__       )
							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      lowerCamelCase    (self   ,				__magic_name__ = True       )	->  str:


							'''simple docstring'''



							if use_diff is True:
											snake_case_		:       Optional[int]           =    self.to_diff_dict()
							else:
											snake_case_		:       List[str]           =    self.to_dict()
							return json.dumps(a__   ,				indent=2   ,				sort_keys=a__       ) + "\n"






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


							'''simple docstring'''



							snake_case_		:       int           =    self.to_dict()

							# get the default config dict
							snake_case_		:       Optional[int]           =    BitsAndBytesConfig().to_dict()

							snake_case_		:       Optional[int]           =    {}

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

							return serializable_config_dict








def 	UpperCamelCase	(							snake_case__  : list	):




     '''simple docstring'''






     if not grid or not grid[0]:
          raise TypeError("""The grid does not contain the appropriate information"""	)

     for cell_n in range(1						,len(grid[0]	)	):
          grid[0][cell_n] += grid[0][cell_n - 1]
     __snake_case      :str 							=    grid[0]

     for row_n in range(1						,len(snake_case__	)	):
          __snake_case      :Optional[int] 							=    grid[row_n]
          __snake_case      :Optional[Any] 							=    fill_row(snake_case__						,snake_case__	)
          __snake_case      :Dict 							=    grid[row_n]

     return grid[-1][-1]






def 	UpperCamelCase	(							snake_case__  : list						,snake_case__  : list	):




     '''simple docstring'''






     current_row[0] += row_above[0]
     for cell_n in range(1						,len(snake_case__	)	):
          current_row[cell_n] += min(current_row[cell_n - 1]						,row_above[cell_n]	)

     return current_row


if __name__ == "__main__":
     import doctest

     doctest.testmod()


