



'''simple docstring'''
import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_flax_cross_test,
    require_flax,
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import is_flax_available, is_torch_available, is_vision_available

from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_flax_bert import FlaxBertModelTester
from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester
from ..vit.test_modeling_flax_vit import FlaxViTModelTester


if is_flax_available():
					from transformers import (
					    FlaxBertModel,
					    FlaxCLIPVisionModel,
					    FlaxVisionTextDualEncoderModel,
					    FlaxViTModel,
					    VisionTextDualEncoderConfig,
					    VisionTextDualEncoderProcessor,
					)
					from transformers.modeling_flax_pytorch_utils import (
					    convert_pytorch_state_dict_to_flax,
					    load_flax_weights_in_pytorch_model,
					)


if is_torch_available():
					import torch

					from transformers import VisionTextDualEncoderModel

if is_vision_available():
					from PIL import Image






def A__    (     UpperCAmelCase_							):
						if isinstance(UpperCAmelCase_  ,  collections.abc.Iterable							):
												return x
						return (x, x)






@require_flax
class 							lowercase__	:





	def 	UpperCamelCase_  ( self					:				Dict ,lowerCamelCase__					:				Union[str, Any] ,lowerCamelCase__					:				Union[str, Any] ):







							'''simple docstring'''
							pass





	def 	UpperCamelCase_  ( self					:				Dict ):







							'''simple docstring'''
							pass





	def 	UpperCamelCase_  ( self					:				List[Any] ):







							'''simple docstring'''
							pass





	def 	UpperCamelCase_  ( self					:				Any ,lowerCamelCase__					:				np.ndarray ,lowerCamelCase__					:				np.ndarray ,lowerCamelCase__					:				float ):







							'''simple docstring'''
							_UpperCamelCase					:		int 				=   np.abs((a - b) ).max()
							self.assertLessEqual(lowerCamelCase__ ,lowerCamelCase__ ,F'Difference between torch and flax is {diff} (>= {tol}).' )





	def 	UpperCamelCase_  ( self					:				Optional[Any] ,lowerCamelCase__					:				List[Any] ,lowerCamelCase__					:				Optional[Any] ,lowerCamelCase__					:				Optional[Any] ,lowerCamelCase__					:				Optional[int] ,lowerCamelCase__					:				Any=None ,**lowerCamelCase__					:				List[Any] ):







							'''simple docstring'''
							_UpperCamelCase					:		Optional[Any] 				=   VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase__ ,lowerCamelCase__ )

							_UpperCamelCase					:		int 				=   FlaxVisionTextDualEncoderModel(lowerCamelCase__ )

							_UpperCamelCase					:		List[Any] 				=   model(input_ids=lowerCamelCase__ ,pixel_values=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )

							self.assertEqual(output['text_embeds'].shape ,(input_ids.shape[0], config.projection_dim) )
							self.assertEqual(output['image_embeds'].shape ,(pixel_values.shape[0], config.projection_dim) )





	def 	UpperCamelCase_  ( self					:				List[str] ,lowerCamelCase__					:				Tuple ,lowerCamelCase__					:				Optional[int] ,lowerCamelCase__					:				str ,lowerCamelCase__					:				Optional[int] ,lowerCamelCase__					:				Any=None ,**lowerCamelCase__					:				Optional[int] ):







							'''simple docstring'''
							_UpperCamelCase				,			_UpperCamelCase					:		List[Any] 				=   self.get_vision_text_model(lowerCamelCase__ ,lowerCamelCase__ )
							_UpperCamelCase					:		Optional[int] 				=   {'vision_model': vision_model, 'text_model': text_model}
							_UpperCamelCase					:		Union[str, Any] 				=   FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase__ )

							_UpperCamelCase					:		Dict 				=   model(input_ids=lowerCamelCase__ ,pixel_values=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )

							self.assertEqual(output['text_embeds'].shape ,(input_ids.shape[0], model.config.projection_dim) )
							self.assertEqual(output['image_embeds'].shape ,(pixel_values.shape[0], model.config.projection_dim) )





	def 	UpperCamelCase_  ( self					:				str ,lowerCamelCase__					:				List[str] ,lowerCamelCase__					:				List[str] ,lowerCamelCase__					:				Optional[int] ,lowerCamelCase__					:				Union[str, Any] ,lowerCamelCase__					:				Dict=None ,**lowerCamelCase__					:				Optional[int] ):







							'''simple docstring'''
							_UpperCamelCase				,			_UpperCamelCase					:		Union[str, Any] 				=   self.get_vision_text_model(lowerCamelCase__ ,lowerCamelCase__ )
							_UpperCamelCase					:		Dict 				=   {'vision_model': vision_model, 'text_model': text_model}
							_UpperCamelCase					:		str 				=   FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase__ )

							_UpperCamelCase					:		int 				=   model(input_ids=lowerCamelCase__ ,pixel_values=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )
							_UpperCamelCase					:		Dict 				=   output[0]

							with tempfile.TemporaryDirectory() as tmpdirname:
													model.save_pretrained(lowerCamelCase__ )
													_UpperCamelCase					:		Any 				=   FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase__ )

													_UpperCamelCase					:		Optional[int] 				=   model(input_ids=lowerCamelCase__ ,pixel_values=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )
													_UpperCamelCase					:		str 				=   after_output[0]
													_UpperCamelCase					:		Any 				=   np.amax(np.abs(out_a - out_a ) )
													self.assertLessEqual(lowerCamelCase__ ,1E-3 )





	def 	UpperCamelCase_  ( self					:				List[Any] ,lowerCamelCase__					:				List[str] ,lowerCamelCase__					:				int ,lowerCamelCase__					:				Optional[Any] ,lowerCamelCase__					:				Any ,lowerCamelCase__					:				Optional[int]=None ,**lowerCamelCase__					:				Tuple ):







							'''simple docstring'''
							_UpperCamelCase				,			_UpperCamelCase					:		Optional[int] 				=   self.get_vision_text_model(lowerCamelCase__ ,lowerCamelCase__ )
							_UpperCamelCase					:		Any 				=   {'vision_model': vision_model, 'text_model': text_model}
							_UpperCamelCase					:		Any 				=   FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase__ )

							_UpperCamelCase					:		Tuple 				=   model(
							    input_ids=lowerCamelCase__ ,pixel_values=lowerCamelCase__ ,attention_mask=lowerCamelCase__ ,output_attentions=lowerCamelCase__ )

							_UpperCamelCase					:		Dict 				=   output.vision_model_output.attentions
							self.assertEqual(len(lowerCamelCase__ ) ,vision_config.num_hidden_layers )

							# in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
							_UpperCamelCase					:		Any 				=   to_atuple(vision_model.config.image_size )
							_UpperCamelCase					:		List[Any] 				=   to_atuple(vision_model.config.patch_size )
							_UpperCamelCase					:		Dict 				=   (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
							_UpperCamelCase					:		Any 				=   num_patches + 1
							self.assertEqual(vision_attentions[0].shape[-3:] ,(vision_config.num_attention_heads, seq_len, seq_len) )

							_UpperCamelCase					:		Union[str, Any] 				=   output.text_model_output.attentions
							self.assertEqual(len(lowerCamelCase__ ) ,text_config.num_hidden_layers )

							self.assertEqual(
							    text_attentions[0].shape[-3:] ,(text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]) ,)





	def 	UpperCamelCase_  ( self					:				List[str] ,lowerCamelCase__					:				str ,lowerCamelCase__					:				Tuple ,lowerCamelCase__					:				Union[str, Any] ):







							'''simple docstring'''
							pt_model.to(lowerCamelCase__ )
							pt_model.eval()

							# prepare inputs
							_UpperCamelCase					:		Dict 				=   inputs_dict
							_UpperCamelCase					:		List[Any] 				=   {k: torch.tensor(v.tolist() ) for k, v in flax_inputs.items()}

							with torch.no_grad():
													_UpperCamelCase					:		str 				=   pt_model(**lowerCamelCase__ ).to_tuple()

							_UpperCamelCase					:		Dict 				=   fx_model(**lowerCamelCase__ ).to_tuple()
							self.assertEqual(len(lowerCamelCase__ ) ,len(lowerCamelCase__ ) ,'Output lengths differ between Flax and PyTorch' )
							for fx_output, pt_output in zip(fx_outputs[:4] ,pt_outputs[:4] ):
													self.assert_almost_equals(lowerCamelCase__ ,pt_output.numpy() ,4E-2 )

							# PT -> Flax
							with tempfile.TemporaryDirectory() as tmpdirname:
													pt_model.save_pretrained(lowerCamelCase__ )
													_UpperCamelCase					:		List[str] 				=   FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase__ ,from_pt=lowerCamelCase__ )

							_UpperCamelCase					:		int 				=   fx_model_loaded(**lowerCamelCase__ ).to_tuple()
							self.assertEqual(len(lowerCamelCase__ ) ,len(lowerCamelCase__ ) ,'Output lengths differ between Flax and PyTorch' )
							for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4] ,pt_outputs[:4] ):
													self.assert_almost_equals(lowerCamelCase__ ,pt_output.numpy() ,4E-2 )

							# Flax -> PT
							with tempfile.TemporaryDirectory() as tmpdirname:
													fx_model.save_pretrained(lowerCamelCase__ )
													_UpperCamelCase					:		Dict 				=   VisionTextDualEncoderModel.from_pretrained(lowerCamelCase__ ,from_flax=lowerCamelCase__ )

							pt_model_loaded.to(lowerCamelCase__ )
							pt_model_loaded.eval()

							with torch.no_grad():
													_UpperCamelCase					:		Tuple 				=   pt_model_loaded(**lowerCamelCase__ ).to_tuple()

							self.assertEqual(len(lowerCamelCase__ ) ,len(lowerCamelCase__ ) ,'Output lengths differ between Flax and PyTorch' )
							for fx_output, pt_output_loaded in zip(fx_outputs[:4] ,pt_outputs_loaded[:4] ):
													self.assert_almost_equals(lowerCamelCase__ ,pt_output_loaded.numpy() ,4E-2 )





	def 	UpperCamelCase_  ( self					:				Optional[Any] ,lowerCamelCase__					:				int ,lowerCamelCase__					:				Optional[Any] ,lowerCamelCase__					:				List[str] ):







							'''simple docstring'''
							_UpperCamelCase					:		Dict 				=   VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase__ ,lowerCamelCase__ )

							_UpperCamelCase					:		Optional[Any] 				=   VisionTextDualEncoderModel(lowerCamelCase__ )
							_UpperCamelCase					:		Optional[int] 				=   FlaxVisionTextDualEncoderModel(lowerCamelCase__ )

							_UpperCamelCase					:		str 				=   convert_pytorch_state_dict_to_flax(pt_model.state_dict() ,lowerCamelCase__ )
							_UpperCamelCase					:		Optional[int] 				=   fx_state

							self.check_pt_flax_equivalence(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )





	def 	UpperCamelCase_  ( self					:				Union[str, Any] ,lowerCamelCase__					:				Optional[Any] ,lowerCamelCase__					:				str ,lowerCamelCase__					:				Dict ):







							'''simple docstring'''
							_UpperCamelCase					:		List[Any] 				=   VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase__ ,lowerCamelCase__ )

							_UpperCamelCase					:		Any 				=   VisionTextDualEncoderModel(lowerCamelCase__ )
							_UpperCamelCase					:		Optional[Any] 				=   FlaxVisionTextDualEncoderModel(lowerCamelCase__ )

							_UpperCamelCase					:		Optional[int] 				=   load_flax_weights_in_pytorch_model(lowerCamelCase__ ,fx_model.params )

							self.check_pt_flax_equivalence(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )





	def 	UpperCamelCase_  ( self					:				int ):







							'''simple docstring'''
							_UpperCamelCase					:		Any 				=   self.prepare_config_and_inputs()
							self.check_model_from_pretrained_configs(**lowerCamelCase__ )





	def 	UpperCamelCase_  ( self					:				Optional[int] ):







							'''simple docstring'''
							_UpperCamelCase					:		Any 				=   self.prepare_config_and_inputs()
							self.check_vision_text_dual_encoder_from_pretrained(**lowerCamelCase__ )





	def 	UpperCamelCase_  ( self					:				Any ):







							'''simple docstring'''
							_UpperCamelCase					:		int 				=   self.prepare_config_and_inputs()
							self.check_save_load(**lowerCamelCase__ )





	def 	UpperCamelCase_  ( self					:				Tuple ):







							'''simple docstring'''
							_UpperCamelCase					:		Union[str, Any] 				=   self.prepare_config_and_inputs()
							self.check_vision_text_output_attention(**lowerCamelCase__ )





	@is_pt_flax_cross_test
	def 	UpperCamelCase_  ( self					:				Union[str, Any] ):







							'''simple docstring'''
							_UpperCamelCase					:		str 				=   self.prepare_config_and_inputs()
							_UpperCamelCase					:		List[Any] 				=   config_inputs_dict.pop('vision_config' )
							_UpperCamelCase					:		int 				=   config_inputs_dict.pop('text_config' )

							_UpperCamelCase					:		str 				=   config_inputs_dict

							self.check_equivalence_pt_to_flax(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
							self.check_equivalence_flax_to_pt(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )





	@slow
	def 	UpperCamelCase_  ( self					:				List[str] ):







							'''simple docstring'''
							_UpperCamelCase				,			_UpperCamelCase					:		int 				=   self.get_pretrained_model_and_inputs()

							_UpperCamelCase					:		List[Any] 				=   model_a(**lowerCamelCase__ )
							_UpperCamelCase					:		Tuple 				=   outputs[0]

							with tempfile.TemporaryDirectory() as tmp_dirname:
													model_a.save_pretrained(lowerCamelCase__ )
													_UpperCamelCase					:		Optional[Any] 				=   FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase__ )

													_UpperCamelCase					:		int 				=   model_a(**lowerCamelCase__ )
													_UpperCamelCase					:		str 				=   after_outputs[0]
													_UpperCamelCase					:		Optional[int] 				=   np.amax(np.abs(out_a - out_a ) )
													self.assertLessEqual(lowerCamelCase__ ,1E-5 )






@require_flax
class 							lowercase__	(							lowercase						,					unittest.TestCase   ):





	def 	UpperCamelCase_  ( self					:				List[Any] ):







							'''simple docstring'''
							_UpperCamelCase					:		str 				=   FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
							    'hf-internal-testing/tiny-random-vit' ,'hf-internal-testing/tiny-bert' ,vision_from_pt=lowerCamelCase__ ,text_from_pt=lowerCamelCase__ ,)
							_UpperCamelCase					:		str 				=   13
							_UpperCamelCase					:		str 				=   floats_tensor(
							    [
							        batch_size,
							        model.config.vision_config.num_channels,
							        model.config.vision_config.image_size,
							        model.config.vision_config.image_size,
							    ] )
							_UpperCamelCase					:		Optional[int] 				=   ids_tensor([batch_size, 4] ,model.config.text_config.vocab_size )
							_UpperCamelCase					:		List[Any] 				=   random_attention_mask([batch_size, 4] )
							_UpperCamelCase					:		List[str] 				=   {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

							return model, inputs





	def 	UpperCamelCase_  ( self					:				Optional[int] ,lowerCamelCase__					:				Optional[int] ,lowerCamelCase__					:				Dict ):







							'''simple docstring'''
							_UpperCamelCase					:		Dict 				=   FlaxViTModel(lowerCamelCase__ )
							_UpperCamelCase					:		Union[str, Any] 				=   FlaxBertModel(lowerCamelCase__ )
							return vision_model, text_model





	def 	UpperCamelCase_  ( self					:				str ):







							'''simple docstring'''
							_UpperCamelCase					:		Tuple 				=   FlaxViTModelTester(self )
							_UpperCamelCase					:		Optional[int] 				=   FlaxBertModelTester(self )
							_UpperCamelCase					:		List[str] 				=   vit_model_tester.prepare_config_and_inputs()
							_UpperCamelCase					:		Any 				=   bert_model_tester.prepare_config_and_inputs()

							_UpperCamelCase				,			_UpperCamelCase					:		Any 				=   vision_config_and_inputs

							_UpperCamelCase				,			_UpperCamelCase				,			_UpperCamelCase				,			_UpperCamelCase					:		Tuple 				=   text_config_and_inputs

							# make sure that cross attention layers are added
							return {
							    "text_config": text_config,
							    "vision_config": vision_config,
							    "pixel_values": pixel_values,
							    "attention_mask": attention_mask,
							    "input_ids": input_ids,
							    "token_type_ids": token_type_ids,
							}






@require_torch
class 							lowercase__	(							lowercase						,					unittest.TestCase   ):





	def 	UpperCamelCase_  ( self					:				Tuple ):







							'''simple docstring'''
							_UpperCamelCase					:		Tuple 				=   FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
							    'hf-internal-testing/tiny-random-clip' ,'hf-internal-testing/tiny-bert' ,vision_from_pt=lowerCamelCase__ ,text_from_pt=lowerCamelCase__ ,)
							_UpperCamelCase					:		Dict 				=   13
							_UpperCamelCase					:		str 				=   floats_tensor(
							    [
							        batch_size,
							        model.config.vision_config.num_channels,
							        model.config.vision_config.image_size,
							        model.config.vision_config.image_size,
							    ] )
							_UpperCamelCase					:		int 				=   ids_tensor([batch_size, 4] ,model.config.text_config.vocab_size )
							_UpperCamelCase					:		Dict 				=   random_attention_mask([batch_size, 4] )
							_UpperCamelCase					:		Any 				=   {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

							return model, inputs





	def 	UpperCamelCase_  ( self					:				List[Any] ,lowerCamelCase__					:				Dict ,lowerCamelCase__					:				int ):







							'''simple docstring'''
							_UpperCamelCase					:		Tuple 				=   FlaxCLIPVisionModel(lowerCamelCase__ )
							_UpperCamelCase					:		Union[str, Any] 				=   FlaxBertModel(lowerCamelCase__ )
							return vision_model, text_model





	def 	UpperCamelCase_  ( self					:				Dict ):







							'''simple docstring'''
							_UpperCamelCase					:		List[str] 				=   FlaxCLIPVisionModelTester(self )
							_UpperCamelCase					:		Union[str, Any] 				=   FlaxBertModelTester(self )
							_UpperCamelCase					:		Dict 				=   clip_model_tester.prepare_config_and_inputs()
							_UpperCamelCase					:		int 				=   bert_model_tester.prepare_config_and_inputs()

							_UpperCamelCase				,			_UpperCamelCase					:		str 				=   vision_config_and_inputs

							_UpperCamelCase				,			_UpperCamelCase				,			_UpperCamelCase				,			_UpperCamelCase					:		Union[str, Any] 				=   text_config_and_inputs

							# make sure that cross attention layers are added
							return {
							    "text_config": text_config,
							    "vision_config": vision_config,
							    "pixel_values": pixel_values,
							    "attention_mask": attention_mask,
							    "input_ids": input_ids,
							    "token_type_ids": token_type_ids,
							}






@require_flax
@require_vision
class 							lowercase__	(							unittest.TestCase   ):





	@slow
	def 	UpperCamelCase_  ( self					:				List[str] ):







							'''simple docstring'''
							_UpperCamelCase					:		Optional[int] 				=   FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian' ,logit_scale_init_value=1.0 )
							_UpperCamelCase					:		Tuple 				=   VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian' )

							_UpperCamelCase					:		List[str] 				=   Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
							_UpperCamelCase					:		Union[str, Any] 				=   processor(
							    text=['una foto di un gatto', 'una foto di un cane'] ,images=lowerCamelCase__ ,padding=lowerCamelCase__ ,return_tensors='np' )

							_UpperCamelCase					:		Tuple 				=   model(**lowerCamelCase__ )

							# verify the logits
							self.assertEqual(outputs.logits_per_image.shape ,(inputs.pixel_values.shape[0], inputs.input_ids.shape[0]) )
							self.assertEqual(
							    outputs.logits_per_text.shape ,(inputs.input_ids.shape[0], inputs.pixel_values.shape[0]) ,)

							_UpperCamelCase					:		Optional[Any] 				=   np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]] )

							self.assertTrue(np.allclose(outputs.logits_per_image ,lowerCamelCase__ ,atol=1E-3 ) )









"""simple docstring"""




from __future__ import annotations






def       _SCREAMING_SNAKE_CASE		(	_lowercase						:    list[int]    ,       _lowercase						:    int					) ->int:






	'''simple docstring'''






	if len(_lowercase					) < k or k < 0:
		raise ValueError("Invalid Input"					)
	a      :		Optional[Any]	=				sum(array[:k]					)
	for i in range(len(_lowercase					) - k					):
		a      :		Optional[Any]	=				current_sum - array[i] + array[i + k]
		a      :		Union[str, Any]	=				max(_lowercase    ,       _lowercase					)
	return max_sum


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

		testmod()
		a						: Any     	=			[randint(-1000, 1000) for i in range(100)]
		a						: List[str]     	=			randint(0, 110)
		print(F'''The maximum sum of {k} consecutive elements is {max_sum_in_array(array,k)}''')


