

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


lowerCAmelCase__										= logging.get_logger(__name__)



@dataclass
class 					lowercase						:


							def __init__(			self    ,			_snake_case=False    ,			_snake_case=False    ,			_snake_case=6.0    ,			_snake_case=None    ,			_snake_case=False    ,			_snake_case=False    ,			_snake_case=None    ,			_snake_case="fp4"    ,			_snake_case=False    ,			**_snake_case    ,			)							->				Union[str, Any]:
								UpperCAmelCase_		:      List[str]       	=					load_in_abit
								UpperCAmelCase_		:      Any       	=					load_in_abit
								UpperCAmelCase_		:      str       	=					llm_inta_threshold
								UpperCAmelCase_		:      str       	=					llm_inta_skip_modules
								UpperCAmelCase_		:      Any       	=					llm_inta_enable_fpaa_cpu_offload
								UpperCAmelCase_		:      Tuple       	=					llm_inta_has_fpaa_weight
								UpperCAmelCase_		:      Any       	=					bnb_abit_quant_type
								UpperCAmelCase_		:      int       	=					bnb_abit_use_double_quant

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

								self.post_init()


							def 						_snake_case							(			self)							->				Union[str, Any]:
								if not isinstance(self.llm_inta_threshold    ,			_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    ,			_snake_case):
									raise ValueError('llm_int8_skip_modules must be a list of strings')
								if not isinstance(self.llm_inta_enable_fpaa_cpu_offload    ,			_snake_case):
									raise ValueError('llm_int8_enable_fp32_cpu_offload must be a boolean')

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

								if not isinstance(self.bnb_abit_use_double_quant    ,			_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 						_snake_case							(			self)							->				Optional[int]:
								return self.load_in_abit or self.load_in_abit


							def 						_snake_case							(			self)							->				str:
								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 						_snake_case							(			cls    ,			_snake_case    ,			_snake_case    ,			**_snake_case)							->				str:
								UpperCAmelCase_		:      str       	=					cls(**_snake_case)

								UpperCAmelCase_		:      List[Any]       	=					[]
								for key, value in kwargs.items():
									if hasattr(_snake_case    ,			_snake_case):
										setattr(_snake_case    ,			_snake_case    ,			_snake_case)
										to_remove.append(_snake_case)
								for key in to_remove:
									kwargs.pop(_snake_case    ,			_snake_case)

								if return_unused_kwargs:
									return config, kwargs
								else:
									return config


							def 						_snake_case							(			self    ,			_snake_case)							->				Dict:
								with open(_snake_case    ,			'w'    ,			encoding='utf-8') as writer:
									UpperCAmelCase_		:      Any       	=					self.to_dict()
									UpperCAmelCase_		:      Optional[int]       	=					json.dumps(_snake_case    ,			indent=2    ,			sort_keys=_snake_case) + '\n'

									writer.write(_snake_case)


							def 						_snake_case							(			self)							->				Dict[str, Any]:
								UpperCAmelCase_		:      Optional[Any]       	=					copy.deepcopy(self.__dict__)
								UpperCAmelCase_		:      Optional[Any]       	=					str(output['bnb_4bit_compute_dtype']).split('.')[1]

								return output


							def __repr__(			self)							->				Optional[Any]:
								return F"""{self.__class__.__name__} {self.to_json_string()}"""


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





							def 						_snake_case							(			self)							->				Dict[str, Any]:
								UpperCAmelCase_		:      List[str]       	=					self.to_dict()

								# get the default config dict
								UpperCAmelCase_		:      List[Any]       	=					BitsAndBytesConfig().to_dict()

								UpperCAmelCase_		:      List[str]       	=					{}

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

								return serializable_config_dict









'''simple docstring'''


from __future__ import annotations

from typing import Any



class 					lowercase						(  a_ ):
							pass



class 					lowercase						:


							def __init__(			self    ,			_snake_case)							->				None:
								UpperCAmelCase_		:      Any       	=					data
								UpperCAmelCase_		:      Node | None       	=					None


							def __iter__(			self)							->				Optional[int]:
								UpperCAmelCase_		:      int       	=					self
								UpperCAmelCase_		:      List[str]       	=					[]
								while node:
									if node in visited:
										raise ContainsLoopError
									visited.append(_snake_case)
									yield node.data
									UpperCAmelCase_		:      Tuple       	=					node.next_node





							@property
							def 						_snake_case							(			self)							->				bool:
								try:
									list(self)
									return False
								except ContainsLoopError:
									return True


if __name__ == "__main__":
						lowerCAmelCase__										= Node(1)
						lowerCAmelCase__										= Node(2)
						lowerCAmelCase__										= Node(3)
						lowerCAmelCase__										= Node(4)
						print(root_node.has_loop)  # False
						lowerCAmelCase__										= root_node.next_node
						print(root_node.has_loop)  # True

						lowerCAmelCase__										= Node(5)
						lowerCAmelCase__										= Node(6)
						lowerCAmelCase__										= Node(5)
						lowerCAmelCase__										= Node(6)
						print(root_node.has_loop)  # False

						lowerCAmelCase__										= Node(1)
						print(root_node.has_loop)  # False






