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
  
  __lowerCAmelCase							:			List[Any]				=[[12, 10], [3, 9]]
  __lowerCAmelCase							:			List[str]				=[[3, 4], [7, 4]]
  __lowerCAmelCase							:			List[Any]				=[[3, 0, 2], [2, 0, -2], [0, 1, 1]]
  __lowerCAmelCase							:			Any				=[[3, 0, -2], [2, 0, 2], [0, 1, 1]]
  __lowerCAmelCase							:			List[str]				=[[3, 0, 2], [2, 0, -2], [0, 1, 1], [2, 0, -2]]
  __lowerCAmelCase							:			str				=[1]
  __lowerCAmelCase							:			Dict				=[2]
  
  __lowerCAmelCase							:			Any				=logging.getLogger()
  __lowerCAmelCase							:			Union[str, Any]				=logging.DEBUG
  __lowerCAmelCase							:			Tuple				=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 		UpperCamelCase       (							_lowerCamelCase      :      Union[str, Any]		, _lowerCamelCase      :      Optional[Any] ):
      if (np.array(_lowerCamelCase )).shape < (2, 2) or (np.array(_lowerCamelCase )).shape < (2, 2):
          with pytest.raises(_lowerCamelCase ):
              logger.info(F"\n\t{test_addition.__name__} returned integer" )
              matop.add(_lowerCamelCase		, _lowerCamelCase )
      elif (np.array(_lowerCamelCase )).shape == (np.array(_lowerCamelCase )).shape:
          logger.info(F"\n\t{test_addition.__name__} with same matrix dims" )
          A__       =    (np.array(_lowerCamelCase ) + np.array(_lowerCamelCase )).tolist()
          A__       =    matop.add(_lowerCamelCase		, _lowerCamelCase )
          assert theo == act
      else:
          with pytest.raises(_lowerCamelCase ):
              logger.info(F"\n\t{test_addition.__name__} with different matrix dims" )
              matop.add(_lowerCamelCase		, _lowerCamelCase )
  
  
  
  
  
  @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 		UpperCamelCase       (							_lowerCamelCase      :      Dict		, _lowerCamelCase      :      Optional[int] ):
      if (np.array(_lowerCamelCase )).shape < (2, 2) or (np.array(_lowerCamelCase )).shape < (2, 2):
          with pytest.raises(_lowerCamelCase ):
              logger.info(F"\n\t{test_subtraction.__name__} returned integer" )
              matop.subtract(_lowerCamelCase		, _lowerCamelCase )
      elif (np.array(_lowerCamelCase )).shape == (np.array(_lowerCamelCase )).shape:
          logger.info(F"\n\t{test_subtraction.__name__} with same matrix dims" )
          A__       =    (np.array(_lowerCamelCase ) - np.array(_lowerCamelCase )).tolist()
          A__       =    matop.subtract(_lowerCamelCase		, _lowerCamelCase )
          assert theo == act
      else:
          with pytest.raises(_lowerCamelCase ):
              logger.info(F"\n\t{test_subtraction.__name__} with different matrix dims" )
              assert matop.subtract(_lowerCamelCase		, _lowerCamelCase )
  
  
  
  
  
  @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 		UpperCamelCase       (							_lowerCamelCase      :      List[Any]		, _lowerCamelCase      :      str ):
      if (np.array(_lowerCamelCase )).shape < (2, 2) or (np.array(_lowerCamelCase )).shape < (2, 2):
          logger.info(F"\n\t{test_multiplication.__name__} returned integer" )
          with pytest.raises(_lowerCamelCase ):
              matop.add(_lowerCamelCase		, _lowerCamelCase )
      elif (np.array(_lowerCamelCase )).shape == (np.array(_lowerCamelCase )).shape:
          logger.info(F"\n\t{test_multiplication.__name__} meets dim requirements" )
          A__       =    (np.matmul(_lowerCamelCase		, _lowerCamelCase )).tolist()
          A__       =    matop.multiply(_lowerCamelCase		, _lowerCamelCase )
          assert theo == act
      else:
          with pytest.raises(_lowerCamelCase ):
              logger.info(
                  F"\n\t{test_multiplication.__name__} does not meet dim requirements" )
              assert matop.subtract(_lowerCamelCase		, _lowerCamelCase )
  
  
  
  
  
  @pytest.mark.mat_ops
  def 		UpperCamelCase       (							):
      A__       =    (3.5 * np.array(_lowerCamelCase )).tolist()
      A__       =    matop.scalar_multiply(_lowerCamelCase		, 3.5 )
      assert theo == act
  
  
  
  
  
  @pytest.mark.mat_ops
  def 		UpperCamelCase       (							):
      A__       =    (np.identity(5 )).tolist()
      A__       =    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 		UpperCamelCase       (							_lowerCamelCase      :      Optional[Any] ):
      if (np.array(_lowerCamelCase )).shape < (2, 2):
          with pytest.raises(_lowerCamelCase ):
              logger.info(F"\n\t{test_transpose.__name__} returned integer" )
              matop.transpose(_lowerCamelCase )
      else:
          A__       =    (np.transpose(_lowerCamelCase )).tolist()
          A__       =    matop.transpose(_lowerCamelCase		, return_map=_lowerCamelCase )
          assert theo == act
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  import os
  import tempfile
  import unittest
  from typing import List
  
  from transformers.models.esm.tokenization_esm import VOCAB_FILES_NAMES, EsmTokenizer
  from transformers.testing_utils import require_tokenizers
  from transformers.tokenization_utils import PreTrainedTokenizer
  from transformers.tokenization_utils_base import PreTrainedTokenizerBase
  
  
  
  
  
  
  @require_tokenizers
  class      UpperCAmelCase			( unittest.TestCase       ):
   __lowercase     	=       EsmTokenizer
   def   UpperCAmelCase_							(       self   :Any							)->							int:
       super().setUp()
       A__       =    tempfile.mkdtemp()
       # fmt: off
       A__       =    ["<cls>", "<pad>", "<eos>", "<unk>", "L", "A", "G", "V", "S", "E", "R", "T", "I", "D", "P", "K", "Q", "N", "F", "Y", "M", "H", "W", "C", "X", "B", "U", "Z", "O", ".", "-", "<null_1>", "<mask>"]  # noqa: E501
       # fmt: on
       A__       =    os.path.join(self.tmpdirname		, VOCAB_FILES_NAMES["vocab_file"]							)
       with open(self.vocab_file		, "w"		, encoding="utf-8"							) as vocab_writer:
           vocab_writer.write("".join([x + "\n" for x in vocab_tokens]							)							)
   def   UpperCAmelCase_							(       self   :Any		, **lowercase_   :int							)->							List[PreTrainedTokenizerBase]:
       return [self.get_tokenizer(**lowercase_							)]
   def   UpperCAmelCase_							(       self   :Any		, **lowercase_   :Dict							)->							PreTrainedTokenizer:
       return self.tokenizer_class.from_pretrained(self.tmpdirname		, **lowercase_							)
   def   UpperCAmelCase_							(       self   :int							)->							Dict:
       A__       =    self.tokenizer_class(self.vocab_file							)
  
       A__       =    tokenizer.tokenize("LAGVS"							)
       self.assertListEqual(lowercase_		, ["L", "A", "G", "V", "S"]							)
       self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase_							)		, [4, 5, 6, 7, 8]							)
   def   UpperCAmelCase_							(       self   :Tuple							)->							Tuple:
       A__       =    self.tokenizer_class(self.vocab_file							)
  
       A__       =    "LAGVS"
       self.assertListEqual(tokenizer.encode(lowercase_							)		, [0, 4, 5, 6, 7, 8, 2]							)
   def   UpperCAmelCase_							(       self   :Any							)->							Tuple:
       A__       =    self.tokenizer_class(self.vocab_file							)
  
       A__       =    ["LAGVS", "WCB"]
       A__       =    tokenizer(lowercase_		, padding=lowercase_							)["input_ids"]
  
       self.assertListEqual(lowercase_		, [[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2]]							)
   def   UpperCAmelCase_							(       self   :str							)->							Any:
       A__       =    self.tokenizer_class(self.vocab_file							)
  
       A__       =    ["LAGVS", "WCB"]
       A__       =    tokenizer(lowercase_		, padding=lowercase_							)["input_ids"]
  
       self.assertListEqual(lowercase_		, [[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2, 1, 1]]							)
  
  
  
   def   UpperCAmelCase_							(       self   :Optional[Any]							)->							List[str]:
       A__       =    self.get_tokenizers(fast=lowercase_							)
       for tokenizer in tokenizers:
           with self.subTest(F"{tokenizer.__class__.__name__}"							):
               A__       =    "<unk>"
               A__       =    "<mask>"
  
               A__       =    tokenizer.tokenize(lowercase_							)
               A__       =    tokenizer.tokenize(lowercase_							)
  
               self.assertEqual(len(lowercase_							)		, 1							)
               self.assertEqual(len(lowercase_							)		, 1							)
               self.assertEqual(token_a[0]		, lowercase_							)
               self.assertEqual(token_a[0]		, lowercase_							)
  
  
  
  