






import numpy as np
from cva import destroyAllWindows, imread, imshow, waitKey




class 							snake_case_       :

						"""simple docstring"""



						def __init__(self:					Tuple ,					__UpperCAmelCase:					int ,					__UpperCAmelCase:					int ,					__UpperCAmelCase:					int   )    ->     str:




											'''simple docstring'''



											if dst_width < 0 or dst_height < 0:
																raise ValueError("Destination width/height should be > 0"   )

											__a					:						List[Any]      =					img
											__a					:						Any      =					img.shape[1]
											__a					:						List[str]      =					img.shape[0]
											__a					:						List[str]      =					dst_width
											__a					:						int      =					dst_height

											__a					:						Any      =					self.src_w / self.dst_w
											__a					:						Optional[int]      =					self.src_h / self.dst_h

											__a					:						Dict      =					(
											    np.ones((self.dst_h, self.dst_w, 3) ,					np.uinta   ) * 255
											)



						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     Optional[int]:




											'''simple docstring'''



											for i in range(self.dst_h   ):
																for j in range(self.dst_w   ):
																					__a					:						List[str]      =					self.img[self.get_y(__UpperCAmelCase   )][self.get_x(__UpperCAmelCase   )]



						def        UpperCAmelCase__					(self:					int ,					__UpperCAmelCase:					int   )    ->     int:




											'''simple docstring'''



											return int(self.ratio_x * x   )



						def        UpperCAmelCase__					(self:					Any ,					__UpperCAmelCase:					int   )    ->     int:




											'''simple docstring'''



											return int(self.ratio_y * y   )


if __name__ == "__main__":
			UpperCAmelCase__			,							UpperCAmelCase__      			=						800, 600
			UpperCAmelCase__      			=						imread('''image_data/lena.jpg''', 1)
			UpperCAmelCase__      			=						NearestNeighbour(im, dst_w, dst_h)
			n.process()

			imshow(
			    F"Image resized from: {im.shape[1]}x{im.shape[0]} to {dst_w}x{dst_h}", n.output
			)
			waitKey(0)
			destroyAllWindows()













import unittest

import numpy as np

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

from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
			from transformers.models.roberta.modeling_flax_roberta import (
			    FlaxRobertaForCausalLM,
			    FlaxRobertaForMaskedLM,
			    FlaxRobertaForMultipleChoice,
			    FlaxRobertaForQuestionAnswering,
			    FlaxRobertaForSequenceClassification,
			    FlaxRobertaForTokenClassification,
			    FlaxRobertaModel,
			)




class 							snake_case_       (    unittest.TestCase      ):

						"""simple docstring"""



						def __init__(self:					Optional[int] ,					__UpperCAmelCase:					str ,					__UpperCAmelCase:					List[str]=13 ,					__UpperCAmelCase:					Any=7 ,					__UpperCAmelCase:					List[str]=True ,					__UpperCAmelCase:					Optional[int]=True ,					__UpperCAmelCase:					Dict=True ,					__UpperCAmelCase:					Optional[Any]=True ,					__UpperCAmelCase:					Optional[int]=99 ,					__UpperCAmelCase:					Optional[Any]=32 ,					__UpperCAmelCase:					int=5 ,					__UpperCAmelCase:					Dict=4 ,					__UpperCAmelCase:					Optional[int]=37 ,					__UpperCAmelCase:					int="gelu" ,					__UpperCAmelCase:					Tuple=0.1 ,					__UpperCAmelCase:					Any=0.1 ,					__UpperCAmelCase:					Union[str, Any]=512 ,					__UpperCAmelCase:					Optional[Any]=16 ,					__UpperCAmelCase:					List[Any]=2 ,					__UpperCAmelCase:					str=0.02 ,					__UpperCAmelCase:					int=4 ,					)    ->     str:




											'''simple docstring'''



											__a					:						Tuple      =					parent
											__a					:						int      =					batch_size
											__a					:						Optional[int]      =					seq_length
											__a					:						List[Any]      =					is_training
											__a					:						Tuple      =					use_attention_mask
											__a					:						Optional[int]      =					use_token_type_ids
											__a					:						Tuple      =					use_labels
											__a					:						str      =					vocab_size
											__a					:						Union[str, Any]      =					hidden_size
											__a					:						List[str]      =					num_hidden_layers
											__a					:						Optional[int]      =					num_attention_heads
											__a					:						Any      =					intermediate_size
											__a					:						Any      =					hidden_act
											__a					:						List[str]      =					hidden_dropout_prob
											__a					:						Dict      =					attention_probs_dropout_prob
											__a					:						Tuple      =					max_position_embeddings
											__a					:						Optional[int]      =					type_vocab_size
											__a					:						Tuple      =					type_sequence_label_size
											__a					:						List[Any]      =					initializer_range
											__a					:						int      =					num_choices



						def        UpperCAmelCase__					(self:					Tuple   )    ->     List[Any]:




											'''simple docstring'''



											__a					:						List[Any]      =					ids_tensor([self.batch_size, self.seq_length] ,					self.vocab_size   )

											__a					:						Dict      =					None
											if self.use_attention_mask:
																__a					:						List[Any]      =					random_attention_mask([self.batch_size, self.seq_length]   )

											__a					:						Optional[int]      =					None
											if self.use_token_type_ids:
																__a					:						Dict      =					ids_tensor([self.batch_size, self.seq_length] ,					self.type_vocab_size   )

											__a					:						Dict      =					RobertaConfig(
											    vocab_size=self.vocab_size ,					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 ,					max_position_embeddings=self.max_position_embeddings ,					type_vocab_size=self.type_vocab_size ,					is_decoder=__UpperCAmelCase ,					initializer_range=self.initializer_range ,					)

											return config, input_ids, token_type_ids, attention_mask



						def        UpperCAmelCase__					(self:					Optional[Any]   )    ->     Union[str, Any]:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					self.prepare_config_and_inputs()
											__a      ,			__a      ,			__a      ,			__a					:						Dict      =					config_and_inputs
											__a					:						str      =					{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": attention_mask}
											return config, inputs_dict



						def        UpperCAmelCase__					(self:					Dict   )    ->     str:




											'''simple docstring'''



											__a					:						Optional[Any]      =					self.prepare_config_and_inputs()
											__a      ,			__a      ,			__a      ,			__a					:						Tuple      =					config_and_inputs

											__a					:						int      =					True
											__a					:						List[str]      =					floats_tensor([self.batch_size, self.seq_length, self.hidden_size]   )
											__a					:						List[Any]      =					ids_tensor([self.batch_size, self.seq_length] ,					vocab_size=2   )

											return (
											    config,
											    input_ids,
											    token_type_ids,
											    encoder_hidden_states,
											    encoder_attention_mask,
											)




@require_flax
class 							snake_case_       (    __UpperCamelCase		,							unittest.TestCase      ):

						"""simple docstring"""



						snake_case__        =      True

						snake_case__        =      (
						    (
						        FlaxRobertaModel,
						        FlaxRobertaForCausalLM,
						        FlaxRobertaForMaskedLM,
						        FlaxRobertaForSequenceClassification,
						        FlaxRobertaForTokenClassification,
						        FlaxRobertaForMultipleChoice,
						        FlaxRobertaForQuestionAnswering,
						    )
						    if is_flax_available()
						    else ()
						)



						def        UpperCAmelCase__					(self:					Dict   )    ->     Union[str, Any]:




											'''simple docstring'''



											__a					:						Tuple      =					FlaxRobertaModelTester(self   )



						@slow
						def        UpperCAmelCase__					(self:					Optional[Any]   )    ->     List[Any]:




											'''simple docstring'''



											for model_class_name in self.all_model_classes:
																__a					:						int      =					model_class_name.from_pretrained("roberta-base" ,					from_pt=__UpperCAmelCase   )
																__a					:						Tuple      =					model(np.ones((1, 1)   )   )
																self.assertIsNotNone(__UpperCAmelCase   )





