


'''simple docstring'''



import inspect
import unittest

from transformers import EfficientNetConfig
from transformers.testing_utils import is_pipeline_test, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import EfficientNetForImageClassification, EfficientNetModel
	from transformers.models.efficientnet.modeling_efficientnet import EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor






class        UpperCamelCase__:




				def __init__(		self			: Tuple      ,    lowerCAmelCase			: Any      ,    lowerCAmelCase			: Union[str, Any]=13      ,    lowerCAmelCase			: List[str]=32      ,    lowerCAmelCase			: int=3      ,    lowerCAmelCase			: Optional[int]=[3, 3, 5]      ,    lowerCAmelCase			: Tuple=[32, 16, 24]      ,    lowerCAmelCase			: Optional[Any]=[16, 24, 40]      ,    lowerCAmelCase			: Dict=[1, 1, 2]      ,    lowerCAmelCase			: Any=[1, 1, 2]      ,    lowerCAmelCase			: Tuple=[1, 6, 6]      ,    lowerCAmelCase			: List[Any]=True      ,    lowerCAmelCase			: int=True      ,    lowerCAmelCase			: Optional[int]=37      ,    lowerCAmelCase			: Dict="gelu"      ,    lowerCAmelCase			: Union[str, Any]=10      ,    )->     Union[str, Any]:

										"""simple docstring"""




										UpperCAmelCase     				=	parent
										UpperCAmelCase     				=	batch_size
										UpperCAmelCase     				=	image_size
										UpperCAmelCase     				=	num_channels
										UpperCAmelCase     				=	kernel_sizes
										UpperCAmelCase     				=	in_channels
										UpperCAmelCase     				=	out_channels
										UpperCAmelCase     				=	strides
										UpperCAmelCase     				=	num_block_repeats
										UpperCAmelCase     				=	expand_ratios
										UpperCAmelCase     				=	is_training
										UpperCAmelCase     				=	hidden_act
										UpperCAmelCase     				=	num_labels
										UpperCAmelCase     				=	use_labels




				def      a__(		self			: str      )->     Dict:

										"""simple docstring"""




										UpperCAmelCase     				=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

										UpperCAmelCase     				=	None
										if self.use_labels:
																UpperCAmelCase     				=	ids_tensor([self.batch_size]      ,    self.num_labels      )

										UpperCAmelCase     				=	self.get_config()
										return config, pixel_values, labels




				def      a__(		self			: Dict      )->     str:

										"""simple docstring"""




										return EfficientNetConfig(
										    num_channels=self.num_channels      ,    kernel_sizes=self.kernel_sizes      ,    in_channels=self.in_channels      ,    out_channels=self.out_channels      ,    strides=self.strides      ,    num_block_repeats=self.num_block_repeats      ,    expand_ratios=self.expand_ratios      ,    hidden_act=self.hidden_act      ,    num_labels=self.num_labels      ,    )




				def      a__(		self			: Tuple      ,    lowerCAmelCase			: Optional[Any]      ,    lowerCAmelCase			: Dict      ,    lowerCAmelCase			: Optional[int]      )->     str:

										"""simple docstring"""




										UpperCAmelCase     				=	EfficientNetModel(config=_SCREAMING_SNAKE_CASE      )
										model.to(_SCREAMING_SNAKE_CASE      )
										model.eval()
										UpperCAmelCase     				=	model(_SCREAMING_SNAKE_CASE      )
										# expected last hidden states: B, C, H // 4, W // 4
										self.parent.assertEqual(
										    result.last_hidden_state.shape      ,    (self.batch_size, config.hidden_dim, self.image_size // 4, self.image_size // 4)      ,    )




				def      a__(		self			: Dict      ,    lowerCAmelCase			: Optional[Any]      ,    lowerCAmelCase			: Tuple      ,    lowerCAmelCase			: Optional[int]      )->     Optional[Any]:

										"""simple docstring"""




										UpperCAmelCase     				=	EfficientNetForImageClassification(_SCREAMING_SNAKE_CASE      )
										model.to(_SCREAMING_SNAKE_CASE      )
										model.eval()
										UpperCAmelCase     				=	model(_SCREAMING_SNAKE_CASE      ,    labels=_SCREAMING_SNAKE_CASE      )
										self.parent.assertEqual(result.logits.shape      ,    (self.batch_size, self.num_labels)      )





				def      a__(		self			: List[str]      )->     Tuple:

										"""simple docstring"""




										UpperCAmelCase     				=	self.prepare_config_and_inputs()
										UpperCAmelCase     				=	config_and_inputs
										UpperCAmelCase     				=	{"pixel_values": pixel_values}
										return config, inputs_dict







@require_torch
class        UpperCamelCase__(   SCREAMING_SNAKE_CASE__						,				SCREAMING_SNAKE_CASE__						,				unittest.TestCase       ):
				__magic_name__				:      Tuple  		=       (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
				__magic_name__				:      str  		=       (
				    {'feature-extraction': EfficientNetModel, 'image-classification': EfficientNetForImageClassification}
				    if is_torch_available()
				    else {}
				)

				__magic_name__				:      Any  		=       False
				__magic_name__				:      Tuple  		=       False
				__magic_name__				:      Optional[int]  		=       False
				__magic_name__				:      Dict  		=       False
				__magic_name__				:      Any  		=       False




				def      a__(		self			: int      )->     Optional[Any]:

										"""simple docstring"""




										UpperCAmelCase     				=	EfficientNetModelTester(self      )
										UpperCAmelCase     				=	ConfigTester(
										    self      ,    config_class=_SCREAMING_SNAKE_CASE      ,    has_text_modality=_SCREAMING_SNAKE_CASE      ,    hidden_size=37      )




				def      a__(		self			: Dict      )->     Tuple:

										"""simple docstring"""




										self.create_and_test_config_common_properties()
										self.config_tester.create_and_test_config_to_json_string()
										self.config_tester.create_and_test_config_to_json_file()
										self.config_tester.create_and_test_config_from_and_save_pretrained()
										self.config_tester.create_and_test_config_with_num_labels()
										self.config_tester.check_config_can_be_init_without_params()
										self.config_tester.check_config_arguments_init()




				def      a__(		self			: Optional[int]      )->     Any:

										"""simple docstring"""




										return




				@unittest.skip(reason='''EfficientNet does not use inputs_embeds'''      )
				def      a__(		self			: str      )->     Optional[int]:

										"""simple docstring"""




										pass




				@unittest.skip(reason='''EfficientNet does not support input and output embeddings'''      )
				def      a__(		self			: str      )->     Optional[Any]:

										"""simple docstring"""




										pass




				@unittest.skip(reason='''EfficientNet does not use feedforward chunking'''      )
				def      a__(		self			: List[Any]      )->     Tuple:

										"""simple docstring"""




										pass




				def      a__(		self			: Optional[int]      )->     str:

										"""simple docstring"""




										UpperCAmelCase     				=	self.model_tester.prepare_config_and_inputs_for_common()

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

																UpperCAmelCase     				=	["pixel_values"]
																self.assertListEqual(arg_names[:1]      ,    _SCREAMING_SNAKE_CASE      )




				def      a__(		self			: Optional[int]      )->     List[Any]:

										"""simple docstring"""




										UpperCAmelCase     				=	self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE      )




				def      a__(		self			: Any      )->     Optional[int]:

										"""simple docstring"""




										def check_hidden_states_output(lowerCAmelCase			: int      ,    lowerCAmelCase			: List[Any]      ,    lowerCAmelCase			: Tuple      ):
																UpperCAmelCase     				=	model_class(_SCREAMING_SNAKE_CASE      )
																model.to(_SCREAMING_SNAKE_CASE      )
																model.eval()

																with torch.no_grad():
																						UpperCAmelCase     				=	model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE      ,    _SCREAMING_SNAKE_CASE      )      )

																UpperCAmelCase     				=	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
																UpperCAmelCase     				=	sum(config.num_block_repeats      ) * 4
																self.assertEqual(len(_SCREAMING_SNAKE_CASE      )      ,    _SCREAMING_SNAKE_CASE      )

																# EfficientNet's feature maps are of shape (batch_size, num_channels, height, width)
																self.assertListEqual(
																    list(hidden_states[0].shape[-2:]      )      ,    [self.model_tester.image_size // 2, self.model_tester.image_size // 2]      ,    )

										UpperCAmelCase     				=	self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																UpperCAmelCase     				=	True
																check_hidden_states_output(_SCREAMING_SNAKE_CASE      ,    _SCREAMING_SNAKE_CASE      ,    _SCREAMING_SNAKE_CASE      )

																# check that output_hidden_states also work using config
																del inputs_dict["output_hidden_states"]
																UpperCAmelCase     				=	True

																check_hidden_states_output(_SCREAMING_SNAKE_CASE      ,    _SCREAMING_SNAKE_CASE      ,    _SCREAMING_SNAKE_CASE      )




				def      a__(		self			: str      )->     Any:

										"""simple docstring"""




										UpperCAmelCase     				=	self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE      )




				@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''      )
				def      a__(		self			: int      )->     Tuple:

										"""simple docstring"""




										pass




				@slow
				def      a__(		self			: int      )->     Union[str, Any]:

										"""simple docstring"""




										for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																UpperCAmelCase     				=	EfficientNetModel.from_pretrained(_SCREAMING_SNAKE_CASE      )
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE      )





				@is_pipeline_test
				@require_vision
				@slow
				def      a__(		self			: Any      )->     Tuple:

										"""simple docstring"""




										super().test_pipeline_image_classification()







def       lowerCamelCase__      (       ):




						'''simple docstring'''






						UpperCAmelCase     				=	Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''     )
						return image






@require_torch
@require_vision
class        UpperCamelCase__(   unittest.TestCase       ):




				@cached_property
				def      a__(		self			: Dict      )->     Any:

										"""simple docstring"""




										return AutoImageProcessor.from_pretrained('''google/efficientnet-b7'''      ) if is_vision_available() else None





				@slow
				def      a__(		self			: str      )->     Dict:

										"""simple docstring"""




										UpperCAmelCase     				=	EfficientNetForImageClassification.from_pretrained('''google/efficientnet-b7'''      ).to(_SCREAMING_SNAKE_CASE      )

										UpperCAmelCase     				=	self.default_image_processor
										UpperCAmelCase     				=	prepare_img()
										UpperCAmelCase     				=	image_processor(images=_SCREAMING_SNAKE_CASE      ,    return_tensors='''pt'''      ).to(_SCREAMING_SNAKE_CASE      )

										# forward pass
										with torch.no_grad():
																UpperCAmelCase     				=	model(**_SCREAMING_SNAKE_CASE      )

										# verify the logits
										UpperCAmelCase     				=	torch.Size((1, 1000)      )
										self.assertEqual(outputs.logits.shape      ,    _SCREAMING_SNAKE_CASE      )

										UpperCAmelCase     				=	torch.tensor([0.0001, 0.0002, 0.0002]      ).to(_SCREAMING_SNAKE_CASE      )
										self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,    _SCREAMING_SNAKE_CASE      ,    atol=1E-4      )      )













def    lowerCAmelCase__		(			_a				:	str     ,					_a				:	int = 13			):
		snake_case_ :							List[Any]         =				""
		for c in s:
				if "A" <= c <= "Z":
						out += chr(ord("A"			) + (ord(_a			) - ord("A"			) + n) % 26			)
				elif "a" <= c <= "z":
						out += chr(ord("a"			) + (ord(_a			) - ord("a"			) + n) % 26			)
				else:
						out += c
		return out

def    lowerCAmelCase__		(			):
		snake_case_ :							int         =				input("Enter message: "			)

		snake_case_ :							List[Any]         =				dencrypt(_a     ,					13			)
		print("Encryption:"     ,					_a			)

		snake_case_ :							int         =				dencrypt(_a     ,					13			)
		print("Decryption: "     ,					_a			)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							main()
