"""simple docstring"""





import os
import random
import sys

from . import cryptomath_module as cryptoMath  # noqa: N812
from . import rabin_miller as rabinMiller  # noqa: N812





def        a_  (   ):





       '''simple docstring'''

       print('Making key files...'  )
       make_key_files('rsa'     ,				1024  )
       print('Key files generation successful.'  )





def        a_  (   _lowerCAmelCase						:				int  ):





       '''simple docstring'''

       print('Generating prime p...'  )
       lowercase__    :	Any     					=			rabinMiller.generate_large_prime(_lowerCAmelCase  )
       print('Generating prime q...'  )
       lowercase__    :	str     					=			rabinMiller.generate_large_prime(_lowerCAmelCase  )
       lowercase__    :	Any     					=			p * q

       print('Generating e that is relatively prime to (p - 1) * (q - 1)...'  )
       while True:
              lowercase__    :	Dict     					=			random.randrange(2 ** (key_size - 1)     ,				2 ** (key_size)  )
              if cryptoMath.gcd(_lowerCAmelCase     ,				(p - 1) * (q - 1)  ) == 1:
                     break

       print('Calculating d that is mod inverse of e...'  )
       lowercase__    :	Tuple     					=			cryptoMath.find_mod_inverse(_lowerCAmelCase     ,				(p - 1) * (q - 1)  )

       lowercase__    :	Any     					=			(n, e)
       lowercase__    :	List[str]     					=			(n, d)
       return (public_key, private_key)





def        a_  (   _lowerCAmelCase						:				str     ,				_lowerCAmelCase						:				int  ):





       '''simple docstring'''

       if os.path.exists(f"""{name}_pubkey.txt"""  ) or os.path.exists(f"""{name}_privkey.txt"""  ):
              print('\nWARNING:'  )
              print(
                  f"""\"{name}_pubkey.txt\" or \"{name}_privkey.txt\" already exists. \n"""
                  'Use a different name or delete these files and re-run this program.'  )
              sys.exit()

       lowercase__					,   lowercase__    :	str     					=			generate_key(_lowerCAmelCase  )
       print(f"""\nWriting public key to file {name}_pubkey.txt..."""  )
       with open(f"""{name}_pubkey.txt"""     ,				'w'  ) as out_file:
              out_file.write(f"""{key_size},{public_key[0]},{public_key[1]}"""  )

       print(f"""Writing private key to file {name}_privkey.txt..."""  )
       with open(f"""{name}_privkey.txt"""     ,				'w'  ) as out_file:
              out_file.write(f"""{key_size},{private_key[0]},{private_key[1]}"""  )


if __name__ == "__main__":
       main()


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


_UpperCamelCase     :		int											=					logging.get_logger(__name__)


@dataclass
class   UpperCAmelCase_			:


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

             if bnb_abit_compute_dtype is None:
                    lowercase__    :	Dict     					=			torch.floataa
             elif isinstance(a	,    a							):
                    lowercase__    :	Any     					=			getattr(a	,    a							)
             elif isinstance(a	,    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 	_UpperCAmelCase (     self							) ->      str:
             if not isinstance(self.llm_inta_threshold	,    a							):
                    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	,    a							):
                    raise ValueError('llm_int8_skip_modules must be a list of strings'							)
             if not isinstance(self.llm_inta_enable_fpaa_cpu_offload	,    a							):
                    raise ValueError('llm_int8_enable_fp32_cpu_offload must be a boolean'							)

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

             if not isinstance(self.bnb_abit_use_double_quant	,    a							):
                    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							) ->      Tuple:
             return self.load_in_abit or self.load_in_abit


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

             lowercase__    :	Union[str, Any]     					=			[]
             for key, value in kwargs.items():
                    if hasattr(a	,    a							):
                           setattr(a	,    a	,    a							)
                           to_remove.append(a							)
             for key in to_remove:
                    kwargs.pop(a	,    a							)

             if return_unused_kwargs:
                    return config, kwargs
             else:
                    return config


      def 	_UpperCAmelCase (     self	,    a							) ->      Dict:
             with open(a	,    'w'	,    encoding='utf-8'							) as writer:
                    lowercase__    :	Any     					=			self.to_dict()
                    lowercase__    :	str     					=			json.dumps(a	,    indent=2	,    sort_keys=a							) + '\n'

                    writer.write(a							)


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

             return output


      def __repr__(     self							) ->      Dict:
             return f"""{self.__class__.__name__} {self.to_json_string()}"""


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


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

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

             lowercase__    :	int     					=			{}

             # 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

