
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 				lowerCAmelCase      (self			: Union[str, Any]       ):
    __a			:  Any		    =  {
        '''task_specific_params''': {
            '''summarization''': {'''length_penalty''': 1.0, '''max_length''': 1_2_8, '''min_length''': 1_2, '''num_beams''': 4},
            '''summarization_cnn''': {'''length_penalty''': 2.0, '''max_length''': 1_4_2, '''min_length''': 5_6, '''num_beams''': 4},
            '''summarization_xsum''': {'''length_penalty''': 1.0, '''max_length''': 6_2, '''min_length''': 1_1, '''num_beams''': 6},
        }
    }
    __a			:  Tuple		    =  {
        '''task_specific_params.summarization.length_penalty''': 1.0,
        '''task_specific_params.summarization.max_length''': 1_2_8,
        '''task_specific_params.summarization.min_length''': 1_2,
        '''task_specific_params.summarization.num_beams''': 4,
        '''task_specific_params.summarization_cnn.length_penalty''': 2.0,
        '''task_specific_params.summarization_cnn.max_length''': 1_4_2,
        '''task_specific_params.summarization_cnn.min_length''': 5_6,
        '''task_specific_params.summarization_cnn.num_beams''': 4,
        '''task_specific_params.summarization_xsum.length_penalty''': 1.0,
        '''task_specific_params.summarization_xsum.max_length''': 6_2,
        '''task_specific_params.summarization_xsum.min_length''': 1_1,
        '''task_specific_params.summarization_xsum.num_beams''': 6,
    }

    self.assertEqual(flatten_dict(snake_case_       ) ,    snake_case_       )
   def 				lowerCAmelCase      (self			: Tuple       ):
    __a			:  List[Any]		    =  np.random.randn(3 ,    4       )
    self.assertTrue(np.allclose(transpose(snake_case_       ) ,    x.transpose()       )       )

    __a			:  Union[str, Any]		    =  np.random.randn(3 ,    4 ,    5       )
    self.assertTrue(np.allclose(transpose(snake_case_ ,    axes=(1, 2, 0)       ) ,    x.transpose((1, 2, 0)       )       )       )
   @require_torch
   def 				lowerCAmelCase      (self			: str       ):
    __a			:  List[Any]		    =  np.random.randn(3 ,    4       )
    __a			:  str		    =  torch.tensor(snake_case_       )
    self.assertTrue(np.allclose(transpose(snake_case_       ) ,    transpose(snake_case_       ).numpy()       )       )

    __a			:  Optional[Any]		    =  np.random.randn(3 ,    4 ,    5       )
    __a			:  Any		    =  torch.tensor(snake_case_       )
    self.assertTrue(np.allclose(transpose(snake_case_ ,    axes=(1, 2, 0)       ) ,    transpose(snake_case_ ,    axes=(1, 2, 0)       ).numpy()       )       )
   @require_tf
   def 				lowerCAmelCase      (self			: Any       ):
    __a			:  Any		    =  np.random.randn(3 ,    4       )
    __a			:  int		    =  tf.constant(snake_case_       )
    self.assertTrue(np.allclose(transpose(snake_case_       ) ,    transpose(snake_case_       ).numpy()       )       )

    __a			:  Optional[Any]		    =  np.random.randn(3 ,    4 ,    5       )
    __a			:  Dict		    =  tf.constant(snake_case_       )
    self.assertTrue(np.allclose(transpose(snake_case_ ,    axes=(1, 2, 0)       ) ,    transpose(snake_case_ ,    axes=(1, 2, 0)       ).numpy()       )       )
   @require_flax
   def 				lowerCAmelCase      (self			: Union[str, Any]       ):
    __a			:  Optional[Any]		    =  np.random.randn(3 ,    4       )
    __a			:  List[str]		    =  jnp.array(snake_case_       )
    self.assertTrue(np.allclose(transpose(snake_case_       ) ,    np.asarray(transpose(snake_case_       )       )       )       )

    __a			:  int		    =  np.random.randn(3 ,    4 ,    5       )
    __a			:  Optional[int]		    =  jnp.array(snake_case_       )
    self.assertTrue(np.allclose(transpose(snake_case_ ,    axes=(1, 2, 0)       ) ,    np.asarray(transpose(snake_case_ ,    axes=(1, 2, 0)       )       )       )       )
   def 				lowerCAmelCase      (self			: int       ):
    __a			:  Optional[Any]		    =  np.random.randn(3 ,    4       )
    self.assertTrue(np.allclose(reshape(snake_case_ ,    (4, 3)       ) ,    np.reshape(snake_case_ ,    (4, 3)       )       )       )

    __a			:  Any		    =  np.random.randn(3 ,    4 ,    5       )
    self.assertTrue(np.allclose(reshape(snake_case_ ,    (1_2, 5)       ) ,    np.reshape(snake_case_ ,    (1_2, 5)       )       )       )
   @require_torch
   def 				lowerCAmelCase      (self			: int       ):
    __a			:  Union[str, Any]		    =  np.random.randn(3 ,    4       )
    __a			:  str		    =  torch.tensor(snake_case_       )
    self.assertTrue(np.allclose(reshape(snake_case_ ,    (4, 3)       ) ,    reshape(snake_case_ ,    (4, 3)       ).numpy()       )       )

    __a			:  List[Any]		    =  np.random.randn(3 ,    4 ,    5       )
    __a			:  int		    =  torch.tensor(snake_case_       )
    self.assertTrue(np.allclose(reshape(snake_case_ ,    (1_2, 5)       ) ,    reshape(snake_case_ ,    (1_2, 5)       ).numpy()       )       )
   @require_tf
   def 				lowerCAmelCase      (self			: Optional[int]       ):
    __a			:  Union[str, Any]		    =  np.random.randn(3 ,    4       )
    __a			:  Dict		    =  tf.constant(snake_case_       )
    self.assertTrue(np.allclose(reshape(snake_case_ ,    (4, 3)       ) ,    reshape(snake_case_ ,    (4, 3)       ).numpy()       )       )

    __a			:  Tuple		    =  np.random.randn(3 ,    4 ,    5       )
    __a			:  Optional[Any]		    =  tf.constant(snake_case_       )
    self.assertTrue(np.allclose(reshape(snake_case_ ,    (1_2, 5)       ) ,    reshape(snake_case_ ,    (1_2, 5)       ).numpy()       )       )
   @require_flax
   def 				lowerCAmelCase      (self			: str       ):
    __a			:  Optional[Any]		    =  np.random.randn(3 ,    4       )
    __a			:  List[Any]		    =  jnp.array(snake_case_       )
    self.assertTrue(np.allclose(reshape(snake_case_ ,    (4, 3)       ) ,    np.asarray(reshape(snake_case_ ,    (4, 3)       )       )       )       )

    __a			:  Any		    =  np.random.randn(3 ,    4 ,    5       )
    __a			:  Optional[Any]		    =  jnp.array(snake_case_       )
    self.assertTrue(np.allclose(reshape(snake_case_ ,    (1_2, 5)       ) ,    np.asarray(reshape(snake_case_ ,    (1_2, 5)       )       )       )       )
   def 				lowerCAmelCase      (self			: Optional[int]       ):
    __a			:  str		    =  np.random.randn(1 ,    3 ,    4       )
    self.assertTrue(np.allclose(squeeze(snake_case_       ) ,    np.squeeze(snake_case_       )       )       )

    __a			:  Dict		    =  np.random.randn(1 ,    4 ,    1 ,    5       )
    self.assertTrue(np.allclose(squeeze(snake_case_ ,    axis=2       ) ,    np.squeeze(snake_case_ ,    axis=2       )       )       )
   @require_torch
   def 				lowerCAmelCase      (self			: Union[str, Any]       ):
    __a			:  Optional[int]		    =  np.random.randn(1 ,    3 ,    4       )
    __a			:  List[Any]		    =  torch.tensor(snake_case_       )
    self.assertTrue(np.allclose(squeeze(snake_case_       ) ,    squeeze(snake_case_       ).numpy()       )       )

    __a			:  Tuple		    =  np.random.randn(1 ,    4 ,    1 ,    5       )
    __a			:  Optional[int]		    =  torch.tensor(snake_case_       )
    self.assertTrue(np.allclose(squeeze(snake_case_ ,    axis=2       ) ,    squeeze(snake_case_ ,    axis=2       ).numpy()       )       )
   @require_tf
   def 				lowerCAmelCase      (self			: int       ):
    __a			:  str		    =  np.random.randn(1 ,    3 ,    4       )
    __a			:  int		    =  tf.constant(snake_case_       )
    self.assertTrue(np.allclose(squeeze(snake_case_       ) ,    squeeze(snake_case_       ).numpy()       )       )

    __a			:  Optional[Any]		    =  np.random.randn(1 ,    4 ,    1 ,    5       )
    __a			:  Any		    =  tf.constant(snake_case_       )
    self.assertTrue(np.allclose(squeeze(snake_case_ ,    axis=2       ) ,    squeeze(snake_case_ ,    axis=2       ).numpy()       )       )
   @require_flax
   def 				lowerCAmelCase      (self			: Optional[Any]       ):
    __a			:  Tuple		    =  np.random.randn(1 ,    3 ,    4       )
    __a			:  str		    =  jnp.array(snake_case_       )
    self.assertTrue(np.allclose(squeeze(snake_case_       ) ,    np.asarray(squeeze(snake_case_       )       )       )       )

    __a			:  Union[str, Any]		    =  np.random.randn(1 ,    4 ,    1 ,    5       )
    __a			:  Dict		    =  jnp.array(snake_case_       )
    self.assertTrue(np.allclose(squeeze(snake_case_ ,    axis=2       ) ,    np.asarray(squeeze(snake_case_ ,    axis=2       )       )       )       )
   def 				lowerCAmelCase      (self			: int       ):
    __a			:  Any		    =  np.random.randn(3 ,    4       )
    self.assertTrue(np.allclose(expand_dims(snake_case_ ,    axis=1       ) ,    np.expand_dims(snake_case_ ,    axis=1       )       )       )
   @require_torch
   def 				lowerCAmelCase      (self			: str       ):
    __a			:  Dict		    =  np.random.randn(3 ,    4       )
    __a			:  Any		    =  torch.tensor(snake_case_       )
    self.assertTrue(np.allclose(expand_dims(snake_case_ ,    axis=1       ) ,    expand_dims(snake_case_ ,    axis=1       ).numpy()       )       )
   @require_tf
   def 				lowerCAmelCase      (self			: Optional[int]       ):
    __a			:  Union[str, Any]		    =  np.random.randn(3 ,    4       )
    __a			:  Optional[Any]		    =  tf.constant(snake_case_       )
    self.assertTrue(np.allclose(expand_dims(snake_case_ ,    axis=1       ) ,    expand_dims(snake_case_ ,    axis=1       ).numpy()       )       )







   @require_flax
   def 				lowerCAmelCase      (self			: Tuple       ):
    __a			:  Dict		    =  np.random.randn(3 ,    4       )
    __a			:  str		    =  jnp.array(snake_case_       )
    self.assertTrue(np.allclose(expand_dims(snake_case_ ,    axis=1       ) ,    np.asarray(expand_dims(snake_case_ ,    axis=1       )       )       )       )


from transformers import BertTokenizerFast

from .custom_tokenization import CustomTokenizer



class 		UpperCamelCase__  (	__lowercase   ):
   _SCREAMING_SNAKE_CASE				:							Union[str, Any]     	=				CustomTokenizer
   pass
