


'''simple docstring'''



from string import ascii_uppercase






def 						lowerCamelCase							(_SCREAMING_SNAKE_CASE   :     str		,   _SCREAMING_SNAKE_CASE   :     str		,   _SCREAMING_SNAKE_CASE   :     bool = False		,   _SCREAMING_SNAKE_CASE   :     str = ascii_uppercase     ):
					__a    : Optional[Any]      					=						keyword.upper()
					__a    : Any      					=						plaintext.upper()
					__a    : Optional[int]      					=						set(_SCREAMING_SNAKE_CASE     )

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

					# create a shifted version of the alphabet
					__a    : Union[str, Any]      					=						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    : Optional[Any]      					=						[
					    shifted_alphabet[k : k + num_unique_chars_in_keyword]
					    for k in range(0		,   26		,   _SCREAMING_SNAKE_CASE     )
					]

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

															# map current letter to letter in modified alphabet
															__a    : Union[str, Any]      					=						row[column]
															letter_index += 1

					if verbose:
										print(_SCREAMING_SNAKE_CASE     )
					# 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'))







'''simple docstring'''



from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import SwinConfig
from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers.models.swin.modeling_tf_swin import (
	    TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
	    TFSwinForImageClassification,
	    TFSwinForMaskedImageModeling,
	    TFSwinModel,
	)


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor





class 							__UpperCamelCase       :




	def __init__(     self		,       __a		,       __a=13		,       __a=32		,       __a=2		,       __a=3		,       __a=16		,       __a=[1, 2, 1]		,       __a=[2, 2, 4]		,       __a=2		,       __a=2.0		,       __a=True		,       __a=0.0		,       __a=0.0		,       __a=0.1		,       __a="gelu"		,       __a=False		,       __a=True		,       __a=0.02		,       __a=1E-5		,       __a=True		,       __a=None		,       __a=True		,       __a=10		,       __a=8		,       ):

						'''simple docstring'''





						__a    : Dict      					=						parent
						__a    : int      					=						batch_size
						__a    : str      					=						image_size
						__a    : List[Any]      					=						patch_size
						__a    : Any      					=						num_channels
						__a    : int      					=						embed_dim
						__a    : Optional[Any]      					=						depths
						__a    : Optional[Any]      					=						num_heads
						__a    : List[Any]      					=						window_size
						__a    : Dict      					=						mlp_ratio
						__a    : Any      					=						qkv_bias
						__a    : Any      					=						hidden_dropout_prob
						__a    : Union[str, Any]      					=						attention_probs_dropout_prob
						__a    : str      					=						drop_path_rate
						__a    : Dict      					=						hidden_act
						__a    : List[str]      					=						use_absolute_embeddings
						__a    : str      					=						patch_norm
						__a    : List[str]      					=						layer_norm_eps
						__a    : Optional[Any]      					=						initializer_range
						__a    : str      					=						is_training
						__a    : Any      					=						scope
						__a    : Union[str, Any]      					=						use_labels
						__a    : Optional[int]      					=						type_sequence_label_size
						__a    : Optional[Any]      					=						encoder_stride




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a    : str      					=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

						__a    : List[Any]      					=						None
						if self.use_labels:
											__a    : str      					=						ids_tensor([self.batch_size]		,       self.type_sequence_label_size							)

						__a    : int      					=						self.get_config()

						return config, pixel_values, labels




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						return SwinConfig(
						    image_size=self.image_size		,       patch_size=self.patch_size		,       num_channels=self.num_channels		,       embed_dim=self.embed_dim		,       depths=self.depths		,       num_heads=self.num_heads		,       window_size=self.window_size		,       mlp_ratio=self.mlp_ratio		,       qkv_bias=self.qkv_bias		,       hidden_dropout_prob=self.hidden_dropout_prob		,       attention_probs_dropout_prob=self.attention_probs_dropout_prob		,       drop_path_rate=self.drop_path_rate		,       hidden_act=self.hidden_act		,       use_absolute_embeddings=self.use_absolute_embeddings		,       path_norm=self.patch_norm		,       layer_norm_eps=self.layer_norm_eps		,       initializer_range=self.initializer_range		,       encoder_stride=self.encoder_stride		,       )




	def    __UpperCAmelCase							(     self		,       __a		,       __a		,       __a							):

						'''simple docstring'''





						__a    : Any      					=						TFSwinModel(config=__a							)
						__a    : List[str]      					=						model(__a							)

						__a    : Dict      					=						((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths							) - 1))
						__a    : Any      					=						int(config.embed_dim * 2 ** (len(config.depths							) - 1)							)

						self.parent.assertEqual(result.last_hidden_state.shape		,       (self.batch_size, expected_seq_len, expected_dim)							)




	def    __UpperCAmelCase							(     self		,       __a		,       __a		,       __a							):

						'''simple docstring'''





						__a    : Any      					=						TFSwinForMaskedImageModeling(config=__a							)
						__a    : Tuple      					=						model(__a							)
						self.parent.assertEqual(
						    result.logits.shape		,       (self.batch_size, self.num_channels, self.image_size, self.image_size)							)

						# test greyscale images
						__a    : str      					=						1
						__a    : Union[str, Any]      					=						TFSwinForMaskedImageModeling(__a							)

						__a    : Optional[int]      					=						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
						__a    : Any      					=						model(__a							)
						self.parent.assertEqual(result.logits.shape		,       (self.batch_size, 1, self.image_size, self.image_size)							)




	def    __UpperCAmelCase							(     self		,       __a		,       __a		,       __a							):

						'''simple docstring'''





						__a    : Dict      					=						self.type_sequence_label_size
						__a    : Tuple      					=						TFSwinForImageClassification(__a							)
						__a    : Any      					=						model(__a		,       labels=__a							)
						self.parent.assertEqual(result.logits.shape		,       (self.batch_size, self.type_sequence_label_size)							)

						# test greyscale images
						__a    : Tuple      					=						1
						__a    : str      					=						TFSwinForImageClassification(__a							)
						__a    : List[Any]      					=						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
						__a    : List[str]      					=						model(__a							)
						self.parent.assertEqual(result.logits.shape		,       (self.batch_size, self.type_sequence_label_size)							)





	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a    : List[Any]      					=						self.prepare_config_and_inputs()
						__a					,       __a					,       __a    : Tuple      					=						config_and_inputs
						__a    : Dict      					=						{'pixel_values': pixel_values}
						return config, inputs_dict





@require_tf
class 							__UpperCamelCase       (	lowerCAmelCase_	,   lowerCAmelCase_	,   unittest.TestCase      ):
	A_			    =					(
	    (
	        TFSwinModel,
	        TFSwinForImageClassification,
	        TFSwinForMaskedImageModeling,
	    )
	    if is_tf_available()
	    else ()
	)
	A_			    =					(
	    {"feature-extraction": TFSwinModel, "image-classification": TFSwinForImageClassification}
	    if is_tf_available()
	    else {}
	)

	A_			    =					False
	A_			    =					False
	A_			    =					False
	A_			    =					False




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a    : Optional[int]      					=						TFSwinModelTester(self							)
						__a    : Union[str, Any]      					=						ConfigTester(self		,       config_class=__a		,       embed_dim=37							)




	def    __UpperCAmelCase							(     self							):

						'''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    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						return




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a    : List[str]      					=						self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__a							)




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a    : List[Any]      					=						self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_image_modeling(*__a							)




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a    : Optional[Any]      					=						self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*__a							)




	@unittest.skip(reason='Swin does not use inputs_embeds'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						pass




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a					,       __a    : int      					=						self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
											__a    : Dict      					=						model_class(__a							)
											self.assertIsInstance(model.get_input_embeddings()		,       tf.keras.layers.Layer							)
											__a    : str      					=						model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(__a		,       tf.keras.layers.Dense							)							)




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a					,       __a    : Dict      					=						self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
											__a    : Optional[int]      					=						model_class(__a							)
											__a    : Union[str, Any]      					=						inspect.signature(model.call							)
											# signature.parameters is an OrderedDict => so arg_names order is deterministic
											__a    : Optional[int]      					=						[*signature.parameters.keys()]

											__a    : str      					=						['pixel_values']
											self.assertListEqual(arg_names[:1]		,       __a							)




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a					,       __a    : Any      					=						self.model_tester.prepare_config_and_inputs_for_common()
						__a    : Optional[int]      					=						True

						for model_class in self.all_model_classes:
											__a    : Optional[int]      					=						True
											__a    : Dict      					=						False
											__a    : Any      					=						True
											__a    : Tuple      					=						model_class(__a							)
											__a    : List[str]      					=						model(**self._prepare_for_class(__a		,       __a							)							)
											__a    : int      					=						outputs.attentions
											__a    : List[Any]      					=						len(self.model_tester.depths							)
											self.assertEqual(len(__a							)		,       __a							)

											# check that output_attentions also work using config
											del inputs_dict["output_attentions"]
											__a    : Any      					=						True
											__a    : List[Any]      					=						config.window_size**2
											__a    : Optional[Any]      					=						model_class(__a							)
											__a    : Tuple      					=						model(**self._prepare_for_class(__a		,       __a							)							)
											__a    : str      					=						outputs.attentions
											self.assertEqual(len(__a							)		,       __a							)

											self.assertListEqual(
											    list(attentions[0].shape[-3:]							)		,       [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,       )
											__a    : Any      					=						len(__a							)

											# Check attention is always last and order is fine
											__a    : int      					=						True
											__a    : Any      					=						True
											__a    : str      					=						model_class(__a							)
											__a    : str      					=						model(**self._prepare_for_class(__a		,       __a							)							)

											if hasattr(self.model_tester		,       'num_hidden_states_types'							):
																__a    : Optional[int]      					=						self.model_tester.num_hidden_states_types
											else:
																# also another +1 for reshaped_hidden_states
																__a    : Union[str, Any]      					=						2
											self.assertEqual(out_len + added_hidden_states		,       len(__a							)							)

											__a    : Dict      					=						outputs.attentions

											self.assertEqual(len(__a							)		,       __a							)

											self.assertListEqual(
											    list(self_attentions[0].shape[-3:]							)		,       [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,       )




	def    __UpperCAmelCase							(     self		,       __a		,       __a		,       __a		,       __a							):

						'''simple docstring'''





						__a    : Optional[Any]      					=						model_class(__a							)
						__a    : int      					=						model(**self._prepare_for_class(__a		,       __a							)							)
						__a    : Tuple      					=						outputs.hidden_states

						__a    : Any      					=						getattr(
						    self.model_tester		,       'expected_num_hidden_layers'		,       len(self.model_tester.depths							) + 1							)
						self.assertEqual(len(__a							)		,       __a							)

						# Swin has a different seq_length
						__a    : Optional[int]      					=						to_atuple(config.patch_size							)

						__a    : List[str]      					=						(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

						self.assertListEqual(
						    list(hidden_states[0].shape[-2:]							)		,       [num_patches, self.model_tester.embed_dim]		,       )

						__a    : str      					=						outputs.reshaped_hidden_states
						self.assertEqual(len(__a							)		,       __a							)

						__a					,       __a					,       __a					,       __a    : str      					=						reshaped_hidden_states[0].shape

						__a    : int      					=						tf.reshape(reshaped_hidden_states[0]		,       (batch_size, num_channels, height * width)							)
						__a    : List[str]      					=						tf.transpose(__a		,       (0, 2, 1)							)

						self.assertListEqual(
						    list(reshaped_hidden_states.shape[-2:]							)		,       [num_patches, self.model_tester.embed_dim]		,       )




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a					,       __a    : Optional[Any]      					=						self.model_tester.prepare_config_and_inputs_for_common()

						__a    : Union[str, Any]      					=						to_atuple(self.model_tester.image_size							)

						for model_class in self.all_model_classes:
											__a    : Optional[int]      					=						True
											self.check_hidden_states_output(__a		,       __a		,       __a		,       __a							)

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											__a    : Tuple      					=						True

											self.check_hidden_states_output(__a		,       __a		,       __a		,       __a							)




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a					,       __a    : List[str]      					=						self.model_tester.prepare_config_and_inputs_for_common()
						__a    : List[str]      					=						3

						__a    : Any      					=						to_atuple(self.model_tester.image_size							)
						__a    : Any      					=						to_atuple(config.patch_size							)

						__a    : Any      					=						image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
						__a    : Optional[int]      					=						image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

						for model_class in self.all_model_classes:
											__a    : Union[str, Any]      					=						True
											self.check_hidden_states_output(__a		,       __a		,       __a		,       (padded_height, padded_width)							)

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											__a    : int      					=						True
											self.check_hidden_states_output(__a		,       __a		,       __a		,       (padded_height, padded_width)							)





	@slow
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__a    : List[Any]      					=						TFSwinModel.from_pretrained(__a							)
											self.assertIsNotNone(__a							)





@require_vision
@require_tf
class 							__UpperCamelCase       (	unittest.TestCase      ):




	@cached_property
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						return (
						    AutoImageProcessor.from_pretrained('microsoft/swin-tiny-patch4-window7-224'							)
						    if is_vision_available()
						    else None
						)





	@slow
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a    : Optional[Any]      					=						TFSwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'							)
						__a    : str      					=						self.default_image_processor

						__a    : Optional[Any]      					=						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							)
						__a    : Optional[Any]      					=						image_processor(images=__a		,       return_tensors='tf'							)

						# forward pass
						__a    : List[Any]      					=						model(__a							)

						# verify the logits
						__a    : List[str]      					=						tf.TensorShape((1, 1000)							)
						self.assertEqual(outputs.logits.shape		,       __a							)
						__a    : Optional[Any]      					=						tf.constant([-0.0948, -0.6454, -0.0921]							)
						self.assertTrue(np.allclose(outputs.logits[0, :3]		,       __a		,       atol=1E-4							)							)



