code: 
  
  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   :     Optional[int]      =			[[12, 10], [3, 9]]
  __A   :     Dict      =			[[3, 4], [7, 4]]
  __A   :     List[str]      =			[[3, 0, 2], [2, 0, -2], [0, 1, 1]]
  __A   :     List[str]      =			[[3, 0, -2], [2, 0, 2], [0, 1, 1]]
  __A   :     Tuple      =			[[3, 0, 2], [2, 0, -2], [0, 1, 1], [2, 0, -2]]
  __A   :     List[str]      =			[1]
  __A   :     List[str]      =			[2]
  
  __A   :     List[Any]      =			logging.getLogger()
  __A   :     Optional[int]      =			logging.DEBUG
  __A   :     Optional[int]      =			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 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase,      _UpperCAmelCase				)					-> Optional[int]:
  
  
  
  
  
  
  
      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"				)
          lowerCAmelCase				:			Optional[int]    			=      (np.array(_A				) + np.array(_A				)).tolist()
          lowerCAmelCase				:			int    			=      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 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase,      _UpperCAmelCase				)					-> List[str]:
  
  
  
  
  
  
  
      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"				)
          lowerCAmelCase				:			List[Any]    			=      (np.array(_A				) - np.array(_A				)).tolist()
          lowerCAmelCase				:			int    			=      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 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase,      _UpperCAmelCase				)					-> Optional[int]:
  
  
  
  
  
  
  
      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"				)
          lowerCAmelCase				:			Union[str, Any]    			=      (np.matmul(_A,      _A				)).tolist()
          lowerCAmelCase				:			Union[str, Any]    			=      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 		SCREAMING_SNAKE_CASE__				(							)					-> List[Any]:
      lowerCAmelCase				:			Union[str, Any]    			=      (3.5 * np.array(_A				)).tolist()
      lowerCAmelCase				:			List[str]    			=      matop.scalar_multiply(_A,      3.5				)
      assert theo == act
  @pytest.mark.mat_ops
  def 		SCREAMING_SNAKE_CASE__				(							)					-> Union[str, Any]:
      lowerCAmelCase				:			Dict    			=      (np.identity(5				)).tolist()
      lowerCAmelCase				:			Any    			=      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 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase				)					-> List[str]:
  
  
  
  
  
  
  
      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:
          lowerCAmelCase				:			Optional[Any]    			=      (np.transpose(_A				)).tolist()
          lowerCAmelCase				:			Optional[Any]    			=      matop.transpose(_A,      return_map=_A				)
          assert theo == act
  
  
  
  
  
  
style_context: 
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
  
  
  __A   :     List[Any]      =			{'''configuration_umt5''': ['''UMT5Config''', '''UMT5OnnxConfig''']}
  
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   __A   :     Tuple      =			[
       '''UMT5EncoderModel''',
       '''UMT5ForConditionalGeneration''',
       '''UMT5ForQuestionAnswering''',
       '''UMT5Model''',
       '''UMT5PreTrainedModel''',
   ]
  
  if TYPE_CHECKING:
   from .configuration_umta import UMTaConfig, UMTaOnnxConfig
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_umta import (
        UMTaEncoderModel,
        UMTaForConditionalGeneration,
        UMTaForQuestionAnswering,
        UMTaModel,
        UMTaPreTrainedModel,
    )
  else:
   import sys
  
   __A   :     Any      =			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  
  
  
  
  