






"""simple docstring"""


import inspect
import unittest

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

from ...test_backbone_common import BackboneTesterMixin
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 torch import nn

   from transformers import ResNetBackbone, ResNetForImageClassification, ResNetModel
   from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image

   from transformers import AutoImageProcessor






class __a   :



  def __init__(self  :		str				,			lowercase_  :		List[Any]				,			lowercase_  :		Tuple=3				,			lowercase_  :		List[Any]=32				,			lowercase_  :		Dict=3				,			lowercase_  :		Any=10				,			lowercase_  :		Optional[Any]=[10, 20, 30, 40]				,			lowercase_  :		List[Any]=[1, 1, 2, 1]				,			lowercase_  :		int=True				,			lowercase_  :		Tuple=True				,			lowercase_  :		Union[str, Any]="relu"				,			lowercase_  :		Union[str, Any]=3				,			lowercase_  :		Union[str, Any]=None				,			lowercase_  :		Any=["stage2", "stage3", "stage4"]				,			lowercase_  :		Optional[int]=[2, 3, 4]				,			)		->							Tuple:
   __A	:       List[str]       =	parent
   __A	:       List[str]       =	batch_size
   __A	:       int       =	image_size
   __A	:       Optional[int]       =	num_channels
   __A	:       Optional[int]       =	embeddings_size
   __A	:       str       =	hidden_sizes
   __A	:       Tuple       =	depths
   __A	:       Union[str, Any]       =	is_training
   __A	:       List[str]       =	use_labels
   __A	:       str       =	hidden_act
   __A	:       Dict       =	num_labels
   __A	:       Optional[Any]       =	scope
   __A	:       Union[str, Any]       =	len(lowercase_   )
   __A	:       List[str]       =	out_features
   __A	:       str       =	out_indices



  def 						A_				(self  :		str   )		->							Optional[Any]:
   __A	:       Union[str, Any]       =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

   __A	:       Any       =	None
   if self.use_labels:
    __A	:       int       =	ids_tensor([self.batch_size]				,			self.num_labels   )

   __A	:       Optional[Any]       =	self.get_config()

   return config, pixel_values, labels



  def 						A_				(self  :		Optional[int]   )		->							str:
   return ResNetConfig(
       num_channels=self.num_channels				,			embeddings_size=self.embeddings_size				,			hidden_sizes=self.hidden_sizes				,			depths=self.depths				,			hidden_act=self.hidden_act				,			num_labels=self.num_labels				,			out_features=self.out_features				,			out_indices=self.out_indices				,			)



  def 						A_				(self  :		Optional[int]				,			lowercase_  :		Optional[Any]				,			lowercase_  :		Tuple				,			lowercase_  :		str   )		->							int:
   __A	:       Union[str, Any]       =	ResNetModel(config=lowercase_   )
   model.to(lowercase_   )
   model.eval()
   __A	:       int       =	model(lowercase_   )
   # expected last hidden states: B, C, H // 32, W // 32
   self.parent.assertEqual(
       result.last_hidden_state.shape				,			(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)				,			)



  def 						A_				(self  :		Optional[int]				,			lowercase_  :		Optional[int]				,			lowercase_  :		List[Any]				,			lowercase_  :		int   )		->							Dict:
   __A	:       List[str]       =	self.num_labels
   __A	:       Any       =	ResNetForImageClassification(lowercase_   )
   model.to(lowercase_   )
   model.eval()
   __A	:       Optional[int]       =	model(lowercase_				,			labels=lowercase_   )
   self.parent.assertEqual(result.logits.shape				,			(self.batch_size, self.num_labels)   )



  def 						A_				(self  :		Optional[Any]				,			lowercase_  :		List[Any]				,			lowercase_  :		List[str]				,			lowercase_  :		Tuple   )		->							Optional[int]:
   __A	:       Tuple       =	ResNetBackbone(config=lowercase_   )
   model.to(lowercase_   )
   model.eval()
   __A	:       Tuple       =	model(lowercase_   )

   # verify feature maps
   self.parent.assertEqual(len(result.feature_maps   )				,			len(config.out_features   )   )
   self.parent.assertListEqual(list(result.feature_maps[0].shape   )				,			[self.batch_size, self.hidden_sizes[1], 4, 4]   )

   # verify channels
   self.parent.assertEqual(len(model.channels   )				,			len(config.out_features   )   )
   self.parent.assertListEqual(model.channels				,			config.hidden_sizes[1:]   )

   # verify backbone works with out_features=None
   __A	:       Optional[Any]       =	None
   __A	:       Optional[Any]       =	ResNetBackbone(config=lowercase_   )
   model.to(lowercase_   )
   model.eval()
   __A	:       List[str]       =	model(lowercase_   )

   # verify feature maps
   self.parent.assertEqual(len(result.feature_maps   )				,			1   )
   self.parent.assertListEqual(list(result.feature_maps[0].shape   )				,			[self.batch_size, self.hidden_sizes[-1], 1, 1]   )

   # verify channels
   self.parent.assertEqual(len(model.channels   )				,			1   )
   self.parent.assertListEqual(model.channels				,			[config.hidden_sizes[-1]]   )



  def 						A_				(self  :		int   )		->							List[str]:
   __A	:       Optional[int]       =	self.prepare_config_and_inputs()
   __A	:       Optional[Any]       =	config_and_inputs
   __A	:       List[Any]       =	{'pixel_values': pixel_values}
   return config, inputs_dict






@require_torch
class __a   (   snake_case_ ,snake_case_ ,unittest.TestCase				):
  __lowercase    :    List[str]						=					(
      (
          ResNetModel,
          ResNetForImageClassification,
          ResNetBackbone,
      )
      if is_torch_available()
      else ()
  )
  __lowercase    :    Dict						=					(
      {'feature-extraction': ResNetModel, 'image-classification': ResNetForImageClassification}
      if is_torch_available()
      else {}
  )

  __lowercase    :    Optional[int]						=					True
  __lowercase    :    Dict						=					False
  __lowercase    :    List[Any]						=					False
  __lowercase    :    Tuple						=					False
  __lowercase    :    Union[str, Any]						=					False



  def 						A_				(self  :		List[Any]   )		->							List[str]:
   __A	:       List[Any]       =	ResNetModelTester(self   )
   __A	:       int       =	ConfigTester(self				,			config_class=lowercase_				,			has_text_modality=lowercase_   )



  def 						A_				(self  :		Any   )		->							Optional[Any]:
   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  :		Any   )		->							Tuple:
   return



  @unittest.skip(reason='ResNet does not use inputs_embeds'   )
  def 						A_				(self  :		Optional[Any]   )		->							Union[str, Any]:
   pass



  @unittest.skip(reason='ResNet does not support input and output embeddings'   )
  def 						A_				(self  :		Optional[int]   )		->							int:
   pass



  def 						A_				(self  :		List[Any]   )		->							List[Any]:
   __A	:       Optional[int]       =	self.model_tester.prepare_config_and_inputs_for_common()

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

    __A	:       Optional[Any]       =	['pixel_values']
    self.assertListEqual(arg_names[:1]				,			lowercase_   )



  def 						A_				(self  :		str   )		->							List[Any]:
   __A	:       str       =	self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*lowercase_   )



  def 						A_				(self  :		Optional[int]   )		->							int:
   __A	:       Optional[Any]       =	self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_backbone(*lowercase_   )



  def 						A_				(self  :		Tuple   )		->							Optional[Any]:
   __A	:       Any       =	self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
    __A	:       Dict       =	model_class(config=lowercase_   )
    for name, module in model.named_modules():
     if isinstance(lowercase_				,			(nn.BatchNormad, nn.GroupNorm)   ):
      self.assertTrue(
          torch.all(module.weight == 1   )				,			msg=f"Parameter {name} of model {model_class} seems not properly initialized"				,			)
      self.assertTrue(
          torch.all(module.bias == 0   )				,			msg=f"Parameter {name} of model {model_class} seems not properly initialized"				,			)



  def 						A_				(self  :		Optional[Any]   )		->							Any:
   def check_hidden_states_output(lowercase_  :		Optional[int]				,			lowercase_  :		Any				,			lowercase_  :		List[str]   ):
    __A	:       Tuple       =	model_class(lowercase_   )
    model.to(lowercase_   )
    model.eval()

    with torch.no_grad():
     __A	:       int       =	model(**self._prepare_for_class(lowercase_				,			lowercase_   )   )

    __A	:       Optional[Any]       =	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

    __A	:       Optional[int]       =	self.model_tester.num_stages
    self.assertEqual(len(lowercase_   )				,			expected_num_stages + 1   )

    # ResNet'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 // 4, self.model_tester.image_size // 4]				,			)

   __A	:       List[str]       =	self.model_tester.prepare_config_and_inputs_for_common()
   __A	:       Optional[Any]       =	['basic', 'bottleneck']
   for model_class in self.all_model_classes:
    for layer_type in layers_type:
     __A	:       int       =	layer_type
     __A	:       Optional[int]       =	True
     check_hidden_states_output(lowercase_				,			lowercase_				,			lowercase_   )

     # check that output_hidden_states also work using config
     del inputs_dict["output_hidden_states"]
     __A	:       Union[str, Any]       =	True

     check_hidden_states_output(lowercase_				,			lowercase_				,			lowercase_   )



  @unittest.skip(reason='ResNet does not use feedforward chunking'   )
  def 						A_				(self  :		Tuple   )		->							str:
   pass



  def 						A_				(self  :		Dict   )		->							Optional[Any]:
   __A	:       List[str]       =	self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*lowercase_   )



  @slow
  def 						A_				(self  :		str   )		->							Tuple:
   for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
    __A	:       Any       =	ResNetModel.from_pretrained(lowercase_   )
    self.assertIsNotNone(lowercase_   )






def 				a      (     )  ->		int:
 __A	:       List[Any]       =	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'		)
 return image






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



  @cached_property
  def 						A_				(self  :		Union[str, Any]   )		->							Dict:
   return (
       AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )
       if is_vision_available()
       else None
   )



  @slow
  def 						A_				(self  :		Union[str, Any]   )		->							Dict:
   __A	:       Union[str, Any]       =	ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   ).to(lowercase_   )

   __A	:       Union[str, Any]       =	self.default_image_processor
   __A	:       int       =	prepare_img()
   __A	:       List[str]       =	image_processor(images=lowercase_				,			return_tensors='pt'   ).to(lowercase_   )

   # forward pass
   with torch.no_grad():
    __A	:       Optional[int]       =	model(**lowercase_   )

   # verify the logits
   __A	:       str       =	torch.Size((1, 1_000)   )
   self.assertEqual(outputs.logits.shape				,			lowercase_   )

   __A	:       Union[str, Any]       =	torch.tensor([-11.1069, -9.7877, -8.3777]   ).to(lowercase_   )

   self.assertTrue(torch.allclose(outputs.logits[0, :3]				,			lowercase_				,			atol=1E-4   )   )






@require_torch
class __a   (   snake_case_ ,unittest.TestCase				):
  __lowercase    :    Optional[Any]						=					(ResNetBackbone,) if is_torch_available() else ()
  __lowercase    :    List[str]						=					False
  __lowercase    :    int						=					ResNetConfig



  def 						A_				(self  :		List[Any]   )		->							Optional[Any]:
   __A	:       List[Any]       =	ResNetModelTester(self   )













"""simple docstring"""


from string import ascii_uppercase




def 				a (     UpperCamelCase_							:				str     ,	UpperCamelCase_							:				str     ,	UpperCamelCase_							:				bool = False     ,	UpperCamelCase_							:				str = ascii_uppercase		)  ->		str:
 __A	:       List[str]       =	keyword.upper()
 __A	:       str       =	plaintext.upper()
 __A	:       int       =	set(UpperCamelCase_		)

 # create a list of unique characters in the keyword - their order matters
 # it determines how we will map plaintext characters to the ciphertext
 __A	:       int       =	[]
 for char in keyword:
  if char in alphabet_set and char not in unique_chars:
   unique_chars.append(UpperCamelCase_		)
    # the number of those unique characters will determine the number of rows
 __A	:       Any       =	len(UpperCamelCase_		)

 # create a shifted version of the alphabet
 __A	:       str       =	unique_chars + [
     char for char in alphabet if char not in unique_chars
 ]

 # create a modified alphabet by splitting the shifted alphabet into rows
 __A	:       int       =	[
     shifted_alphabet[k : k + num_unique_chars_in_keyword]
     for k in range(0     ,	2_6     ,	UpperCamelCase_		)
 ]

 # map the alphabet characters to the modified alphabet characters
 # going 'vertically' through the modified alphabet - consider columns first
 __A	:       Any       =	{}
 __A	:       Union[str, Any]       =	0
 for column in range(UpperCamelCase_		):
  for row in modified_alphabet:
   # if current row (the last one) is too short, break out of loop
   if len(UpperCamelCase_		) <= column:
    break

   # map current letter to letter in modified alphabet
   __A	:       str       =	row[column]
   letter_index += 1

 if verbose:
  print(UpperCamelCase_		)
 # create the encrypted text by mapping the plaintext to the modified alphabet
 return "".join(mapping[char] if char in mapping else char for char in plaintext		)


if __name__ == "__main__":
   # example use
   print(mixed_keyword("""college""", """UNIVERSITY"""))





