code: 
  
  
  
  '''simple docstring'''
  
  
  
  import logging
  
  # standard libraries
  import sys
  
  import numpy as np
  import pytest  # type: ignore
  
  # Custom/local libraries
  from matrix import matrix_operation as matop
  
  a__						:			Tuple										=			[[1_2, 1_0], [3, 9]]
  a__						:			Optional[Any]										=			[[3, 4], [7, 4]]
  a__						:			Union[str, Any]										=			[[3, 0, 2], [2, 0, -2], [0, 1, 1]]
  a__						:			Union[str, Any]										=			[[3, 0, -2], [2, 0, 2], [0, 1, 1]]
  a__						:			Dict										=			[[3, 0, 2], [2, 0, -2], [0, 1, 1], [2, 0, -2]]
  a__						:			List[str]										=			[1]
  a__						:			Tuple										=			[2]
  
  a__						:			Any										=			logging.getLogger()
  a__						:			Tuple										=			logging.DEBUG
  a__						:			Any										=			logging.StreamHandler(sys.stdout)
  logger.addHandler(stream_handler)
  
  
  
  
  
  
  
  @pytest.mark.mat_ops
  @pytest.mark.parametrize(
      ("""mat1""", """mat2""")							,[(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e), (mat_f, mat_h)]       )
  def _lowercase   (  __A							,__A       ):
  
  
  
   '''simple docstring'''
  
  
  
   if (np.array(__A       )).shape < (2, 2) or (np.array(__A       )).shape < (2, 2):
    with pytest.raises(__A       ):
     logger.info(f"\n\t{test_addition.__name__} returned integer"       )
     matop.add(__A							,__A       )
   elif (np.array(__A       )).shape == (np.array(__A       )).shape:
    logger.info(f"\n\t{test_addition.__name__} with same matrix dims"       )
    __UpperCamelCase				      =  (np.array(__A       ) + np.array(__A       )).tolist()
    __UpperCamelCase				      =  matop.add(__A							,__A       )
    assert theo == act
   else:
    with pytest.raises(__A       ):
     logger.info(f"\n\t{test_addition.__name__} with different matrix dims"       )
     matop.add(__A							,__A       )
  
  
  
  
  
  
  
  @pytest.mark.mat_ops
  @pytest.mark.parametrize(
      ("""mat1""", """mat2""")							,[(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e), (mat_f, mat_h)]       )
  def _lowercase   (  __A							,__A       ):
  
  
  
   '''simple docstring'''
  
  
  
   if (np.array(__A       )).shape < (2, 2) or (np.array(__A       )).shape < (2, 2):
    with pytest.raises(__A       ):
     logger.info(f"\n\t{test_subtraction.__name__} returned integer"       )
     matop.subtract(__A							,__A       )
   elif (np.array(__A       )).shape == (np.array(__A       )).shape:
    logger.info(f"\n\t{test_subtraction.__name__} with same matrix dims"       )
    __UpperCamelCase				      =  (np.array(__A       ) - np.array(__A       )).tolist()
    __UpperCamelCase				      =  matop.subtract(__A							,__A       )
    assert theo == act
   else:
    with pytest.raises(__A       ):
     logger.info(f"\n\t{test_subtraction.__name__} with different matrix dims"       )
     assert matop.subtract(__A							,__A       )
  
  
  
  
  
  
  
  @pytest.mark.mat_ops
  @pytest.mark.parametrize(
      ("""mat1""", """mat2""")							,[(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e), (mat_f, mat_h)]       )
  def _lowercase   (  __A							,__A       ):
  
  
  
   '''simple docstring'''
  
  
  
   if (np.array(__A       )).shape < (2, 2) or (np.array(__A       )).shape < (2, 2):
    logger.info(f"\n\t{test_multiplication.__name__} returned integer"       )
    with pytest.raises(__A       ):
     matop.add(__A							,__A       )
   elif (np.array(__A       )).shape == (np.array(__A       )).shape:
    logger.info(f"\n\t{test_multiplication.__name__} meets dim requirements"       )
    __UpperCamelCase				      =  (np.matmul(__A							,__A       )).tolist()
    __UpperCamelCase				      =  matop.multiply(__A							,__A       )
    assert theo == act
   else:
    with pytest.raises(__A       ):
     logger.info(
         f"\n\t{test_multiplication.__name__} does not meet dim requirements"       )
     assert matop.subtract(__A							,__A       )
  
  
  
  
  
  
  
  @pytest.mark.mat_ops
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  (3.5 * np.array(__A       )).tolist()
   __UpperCamelCase				      =  matop.scalar_multiply(__A							,3.5       )
   assert theo == act
  
  
  
  
  
  
  
  @pytest.mark.mat_ops
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  (np.identity(5       )).tolist()
   __UpperCamelCase				      =  matop.identity(5       )
   assert theo == act
  
  
  
  
  
  
  
  @pytest.mark.mat_ops
  @pytest.mark.parametrize("""mat"""							,[mat_a, mat_b, mat_c, mat_d, mat_e, mat_f]       )
  def _lowercase   (  __A       ):
  
  
  
   '''simple docstring'''
  
  
  
   if (np.array(__A       )).shape < (2, 2):
    with pytest.raises(__A       ):
     logger.info(f"\n\t{test_transpose.__name__} returned integer"       )
     matop.transpose(__A       )
   else:
    __UpperCamelCase				      =  (np.transpose(__A       )).tolist()
    __UpperCamelCase				      =  matop.transpose(__A							,return_map=__A       )
    assert theo == act
  
  
  
  
  
  
style_context: 
  
  
  
  '''simple docstring'''
  
  
  
  a__						:			str										=			[chr(i) for i in range(3_2, 1_2_6)]
  a__						:			List[Any]										=			list(range(len(alphabets)))
  a__						:			Union[str, Any]										=			list(range(len(alphabets)))
  a__						:			Dict										=			list(range(len(alphabets)))
  a__						:			Union[str, Any]										=			list(reversed(range(len(alphabets))))
  a__						:			List[str]										=			[]
  a__						:			int										=			0
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   global gear_one_pos
   global gear_two_pos
   global gear_three_pos
   __UpperCamelCase				      =  gear_one[0]
   gear_one.append(__A       )
   del gear_one[0]
   gear_one_pos += 1
   if gear_one_pos % int(len(__A       )       ) == 0:
    __UpperCamelCase				      =  gear_two[0]
    gear_two.append(__A       )
    del gear_two[0]
    gear_two_pos += 1
    if gear_two_pos % int(len(__A       )       ) == 0:
     __UpperCamelCase				      =  gear_three[0]
     gear_three.append(__A       )
     del gear_three[0]
     gear_three_pos += 1
  
  
  
  
  
  
  
  def _lowercase   (  __A       ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  alphabets.index(__A       )
   __UpperCamelCase				      =  gear_one[target]
   __UpperCamelCase				      =  gear_two[target]
   __UpperCamelCase				      =  gear_three[target]
   __UpperCamelCase				      =  reflector[target]
   __UpperCamelCase				      =  gear_three.index(__A       )
   __UpperCamelCase				      =  gear_two.index(__A       )
   __UpperCamelCase				      =  gear_one.index(__A       )
   code.append(alphabets[target]       )
   rotator()
  
  
  if __name__ == "__main__":
   a__						:			Any										=			list(input('Type your message:\n'))
   while True:
    try:
     a__						:			List[Any]										=			int(input('Please set token:(must be only digits)\n'))
     break
    except Exception as error:
     print(error)
   for _ in range(token):
    rotator()
   for j in decode:
    engine(j)
   print('\n' + ''.join(code))
   print(
       f'''\nYour Token is {token} please write it down.\nIf you want to decode '''
       'this message again you should input same digits as token!'
   )
  
  
  
  
  
  