

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

				def __init__(	self							:				Any     ,  UpperCamelCase__							:				Any=False     ,  UpperCamelCase__							:				List[Any]=False     ,  UpperCamelCase__							:				str=6.0     ,  UpperCamelCase__							:				Optional[int]=None     ,  UpperCamelCase__							:				Tuple=False     ,  UpperCamelCase__							:				Union[str, Any]=False     ,  UpperCamelCase__							:				Dict=None     ,  UpperCamelCase__							:				Any="fp4"     ,  UpperCamelCase__							:				int=False     ,  **UpperCamelCase__							:				str     ,  )->   List[str]:



						'''simple docstring'''


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

						if bnb_abit_compute_dtype is None:
								__lowerCAmelCase:       Tuple          =			torch.floataa
						elif isinstance(UpperCamelCase__     ,  UpperCamelCase__):
								__lowerCAmelCase:       List[Any]          =			getattr(UpperCamelCase__     ,  UpperCamelCase__)
						elif isinstance(UpperCamelCase__     ,  torch.dtype):
								__lowerCAmelCase:       Any          =			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							:				str)->   int:



						'''simple docstring'''


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

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

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



						'''simple docstring'''


						return self.load_in_abit or self.load_in_abit

				def 							lowercase_     (	self							:				List[Any])->   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 							lowercase_     (	cls							:				Optional[Any]     ,  UpperCamelCase__							:				int     ,  UpperCamelCase__							:				Union[str, Any]     ,  **UpperCamelCase__							:				Optional[Any])->   Union[str, Any]:



						'''simple docstring'''


						__lowerCAmelCase:       List[Any]          =			cls(**UpperCamelCase__)

						__lowerCAmelCase:       Optional[Any]          =			[]
						for key, value in kwargs.items():
								if hasattr(UpperCamelCase__     ,  UpperCamelCase__):
										setattr(UpperCamelCase__     ,  UpperCamelCase__     ,  UpperCamelCase__)
										to_remove.append(UpperCamelCase__)
						for key in to_remove:
								kwargs.pop(UpperCamelCase__     ,  UpperCamelCase__)

						if return_unused_kwargs:
								return config, kwargs
						else:
								return config

				def 							lowercase_     (	self							:				str     ,  UpperCamelCase__							:				Union[str, os.PathLike])->   Tuple:



						'''simple docstring'''


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

								writer.write(UpperCamelCase__)

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



						'''simple docstring'''


						__lowerCAmelCase:       Union[str, Any]          =			copy.deepcopy(self.__dict__)
						__lowerCAmelCase:       Union[str, Any]          =			str(output["bnb_4bit_compute_dtype"]).split(".")[1]

						return output

				def __repr__(	self							:				Union[str, Any])->   int:



						'''simple docstring'''


						return f"{self.__class__.__name__} {self.to_json_string()}"

				def 							lowercase_     (	self							:				List[Any]     ,  UpperCamelCase__							:				bool = True)->   str:



						'''simple docstring'''


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




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



						'''simple docstring'''


						__lowerCAmelCase:       int          =			self.to_dict()

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

						__lowerCAmelCase:       List[Any]          =			{}

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

						return serializable_config_dict





"""simple docstring"""


import pytest

from datasets import inspect_metric, list_metrics, load_metric






@pytest.fixture
def     a__    (    __SCREAMING_SNAKE_CASE )	->	Union[str, Any]:
		monkeypatch.setattr("datasets.utils.deprecation_utils._emitted_deprecation_warnings"					, set() )






@pytest.fixture
def     a__    (    __SCREAMING_SNAKE_CASE )	->	str:





		class     snake_case	:

						def __init__(	self							:				int     ,  UpperCamelCase__							:				Optional[int])->   Union[str, Any]:



								'''simple docstring'''


								__lowerCAmelCase:       str          =			metric_id





		class     snake_case	:
						SCREAMING_SNAKE_CASE_   :      List[Any]         =  [MetricMock(__snake_case  ) for metric_id in ["""accuracy""", """mse""", """precision""", """codeparrot/apps_metric"""]]

						def 							lowercase_     (	self							:				Tuple)->   Union[str, Any]:



								'''simple docstring'''


								return self._metrics


		monkeypatch.setattr("datasets.inspect.huggingface_hub"					, HfhMock() )






@pytest.mark.parametrize(
    "func, args"					, [(load_metric, ("metrics/mse",)), (list_metrics, ()), (inspect_metric, ("metrics/mse", "tmp_path"))] )
def     a__    (    __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE )	->	Optional[Any]:
		if "tmp_path" in args:
				__lowerCAmelCase:       Tuple          =			tuple(arg if arg != "tmp_path" else tmp_path for arg in args )
		with pytest.warns(__SCREAMING_SNAKE_CASE					, match="https://huggingface.co/docs/evaluate" ):
				func(*__SCREAMING_SNAKE_CASE )


