



"""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   :							Dict										=   logging.get_logger(__name__)
@dataclass
class 			_a :
			"""simple docstring"""



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

							if bnb_abit_compute_dtype is None:
											_UpperCAmelCase					=    torch.floataa
							elif isinstance(__UpperCamelCase				,   __UpperCamelCase   ):
											_UpperCAmelCase					=    getattr(__UpperCamelCase				,   __UpperCamelCase   )
							elif isinstance(__UpperCamelCase				,   torch.dtype   ):
											_UpperCAmelCase					=    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     :    Dict   )->List[Any]:
							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     :    str   )->str:
							return self.load_in_abit or self.load_in_abit



			def  lowercase__						(		self     :    Tuple   )->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  lowercase__						(		cls     :    Dict				,   __UpperCamelCase     :    Dict				,   __UpperCamelCase     :    Any				,   **__UpperCamelCase     :    Optional[Any]   )->List[Any]:
							_UpperCAmelCase					=    cls(**__UpperCamelCase   )

							_UpperCAmelCase					=    []
							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     :    int				,   __UpperCamelCase     :    Union[str, os.PathLike]   )->int:
							with open(__UpperCamelCase				,   '''w'''				,   encoding='''utf-8'''   ) as writer:
											_UpperCAmelCase					=    self.to_dict()
											_UpperCAmelCase					=    json.dumps(__UpperCamelCase				,   indent=2				,   sort_keys=__UpperCamelCase   ) + '''\n'''

											writer.write(__UpperCamelCase   )



			def  lowercase__						(		self     :    Tuple   )->Dict[str, Any]:
							_UpperCAmelCase					=    copy.deepcopy(self.__dict__   )
							_UpperCAmelCase					=    str(output['''bnb_4bit_compute_dtype''']   ).split('''.'''   )[1]

							return output



			def __repr__(		self     :    Union[str, Any]   )->List[str]:
							return F'{self.__class__.__name__} {self.to_json_string()}'



			def  lowercase__						(		self     :    Union[str, Any]				,   __UpperCamelCase     :    bool = True   )->str:
							if use_diff is True:
											_UpperCAmelCase					=    self.to_diff_dict()
							else:
											_UpperCAmelCase					=    self.to_dict()
							return json.dumps(__UpperCamelCase				,   indent=2				,   sort_keys=__UpperCamelCase   ) + "\n"



			def  lowercase__						(		self     :    Optional[Any]   )->Dict[str, Any]:
							_UpperCAmelCase					=    self.to_dict()

							# get the default config dict
							_UpperCAmelCase					=    BitsAndBytesConfig().to_dict()

							_UpperCAmelCase					=    {}

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

							return serializable_config_dict








"""simple docstring"""


def  lowercase	(      _SCREAMING_SNAKE_CASE   :						int					,     _SCREAMING_SNAKE_CASE   :						int				):






				'''simple docstring'''



				if a < 0 or b < 0:
								raise ValueError('''the value of both inputs must be positive'''				)

				_UpperCAmelCase					=    str(bin(_SCREAMING_SNAKE_CASE				)				)[2:]  # remove the leading "0b"
				_UpperCAmelCase					=    str(bin(_SCREAMING_SNAKE_CASE				)				)[2:]  # remove the leading "0b"

				_UpperCAmelCase					=    max(len(_SCREAMING_SNAKE_CASE				)					,     len(_SCREAMING_SNAKE_CASE				)				)

				return "0b" + "".join(
				    str(int(char_a == '''1''' and char_b == '''1'''				)				)
				    for char_a, char_b in zip(a_binary.zfill(_SCREAMING_SNAKE_CASE				)					,     b_binary.zfill(_SCREAMING_SNAKE_CASE				)				)				)


if __name__ == "__main__":
					import doctest

					doctest.testmod()



