





import inspect
import unittest

import numpy as np

from transformers import ViTConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
					import jax

					from transformers.models.vit.modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel
class      UpperCamelCase_						(					unittest.TestCase   ):




					def __init__(						self			,  lowerCAmelCase_			,  lowerCAmelCase_=13			,  lowerCAmelCase_=30			,  lowerCAmelCase_=2			,  lowerCAmelCase_=3			,  lowerCAmelCase_=True			,  lowerCAmelCase_=True			,  lowerCAmelCase_=32			,  lowerCAmelCase_=5			,  lowerCAmelCase_=4			,  lowerCAmelCase_=37			,  lowerCAmelCase_="gelu"			,  lowerCAmelCase_=0.1			,  lowerCAmelCase_=0.1			,  lowerCAmelCase_=10			,  lowerCAmelCase_=0.02			,  )						->							List[Any]:
										_snake_case													=			parent
										_snake_case													=			batch_size
										_snake_case													=			image_size
										_snake_case													=			patch_size
										_snake_case													=			num_channels
										_snake_case													=			is_training
										_snake_case													=			use_labels
										_snake_case													=			hidden_size
										_snake_case													=			num_hidden_layers
										_snake_case													=			num_attention_heads
										_snake_case													=			intermediate_size
										_snake_case													=			hidden_act
										_snake_case													=			hidden_dropout_prob
										_snake_case													=			attention_probs_dropout_prob
										_snake_case													=			type_sequence_label_size
										_snake_case													=			initializer_range

										# in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
										_snake_case													=			(image_size // patch_size) ** 2
										_snake_case													=			num_patches + 1




					def 		lowerCAmelCase     (						self					)						->							str:
										_snake_case													=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

										_snake_case													=			ViTConfig(
										    image_size=self.image_size			,  patch_size=self.patch_size			,  num_channels=self.num_channels			,  hidden_size=self.hidden_size			,  num_hidden_layers=self.num_hidden_layers			,  num_attention_heads=self.num_attention_heads			,  intermediate_size=self.intermediate_size			,  hidden_act=self.hidden_act			,  hidden_dropout_prob=self.hidden_dropout_prob			,  attention_probs_dropout_prob=self.attention_probs_dropout_prob			,  is_decoder=lowerCAmelCase_			,  initializer_range=self.initializer_range			,  )

										return config, pixel_values




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							List[Any]:
										_snake_case													=			FlaxViTModel(config=lowerCAmelCase_					)
										_snake_case													=			model(lowerCAmelCase_					)
										# expected sequence length = num_patches + 1 (we add 1 for the [CLS] token)
										_snake_case													=			(self.image_size, self.image_size)
										_snake_case													=			(self.patch_size, self.patch_size)
										_snake_case													=			(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
										self.parent.assertEqual(result.last_hidden_state.shape			,  (self.batch_size, num_patches + 1, self.hidden_size)					)




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Dict:
										_snake_case													=			self.type_sequence_label_size
										_snake_case													=			FlaxViTForImageClassification(config=lowerCAmelCase_					)
										_snake_case													=			model(lowerCAmelCase_					)
										self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.type_sequence_label_size)					)

										# test greyscale images
										_snake_case													=			1
										_snake_case													=			FlaxViTForImageClassification(lowerCAmelCase_					)

										_snake_case													=			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
										_snake_case													=			model(lowerCAmelCase_					)






					def 		lowerCAmelCase     (						self					)						->							str:
										_snake_case													=			self.prepare_config_and_inputs()
										(
										    (
										    _snake_case
										)							,       (
										    _snake_case
										)							,       
										)													=			config_and_inputs
										_snake_case													=			{'pixel_values': pixel_values}
										return config, inputs_dict





@require_flax
class      UpperCamelCase_						(					_lowerCamelCase							,					unittest.TestCase   ):
					lowerCAmelCase_							=		(FlaxViTModel, FlaxViTForImageClassification) if is_flax_available() else ()




					def 		lowerCAmelCase     (						self					)						->							None:
										_snake_case													=			FlaxViTModelTester(self					)
										_snake_case													=			ConfigTester(self			,  config_class=lowerCAmelCase_			,  has_text_modality=lowerCAmelCase_			,  hidden_size=37					)




					def 		lowerCAmelCase     (						self					)						->							Union[str, Any]:
										self.config_tester.run_common_tests()




					def 		lowerCAmelCase     (						self					)						->							Optional[int]:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self					)						->							Union[str, Any]:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self					)						->							int:
										_snake_case							,       _snake_case													=			self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
															_snake_case													=			model_class(lowerCAmelCase_					)
															_snake_case													=			inspect.signature(model.__call__					)
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															_snake_case													=			[*signature.parameters.keys()]

															_snake_case													=			['pixel_values']
															self.assertListEqual(arg_names[:1]			,  lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self					)						->							Optional[int]:
										_snake_case							,       _snake_case													=			self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
															with self.subTest(model_class.__name__					):
																				_snake_case													=			self._prepare_for_class(lowerCAmelCase_			,  lowerCAmelCase_					)
																				_snake_case													=			model_class(lowerCAmelCase_					)

																				@jax.jit
																				def model_jitted(lowerCAmelCase_			,  **lowerCAmelCase_					):
																									return model(pixel_values=lowerCAmelCase_			,  **lowerCAmelCase_					)

																				with self.subTest('JIT Enabled'					):
																									_snake_case													=			model_jitted(**lowerCAmelCase_					).to_tuple()

																				with self.subTest('JIT Disabled'					):
																									with jax.disable_jit():
																														_snake_case													=			model_jitted(**lowerCAmelCase_					).to_tuple()

																				self.assertEqual(len(lowerCAmelCase_					)			,  len(lowerCAmelCase_					)					)
																				for jitted_output, output in zip(lowerCAmelCase_			,  lowerCAmelCase_					):
																									self.assertEqual(jitted_output.shape			,  output.shape					)






					@slow
					def 		lowerCAmelCase     (						self					)						->							Optional[int]:
										for model_class_name in self.all_model_classes:
															_snake_case													=			model_class_name.from_pretrained('google/vit-base-patch16-224'					)
															_snake_case													=			model(np.ones((1, 3, 224, 224)					)					)
															self.assertIsNotNone(lowerCAmelCase_					)










from collections.abc import Sequence





def   lowerCamelCase__       (       UpperCamelCase__     :    Sequence[float]    ,      UpperCamelCase__     :    bool = False  )     ->	float:



					'''simple docstring'''




					if not arr:
										return 0

					_snake_case													=			0 if allow_empty_subarrays else float('-inf'  )
					_snake_case													=			0.0
					for num in arr:
										_snake_case													=			max(0 if allow_empty_subarrays else num    ,      curr_sum + num  )
										_snake_case													=			max(UpperCamelCase__    ,      UpperCamelCase__  )

					return max_sum


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

					testmod()

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



