


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





							"""simple docstring"""







							def __init__(      self			,						lowerCAmelCase__=False			,						lowerCAmelCase__=False			,						lowerCAmelCase__=6.0			,						lowerCAmelCase__=None			,						lowerCAmelCase__=False			,						lowerCAmelCase__=False			,						lowerCAmelCase__=None			,						lowerCAmelCase__="fp4"			,						lowerCAmelCase__=False			,						**lowerCAmelCase__			,						):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Tuple					=					load_in_abit
										SCREAMING_SNAKE_CASE_		:     str					=					load_in_abit
										SCREAMING_SNAKE_CASE_		:     Tuple					=					llm_inta_threshold
										SCREAMING_SNAKE_CASE_		:     Any					=					llm_inta_skip_modules
										SCREAMING_SNAKE_CASE_		:     Any					=					llm_inta_enable_fpaa_cpu_offload
										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					llm_inta_has_fpaa_weight
										SCREAMING_SNAKE_CASE_		:     Any					=					bnb_abit_quant_type
										SCREAMING_SNAKE_CASE_		:     int					=					bnb_abit_use_double_quant

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

										self.post_init()






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




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

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

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





										"""simple docstring"""




										return self.load_in_abit or self.load_in_abit






							def 					UpperCamelCase__     (      self       ):





										"""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 					UpperCamelCase__     (      cls			,						lowerCAmelCase__			,						lowerCAmelCase__			,						**lowerCAmelCase__       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Dict					=					cls(**lowerCAmelCase__       )

										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					[]
										for key, value in kwargs.items():
													if hasattr(lowerCAmelCase__			,						lowerCAmelCase__       ):
																setattr(lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__       )
																to_remove.append(lowerCAmelCase__       )
										for key in to_remove:
													kwargs.pop(lowerCAmelCase__			,						lowerCAmelCase__       )

										if return_unused_kwargs:
													return config, kwargs
										else:
													return config






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__       ):





										"""simple docstring"""




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

													writer.write(lowerCAmelCase__       )






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     List[Any]					=					copy.deepcopy(self.__dict__       )
										SCREAMING_SNAKE_CASE_		:     str					=					str(output['bnb_4bit_compute_dtype']       ).split('.'       )[1]

										return output






							def __repr__(      self       ):





										"""simple docstring"""




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






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__ = True       ):





										"""simple docstring"""




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






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Dict					=					self.to_dict()

										# get the default config dict
										SCREAMING_SNAKE_CASE_		:     Dict					=					BitsAndBytesConfig().to_dict()

										SCREAMING_SNAKE_CASE_		:     Dict					=					{}

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

										return serializable_config_dict







def 		UpperCamelCase     (       _UpperCAmelCase  :   list[int] ,			_UpperCAmelCase  :   list[int]  )   ->			tuple[float, float]:






						'''simple docstring'''

						if not len(_UpperCAmelCase  ) == len(_UpperCAmelCase  ) == 3:
												raise ValueError("Please enter a valid equation."  )
						if equationa[0] == equationa[1] == equationa[0] == equationa[1] == 0:
												raise ValueError("Both a & b of two equations can't be zero."  )

						# Extract the coefficients
						_lowercase      ,    _lowercase      ,    _lowercase       :	List[str]           =   equationa
						_lowercase      ,    _lowercase      ,    _lowercase       :	List[str]           =   equationa

						# Calculate the determinants of the matrices
						_lowercase       :	List[Any]           =   aa * ba - aa * ba
						_lowercase       :	Tuple           =   ca * ba - ca * ba
						_lowercase       :	Union[str, Any]           =   aa * ca - aa * ca

						# Check if the system of linear equations has a solution (using Cramer's rule)
						if determinant == 0:
												if determinant_x == determinant_y == 0:
																		raise ValueError("Infinite solutions. (Consistent system)"  )
												else:
																		raise ValueError("No solution. (Inconsistent system)"  )
						else:
												if determinant_x == determinant_y == 0:
																		# Trivial solution (Inconsistent system)
																		return (0.0, 0.0)
												else:
																		_lowercase       :	str           =   determinant_x / determinant
																		_lowercase       :	Union[str, Any]           =   determinant_y / determinant
																		# Non-Trivial Solution (Consistent system)
																		return (x, y)




