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

 """simple docstring"""

 def      __lowerCAmelCase  (						self			:			Union[str, Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					{
          'task_specific_params': {
              'summarization': {'length_penalty': 1.0, 'max_length': 1_28, 'min_length': 12, 'num_beams': 4},
              'summarization_cnn': {'length_penalty': 2.0, 'max_length': 1_42, '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': 1_28,
          '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': 1_42,
          '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(_SCREAMING_SNAKE_CASE   )					, _SCREAMING_SNAKE_CASE   )

 def      __lowerCAmelCase  (						self			:			int   ):






      """simple docstring"""



      UpperCamelCase						    =					np.random.randn(3					, 4   )
      self.assertTrue(np.allclose(transpose(_SCREAMING_SNAKE_CASE   )					, x.transpose()   )   )

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

 @require_torch
 def      __lowerCAmelCase  (						self			:			Dict   ):






      """simple docstring"""



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

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

 @require_tf
 def      __lowerCAmelCase  (						self			:			List[str]   ):






      """simple docstring"""



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

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

 @require_flax
 def      __lowerCAmelCase  (						self			:			Union[str, Any]   ):






      """simple docstring"""



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

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

 def      __lowerCAmelCase  (						self			:			Optional[Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					np.random.randn(3					, 4   )
      self.assertTrue(np.allclose(reshape(_SCREAMING_SNAKE_CASE					, (4, 3)   )					, np.reshape(_SCREAMING_SNAKE_CASE					, (4, 3)   )   )   )

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

 @require_torch
 def      __lowerCAmelCase  (						self			:			Union[str, Any]   ):






      """simple docstring"""



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

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

 @require_tf
 def      __lowerCAmelCase  (						self			:			Union[str, Any]   ):






      """simple docstring"""



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

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

 @require_flax
 def      __lowerCAmelCase  (						self			:			Tuple   ):






      """simple docstring"""



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

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

 def      __lowerCAmelCase  (						self			:			Union[str, Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					np.random.randn(1					, 3					, 4   )
      self.assertTrue(np.allclose(squeeze(_SCREAMING_SNAKE_CASE   )					, np.squeeze(_SCREAMING_SNAKE_CASE   )   )   )

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

 @require_torch
 def      __lowerCAmelCase  (						self			:			Optional[Any]   ):






      """simple docstring"""



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

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

 @require_tf
 def      __lowerCAmelCase  (						self			:			int   ):






      """simple docstring"""



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

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

 @require_flax
 def      __lowerCAmelCase  (						self			:			Tuple   ):






      """simple docstring"""



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

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

 def      __lowerCAmelCase  (						self			:			str   ):






      """simple docstring"""



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

 @require_torch
 def      __lowerCAmelCase  (						self			:			str   ):






      """simple docstring"""



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

 @require_tf
 def      __lowerCAmelCase  (						self			:			Union[str, Any]   ):






      """simple docstring"""



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






 @require_flax
 def      __lowerCAmelCase  (						self			:			Optional[int]   ):






      """simple docstring"""



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





'''simple docstring'''



import operator


def       snake_case   (	snake_case      : list					,		snake_case      : bool = False					,		snake_case      : list | None = None			) ->  list:


    """simple docstring"""


    lowerCAmelCase 						=							operator.lt if reverse else operator.gt
    lowerCAmelCase 						=							solution or []

    if not arr:
        return solution

    lowerCAmelCase 						=							[arr.pop(0			)]
    for i, item in enumerate(snake_case			):
        if _operator(snake_case					,		sublist[-1]			):
            sublist.append(snake_case			)
            arr.pop(snake_case			)

    #  merging sublist into solution list
    if not solution:
        solution.extend(snake_case			)
    else:
        while sublist:
            lowerCAmelCase 						=							sublist.pop(0			)
            for i, xx in enumerate(snake_case			):
                if not _operator(snake_case					,		snake_case			):
                    solution.insert(snake_case					,		snake_case			)
                    break
            else:
                solution.append(snake_case			)

    strand_sort(snake_case					,		snake_case					,		snake_case			)
    return solution


if __name__ == "__main__":
     assert strand_sort([4, 3, 5, 1, 2]) == [1, 2, 3, 4, 5]
     assert strand_sort([4, 3, 5, 1, 2], reverse=True) == [5, 4, 3, 2, 1]





