




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






				'''simple docstring'''





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   {
							    """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},
							    }
							}
							lowerCamelCase      =   {
							    """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(_a					)						,					_a					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(3						,					4					)
							self.assertTrue(np.allclose(transpose(_a					)						,					x.transpose()					)					)

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





				@require_torch
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(3						,					4					)
							lowerCamelCase      =   torch.tensor(_a					)
							self.assertTrue(np.allclose(transpose(_a					)						,					transpose(_a					).numpy()					)					)

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





				@require_tf
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(3						,					4					)
							lowerCamelCase      =   tf.constant(_a					)
							self.assertTrue(np.allclose(transpose(_a					)						,					transpose(_a					).numpy()					)					)

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





				@require_flax
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(3						,					4					)
							lowerCamelCase      =   jnp.array(_a					)
							self.assertTrue(np.allclose(transpose(_a					)						,					np.asarray(transpose(_a					)					)					)					)

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





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(3						,					4					)
							self.assertTrue(np.allclose(reshape(_a						,					(4, 3)					)						,					np.reshape(_a						,					(4, 3)					)					)					)

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





				@require_torch
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(3						,					4					)
							lowerCamelCase      =   torch.tensor(_a					)
							self.assertTrue(np.allclose(reshape(_a						,					(4, 3)					)						,					reshape(_a						,					(4, 3)					).numpy()					)					)

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





				@require_tf
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(3						,					4					)
							lowerCamelCase      =   tf.constant(_a					)
							self.assertTrue(np.allclose(reshape(_a						,					(4, 3)					)						,					reshape(_a						,					(4, 3)					).numpy()					)					)

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





				@require_flax
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(3						,					4					)
							lowerCamelCase      =   jnp.array(_a					)
							self.assertTrue(np.allclose(reshape(_a						,					(4, 3)					)						,					np.asarray(reshape(_a						,					(4, 3)					)					)					)					)

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





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(1						,					3						,					4					)
							self.assertTrue(np.allclose(squeeze(_a					)						,					np.squeeze(_a					)					)					)

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





				@require_torch
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(1						,					3						,					4					)
							lowerCamelCase      =   torch.tensor(_a					)
							self.assertTrue(np.allclose(squeeze(_a					)						,					squeeze(_a					).numpy()					)					)

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





				@require_tf
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(1						,					3						,					4					)
							lowerCamelCase      =   tf.constant(_a					)
							self.assertTrue(np.allclose(squeeze(_a					)						,					squeeze(_a					).numpy()					)					)

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





				@require_flax
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(1						,					3						,					4					)
							lowerCamelCase      =   jnp.array(_a					)
							self.assertTrue(np.allclose(squeeze(_a					)						,					np.asarray(squeeze(_a					)					)					)					)

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





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(3						,					4					)
							self.assertTrue(np.allclose(expand_dims(_a						,					axis=1					)						,					np.expand_dims(_a						,					axis=1					)					)					)





				@require_torch
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(3						,					4					)
							lowerCamelCase      =   torch.tensor(_a					)
							self.assertTrue(np.allclose(expand_dims(_a						,					axis=1					)						,					expand_dims(_a						,					axis=1					).numpy()					)					)





				@require_tf
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(3						,					4					)
							lowerCamelCase      =   tf.constant(_a					)
							self.assertTrue(np.allclose(expand_dims(_a						,					axis=1					)						,					expand_dims(_a						,					axis=1					).numpy()					)					)





				@require_flax
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   np.random.randn(3						,					4					)
							lowerCamelCase      =   jnp.array(_a					)
							self.assertTrue(np.allclose(expand_dims(_a						,					axis=1					)						,					np.asarray(expand_dims(_a						,					axis=1					)					)					)					)









"""simple docstring"""




from collections.abc import Sequence



def        a__					(							snake_case__			,					snake_case__ = False							)		->   float:
			if not arr:
						return 0

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

			return max_sum


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

					testmod()

					lowerCAmelCase				:     Union[str, Any]					=				[-2, 1, -3, 4, -1, 2, 1, -5, 4]
					print(F"""{max_subarray_sum(nums) = }""")



