


'''simple docstring'''



import unittest

import numpy as np

from transformers.testing_utils import require_flax, require_tf, require_torch
from transformers.utils import (
    expand_dims,
    flatten_dict,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    reshape,
    squeeze,
    transpose,
)


if is_flax_available():
	import jax.numpy as jnp

if is_tf_available():
	import tensorflow as tf

if is_torch_available():
	import torch






class 	UpperCamelCase__(       unittest.TestCase	):




				def 					a__(		self      :			int				)->					List[str]:

										"""simple docstring"""




										UpperCAmelCase					    =     {
										    '''task_specific_params''': {
										        '''summarization''': {'''length_penalty''': 1.0, '''max_length''': 128, '''min_length''': 12, '''num_beams''': 4},
										        '''summarization_cnn''': {'''length_penalty''': 2.0, '''max_length''': 142, '''min_length''': 56, '''num_beams''': 4},
										        '''summarization_xsum''': {'''length_penalty''': 1.0, '''max_length''': 62, '''min_length''': 11, '''num_beams''': 6},
										    }
										}
										UpperCAmelCase					    =     {
										    '''task_specific_params.summarization.length_penalty''': 1.0,
										    '''task_specific_params.summarization.max_length''': 128,
										    '''task_specific_params.summarization.min_length''': 12,
										    '''task_specific_params.summarization.num_beams''': 4,
										    '''task_specific_params.summarization_cnn.length_penalty''': 2.0,
										    '''task_specific_params.summarization_cnn.max_length''': 142,
										    '''task_specific_params.summarization_cnn.min_length''': 56,
										    '''task_specific_params.summarization_cnn.num_beams''': 4,
										    '''task_specific_params.summarization_xsum.length_penalty''': 1.0,
										    '''task_specific_params.summarization_xsum.max_length''': 62,
										    '''task_specific_params.summarization_xsum.min_length''': 11,
										    '''task_specific_params.summarization_xsum.num_beams''': 6,
										}

										self.assertEqual(flatten_dict(lowerCAmelCase				)				,   lowerCAmelCase				)




				def 					a__(		self      :			List[Any]				)->					Union[str, Any]:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(3				,   4				)
										self.assertTrue(np.allclose(transpose(lowerCAmelCase				)				,   x.transpose()				)				)

										UpperCAmelCase					    =     np.random.randn(3				,   4				,   5				)
										self.assertTrue(np.allclose(transpose(lowerCAmelCase				,   axes=(1, 2, 0)				)				,   x.transpose((1, 2, 0)				)				)				)




				@require_torch
				def 					a__(		self      :			Tuple				)->					Dict:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(3				,   4				)
										UpperCAmelCase					    =     torch.tensor(lowerCAmelCase				)
										self.assertTrue(np.allclose(transpose(lowerCAmelCase				)				,   transpose(lowerCAmelCase				).numpy()				)				)

										UpperCAmelCase					    =     np.random.randn(3				,   4				,   5				)
										UpperCAmelCase					    =     torch.tensor(lowerCAmelCase				)
										self.assertTrue(np.allclose(transpose(lowerCAmelCase				,   axes=(1, 2, 0)				)				,   transpose(lowerCAmelCase				,   axes=(1, 2, 0)				).numpy()				)				)




				@require_tf
				def 					a__(		self      :			List[str]				)->					Tuple:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(3				,   4				)
										UpperCAmelCase					    =     tf.constant(lowerCAmelCase				)
										self.assertTrue(np.allclose(transpose(lowerCAmelCase				)				,   transpose(lowerCAmelCase				).numpy()				)				)

										UpperCAmelCase					    =     np.random.randn(3				,   4				,   5				)
										UpperCAmelCase					    =     tf.constant(lowerCAmelCase				)
										self.assertTrue(np.allclose(transpose(lowerCAmelCase				,   axes=(1, 2, 0)				)				,   transpose(lowerCAmelCase				,   axes=(1, 2, 0)				).numpy()				)				)




				@require_flax
				def 					a__(		self      :			str				)->					Dict:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(3				,   4				)
										UpperCAmelCase					    =     jnp.array(lowerCAmelCase				)
										self.assertTrue(np.allclose(transpose(lowerCAmelCase				)				,   np.asarray(transpose(lowerCAmelCase				)				)				)				)

										UpperCAmelCase					    =     np.random.randn(3				,   4				,   5				)
										UpperCAmelCase					    =     jnp.array(lowerCAmelCase				)
										self.assertTrue(np.allclose(transpose(lowerCAmelCase				,   axes=(1, 2, 0)				)				,   np.asarray(transpose(lowerCAmelCase				,   axes=(1, 2, 0)				)				)				)				)




				def 					a__(		self      :			Union[str, Any]				)->					Optional[Any]:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(3				,   4				)
										self.assertTrue(np.allclose(reshape(lowerCAmelCase				,   (4, 3)				)				,   np.reshape(lowerCAmelCase				,   (4, 3)				)				)				)

										UpperCAmelCase					    =     np.random.randn(3				,   4				,   5				)
										self.assertTrue(np.allclose(reshape(lowerCAmelCase				,   (12, 5)				)				,   np.reshape(lowerCAmelCase				,   (12, 5)				)				)				)




				@require_torch
				def 					a__(		self      :			Union[str, Any]				)->					Any:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(3				,   4				)
										UpperCAmelCase					    =     torch.tensor(lowerCAmelCase				)
										self.assertTrue(np.allclose(reshape(lowerCAmelCase				,   (4, 3)				)				,   reshape(lowerCAmelCase				,   (4, 3)				).numpy()				)				)

										UpperCAmelCase					    =     np.random.randn(3				,   4				,   5				)
										UpperCAmelCase					    =     torch.tensor(lowerCAmelCase				)
										self.assertTrue(np.allclose(reshape(lowerCAmelCase				,   (12, 5)				)				,   reshape(lowerCAmelCase				,   (12, 5)				).numpy()				)				)




				@require_tf
				def 					a__(		self      :			Any				)->					Optional[Any]:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(3				,   4				)
										UpperCAmelCase					    =     tf.constant(lowerCAmelCase				)
										self.assertTrue(np.allclose(reshape(lowerCAmelCase				,   (4, 3)				)				,   reshape(lowerCAmelCase				,   (4, 3)				).numpy()				)				)

										UpperCAmelCase					    =     np.random.randn(3				,   4				,   5				)
										UpperCAmelCase					    =     tf.constant(lowerCAmelCase				)
										self.assertTrue(np.allclose(reshape(lowerCAmelCase				,   (12, 5)				)				,   reshape(lowerCAmelCase				,   (12, 5)				).numpy()				)				)




				@require_flax
				def 					a__(		self      :			Union[str, Any]				)->					List[str]:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(3				,   4				)
										UpperCAmelCase					    =     jnp.array(lowerCAmelCase				)
										self.assertTrue(np.allclose(reshape(lowerCAmelCase				,   (4, 3)				)				,   np.asarray(reshape(lowerCAmelCase				,   (4, 3)				)				)				)				)

										UpperCAmelCase					    =     np.random.randn(3				,   4				,   5				)
										UpperCAmelCase					    =     jnp.array(lowerCAmelCase				)
										self.assertTrue(np.allclose(reshape(lowerCAmelCase				,   (12, 5)				)				,   np.asarray(reshape(lowerCAmelCase				,   (12, 5)				)				)				)				)




				def 					a__(		self      :			Any				)->					Optional[Any]:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(1				,   3				,   4				)
										self.assertTrue(np.allclose(squeeze(lowerCAmelCase				)				,   np.squeeze(lowerCAmelCase				)				)				)

										UpperCAmelCase					    =     np.random.randn(1				,   4				,   1				,   5				)
										self.assertTrue(np.allclose(squeeze(lowerCAmelCase				,   axis=2				)				,   np.squeeze(lowerCAmelCase				,   axis=2				)				)				)




				@require_torch
				def 					a__(		self      :			List[str]				)->					Dict:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(1				,   3				,   4				)
										UpperCAmelCase					    =     torch.tensor(lowerCAmelCase				)
										self.assertTrue(np.allclose(squeeze(lowerCAmelCase				)				,   squeeze(lowerCAmelCase				).numpy()				)				)

										UpperCAmelCase					    =     np.random.randn(1				,   4				,   1				,   5				)
										UpperCAmelCase					    =     torch.tensor(lowerCAmelCase				)
										self.assertTrue(np.allclose(squeeze(lowerCAmelCase				,   axis=2				)				,   squeeze(lowerCAmelCase				,   axis=2				).numpy()				)				)




				@require_tf
				def 					a__(		self      :			List[str]				)->					int:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(1				,   3				,   4				)
										UpperCAmelCase					    =     tf.constant(lowerCAmelCase				)
										self.assertTrue(np.allclose(squeeze(lowerCAmelCase				)				,   squeeze(lowerCAmelCase				).numpy()				)				)

										UpperCAmelCase					    =     np.random.randn(1				,   4				,   1				,   5				)
										UpperCAmelCase					    =     tf.constant(lowerCAmelCase				)
										self.assertTrue(np.allclose(squeeze(lowerCAmelCase				,   axis=2				)				,   squeeze(lowerCAmelCase				,   axis=2				).numpy()				)				)




				@require_flax
				def 					a__(		self      :			Optional[Any]				)->					Tuple:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(1				,   3				,   4				)
										UpperCAmelCase					    =     jnp.array(lowerCAmelCase				)
										self.assertTrue(np.allclose(squeeze(lowerCAmelCase				)				,   np.asarray(squeeze(lowerCAmelCase				)				)				)				)

										UpperCAmelCase					    =     np.random.randn(1				,   4				,   1				,   5				)
										UpperCAmelCase					    =     jnp.array(lowerCAmelCase				)
										self.assertTrue(np.allclose(squeeze(lowerCAmelCase				,   axis=2				)				,   np.asarray(squeeze(lowerCAmelCase				,   axis=2				)				)				)				)




				def 					a__(		self      :			Union[str, Any]				)->					Optional[int]:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(3				,   4				)
										self.assertTrue(np.allclose(expand_dims(lowerCAmelCase				,   axis=1				)				,   np.expand_dims(lowerCAmelCase				,   axis=1				)				)				)




				@require_torch
				def 					a__(		self      :			str				)->					str:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(3				,   4				)
										UpperCAmelCase					    =     torch.tensor(lowerCAmelCase				)
										self.assertTrue(np.allclose(expand_dims(lowerCAmelCase				,   axis=1				)				,   expand_dims(lowerCAmelCase				,   axis=1				).numpy()				)				)




				@require_tf
				def 					a__(		self      :			List[Any]				)->					int:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(3				,   4				)
										UpperCAmelCase					    =     tf.constant(lowerCAmelCase				)
										self.assertTrue(np.allclose(expand_dims(lowerCAmelCase				,   axis=1				)				,   expand_dims(lowerCAmelCase				,   axis=1				).numpy()				)				)





				@require_flax
				def 					a__(		self      :			List[str]				)->					List[str]:

										"""simple docstring"""




										UpperCAmelCase					    =     np.random.randn(3				,   4				)
										UpperCAmelCase					    =     jnp.array(lowerCAmelCase				)
										self.assertTrue(np.allclose(expand_dims(lowerCAmelCase				,   axis=1				)				,   np.asarray(expand_dims(lowerCAmelCase				,   axis=1				)				)				)				)









'''simple docstring'''



def 				lowerCamelCase__				(	A       :      int				,       A       :      int					):




						'''simple docstring'''






						while a != 0:
												UpperCAmelCase    ,    UpperCAmelCase					    =     b % a, a
						return b




def 				lowerCamelCase__				(	A       :      int				,       A       :      int					):




						'''simple docstring'''






						if gcd(A				,       A					) != 1:
												UpperCAmelCase					    =     f"""mod inverse of {a!r} and {m!r} does not exist"""
												raise ValueError(A					)
						UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase					    =     1, 0, a
						UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase					    =     0, 1, m
						while va != 0:
												UpperCAmelCase					    =     ua // va
												UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase					    =     (ua - q * va), (ua - q * va), (ua - q * va), va, va, va
						return ua % m





