

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 					__lowerCAmelCase	(   unittest.TestCase				):




  def     A__	(							self   )    ->					List[Any]:
        '''simple docstring'''






        _lowercase      			={
            '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},
            }
        }
        _lowercase      			={
            '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]:
        '''simple docstring'''






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

        _lowercase      			=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   )    ->					Union[str, Any]:
        '''simple docstring'''






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

        _lowercase      			=np.random.randn(3				,  4				,  5   )
        _lowercase      			=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   )    ->					Any:
        '''simple docstring'''






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

        _lowercase      			=np.random.randn(3				,  4				,  5   )
        _lowercase      			=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   )    ->					List[Any]:
        '''simple docstring'''






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

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




  def     A__	(							self   )    ->					List[str]:
        '''simple docstring'''






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

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




  @require_torch
  def     A__	(							self   )    ->					Tuple:
        '''simple docstring'''






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

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




  @require_tf
  def     A__	(							self   )    ->					Any:
        '''simple docstring'''






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

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




  @require_flax
  def     A__	(							self   )    ->					str:
        '''simple docstring'''






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

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




  def     A__	(							self   )    ->					List[str]:
        '''simple docstring'''






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

        _lowercase      			=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   )    ->					Any:
        '''simple docstring'''






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

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




  @require_tf
  def     A__	(							self   )    ->					int:
        '''simple docstring'''






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

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




  @require_flax
  def     A__	(							self   )    ->					Dict:
        '''simple docstring'''






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

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




  def     A__	(							self   )    ->					str:
        '''simple docstring'''






        _lowercase      			=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   )    ->					List[Any]:
        '''simple docstring'''






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




  @require_tf
  def     A__	(							self   )    ->					Dict:
        '''simple docstring'''






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




  @require_flax
  def     A__	(							self   )    ->					Dict:
        '''simple docstring'''






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





def 	a (     A__      :  int	)       -> bool:





      """simple docstring"""



      return sum(i for i in range(1 ,  number // 2 + 1	) if number % i == 0	) == number


if __name__ == "__main__":
  print('Program to check whether a number is a Perfect number or not...')
  lowercase_   							=  int(input('Enter number: ').strip())
  print(f"{number} is {'' if perfect(number) else 'not '}a Perfect Number.")


