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





       '''simple docstring'''



       def _lowerCAmelCase(						self			)  ->  Optional[Any]:
        lowercase__    :   Tuple						= {
            '''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__    :   List[str]						= {
            '''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 _lowerCAmelCase(						self			)  ->  List[str]:
        lowercase__    :   Dict						= np.random.randn(3     ,       4			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase			)     ,       x.transpose()			)			)

        lowercase__    :   Any						= np.random.randn(3     ,       4     ,       5			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			)     ,       x.transpose((1, 2, 0)			)			)			)

       @require_torch
       def _lowerCAmelCase(						self			)  ->  Any:
        lowercase__    :   Dict						= np.random.randn(3     ,       4			)
        lowercase__    :   Dict						= torch.tensor(__lowerCAmelCase			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase			)     ,       transpose(__lowerCAmelCase			).numpy()			)			)

        lowercase__    :   Optional[int]						= np.random.randn(3     ,       4     ,       5			)
        lowercase__    :   Union[str, Any]						= torch.tensor(__lowerCAmelCase			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			)     ,       transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			).numpy()			)			)

       @require_tf
       def _lowerCAmelCase(						self			)  ->  Optional[Any]:
        lowercase__    :   Optional[int]						= np.random.randn(3     ,       4			)
        lowercase__    :   Union[str, Any]						= tf.constant(__lowerCAmelCase			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase			)     ,       transpose(__lowerCAmelCase			).numpy()			)			)

        lowercase__    :   int						= np.random.randn(3     ,       4     ,       5			)
        lowercase__    :   str						= tf.constant(__lowerCAmelCase			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			)     ,       transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			).numpy()			)			)

       @require_flax
       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   int						= np.random.randn(3     ,       4			)
        lowercase__    :   Union[str, Any]						= jnp.array(__lowerCAmelCase			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase			)     ,       np.asarray(transpose(__lowerCAmelCase			)			)			)			)

        lowercase__    :   Optional[Any]						= np.random.randn(3     ,       4     ,       5			)
        lowercase__    :   Union[str, Any]						= jnp.array(__lowerCAmelCase			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			)     ,       np.asarray(transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			)			)			)			)

       def _lowerCAmelCase(						self			)  ->  Tuple:
        lowercase__    :   List[Any]						= np.random.randn(3     ,       4			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (4, 3)			)     ,       np.reshape(__lowerCAmelCase     ,       (4, 3)			)			)			)

        lowercase__    :   str						= np.random.randn(3     ,       4     ,       5			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (12, 5)			)     ,       np.reshape(__lowerCAmelCase     ,       (12, 5)			)			)			)

       @require_torch
       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   str						= np.random.randn(3     ,       4			)
        lowercase__    :   Tuple						= torch.tensor(__lowerCAmelCase			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (4, 3)			)     ,       reshape(__lowerCAmelCase     ,       (4, 3)			).numpy()			)			)

        lowercase__    :   List[str]						= np.random.randn(3     ,       4     ,       5			)
        lowercase__    :   Union[str, Any]						= torch.tensor(__lowerCAmelCase			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (12, 5)			)     ,       reshape(__lowerCAmelCase     ,       (12, 5)			).numpy()			)			)

       @require_tf
       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   int						= np.random.randn(3     ,       4			)
        lowercase__    :   Optional[int]						= tf.constant(__lowerCAmelCase			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (4, 3)			)     ,       reshape(__lowerCAmelCase     ,       (4, 3)			).numpy()			)			)

        lowercase__    :   Optional[Any]						= np.random.randn(3     ,       4     ,       5			)
        lowercase__    :   Optional[Any]						= tf.constant(__lowerCAmelCase			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (12, 5)			)     ,       reshape(__lowerCAmelCase     ,       (12, 5)			).numpy()			)			)

       @require_flax
       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   Optional[Any]						= np.random.randn(3     ,       4			)
        lowercase__    :   Any						= jnp.array(__lowerCAmelCase			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (4, 3)			)     ,       np.asarray(reshape(__lowerCAmelCase     ,       (4, 3)			)			)			)			)

        lowercase__    :   Optional[Any]						= np.random.randn(3     ,       4     ,       5			)
        lowercase__    :   Tuple						= jnp.array(__lowerCAmelCase			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (12, 5)			)     ,       np.asarray(reshape(__lowerCAmelCase     ,       (12, 5)			)			)			)			)

       def _lowerCAmelCase(						self			)  ->  int:
        lowercase__    :   str						= np.random.randn(1     ,       3     ,       4			)
        self.assertTrue(np.allclose(squeeze(__lowerCAmelCase			)     ,       np.squeeze(__lowerCAmelCase			)			)			)

        lowercase__    :   int						= np.random.randn(1     ,       4     ,       1     ,       5			)
        self.assertTrue(np.allclose(squeeze(__lowerCAmelCase     ,       axis=2			)     ,       np.squeeze(__lowerCAmelCase     ,       axis=2			)			)			)

       @require_torch
       def _lowerCAmelCase(						self			)  ->  Optional[Any]:
        lowercase__    :   Optional[int]						= np.random.randn(1     ,       3     ,       4			)
        lowercase__    :   Union[str, Any]						= torch.tensor(__lowerCAmelCase			)
        self.assertTrue(np.allclose(squeeze(__lowerCAmelCase			)     ,       squeeze(__lowerCAmelCase			).numpy()			)			)

        lowercase__    :   Optional[int]						= np.random.randn(1     ,       4     ,       1     ,       5			)
        lowercase__    :   Optional[Any]						= torch.tensor(__lowerCAmelCase			)
        self.assertTrue(np.allclose(squeeze(__lowerCAmelCase     ,       axis=2			)     ,       squeeze(__lowerCAmelCase     ,       axis=2			).numpy()			)			)

       @require_tf
       def _lowerCAmelCase(						self			)  ->  Optional[Any]:
        lowercase__    :   Dict						= np.random.randn(1     ,       3     ,       4			)
        lowercase__    :   int						= tf.constant(__lowerCAmelCase			)
        self.assertTrue(np.allclose(squeeze(__lowerCAmelCase			)     ,       squeeze(__lowerCAmelCase			).numpy()			)			)

        lowercase__    :   Optional[Any]						= np.random.randn(1     ,       4     ,       1     ,       5			)
        lowercase__    :   Dict						= tf.constant(__lowerCAmelCase			)
        self.assertTrue(np.allclose(squeeze(__lowerCAmelCase     ,       axis=2			)     ,       squeeze(__lowerCAmelCase     ,       axis=2			).numpy()			)			)

       @require_flax
       def _lowerCAmelCase(						self			)  ->  Any:
        lowercase__    :   int						= np.random.randn(1     ,       3     ,       4			)
        lowercase__    :   List[str]						= jnp.array(__lowerCAmelCase			)
        self.assertTrue(np.allclose(squeeze(__lowerCAmelCase			)     ,       np.asarray(squeeze(__lowerCAmelCase			)			)			)			)

        lowercase__    :   Union[str, Any]						= np.random.randn(1     ,       4     ,       1     ,       5			)
        lowercase__    :   Tuple						= jnp.array(__lowerCAmelCase			)
        self.assertTrue(np.allclose(squeeze(__lowerCAmelCase     ,       axis=2			)     ,       np.asarray(squeeze(__lowerCAmelCase     ,       axis=2			)			)			)			)

       def _lowerCAmelCase(						self			)  ->  Dict:
        lowercase__    :   Dict						= np.random.randn(3     ,       4			)
        self.assertTrue(np.allclose(expand_dims(__lowerCAmelCase     ,       axis=1			)     ,       np.expand_dims(__lowerCAmelCase     ,       axis=1			)			)			)

       @require_torch
       def _lowerCAmelCase(						self			)  ->  Any:
        lowercase__    :   Any						= np.random.randn(3     ,       4			)
        lowercase__    :   Optional[Any]						= torch.tensor(__lowerCAmelCase			)
        self.assertTrue(np.allclose(expand_dims(__lowerCAmelCase     ,       axis=1			)     ,       expand_dims(__lowerCAmelCase     ,       axis=1			).numpy()			)			)

       @require_tf
       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   str						= np.random.randn(3     ,       4			)
        lowercase__    :   List[str]						= tf.constant(__lowerCAmelCase			)
        self.assertTrue(np.allclose(expand_dims(__lowerCAmelCase     ,       axis=1			)     ,       expand_dims(__lowerCAmelCase     ,       axis=1			).numpy()			)			)


       @require_flax
       def _lowerCAmelCase(						self			)  ->  Tuple:
        lowercase__    :   Dict						= np.random.randn(3     ,       4			)
        lowercase__    :   List[str]						= jnp.array(__lowerCAmelCase			)
        self.assertTrue(np.allclose(expand_dims(__lowerCAmelCase     ,       axis=1			)     ,       np.asarray(expand_dims(__lowerCAmelCase     ,       axis=1			)			)			)			)


'''simple docstring'''

import unittest

from datasets import load_dataset

from transformers.pipelines import pipeline
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_torch, slow



@is_pipeline_test
@require_torch
class       UpperCAmelCase  (						unittest.TestCase ):





       '''simple docstring'''



       @require_torch
       def _lowerCAmelCase(						self			)  ->  int:
        lowercase__    :   str						= pipeline(
            task='''zero-shot-audio-classification'''     ,       model='''hf-internal-testing/tiny-clap-htsat-unfused'''			)
        lowercase__    :   Optional[Any]						= load_dataset('''ashraq/esc50'''			)
        lowercase__    :   Tuple						= dataset['''train''']['''audio'''][-1]['''array''']
        lowercase__    :   Optional[Any]						= audio_classifier(__lowerCAmelCase     ,       candidate_labels=['''Sound of a dog''', '''Sound of vaccum cleaner''']			)
        self.assertEqual(
            nested_simplify(__lowerCAmelCase			)     ,       [{'''score''': 0.5_0_1, '''label''': '''Sound of a dog'''}, {'''score''': 0.4_9_9, '''label''': '''Sound of vaccum cleaner'''}]     ,       )

       @unittest.skip('''No models are available in TF'''			)
       def _lowerCAmelCase(						self			)  ->  str:
        pass

       @slow
       @require_torch
       def _lowerCAmelCase(						self			)  ->  Tuple:
        lowercase__    :   List[str]						= pipeline(
            task='''zero-shot-audio-classification'''     ,       model='''laion/clap-htsat-unfused'''     ,       )
        # This is an audio of a dog
        lowercase__    :   int						= load_dataset('''ashraq/esc50'''			)
        lowercase__    :   str						= dataset['''train''']['''audio'''][-1]['''array''']
        lowercase__    :   Any						= audio_classifier(__lowerCAmelCase     ,       candidate_labels=['''Sound of a dog''', '''Sound of vaccum cleaner''']			)

        self.assertEqual(
            nested_simplify(__lowerCAmelCase			)     ,       [
                {'''score''': 0.9_9_9, '''label''': '''Sound of a dog'''},
                {'''score''': 0.0_0_1, '''label''': '''Sound of vaccum cleaner'''},
            ]     ,       )

        lowercase__    :   Dict						= audio_classifier([audio] * 5     ,       candidate_labels=['''Sound of a dog''', '''Sound of vaccum cleaner''']			)
        self.assertEqual(
            nested_simplify(__lowerCAmelCase			)     ,       [
                [
                    {'''score''': 0.9_9_9, '''label''': '''Sound of a dog'''},
                    {'''score''': 0.0_0_1, '''label''': '''Sound of vaccum cleaner'''},
                ],
            ]
            * 5     ,       )
        lowercase__    :   Any						= audio_classifier(
            [audio] * 5     ,       candidate_labels=['''Sound of a dog''', '''Sound of vaccum cleaner''']     ,       batch_size=5			)
        self.assertEqual(
            nested_simplify(__lowerCAmelCase			)     ,       [
                [
                    {'''score''': 0.9_9_9, '''label''': '''Sound of a dog'''},
                    {'''score''': 0.0_0_1, '''label''': '''Sound of vaccum cleaner'''},
                ],
            ]
            * 5     ,       )


       @unittest.skip('''No models are available in TF'''			)
       def _lowerCAmelCase(						self			)  ->  Union[str, Any]:
        pass

