
import os
import random
import sys

from . import cryptomath_module as cryptomath
from . import rabin_miller

_snake_case      :							str     	=    3

def  __snake_case							(	__magic_name__						):







				'''simple docstring'''


				print("Generating primitive root of p"						)
				while True:
								lowercase         =      random.randrange(3		,    __magic_name__						)
								if pow(__magic_name__		,    2		,    __magic_name__						) == 1:
												continue
								if pow(__magic_name__		,    __magic_name__		,    __magic_name__						) == 1:
												continue
								return g

def  __snake_case							(	__magic_name__						):







				'''simple docstring'''


				print("Generating prime p..."						)
				lowercase         =      rabin_miller.generate_large_prime(__magic_name__						)  # select large prime number.
				lowercase         =      primitive_root(__magic_name__						)  # one primitive root on modulo p.
				lowercase         =      random.randrange(3		,    __magic_name__						)  # private_key -> have to be greater than 2 for safety.
				lowercase         =      cryptomath.find_mod_inverse(pow(__magic_name__		,    __magic_name__		,    __magic_name__						)		,    __magic_name__						)

				lowercase         =      (key_size, e_a, e_a, p)
				lowercase         =      (key_size, d)

				return public_key, private_key

def  __snake_case							(	__magic_name__		,    __magic_name__						):







				'''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         =      generate_key(__magic_name__						)
				print(F'''\nWriting public key to file {name}_pubkey.txt...'''						)
				with open(F'''{name}_pubkey.txt'''		,    "w"						) as fo:
								fo.write(F'''{public_key[0]},{public_key[1]},{public_key[2]},{public_key[3]}'''						)

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

def  __snake_case							(	):







				'''simple docstring'''


				print("Making key files..."						)
				make_key_files("elgamal"		,    2048						)
				print("Key files generation successful"						)


if __name__ == "__main__":
						main()


# Imports
import numpy as np





class   UpperCamelCase_      :







						'''simple docstring'''



						def __init__(			self							:Optional[int]		,    lowerCAmelCase__							:int=None		,    lowerCAmelCase__							:List[str]=None		,    lowerCAmelCase__							:int=None		,    lowerCAmelCase__							:Optional[int]=None		,    lowerCAmelCase__							:List[str]=None     )  ->int:
										self.set_matricies(red=lowerCAmelCase__		,    green=lowerCAmelCase__		,    blue=lowerCAmelCase__		,    red_edge=lowerCAmelCase__		,    nir=lowerCAmelCase__     )





						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]		,    lowerCAmelCase__							:List[Any]=None		,    lowerCAmelCase__							:Any=None		,    lowerCAmelCase__							:Tuple=None		,    lowerCAmelCase__							:Optional[Any]=None		,    lowerCAmelCase__							:Optional[Any]=None     )  ->List[Any]:
										if red is not None:
														lowercase         =      red
										if green is not None:
														lowercase         =      green
										if blue is not None:
														lowercase         =      blue
										if red_edge is not None:
														lowercase         =      red_edge
										if nir is not None:
														lowercase         =      nir
										return True





						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]		,    lowerCAmelCase__							:Dict=""		,    lowerCAmelCase__							:Optional[Any]=None		,    lowerCAmelCase__							:Union[str, Any]=None		,    lowerCAmelCase__							:int=None		,    lowerCAmelCase__							:int=None		,    lowerCAmelCase__							:Union[str, Any]=None     )  ->Optional[Any]:
										self.set_matricies(red=lowerCAmelCase__		,    green=lowerCAmelCase__		,    blue=lowerCAmelCase__		,    red_edge=lowerCAmelCase__		,    nir=lowerCAmelCase__     )
										lowercase         =      {
										    "ARVI2": self.arvaa,
										    "CCCI": self.ccci,
										    "CVI": self.cvi,
										    "GLI": self.gli,
										    "NDVI": self.ndvi,
										    "BNDVI": self.bndvi,
										    "redEdgeNDVI": self.red_edge_ndvi,
										    "GNDVI": self.gndvi,
										    "GBNDVI": self.gbndvi,
										    "GRNDVI": self.grndvi,
										    "RBNDVI": self.rbndvi,
										    "PNDVI": self.pndvi,
										    "ATSAVI": self.atsavi,
										    "BWDRVI": self.bwdrvi,
										    "CIgreen": self.ci_green,
										    "CIrededge": self.ci_rededge,
										    "CI": self.ci,
										    "CTVI": self.ctvi,
										    "GDVI": self.gdvi,
										    "EVI": self.evi,
										    "GEMI": self.gemi,
										    "GOSAVI": self.gosavi,
										    "GSAVI": self.gsavi,
										    "Hue": self.hue,
										    "IVI": self.ivi,
										    "IPVI": self.ipvi,
										    "I": self.i,
										    "RVI": self.rvi,
										    "MRVI": self.mrvi,
										    "MSAVI": self.m_savi,
										    "NormG": self.norm_g,
										    "NormNIR": self.norm_nir,
										    "NormR": self.norm_r,
										    "NGRDI": self.ngrdi,
										    "RI": self.ri,
										    "S": self.s,
										    "IF": self._if,
										    "DVI": self.dvi,
										    "TVI": self.tvi,
										    "NDRE": self.ndre,
										}

										try:
														return funcs[index]()
										except KeyError:
														print("Index not in the list!"     )
														return False





						def        SCREAMING_SNAKE_CASE(			self							:Any     )  ->int:
										return -0.18 + (1.17 * ((self.nir - self.red) / (self.nir + self.red)))





						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->int:
										return ((self.nir - self.redEdge) / (self.nir + self.redEdge)) / (
										    (self.nir - self.red) / (self.nir + self.red)
										)





						def        SCREAMING_SNAKE_CASE(			self							:int     )  ->Tuple:
										return self.nir * (self.red / (self.green**2))





						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->Dict:
										return (2 * self.green - self.red - self.blue) / (
										    2 * self.green + self.red + self.blue
										)





						def        SCREAMING_SNAKE_CASE(			self							:str     )  ->Optional[int]:
										return (self.nir - self.red) / (self.nir + self.red)





						def        SCREAMING_SNAKE_CASE(			self							:str     )  ->int:
										return (self.nir - self.blue) / (self.nir + self.blue)





						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->List[str]:
										return (self.redEdge - self.red) / (self.redEdge + self.red)





						def        SCREAMING_SNAKE_CASE(			self							:Optional[int]     )  ->str:
										return (self.nir - self.green) / (self.nir + self.green)





						def        SCREAMING_SNAKE_CASE(			self							:int     )  ->Any:
										return (self.nir - (self.green + self.blue)) / (
										    self.nir + (self.green + self.blue)
										)





						def        SCREAMING_SNAKE_CASE(			self							:Union[str, Any]     )  ->List[Any]:
										return (self.nir - (self.green + self.red)) / (
										    self.nir + (self.green + self.red)
										)





						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]     )  ->Union[str, Any]:
										return (self.nir - (self.blue + self.red)) / (self.nir + (self.blue + self.red))





						def        SCREAMING_SNAKE_CASE(			self							:Any     )  ->Union[str, Any]:
										return (self.nir - (self.green + self.red + self.blue)) / (
										    self.nir + (self.green + self.red + self.blue)
										)





						def        SCREAMING_SNAKE_CASE(			self							:Tuple		,    lowerCAmelCase__							:Union[str, Any]=0.08		,    lowerCAmelCase__							:Dict=1.22		,    lowerCAmelCase__							:Tuple=0.03     )  ->Tuple:
										return a * (
										    (self.nir - a * self.red - b)
										    / (a * self.nir + self.red - a * b + x * (1 + a**2))
										)





						def        SCREAMING_SNAKE_CASE(			self							:Dict     )  ->Any:
										return (0.1 * self.nir - self.blue) / (0.1 * self.nir + self.blue)





						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]     )  ->int:
										return (self.nir / self.green) - 1





						def        SCREAMING_SNAKE_CASE(			self							:int     )  ->List[str]:
										return (self.nir / self.redEdge) - 1





						def        SCREAMING_SNAKE_CASE(			self							:Union[str, Any]     )  ->List[Any]:
										return (self.red - self.blue) / self.red





						def        SCREAMING_SNAKE_CASE(			self							:Any     )  ->int:
										lowercase         =      self.ndvi()
										return ((ndvi + 0.5) / (abs(ndvi + 0.5     ))) * (abs(ndvi + 0.5     ) ** (1 / 2))





						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->Optional[Any]:
										return self.nir - self.green





						def        SCREAMING_SNAKE_CASE(			self							:str     )  ->int:
										return 2.5 * (
										    (self.nir - self.red) / (self.nir + 6 * self.red - 7.5 * self.blue + 1)
										)





						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->Optional[Any]:
										lowercase         =      (2 * (self.nir**2 - self.red**2) + 1.5 * self.nir + 0.5 * self.red) / (
										    self.nir + self.red + 0.5
										)
										return n * (1 - 0.25 * n) - (self.red - 0.1_25) / (1 - self.red)





						def        SCREAMING_SNAKE_CASE(			self							:Union[str, Any]		,    lowerCAmelCase__							:Tuple=0.16     )  ->Any:
										return (self.nir - self.green) / (self.nir + self.green + y)





						def        SCREAMING_SNAKE_CASE(			self							:Dict		,    lowerCAmelCase__							:Any=0.5     )  ->str:
										return ((self.nir - self.green) / (self.nir + self.green + n)) * (1 + n)





						def        SCREAMING_SNAKE_CASE(			self							:int     )  ->List[str]:
										return np.arctan(
										    ((2 * self.red - self.green - self.blue) / 30.5) * (self.green - self.blue)     )





						def        SCREAMING_SNAKE_CASE(			self							:Any		,    lowerCAmelCase__							:str=None		,    lowerCAmelCase__							:Tuple=None     )  ->Dict:
										return (self.nir - b) / (a * self.red)





						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]     )  ->Dict:
										return (self.nir / ((self.nir + self.red) / 2)) * (self.ndvi() + 1)





						def        SCREAMING_SNAKE_CASE(			self							:str     )  ->List[Any]:
										return (self.red + self.green + self.blue) / 30.5





						def        SCREAMING_SNAKE_CASE(			self							:Tuple     )  ->Optional[Any]:
										return self.nir / self.red





						def        SCREAMING_SNAKE_CASE(			self							:Optional[int]     )  ->Dict:
										return (self.rvi() - 1) / (self.rvi() + 1)





						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]     )  ->Dict:
										return (
										    (2 * self.nir + 1)
										    - ((2 * self.nir + 1) ** 2 - 8 * (self.nir - self.red)) ** (1 / 2)
										) / 2





						def        SCREAMING_SNAKE_CASE(			self							:str     )  ->int:
										return self.green / (self.nir + self.red + self.green)





						def        SCREAMING_SNAKE_CASE(			self							:Any     )  ->Any:
										return self.nir / (self.nir + self.red + self.green)





						def        SCREAMING_SNAKE_CASE(			self							:int     )  ->Tuple:
										return self.red / (self.nir + self.red + self.green)





						def        SCREAMING_SNAKE_CASE(			self							:List[Any]     )  ->List[Any]:
										return (self.green - self.red) / (self.green + self.red)





						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->str:
										return (self.red - self.green) / (self.red + self.green)





						def        SCREAMING_SNAKE_CASE(			self							:Union[str, Any]     )  ->List[str]:
										lowercase         =      np.max([np.max(self.red     ), np.max(self.green     ), np.max(self.blue     )]     )
										lowercase         =      np.min([np.min(self.red     ), np.min(self.green     ), np.min(self.blue     )]     )
										return (max_value - min_value) / max_value





						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->Any:
										return (2 * self.red - self.green - self.blue) / (self.green - self.blue)





						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->List[Any]:
										return self.nir / self.red





						def        SCREAMING_SNAKE_CASE(			self							:Any     )  ->List[str]:
										return (self.ndvi() + 0.5) ** (1 / 2)





						def        SCREAMING_SNAKE_CASE(			self							:Optional[int]     )  ->Union[str, Any]:
										return (self.nir - self.redEdge) / (self.nir + self.redEdge)
