


'''simple docstring'''


from __future__ import annotations

lowerCamelCase__					=   tuple[int, int, int]
lowerCamelCase__					=   tuple[str, str, str]


# used alphabet --------------------------
# from string.ascii_uppercase
lowerCamelCase__					=   'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

# -------------------------- default selection --------------------------
# rotors --------------------------
lowerCamelCase__					=   'EGZWVONAHDCLFQMSIPJBYUKXTR'
lowerCamelCase__					=   'FOBHMDKEXQNRAULPGSJVTYICZW'
lowerCamelCase__					=   'ZJXESIUQLHAVRMDOYGTNFWPBKC'
# reflector --------------------------
lowerCamelCase__					=   {
    'A': 'N',
    'N': 'A',
    'B': 'O',
    'O': 'B',
    'C': 'P',
    'P': 'C',
    'D': 'Q',
    'Q': 'D',
    'E': 'R',
    'R': 'E',
    'F': 'S',
    'S': 'F',
    'G': 'T',
    'T': 'G',
    'H': 'U',
    'U': 'H',
    'I': 'V',
    'V': 'I',
    'J': 'W',
    'W': 'J',
    'K': 'X',
    'X': 'K',
    'L': 'Y',
    'Y': 'L',
    'M': 'Z',
    'Z': 'M',
}

# -------------------------- extra rotors --------------------------
lowerCamelCase__					=   'RMDJXFUWGISLHVTCQNKYPBEZOA'
lowerCamelCase__					=   'SGLCPQWZHKXAREONTFBVIYJUDM'
lowerCamelCase__					=   'HVSICLTYKQUBXDWAJZOMFGPREN'
lowerCamelCase__					=   'RZWQHFMVDBKICJLNTUXAGYPSOE'
lowerCamelCase__					=   'LFKIJODBEGAMQPXVUHYSTCZRWN'
lowerCamelCase__					=   'KOAEGVDHXPQZMLFTYWJNBRCIUS'






def        __lowerCAmelCase       (__lowerCAmelCase					,       __lowerCAmelCase					,       __lowerCAmelCase      ):
		# Checks if there are 3 unique rotors

		if (unique_rotsel := len(set(lowercase__      )      )) < 3:
				_UpperCAmelCase						:				Optional[Any]	    =					F"""Please use 3 unique rotors (not {unique_rotsel})"""
				raise Exception(lowercase__      )

		# Checks if rotor positions are valid
		_UpperCAmelCase						:				Any	    =					rotpos
		if not 0 < rotorposa <= len(lowercase__      ):
				_UpperCAmelCase						:				Optional[Any]	    =					F"""First rotor position is not within range of 1..26 ({rotorposa}"""
				raise ValueError(lowercase__      )
		if not 0 < rotorposa <= len(lowercase__      ):
				_UpperCAmelCase						:				int	    =					F"""Second rotor position is not within range of 1..26 ({rotorposa})"""
				raise ValueError(lowercase__      )
		if not 0 < rotorposa <= len(lowercase__      ):
				_UpperCAmelCase						:				Dict	    =					F"""Third rotor position is not within range of 1..26 ({rotorposa})"""
				raise ValueError(lowercase__      )

		# Validates string and returns dict
		_UpperCAmelCase						:				List[Any]	    =					_plugboard(lowercase__      )

		return rotpos, rotsel, pbdict






def        __lowerCAmelCase       (__lowerCAmelCase      ):

		# tests the input string if it
		# a) is type string
		# b) has even length (so pairs can be made)
		if not isinstance(lowercase__					,       lowercase__      ):
				_UpperCAmelCase						:				Union[str, Any]	    =					F"""Plugboard setting isn't type string ({type(lowercase__      )})"""
				raise TypeError(lowercase__      )
		elif len(lowercase__      ) % 2 != 0:
				_UpperCAmelCase						:				List[Any]	    =					F"""Odd number of symbols ({len(lowercase__      )})"""
				raise Exception(lowercase__      )
		elif pbstring == "":
				return {}

		pbstring.replace(" "					,       ""      )

		# Checks if all characters are unique
		_UpperCAmelCase						:				Any	    =					set()
		for i in pbstring:
				if i not in abc:
						_UpperCAmelCase						:				Optional[int]	    =					F"""'{i}' not in list of symbols"""
						raise Exception(lowercase__      )
				elif i in tmppbl:
						_UpperCAmelCase						:				int	    =					F"""Duplicate symbol ({i})"""
						raise Exception(lowercase__      )
				else:
						tmppbl.add(lowercase__      )
		del tmppbl

		# Created the dictionary
		_UpperCAmelCase						:				Optional[int]	    =					{}
		for j in range(0					,       len(lowercase__      ) - 1					,       2      ):
				_UpperCAmelCase						:				Tuple	    =					pbstring[j + 1]
				_UpperCAmelCase						:				int	    =					pbstring[j]

		return pb






def        __lowerCAmelCase       (__lowerCAmelCase					,       __lowerCAmelCase					,       __lowerCAmelCase = (rotora, rotora, rotora)					,       __lowerCAmelCase = ""					,       ):
		_UpperCAmelCase						:				List[Any]	    =					text.upper()
		_UpperCAmelCase						:				Optional[int]	    =					_validator(
		    lowercase__					,       lowercase__					,       plugb.upper()      )

		_UpperCAmelCase						:				Optional[int]	    =					rotor_position
		_UpperCAmelCase						:				List[str]	    =					rotor_selection
		rotorposa -= 1
		rotorposa -= 1
		rotorposa -= 1

		_UpperCAmelCase						:				Optional[Any]	    =					[]

		# encryption/decryption process --------------------------
		for symbol in text:
				if symbol in abc:
						# 1st plugboard --------------------------
						if symbol in plugboard:
								_UpperCAmelCase						:				Any	    =					plugboard[symbol]

						# rotor ra --------------------------
						_UpperCAmelCase						:				List[str]	    =					abc.index(lowercase__      ) + rotorposa
						_UpperCAmelCase						:				Dict	    =					rotora[index % len(lowercase__      )]

						# rotor rb --------------------------
						_UpperCAmelCase						:				Optional[int]	    =					abc.index(lowercase__      ) + rotorposa
						_UpperCAmelCase						:				Optional[Any]	    =					rotora[index % len(lowercase__      )]

						# rotor rc --------------------------
						_UpperCAmelCase						:				int	    =					abc.index(lowercase__      ) + rotorposa
						_UpperCAmelCase						:				Any	    =					rotora[index % len(lowercase__      )]

						# reflector --------------------------
						# this is the reason you don't need another machine to decipher

						_UpperCAmelCase						:				Any	    =					reflector[symbol]

						# 2nd rotors
						_UpperCAmelCase						:				int	    =					abc[rotora.index(lowercase__      ) - rotorposa]
						_UpperCAmelCase						:				Dict	    =					abc[rotora.index(lowercase__      ) - rotorposa]
						_UpperCAmelCase						:				Optional[Any]	    =					abc[rotora.index(lowercase__      ) - rotorposa]

						# 2nd plugboard
						if symbol in plugboard:
								_UpperCAmelCase						:				str	    =					plugboard[symbol]

						# moves/resets rotor positions
						rotorposa += 1
						if rotorposa >= len(lowercase__      ):
								_UpperCAmelCase						:				List[Any]	    =					0
								rotorposa += 1
						if rotorposa >= len(lowercase__      ):
								_UpperCAmelCase						:				List[str]	    =					0
								rotorposa += 1
						if rotorposa >= len(lowercase__      ):
								_UpperCAmelCase						:				Optional[Any]	    =					0

        # else:
        #    pass
        #    Error could be also raised
        #    raise ValueError(
        #       'Invalid symbol('+repr(symbol)+')')
				result.append(lowercase__      )

		return "".join(lowercase__      )


if __name__ == "__main__":
						lowerCamelCase__					=   'This is my Python script that emulates the Enigma machine from WWII.'
						lowerCamelCase__					=   (1, 1, 1)
						lowerCamelCase__					=   'pictures'
						lowerCamelCase__					=   (rotora, rotora, rotora)
						lowerCamelCase__					=   enigma(message, rotor_pos, rotor_sel, pb)

						print('Encrypted message:', en)
						print('Decrypted message:', enigma(en, rotor_pos, rotor_sel, pb))






import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)







class   __lowercase      (unittest.TestCase ):
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						List[str]					=					Vector([1, 2, 3]					)
       self.assertEqual(x.component(0					)      ,							1					)
       self.assertEqual(x.component(2					)      ,							3					)
       __lowerCAmelCase					:						Dict					=					Vector()
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Any					=					Vector([0, 0, 0, 0, 0, 1]					)
       self.assertEqual(str(A_					)      ,							'''(0,0,0,0,0,1)'''					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Union[str, Any]					=					Vector([1, 2, 3, 4]					)
       self.assertEqual(len(A_					)      ,							4					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Dict					=					Vector([1, 2]					)
       __lowerCAmelCase					:						Optional[int]					=					Vector([1, 2, 3, 4, 5]					)
       __lowerCAmelCase					:						Optional[Any]					=					Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]					)
       __lowerCAmelCase					:						str					=					Vector([1, -1, 1, -1, 2, -3, 4, -5]					)
       self.assertAlmostEqual(x.euclidean_length()      ,							2.236      ,							3					)
       self.assertAlmostEqual(y.euclidean_length()      ,							7.416      ,							3					)
       self.assertEqual(z.euclidean_length()      ,							0					)
       self.assertAlmostEqual(w.euclidean_length()      ,							7.616      ,							3					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Tuple					=					Vector([1, 2, 3]					)
       __lowerCAmelCase					:						List[str]					=					Vector([1, 1, 1]					)
       self.assertEqual((x + y).component(0					)      ,							2					)
       self.assertEqual((x + y).component(1					)      ,							3					)
       self.assertEqual((x + y).component(2					)      ,							4					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Any					=					Vector([1, 2, 3]					)
       __lowerCAmelCase					:						List[str]					=					Vector([1, 1, 1]					)
       self.assertEqual((x - y).component(0					)      ,							0					)
       self.assertEqual((x - y).component(1					)      ,							1					)
       self.assertEqual((x - y).component(2					)      ,							2					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						str					=					Vector([1, 2, 3]					)
       __lowerCAmelCase					:						List[Any]					=					Vector([2, -1, 4]					)  # for test of dot product
       __lowerCAmelCase					:						Optional[int]					=					Vector([1, -2, -1]					)
       self.assertEqual(str(x * 3.0					)      ,							'''(3.0,6.0,9.0)'''					)
       self.assertEqual((a * b)      ,							0					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       self.assertEqual(str(zero_vector(10					)					).count('''0'''					)      ,							10					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       self.assertEqual(str(unit_basis_vector(3      ,							1					)					)      ,							'''(0,1,0)'''					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						str					=					Vector([1, 2, 3]					)
       __lowerCAmelCase					:						Any					=					Vector([1, 0, 1]					)
       self.assertEqual(str(axpy(2      ,							A_      ,							A_					)					)      ,							'''(3,4,7)'''					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Tuple					=					Vector([1, 0, 0, 0, 0, 0]					)
       __lowerCAmelCase					:						Optional[Any]					=					x.copy()
       self.assertEqual(str(A_					)      ,							str(A_					)					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						List[str]					=					Vector([1, 0, 0]					)
       x.change_component(0      ,							0					)
       x.change_component(1      ,							1					)
       self.assertEqual(str(A_					)      ,							'''(0,1,0)'''					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Union[str, Any]					=					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,							3      ,							3					)
       self.assertEqual('''|1,2,3|\n|2,4,5|\n|6,7,8|\n'''      ,							str(A_					)					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						List[Any]					=					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,							3      ,							3					)
       __lowerCAmelCase					:						str					=					[[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
       for x in range(a.height()					):
             for y in range(a.width()					):
                   self.assertEqual(minors[x][y]      ,							a.minor(A_      ,							A_					)					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Optional[int]					=					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,							3      ,							3					)
       __lowerCAmelCase					:						Tuple					=					[[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
       for x in range(a.height()					):
             for y in range(a.width()					):
                   self.assertEqual(cofactors[x][y]      ,							a.cofactor(A_      ,							A_					)					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Dict					=					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,							3      ,							3					)
       self.assertEqual(-5      ,							a.determinant()					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Tuple					=					Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]      ,							3      ,							3					)
       __lowerCAmelCase					:						Union[str, Any]					=					Vector([1, 2, 3]					)
       self.assertEqual('''(14,32,50)'''      ,							str(a * x					)					)
       self.assertEqual('''|2,4,6|\n|8,10,12|\n|14,16,18|\n'''      ,							str(a * 2					)					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Any					=					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,							3      ,							3					)
       a.change_component(0      ,							2      ,							5					)
       self.assertEqual('''|1,2,5|\n|2,4,5|\n|6,7,8|\n'''      ,							str(A_					)					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Tuple					=					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,							3      ,							3					)
       self.assertEqual(7      ,							a.component(2      ,							1					)      ,							0.01					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Any					=					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,							3      ,							3					)
       __lowerCAmelCase					:						Dict					=					Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]      ,							3      ,							3					)
       self.assertEqual('''|2,4,10|\n|4,8,10|\n|12,14,18|\n'''      ,							str(a + b					)					)
 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       __lowerCAmelCase					:						Dict					=					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,							3      ,							3					)
       __lowerCAmelCase					:						str					=					Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]      ,							3      ,							3					)
       self.assertEqual('''|0,0,-4|\n|0,0,0|\n|0,0,-2|\n'''      ,							str(a - b					)					)





 def 	UpperCamelCase__  (							self					)					->None:



       '''simple docstring'''





       self.assertEqual(
           '''|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n'''      ,							str(square_zero_matrix(5					)					)      ,							)


if __name__ == "__main__":
 unittest.main()


