"""simple docstring"""







import collections
import inspect
import unittest

from transformers import DonutSwinConfig
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import is_torch_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch
     from torch import nn

     from transformers import DonutSwinModel
     from transformers.models.donut.modeling_donut_swin import DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST






class      _SCREAMING_SNAKE_CASE							:



   '''simple docstring'''



   def __init__(	self ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE=13 ,				_SCREAMING_SNAKE_CASE=32 ,				_SCREAMING_SNAKE_CASE=2 ,				_SCREAMING_SNAKE_CASE=3 ,				_SCREAMING_SNAKE_CASE=16 ,				_SCREAMING_SNAKE_CASE=[1, 2, 1] ,				_SCREAMING_SNAKE_CASE=[2, 2, 4] ,				_SCREAMING_SNAKE_CASE=2 ,				_SCREAMING_SNAKE_CASE=2.0 ,				_SCREAMING_SNAKE_CASE=True ,				_SCREAMING_SNAKE_CASE=0.0 ,				_SCREAMING_SNAKE_CASE=0.0 ,				_SCREAMING_SNAKE_CASE=0.1 ,				_SCREAMING_SNAKE_CASE="gelu" ,				_SCREAMING_SNAKE_CASE=False ,				_SCREAMING_SNAKE_CASE=True ,				_SCREAMING_SNAKE_CASE=0.02 ,				_SCREAMING_SNAKE_CASE=1E-5 ,				_SCREAMING_SNAKE_CASE=True ,				_SCREAMING_SNAKE_CASE=None ,				_SCREAMING_SNAKE_CASE=True ,				_SCREAMING_SNAKE_CASE=10 ,				_SCREAMING_SNAKE_CASE=8 ,				):


      '''simple docstring'''

      __lowerCamelCase    		=					parent
      __lowerCamelCase    		=					batch_size
      __lowerCamelCase    		=					image_size
      __lowerCamelCase    		=					patch_size
      __lowerCamelCase    		=					num_channels
      __lowerCamelCase    		=					embed_dim
      __lowerCamelCase    		=					depths
      __lowerCamelCase    		=					num_heads
      __lowerCamelCase    		=					window_size
      __lowerCamelCase    		=					mlp_ratio
      __lowerCamelCase    		=					qkv_bias
      __lowerCamelCase    		=					hidden_dropout_prob
      __lowerCamelCase    		=					attention_probs_dropout_prob
      __lowerCamelCase    		=					drop_path_rate
      __lowerCamelCase    		=					hidden_act
      __lowerCamelCase    		=					use_absolute_embeddings
      __lowerCamelCase    		=					patch_norm
      __lowerCamelCase    		=					layer_norm_eps
      __lowerCamelCase    		=					initializer_range
      __lowerCamelCase    		=					is_training
      __lowerCamelCase    		=					scope
      __lowerCamelCase    		=					use_labels
      __lowerCamelCase    		=					type_sequence_label_size
      __lowerCamelCase    		=					encoder_stride







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

      __lowerCamelCase    		=					None
      if self.use_labels:
         __lowerCamelCase    		=					ids_tensor([self.batch_size] ,				self.type_sequence_label_size	)

      __lowerCamelCase    		=					self.get_config()

      return config, pixel_values, labels







   def    _A				(	self	):


      '''simple docstring'''

      return DonutSwinConfig(
          image_size=self.image_size ,				patch_size=self.patch_size ,				num_channels=self.num_channels ,				embed_dim=self.embed_dim ,				depths=self.depths ,				num_heads=self.num_heads ,				window_size=self.window_size ,				mlp_ratio=self.mlp_ratio ,				qkv_bias=self.qkv_bias ,				hidden_dropout_prob=self.hidden_dropout_prob ,				attention_probs_dropout_prob=self.attention_probs_dropout_prob ,				drop_path_rate=self.drop_path_rate ,				hidden_act=self.hidden_act ,				use_absolute_embeddings=self.use_absolute_embeddings ,				path_norm=self.patch_norm ,				layer_norm_eps=self.layer_norm_eps ,				initializer_range=self.initializer_range ,				encoder_stride=self.encoder_stride ,				)







   def    _A				(	self ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase    		=					DonutSwinModel(config=_SCREAMING_SNAKE_CASE	)
      model.to(_SCREAMING_SNAKE_CASE	)
      model.eval()
      __lowerCamelCase    		=					model(_SCREAMING_SNAKE_CASE	)

      __lowerCamelCase    		=					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths	) - 1))
      __lowerCamelCase    		=					int(config.embed_dim * 2 ** (len(config.depths	) - 1)	)

      self.parent.assertEqual(result.last_hidden_state.shape ,				(self.batch_size, expected_seq_len, expected_dim)	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					self.prepare_config_and_inputs()
      (
          (
          __lowerCamelCase
      )		,(
          __lowerCamelCase
      )		,(
          __lowerCamelCase
      )		,
      )    		=					config_and_inputs
      __lowerCamelCase    		=					{'pixel_values': pixel_values}
      return config, inputs_dict






@require_torch
class      _SCREAMING_SNAKE_CASE							(			UpperCAmelCase    ,				UpperCAmelCase    ,				unittest.TestCase				):



   '''simple docstring'''



   __UpperCAmelCase	:							Tuple    =    (DonutSwinModel,) if is_torch_available() else ()
   __UpperCAmelCase	:							Any    =    {"feature-extraction": DonutSwinModel} if is_torch_available() else {}
   __UpperCAmelCase	:							Optional[int]    =    True

   __UpperCAmelCase	:							Optional[int]    =    False
   __UpperCAmelCase	:							Optional[int]    =    False
   __UpperCAmelCase	:							int    =    False







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					DonutSwinModelTester(self	)
      __lowerCamelCase    		=					ConfigTester(self ,				config_class=_SCREAMING_SNAKE_CASE ,				embed_dim=37	)







   def    _A				(	self	):


      '''simple docstring'''

      self.create_and_test_config_common_properties()
      self.config_tester.create_and_test_config_to_json_string()
      self.config_tester.create_and_test_config_to_json_file()
      self.config_tester.create_and_test_config_from_and_save_pretrained()
      self.config_tester.create_and_test_config_with_num_labels()
      self.config_tester.check_config_can_be_init_without_params()
      self.config_tester.check_config_arguments_init()







   def    _A				(	self	):


      '''simple docstring'''

      return







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE	)







   def    _A				(	self	):


      '''simple docstring'''

      pass







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __lowerCamelCase    		=					model_class(_SCREAMING_SNAKE_CASE	)
         self.assertIsInstance(model.get_input_embeddings() ,				(nn.Module)	)
         __lowerCamelCase    		=					model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(_SCREAMING_SNAKE_CASE ,				nn.Linear	)	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __lowerCamelCase    		=					model_class(_SCREAMING_SNAKE_CASE	)
         __lowerCamelCase    		=					inspect.signature(model.forward	)
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         __lowerCamelCase    		=					[*signature.parameters.keys()]

         __lowerCamelCase    		=					['pixel_values']
         self.assertListEqual(arg_names[:1] ,				_SCREAMING_SNAKE_CASE	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs_for_common()
      __lowerCamelCase    		=					True

      for model_class in self.all_model_classes:
         __lowerCamelCase    		=					True
         __lowerCamelCase    		=					False
         __lowerCamelCase    		=					True
         __lowerCamelCase    		=					model_class(_SCREAMING_SNAKE_CASE	)
         model.to(_SCREAMING_SNAKE_CASE	)
         model.eval()
         with torch.no_grad():
            __lowerCamelCase    		=					model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)	)
         __lowerCamelCase    		=					outputs.attentions
         __lowerCamelCase    		=					len(self.model_tester.depths	)
         self.assertEqual(len(_SCREAMING_SNAKE_CASE	) ,				_SCREAMING_SNAKE_CASE	)

         # check that output_attentions also work using config
         del inputs_dict["output_attentions"]
         __lowerCamelCase    		=					True
         __lowerCamelCase    		=					config.window_size**2
         __lowerCamelCase    		=					model_class(_SCREAMING_SNAKE_CASE	)
         model.to(_SCREAMING_SNAKE_CASE	)
         model.eval()
         with torch.no_grad():
            __lowerCamelCase    		=					model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)	)
         __lowerCamelCase    		=					outputs.attentions
         self.assertEqual(len(_SCREAMING_SNAKE_CASE	) ,				_SCREAMING_SNAKE_CASE	)

         self.assertListEqual(
             list(attentions[0].shape[-3:]	) ,				[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,				)
         __lowerCamelCase    		=					len(_SCREAMING_SNAKE_CASE	)

         # Check attention is always last and order is fine
         __lowerCamelCase    		=					True
         __lowerCamelCase    		=					True
         __lowerCamelCase    		=					model_class(_SCREAMING_SNAKE_CASE	)
         model.to(_SCREAMING_SNAKE_CASE	)
         model.eval()
         with torch.no_grad():
            __lowerCamelCase    		=					model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)	)

         if hasattr(self.model_tester ,				'num_hidden_states_types'	):
            __lowerCamelCase    		=					self.model_tester.num_hidden_states_types
         else:
            # also another +1 for reshaped_hidden_states
            __lowerCamelCase    		=					2
         self.assertEqual(out_len + added_hidden_states ,				len(_SCREAMING_SNAKE_CASE	)	)

         __lowerCamelCase    		=					outputs.attentions

         self.assertEqual(len(_SCREAMING_SNAKE_CASE	) ,				_SCREAMING_SNAKE_CASE	)

         self.assertListEqual(
             list(self_attentions[0].shape[-3:]	) ,				[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,				)







   def    _A				(	self ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase    		=					model_class(_SCREAMING_SNAKE_CASE	)
      model.to(_SCREAMING_SNAKE_CASE	)
      model.eval()

      with torch.no_grad():
         __lowerCamelCase    		=					model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)	)

      __lowerCamelCase    		=					outputs.hidden_states

      __lowerCamelCase    		=					getattr(
          self.model_tester ,				'expected_num_hidden_layers' ,				len(self.model_tester.depths	) + 1	)
      self.assertEqual(len(_SCREAMING_SNAKE_CASE	) ,				_SCREAMING_SNAKE_CASE	)

      # DonutSwin has a different seq_length
      __lowerCamelCase    		=					(
          config.patch_size
          if isinstance(config.patch_size ,				collections.abc.Iterable	)
          else (config.patch_size, config.patch_size)
      )

      __lowerCamelCase    		=					(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

      self.assertListEqual(
          list(hidden_states[0].shape[-2:]	) ,				[num_patches, self.model_tester.embed_dim] ,				)

      __lowerCamelCase    		=					outputs.reshaped_hidden_states
      self.assertEqual(len(_SCREAMING_SNAKE_CASE	) ,				_SCREAMING_SNAKE_CASE	)

      __lowerCamelCase		,__lowerCamelCase		,__lowerCamelCase		,__lowerCamelCase    		=					reshaped_hidden_states[0].shape
      __lowerCamelCase    		=					(
          reshaped_hidden_states[0].view(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				height * width	).permute(0 ,				2 ,				1	)
      )
      self.assertListEqual(
          list(reshaped_hidden_states.shape[-2:]	) ,				[num_patches, self.model_tester.embed_dim] ,				)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs_for_common()

      __lowerCamelCase    		=					(
          self.model_tester.image_size
          if isinstance(self.model_tester.image_size ,				collections.abc.Iterable	)
          else (self.model_tester.image_size, self.model_tester.image_size)
      )

      for model_class in self.all_model_classes:
         __lowerCamelCase    		=					True
         self.check_hidden_states_output(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         __lowerCamelCase    		=					True

         self.check_hidden_states_output(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs_for_common()
      __lowerCamelCase    		=					3

      __lowerCamelCase    		=					(
          self.model_tester.image_size
          if isinstance(self.model_tester.image_size ,				collections.abc.Iterable	)
          else (self.model_tester.image_size, self.model_tester.image_size)
      )
      __lowerCamelCase    		=					(
          config.patch_size
          if isinstance(config.patch_size ,				collections.abc.Iterable	)
          else (config.patch_size, config.patch_size)
      )

      __lowerCamelCase    		=					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
      __lowerCamelCase    		=					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

      for model_class in self.all_model_classes:
         __lowerCamelCase    		=					True
         self.check_hidden_states_output(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				(padded_height, padded_width)	)

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         __lowerCamelCase    		=					True
         self.check_hidden_states_output(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				(padded_height, padded_width)	)







   @slow
   def    _A				(	self	):


      '''simple docstring'''

      for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __lowerCamelCase    		=					DonutSwinModel.from_pretrained(_SCREAMING_SNAKE_CASE	)
         self.assertIsNotNone(_SCREAMING_SNAKE_CASE	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs_for_common()

      __lowerCamelCase    		=					_config_zero_init(_SCREAMING_SNAKE_CASE	)
      for model_class in self.all_model_classes:
         __lowerCamelCase    		=					model_class(config=_SCREAMING_SNAKE_CASE	)
         for name, param in model.named_parameters():
            if "embeddings" not in name and param.requires_grad:
               self.assertIn(
                   ((param.data.mean() * 1E9).round() / 1E9).item() ,				[0.0, 1.0] ,				msg=F'''Parameter {name} of model {model_class} seems not properly initialized''' ,				)








'''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

_snake_case					: List[str]     			=					[[12, 10], [3, 9]]
_snake_case					: Any     			=					[[3, 4], [7, 4]]
_snake_case					: List[str]     			=					[[3, 0, 2], [2, 0, -2], [0, 1, 1]]
_snake_case					: Any     			=					[[3, 0, -2], [2, 0, 2], [0, 1, 1]]
_snake_case					: Any     			=					[[3, 0, 2], [2, 0, -2], [0, 1, 1], [2, 0, -2]]
_snake_case					: Optional[Any]     			=					[1]
_snake_case					: str     			=					[2]

_snake_case					: Optional[int]     			=					logging.getLogger()
_snake_case					: Optional[Any]     			=					logging.DEBUG
_snake_case					: 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       _a		(						_SCREAMING_SNAKE_CASE		: List[Any]						,      _SCREAMING_SNAKE_CASE		: Tuple	):
						if (np.array(_SCREAMING_SNAKE_CASE	)).shape < (2, 2) or (np.array(_SCREAMING_SNAKE_CASE	)).shape < (2, 2):
												with pytest.raises(_SCREAMING_SNAKE_CASE	):
																		logger.info(F'\n\t{test_addition.__name__} returned integer'	)
																		matop.add(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	)
						elif (np.array(_SCREAMING_SNAKE_CASE	)).shape == (np.array(_SCREAMING_SNAKE_CASE	)).shape:
												logger.info(F'\n\t{test_addition.__name__} with same matrix dims'	)
												_SCREAMING_SNAKE_CASE					=			(np.array(_SCREAMING_SNAKE_CASE	) + np.array(_SCREAMING_SNAKE_CASE	)).tolist()
												_SCREAMING_SNAKE_CASE					=			matop.add(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	)
												assert theo == act
						else:
												with pytest.raises(_SCREAMING_SNAKE_CASE	):
																		logger.info(F'\n\t{test_addition.__name__} with different matrix dims'	)
																		matop.add(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	)



@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       _a		(						_SCREAMING_SNAKE_CASE		: Optional[Any]						,      _SCREAMING_SNAKE_CASE		: List[str]	):
						if (np.array(_SCREAMING_SNAKE_CASE	)).shape < (2, 2) or (np.array(_SCREAMING_SNAKE_CASE	)).shape < (2, 2):
												with pytest.raises(_SCREAMING_SNAKE_CASE	):
																		logger.info(F'\n\t{test_subtraction.__name__} returned integer'	)
																		matop.subtract(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	)
						elif (np.array(_SCREAMING_SNAKE_CASE	)).shape == (np.array(_SCREAMING_SNAKE_CASE	)).shape:
												logger.info(F'\n\t{test_subtraction.__name__} with same matrix dims'	)
												_SCREAMING_SNAKE_CASE					=			(np.array(_SCREAMING_SNAKE_CASE	) - np.array(_SCREAMING_SNAKE_CASE	)).tolist()
												_SCREAMING_SNAKE_CASE					=			matop.subtract(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	)
												assert theo == act
						else:
												with pytest.raises(_SCREAMING_SNAKE_CASE	):
																		logger.info(F'\n\t{test_subtraction.__name__} with different matrix dims'	)
																		assert matop.subtract(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	)



@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       _a		(						_SCREAMING_SNAKE_CASE		: Any						,      _SCREAMING_SNAKE_CASE		: List[str]	):
						if (np.array(_SCREAMING_SNAKE_CASE	)).shape < (2, 2) or (np.array(_SCREAMING_SNAKE_CASE	)).shape < (2, 2):
												logger.info(F'\n\t{test_multiplication.__name__} returned integer'	)
												with pytest.raises(_SCREAMING_SNAKE_CASE	):
																		matop.add(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	)
						elif (np.array(_SCREAMING_SNAKE_CASE	)).shape == (np.array(_SCREAMING_SNAKE_CASE	)).shape:
												logger.info(F'\n\t{test_multiplication.__name__} meets dim requirements'	)
												_SCREAMING_SNAKE_CASE					=			(np.matmul(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	)).tolist()
												_SCREAMING_SNAKE_CASE					=			matop.multiply(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	)
												assert theo == act
						else:
												with pytest.raises(_SCREAMING_SNAKE_CASE	):
																		logger.info(
																		    F'\n\t{test_multiplication.__name__} does not meet dim requirements'	)
																		assert matop.subtract(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	)



@pytest.mark.mat_ops
def       _a		(						):
						_SCREAMING_SNAKE_CASE					=			(3.5 * np.array(_SCREAMING_SNAKE_CASE	)).tolist()
						_SCREAMING_SNAKE_CASE					=			matop.scalar_multiply(_SCREAMING_SNAKE_CASE						,      3.5	)
						assert theo == act



@pytest.mark.mat_ops
def       _a		(						):
						_SCREAMING_SNAKE_CASE					=			(np.identity(5	)).tolist()
						_SCREAMING_SNAKE_CASE					=			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       _a		(						_SCREAMING_SNAKE_CASE		: Tuple	):
						if (np.array(_SCREAMING_SNAKE_CASE	)).shape < (2, 2):
												with pytest.raises(_SCREAMING_SNAKE_CASE	):
																		logger.info(F'\n\t{test_transpose.__name__} returned integer'	)
																		matop.transpose(_SCREAMING_SNAKE_CASE	)
						else:
												_SCREAMING_SNAKE_CASE					=			(np.transpose(_SCREAMING_SNAKE_CASE	)).tolist()
												_SCREAMING_SNAKE_CASE					=			matop.transpose(_SCREAMING_SNAKE_CASE						,      return_map=_SCREAMING_SNAKE_CASE	)
												assert theo == act