



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




    '''simple docstring'''






    def 			_lowerCAmelCase					(       self		):
        A :       int          =   {
            """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},
            }
        }
        A :       Union[str, Any]          =   {
            """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		):
        A :       int          =   np.random.randn(3,		4		)
        self.assertTrue(np.allclose(transpose(lowerCamelCase__		),		x.transpose()		)		)

        A :       Tuple          =   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		):
        A :       List[str]          =   np.random.randn(3,		4		)
        A :       str          =   torch.tensor(lowerCamelCase__		)
        self.assertTrue(np.allclose(transpose(lowerCamelCase__		),		transpose(lowerCamelCase__		).numpy()		)		)

        A :       Optional[int]          =   np.random.randn(3,		4,		5		)
        A :       Optional[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		):
        A :       str          =   np.random.randn(3,		4		)
        A :       Optional[int]          =   tf.constant(lowerCamelCase__		)
        self.assertTrue(np.allclose(transpose(lowerCamelCase__		),		transpose(lowerCamelCase__		).numpy()		)		)

        A :       Optional[Any]          =   np.random.randn(3,		4,		5		)
        A :       List[Any]          =   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		):
        A :       Tuple          =   np.random.randn(3,		4		)
        A :       Optional[int]          =   jnp.array(lowerCamelCase__		)
        self.assertTrue(np.allclose(transpose(lowerCamelCase__		),		np.asarray(transpose(lowerCamelCase__		)		)		)		)

        A :       Optional[int]          =   np.random.randn(3,		4,		5		)
        A :       Optional[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		):
        A :       Optional[int]          =   np.random.randn(3,		4		)
        self.assertTrue(np.allclose(reshape(lowerCamelCase__,		(4, 3)		),		np.reshape(lowerCamelCase__,		(4, 3)		)		)		)

        A :       int          =   np.random.randn(3,		4,		5		)
        self.assertTrue(np.allclose(reshape(lowerCamelCase__,		(12, 5)		),		np.reshape(lowerCamelCase__,		(12, 5)		)		)		)






    @require_torch
    def 			_lowerCAmelCase					(       self		):
        A :       Optional[Any]          =   np.random.randn(3,		4		)
        A :       Tuple          =   torch.tensor(lowerCamelCase__		)
        self.assertTrue(np.allclose(reshape(lowerCamelCase__,		(4, 3)		),		reshape(lowerCamelCase__,		(4, 3)		).numpy()		)		)

        A :       str          =   np.random.randn(3,		4,		5		)
        A :       Optional[Any]          =   torch.tensor(lowerCamelCase__		)
        self.assertTrue(np.allclose(reshape(lowerCamelCase__,		(12, 5)		),		reshape(lowerCamelCase__,		(12, 5)		).numpy()		)		)






    @require_tf
    def 			_lowerCAmelCase					(       self		):
        A :       int          =   np.random.randn(3,		4		)
        A :       str          =   tf.constant(lowerCamelCase__		)
        self.assertTrue(np.allclose(reshape(lowerCamelCase__,		(4, 3)		),		reshape(lowerCamelCase__,		(4, 3)		).numpy()		)		)

        A :       Tuple          =   np.random.randn(3,		4,		5		)
        A :       Any          =   tf.constant(lowerCamelCase__		)
        self.assertTrue(np.allclose(reshape(lowerCamelCase__,		(12, 5)		),		reshape(lowerCamelCase__,		(12, 5)		).numpy()		)		)






    @require_flax
    def 			_lowerCAmelCase					(       self		):
        A :       Any          =   np.random.randn(3,		4		)
        A :       Optional[Any]          =   jnp.array(lowerCamelCase__		)
        self.assertTrue(np.allclose(reshape(lowerCamelCase__,		(4, 3)		),		np.asarray(reshape(lowerCamelCase__,		(4, 3)		)		)		)		)

        A :       Optional[int]          =   np.random.randn(3,		4,		5		)
        A :       Dict          =   jnp.array(lowerCamelCase__		)
        self.assertTrue(np.allclose(reshape(lowerCamelCase__,		(12, 5)		),		np.asarray(reshape(lowerCamelCase__,		(12, 5)		)		)		)		)






    def 			_lowerCAmelCase					(       self		):
        A :       str          =   np.random.randn(1,		3,		4		)
        self.assertTrue(np.allclose(squeeze(lowerCamelCase__		),		np.squeeze(lowerCamelCase__		)		)		)

        A :       str          =   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		):
        A :       List[Any]          =   np.random.randn(1,		3,		4		)
        A :       Tuple          =   torch.tensor(lowerCamelCase__		)
        self.assertTrue(np.allclose(squeeze(lowerCamelCase__		),		squeeze(lowerCamelCase__		).numpy()		)		)

        A :       Any          =   np.random.randn(1,		4,		1,		5		)
        A :       Dict          =   torch.tensor(lowerCamelCase__		)
        self.assertTrue(np.allclose(squeeze(lowerCamelCase__,		axis=2		),		squeeze(lowerCamelCase__,		axis=2		).numpy()		)		)






    @require_tf
    def 			_lowerCAmelCase					(       self		):
        A :       str          =   np.random.randn(1,		3,		4		)
        A :       int          =   tf.constant(lowerCamelCase__		)
        self.assertTrue(np.allclose(squeeze(lowerCamelCase__		),		squeeze(lowerCamelCase__		).numpy()		)		)

        A :       Dict          =   np.random.randn(1,		4,		1,		5		)
        A :       Dict          =   tf.constant(lowerCamelCase__		)
        self.assertTrue(np.allclose(squeeze(lowerCamelCase__,		axis=2		),		squeeze(lowerCamelCase__,		axis=2		).numpy()		)		)






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

        A :       Dict          =   np.random.randn(1,		4,		1,		5		)
        A :       List[Any]          =   jnp.array(lowerCamelCase__		)
        self.assertTrue(np.allclose(squeeze(lowerCamelCase__,		axis=2		),		np.asarray(squeeze(lowerCamelCase__,		axis=2		)		)		)		)






    def 			_lowerCAmelCase					(       self		):
        A :       Any          =   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		):
        A :       Optional[Any]          =   np.random.randn(3,		4		)
        A :       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		):
        A :       Optional[Any]          =   np.random.randn(3,		4		)
        A :       Tuple          =   tf.constant(lowerCamelCase__		)
        self.assertTrue(np.allclose(expand_dims(lowerCamelCase__,		axis=1		),		expand_dims(lowerCamelCase__,		axis=1		).numpy()		)		)






    @require_flax
    def 			_lowerCAmelCase					(       self		):
        A :       Tuple          =   np.random.randn(3,		4		)
        A :       int          =   jnp.array(lowerCamelCase__		)
        self.assertTrue(np.allclose(expand_dims(lowerCamelCase__,		axis=1		),		np.asarray(expand_dims(lowerCamelCase__,		axis=1		)		)		)		)









'''simple docstring'''

from collections.abc import Sequence





def lowerCamelCase						(     __lowerCamelCase :    Sequence[float]					,       __lowerCamelCase :    bool = False    )						->float:
    if not arr:
        return 0

    _SCREAMING_SNAKE_CASE									=			0 if allow_empty_subarrays else float("""-inf"""    )
    _SCREAMING_SNAKE_CASE									=			0.0
    for num in arr:
        _SCREAMING_SNAKE_CASE									=			max(0 if allow_empty_subarrays else num					,       curr_sum + num    )
        _SCREAMING_SNAKE_CASE									=			max(__lowerCamelCase					,       __lowerCamelCase    )

    return max_sum


if __name__ == "__main__":
      from doctest import testmod

      testmod()

      lowercase_					= [-2, 1, -3, 4, -1, 2, 1, -5, 4]
      print(f"""{max_subarray_sum(nums) = }""")



