






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 							lowercase__  (	self		:       List[str]    ):

								'''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 							lowercase__  (	self		:       Optional[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 							lowercase__  (	self		:       List[str]    ):

								'''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 							lowercase__  (	self		:       Union[str, 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 							lowercase__  (	self		:       Dict    ):

								'''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 							lowercase__  (	self		:       Optional[int]    ):

								'''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 							lowercase__  (	self		:       Dict    ):

								'''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 							lowercase__  (	self		:       str    ):

								'''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 							lowercase__  (	self		:       List[Any]    ):

								'''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 							lowercase__  (	self		:       Union[str, Any]    ):

								'''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 							lowercase__  (	self		:       Optional[int]    ):

								'''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 							lowercase__  (	self		:       Optional[Any]    ):

								'''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 							lowercase__  (	self		:       List[Any]    ):

								'''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 							lowercase__  (	self		:       Dict    ):

								'''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 							lowercase__  (	self		:       List[str]    ):

								'''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 							lowercase__  (	self		:       Optional[int]    ):

								'''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 							lowercase__  (	self		:       str    ):

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






				'''simple docstring'''
				lowercase__  					=     []
				for data in source_data:
								for i, el in enumerate(lowerCamelCase_							):
												if len(lowerCamelCase_							) < i + 1:
																data_lists.append([]							)
												data_lists[i].append(float(lowerCamelCase_							)							)
				return data_lists






def     a     (		lowerCamelCase_						,  lowerCamelCase_							):






				'''simple docstring'''
				lowercase__  					=     []
				for dlist, weight in zip(lowerCamelCase_						,  lowerCamelCase_							):
								lowercase__  					=     min(lowerCamelCase_							)
								lowercase__  					=     max(lowerCamelCase_							)

								lowercase__  					=     []
								# for weight 0 score is 1 - actual score
								if weight == 0:
												for item in dlist:
																try:
																				score.append(1 - ((item - mind) / (maxd - mind))							)
																except ZeroDivisionError:
																				score.append(1							)

								elif weight == 1:
												for item in dlist:
																try:
																				score.append((item - mind) / (maxd - mind)							)
																except ZeroDivisionError:
																				score.append(0							)

        # weight not 0 or 1
								else:
												lowercase__  					=     F"""Invalid weight of {weight:f} provided"""
												raise ValueError(lowerCamelCase_							)

								score_lists.append(lowerCamelCase_							)

				return score_lists






def     a     (		lowerCamelCase_							):






				'''simple docstring'''
				lowercase__  					=     [0 for i in range(len(score_lists[0]							)							)]

				for slist in score_lists:
								for j, ele in enumerate(lowerCamelCase_							):
												lowercase__  					=     final_scores[j] + ele

				return final_scores






def     a     (		lowerCamelCase_						,  lowerCamelCase_							):






				'''simple docstring'''
				lowercase__  					=     get_data(lowerCamelCase_							)
				lowercase__  					=     calculate_each_score(lowerCamelCase_						,  lowerCamelCase_							)
				lowercase__  					=     generate_final_scores(lowerCamelCase_							)

				# append scores to source data
				for i, ele in enumerate(lowerCamelCase_							):
								source_data[i].append(lowerCamelCase_							)

				return source_data




