




"""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


a_        =       logging.get_logger(__name__)

@dataclass
class   UpperCAmelCase_    :
		def __init__(						self				,						UpperCamelCase_=False				,						UpperCamelCase_=False				,						UpperCamelCase_=6.0				,						UpperCamelCase_=None				,						UpperCamelCase_=False				,						UpperCamelCase_=False				,						UpperCamelCase_=None				,						UpperCamelCase_="fp4"				,						UpperCamelCase_=False				,						**UpperCamelCase_				,						)						->       List[Any]:
					__lowercase			:  str								=       load_in_abit
					__lowercase			:  str								=       load_in_abit
					__lowercase			:  Any								=       llm_inta_threshold
					__lowercase			:  Tuple								=       llm_inta_skip_modules
					__lowercase			:  Tuple								=       llm_inta_enable_fpaa_cpu_offload
					__lowercase			:  Any								=       llm_inta_has_fpaa_weight
					__lowercase			:  List[Any]								=       bnb_abit_quant_type
					__lowercase			:  Tuple								=       bnb_abit_use_double_quant

					if bnb_abit_compute_dtype is None:
								__lowercase			:  Tuple								=       torch.floataa
					elif isinstance(__lowerCAmelCase				,						__lowerCAmelCase       ):
								__lowercase			:  Tuple								=       getattr(__lowerCAmelCase				,						__lowerCAmelCase       )
					elif isinstance(__lowerCAmelCase				,						torch.dtype       ):
								__lowercase			:  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:
					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 	_lowerCamelCase							(						self       )						->       str:
					return self.load_in_abit or self.load_in_abit
		def 	_lowerCamelCase							(						self       )						->       Tuple:
					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				,						UpperCamelCase_				,						UpperCamelCase_				,						**UpperCamelCase_       )						->       Optional[Any]:
					__lowercase			:  Optional[Any]								=       cls(**__lowerCAmelCase       )

					__lowercase			:  List[str]								=       []
					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 	_lowerCamelCase							(						self				,						UpperCamelCase_       )						->       Optional[int]:
					with open(__lowerCAmelCase				,						'''w'''				,						encoding='''utf-8'''       ) as writer:
								__lowercase			:  int								=       self.to_dict()
								__lowercase			:  int								=       json.dumps(__lowerCAmelCase				,						indent=2				,						sort_keys=__lowerCAmelCase       ) + '''\n'''

								writer.write(__lowerCAmelCase       )
		def 	_lowerCamelCase							(						self       )						->       Dict[str, Any]:
					__lowercase			:  List[Any]								=       copy.deepcopy(self.__dict__       )
					__lowercase			:  Optional[int]								=       str(output['''bnb_4bit_compute_dtype''']       ).split('''.'''       )[1]

					return output
		def __repr__(						self       )						->       List[str]:
					return F"""{self.__class__.__name__} {self.to_json_string()}"""
		def 	_lowerCamelCase							(						self				,						UpperCamelCase_ = True       )						->       str:
					if use_diff is True:
								__lowercase			:  str								=       self.to_diff_dict()
					else:
								__lowercase			:  str								=       self.to_dict()
					return json.dumps(__lowerCAmelCase				,						indent=2				,						sort_keys=__lowerCAmelCase       ) + "\n"
		def 	_lowerCamelCase							(						self       )						->       Dict[str, Any]:
					__lowercase			:  Dict								=       self.to_dict()

					# get the default config dict
					__lowercase			:  int								=       BitsAndBytesConfig().to_dict()

					__lowercase			:  List[Any]								=       {}

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

					return serializable_config_dict








from graphs.minimum_spanning_tree_kruskal import kruskal

def 	SCREAMING_SNAKE_CASE_							(	)  ->     Tuple:
   _A      =       9
   _A      =       [
       [0, 1, 4],
       [0, 7, 8],
       [1, 2, 8],
       [7, 8, 7],
       [7, 6, 1],
       [2, 8, 2],
       [8, 6, 6],
       [2, 3, 7],
       [2, 5, 4],
       [6, 5, 2],
       [3, 5, 14],
       [3, 4, 9],
       [5, 4, 10],
       [1, 7, 11],
   ]

   _A      =       kruskal(_snake_case	,   _snake_case				)

   _A      =       [
       [7, 6, 1],
       [2, 8, 2],
       [6, 5, 2],
       [0, 1, 4],
       [2, 5, 4],
       [2, 3, 7],
       [0, 7, 8],
       [3, 4, 9],
   ]

   assert sorted(_snake_case				) == sorted(_snake_case				)



