
import unittest

import numpy as np

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

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
							from transformers.models.electra.modeling_flax_electra import (
							    FlaxElectraForCausalLM,
							    FlaxElectraForMaskedLM,
							    FlaxElectraForMultipleChoice,
							    FlaxElectraForPreTraining,
							    FlaxElectraForQuestionAnswering,
							    FlaxElectraForSequenceClassification,
							    FlaxElectraForTokenClassification,
							    FlaxElectraModel,
							)

class 				_UpperCamelCase (    unittest.TestCase     ):






			'''simple docstring'''

			def __init__(				self       :				Union[str, Any]  ,		snake_case_       :				Optional[Any]  ,		snake_case_       :				Any=13  ,		snake_case_       :				str=7  ,		snake_case_       :				Any=True  ,		snake_case_       :				Any=True  ,		snake_case_       :				List[str]=True  ,		snake_case_       :				Optional[int]=True  ,		snake_case_       :				Optional[Any]=99  ,		snake_case_       :				Dict=24  ,		snake_case_       :				str=32  ,		snake_case_       :				List[Any]=5  ,		snake_case_       :				Any=4  ,		snake_case_       :				Tuple=37  ,		snake_case_       :				Optional[int]="gelu"  ,		snake_case_       :				Dict=0.1  ,		snake_case_       :				Optional[int]=0.1  ,		snake_case_       :				List[str]=512  ,		snake_case_       :				Optional[Any]=16  ,		snake_case_       :				Optional[int]=2  ,		snake_case_       :				int=0.02  ,		snake_case_       :				Dict=4  ,		):
							UpperCamelCase_:							Any		=  parent
							UpperCamelCase_:							List[str]		=  batch_size
							UpperCamelCase_:							List[Any]		=  seq_length
							UpperCamelCase_:							Tuple		=  is_training
							UpperCamelCase_:							Optional[int]		=  use_attention_mask
							UpperCamelCase_:							Union[str, Any]		=  use_token_type_ids
							UpperCamelCase_:							int		=  use_labels
							UpperCamelCase_:							List[Any]		=  vocab_size
							UpperCamelCase_:							Tuple		=  hidden_size
							UpperCamelCase_:							Union[str, Any]		=  embedding_size
							UpperCamelCase_:							Any		=  num_hidden_layers
							UpperCamelCase_:							List[Any]		=  num_attention_heads
							UpperCamelCase_:							int		=  intermediate_size
							UpperCamelCase_:							List[str]		=  hidden_act
							UpperCamelCase_:							List[str]		=  hidden_dropout_prob
							UpperCamelCase_:							List[Any]		=  attention_probs_dropout_prob
							UpperCamelCase_:							Union[str, Any]		=  max_position_embeddings
							UpperCamelCase_:							List[Any]		=  type_vocab_size
							UpperCamelCase_:							int		=  type_sequence_label_size
							UpperCamelCase_:							Any		=  initializer_range
							UpperCamelCase_:							Dict		=  num_choices

			def 					lowerCAmelCase__		(				self       :				int					):
							UpperCamelCase_:							Optional[Any]		=  ids_tensor([self.batch_size, self.seq_length]  ,		self.vocab_size					)

							UpperCamelCase_:							Optional[Any]		=  None
							if self.use_attention_mask:
											UpperCamelCase_:							str		=  random_attention_mask([self.batch_size, self.seq_length]					)

							UpperCamelCase_:							List[Any]		=  None
							if self.use_token_type_ids:
											UpperCamelCase_:							int		=  ids_tensor([self.batch_size, self.seq_length]  ,		self.type_vocab_size					)

							UpperCamelCase_:							Dict		=  ElectraConfig(
							    vocab_size=self.vocab_size  ,		hidden_size=self.hidden_size  ,		embedding_size=self.embedding_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  ,		max_position_embeddings=self.max_position_embeddings  ,		type_vocab_size=self.type_vocab_size  ,		initializer_range=self.initializer_range  ,		)

							return config, input_ids, token_type_ids, attention_mask




			def 					lowerCAmelCase__		(				self       :				Optional[Any]					):
							UpperCamelCase_:							Optional[Any]		=  self.prepare_config_and_inputs()
							UpperCamelCase_,      UpperCamelCase_,      UpperCamelCase_,      UpperCamelCase_:							Any		=  config_and_inputs
							UpperCamelCase_:							Tuple		=  {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": attention_mask}
							return config, inputs_dict




@require_flax
class 				_UpperCamelCase (    _A   ,				unittest.TestCase     ):






			'''simple docstring'''

			__UpperCamelCase					:  Tuple    					=       True

			__UpperCamelCase					:  List[str]    					=       (
			    (
			        FlaxElectraModel,
			        FlaxElectraForCausalLM,
			        FlaxElectraForMaskedLM,
			        FlaxElectraForPreTraining,
			        FlaxElectraForTokenClassification,
			        FlaxElectraForQuestionAnswering,
			        FlaxElectraForMultipleChoice,
			        FlaxElectraForSequenceClassification,
			    )
			    if is_flax_available()
			    else ()
			)

			def 					lowerCAmelCase__		(				self       :				List[str]					):
							UpperCamelCase_:							Any		=  FlaxElectraModelTester(self					)




			@slow
			def 					lowerCAmelCase__		(				self       :				Tuple					):
							for model_class_name in self.all_model_classes:
											if model_class_name == FlaxElectraForMaskedLM:
															UpperCamelCase_:							Any		=  model_class_name.from_pretrained("""google/electra-small-generator"""					)
											else:
															UpperCamelCase_:							Any		=  model_class_name.from_pretrained("""google/electra-small-discriminator"""					)
											UpperCamelCase_:							Optional[Any]		=  model(np.ones((1, 1)					)					)
											self.assertIsNotNone(snake_case_					)












import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image

							from transformers import TvltImageProcessor






def 					snake_case					(							A						,   A=10						,   A=10						,   A=False						,   A=False			)							->							str:




	'''simple docstring'''


	lowerCamelCase_							:		Any							   =							[]
	for i in range(image_processor_tester.num_frames			):
		video.append(np.random.randint(255						,   size=(image_processor_tester.num_channels, width, height)						,   dtype=np.uinta			)			)

	if not numpify and not torchify:
		# PIL expects the channel dimension as last dimension
		lowerCamelCase_							:		Any							   =							[Image.fromarray(np.moveaxis(A						,   0						,   -1			)			) for frame in video]

	if torchify:
		lowerCamelCase_							:		List[str]							   =							[torch.from_numpy(A			) for frame in video]

	return video






def 					snake_case					(							A						,   A=False						,   A=False						,   A=False			)							->							Dict:




	'''simple docstring'''


	assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

	lowerCamelCase_							:		int							   =							[]
	for i in range(image_processor_tester.batch_size			):
		if equal_resolution:
			lowerCamelCase_							:		Union[str, Any]							   =							image_processor_tester.max_resolution
		else:
			lowerCamelCase_   ,			lowerCamelCase_							:		Optional[int]							   =							np.random.choice(
			    np.arange(image_processor_tester.min_resolution						,   image_processor_tester.max_resolution			)						,   2			)
			lowerCamelCase_							:		str							   =							prepare_video(
			    image_processor_tester=A						,   width=A						,   height=A						,   numpify=A						,   torchify=A						,   )
		video_inputs.append(A			)

	return video_inputs


class 				__SCREAMING_SNAKE_CASE							(		unittest.TestCase  ):

					def __init__(				self ,       __lowercase ,       __lowercase=7 ,       __lowercase=3 ,       __lowercase=4 ,       __lowercase=18 ,       __lowercase=30 ,       __lowercase=400 ,       __lowercase=True ,       __lowercase=None ,       __lowercase=True ,       __lowercase=[0.5, 0.5, 0.5] ,       __lowercase=[0.5, 0.5, 0.5] ,       __lowercase=True ,       __lowercase=None ,       ):







						'''simple docstring'''




						lowerCamelCase_							:		Optional[int]							   =							size if size is not None else {'shortest_edge': 18}
						lowerCamelCase_							:		Union[str, Any]							   =							crop_size if crop_size is not None else {'height': 18, 'width': 18}

						lowerCamelCase_							:		List[Any]							   =							parent
						lowerCamelCase_							:		Optional[Any]							   =							batch_size
						lowerCamelCase_							:		Tuple							   =							num_channels
						lowerCamelCase_							:		Dict							   =							num_frames
						lowerCamelCase_							:		Dict							   =							image_size
						lowerCamelCase_							:		Optional[Any]							   =							min_resolution
						lowerCamelCase_							:		List[Any]							   =							max_resolution
						lowerCamelCase_							:		Dict							   =							do_resize
						lowerCamelCase_							:		List[Any]							   =							size
						lowerCamelCase_							:		Dict							   =							do_normalize
						lowerCamelCase_							:		Optional[Any]							   =							image_mean
						lowerCamelCase_							:		List[str]							   =							image_std
						lowerCamelCase_							:		Tuple							   =							do_center_crop
						lowerCamelCase_							:		List[Any]							   =							crop_size





					def 	lowercase_							(				self					):







						'''simple docstring'''




						return {
						    "image_mean": self.image_mean,
						    "image_std": self.image_std,
						    "do_normalize": self.do_normalize,
						    "do_resize": self.do_resize,
						    "size": self.size,
						    "do_center_crop": self.do_center_crop,
						    "crop_size": self.crop_size,
						}


@require_torch
@require_vision
class 				__SCREAMING_SNAKE_CASE							(		lowerCamelCase   ,     unittest.TestCase  ):
					_lowerCamelCase		  = TvltImageProcessor if is_vision_available() else None

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Optional[Any]							   =							TvltImageProcessorTester(self					)

					@property
					def 	lowercase_							(				self					):







						'''simple docstring'''




						return self.image_processor_tester.prepare_image_processor_dict()

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		int							   =							self.image_processing_class(**self.image_processor_dict					)
						self.assertTrue(hasattr(__lowercase ,       'image_mean'					)					)
						self.assertTrue(hasattr(__lowercase ,       'image_std'					)					)
						self.assertTrue(hasattr(__lowercase ,       'do_normalize'					)					)
						self.assertTrue(hasattr(__lowercase ,       'do_resize'					)					)
						self.assertTrue(hasattr(__lowercase ,       'do_center_crop'					)					)
						self.assertTrue(hasattr(__lowercase ,       'size'					)					)

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Optional[Any]							   =							self.image_processing_class(**self.image_processor_dict					)
						# create random PIL videos
						lowerCamelCase_							:		Dict							   =							prepare_video_inputs(self.image_processor_tester ,       equal_resolution=__lowercase					)
						for video in video_inputs:
							self.assertIsInstance(__lowercase ,       __lowercase					)
							self.assertIsInstance(video[0] ,       Image.Image					)

						# Test not batched input
						lowerCamelCase_							:		Any							   =							image_processor(video_inputs[0] ,       return_tensors='pt'					).pixel_values
						self.assertEqual(
						    encoded_videos.shape ,       (
						        1,
						        self.image_processor_tester.num_frames,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    ) ,       )

						# Test batched
						lowerCamelCase_							:		List[Any]							   =							image_processor(__lowercase ,       return_tensors='pt'					).pixel_values
						self.assertEqual(
						    encoded_videos.shape ,       (
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_frames,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    ) ,       )

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Dict							   =							self.image_processing_class(**self.image_processor_dict					)
						# create random numpy tensors
						lowerCamelCase_							:		Union[str, Any]							   =							prepare_video_inputs(self.image_processor_tester ,       equal_resolution=__lowercase ,       numpify=__lowercase					)
						for video in video_inputs:
							self.assertIsInstance(__lowercase ,       __lowercase					)
							self.assertIsInstance(video[0] ,       np.ndarray					)

						# Test not batched input
						lowerCamelCase_							:		Union[str, Any]							   =							image_processor(video_inputs[0] ,       return_tensors='pt'					).pixel_values
						self.assertEqual(
						    encoded_videos.shape ,       (
						        1,
						        self.image_processor_tester.num_frames,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    ) ,       )

						# Test batched
						lowerCamelCase_							:		Tuple							   =							image_processor(__lowercase ,       return_tensors='pt'					).pixel_values
						self.assertEqual(
						    encoded_videos.shape ,       (
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_frames,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    ) ,       )





					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		str							   =							self.image_processing_class(**self.image_processor_dict					)
						# create random PyTorch tensors
						lowerCamelCase_							:		Union[str, Any]							   =							prepare_video_inputs(self.image_processor_tester ,       equal_resolution=__lowercase ,       torchify=__lowercase					)
						for video in video_inputs:
							self.assertIsInstance(__lowercase ,       __lowercase					)
							self.assertIsInstance(video[0] ,       torch.Tensor					)

						# Test not batched input
						lowerCamelCase_							:		Optional[Any]							   =							image_processor(video_inputs[0] ,       return_tensors='pt'					).pixel_values
						self.assertEqual(
						    encoded_videos.shape ,       (
						        1,
						        self.image_processor_tester.num_frames,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    ) ,       )

						# Test batched
						lowerCamelCase_							:		Tuple							   =							image_processor(__lowercase ,       return_tensors='pt'					).pixel_values
						self.assertEqual(
						    encoded_videos.shape ,       (
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_frames,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    ) ,       )
