






# 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


snake_case__      :	Optional[int]       	=      logging.get_logger(__name__)


@dataclass
class 						_a       :






  """simple docstring"""





  def __init__(     self		,		_UpperCAmelCase=False		,		_UpperCAmelCase=False		,		_UpperCAmelCase=6.0		,		_UpperCAmelCase=None		,		_UpperCAmelCase=False		,		_UpperCAmelCase=False		,		_UpperCAmelCase=None		,		_UpperCAmelCase="fp4"		,		_UpperCAmelCase=False		,		**_UpperCAmelCase		,		)			-> List[str]:
     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    _UpperCAmelCase     (     self )			-> Optional[int]:
     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    _UpperCAmelCase     (     self )			-> Any:
     return self.load_in_abit or self.load_in_abit




  def    _UpperCAmelCase     (     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    _UpperCAmelCase     (     cls		,		_UpperCAmelCase		,		_UpperCAmelCase		,		**_UpperCAmelCase )			-> Dict:
     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    _UpperCAmelCase     (     self		,		_UpperCAmelCase )			-> 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    _UpperCAmelCase     (     self )			-> Dict[str, Any]:
     UpperCamelCase_									=     copy.deepcopy(self.__dict__ )
     UpperCamelCase_									=     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    _UpperCAmelCase     (     self		,		_UpperCAmelCase = 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    _UpperCAmelCase     (     self )			-> 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













snake_case__      :	List[Any]       	=      """Tobias Carryer"""

from time import time


class 						_a       :






  """simple docstring"""





  def __init__(     self		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase=int(time() ) )			-> Tuple:  # noqa: B008
     UpperCamelCase_									=     multiplier
     UpperCamelCase_									=     increment
     UpperCamelCase_									=     modulo
     UpperCamelCase_									=     seed




  def    _UpperCAmelCase     (     self )			-> Any:
     UpperCamelCase_									=     (self.multiplier * self.seed + self.increment) % self.modulo
     return self.seed


if __name__ == "__main__":
 # Show the LCG in action.
 snake_case__      :	List[Any]       	=      LinearCongruentialGenerator(1_6_6_4_5_2_5, 1_0_1_3_9_0_4_2_2_3, 2 << 3_1)
 while True:
  print(lcg.next_number())





