




'''simple docstring'''


import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_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 MaskFormerSwinBackbone
	from transformers.models.maskformer import MaskFormerSwinModel
class 						a_				:




	def __init__(       self     :  Dict       ,		__lowerCAmelCase     :  Optional[int]       ,		__lowerCAmelCase     :  Dict=1_3       ,		__lowerCAmelCase     :  int=3_2       ,		__lowerCAmelCase     :  List[str]=2       ,		__lowerCAmelCase     :  List[str]=3       ,		__lowerCAmelCase     :  str=1_6       ,		__lowerCAmelCase     :  int=[1, 2, 1]       ,		__lowerCAmelCase     :  int=[2, 2, 4]       ,		__lowerCAmelCase     :  Dict=2       ,		__lowerCAmelCase     :  Any=2.0       ,		__lowerCAmelCase     :  Tuple=True       ,		__lowerCAmelCase     :  str=0.0       ,		__lowerCAmelCase     :  Union[str, Any]=0.0       ,		__lowerCAmelCase     :  List[str]=0.1       ,		__lowerCAmelCase     :  Optional[Any]="gelu"       ,		__lowerCAmelCase     :  Tuple=False       ,		__lowerCAmelCase     :  Optional[Any]=True       ,		__lowerCAmelCase     :  Dict=0.02       ,		__lowerCAmelCase     :  List[str]=1E-5       ,		__lowerCAmelCase     :  Tuple=True       ,		__lowerCAmelCase     :  Any=None       ,		__lowerCAmelCase     :  int=True       ,		__lowerCAmelCase     :  Optional[int]=1_0       ,		__lowerCAmelCase     :  int=8       ,		__lowerCAmelCase     :  Optional[Any]=["stage1", "stage2", "stage3"]       ,		__lowerCAmelCase     :  Union[str, Any]=[1, 2, 3]       ,		):
							__snake_case						 =   parent
							__snake_case						 =   batch_size
							__snake_case						 =   image_size
							__snake_case						 =   patch_size
							__snake_case						 =   num_channels
							__snake_case						 =   embed_dim
							__snake_case						 =   depths
							__snake_case						 =   num_heads
							__snake_case						 =   window_size
							__snake_case						 =   mlp_ratio
							__snake_case						 =   qkv_bias
							__snake_case						 =   hidden_dropout_prob
							__snake_case						 =   attention_probs_dropout_prob
							__snake_case						 =   drop_path_rate
							__snake_case						 =   hidden_act
							__snake_case						 =   use_absolute_embeddings
							__snake_case						 =   patch_norm
							__snake_case						 =   layer_norm_eps
							__snake_case						 =   initializer_range
							__snake_case						 =   is_training
							__snake_case						 =   scope
							__snake_case						 =   use_labels
							__snake_case						 =   type_sequence_label_size
							__snake_case						 =   encoder_stride
							__snake_case						 =   out_features
							__snake_case						 =   out_indices




	def   lowercase__   (       self     :  str      ):
							__snake_case						 =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

							__snake_case						 =   None
							if self.use_labels:
													__snake_case						 =   ids_tensor([self.batch_size]       ,		self.type_sequence_label_size      )

							__snake_case						 =   self.get_config()

							return config, pixel_values, labels




	def   lowercase__   (       self     :  Optional[Any]      ):
							return MaskFormerSwinConfig(
							    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       ,		out_features=self.out_features       ,		out_indices=self.out_indices       ,		)




	def   lowercase__   (       self     :  Tuple       ,		__lowerCAmelCase     :  Dict       ,		__lowerCAmelCase     :  Union[str, Any]       ,		__lowerCAmelCase     :  List[str]      ):
							__snake_case						 =   MaskFormerSwinModel(config=__lowerCAmelCase      )
							model.to(__lowerCAmelCase      )
							model.eval()
							__snake_case						 =   model(__lowerCAmelCase      )

							__snake_case						 =   ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths      ) - 1))
							__snake_case						 =   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   lowercase__   (       self     :  Union[str, Any]       ,		__lowerCAmelCase     :  Optional[int]       ,		__lowerCAmelCase     :  Optional[int]       ,		__lowerCAmelCase     :  Optional[int]      ):
							__snake_case						 =   MaskFormerSwinBackbone(config=__lowerCAmelCase      )
							model.to(__lowerCAmelCase      )
							model.eval()
							__snake_case						 =   model(__lowerCAmelCase      )

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

							# verify channels
							self.parent.assertEqual(len(model.channels      )       ,		len(config.out_features      )      )
							self.parent.assertListEqual(model.channels       ,		[1_6, 3_2, 6_4]      )

							# verify ValueError
							with self.parent.assertRaises(__lowerCAmelCase      ):
													__snake_case						 =   ['stem']
													__snake_case						 =   MaskFormerSwinBackbone(config=__lowerCAmelCase      )




	def   lowercase__   (       self     :  Tuple      ):
							__snake_case						 =   self.prepare_config_and_inputs()
							__snake_case ,       __snake_case ,       __snake_case						 =   config_and_inputs
							__snake_case						 =   {'pixel_values': pixel_values}
							return config, inputs_dict





@require_torch
class 						a_				(			UpperCAmelCase__     ,						UpperCAmelCase__     ,						unittest.TestCase						):
	lowercase_       :     List[Any]			  =      (
	    (
	        MaskFormerSwinModel,
	        MaskFormerSwinBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	lowercase_       :     Dict			  =      {'''feature-extraction''': MaskFormerSwinModel} if is_torch_available() else {}
	lowercase_       :     Any			  =      False
	lowercase_       :     Any			  =      False
	lowercase_       :     List[str]			  =      False
	lowercase_       :     str			  =      False
	lowercase_       :     List[str]			  =      False




	def   lowercase__   (       self     :  Optional[Any]      ):
							__snake_case						 =   MaskFormerSwinModelTester(self      )
							__snake_case						 =   ConfigTester(self       ,		config_class=__lowerCAmelCase       ,		embed_dim=3_7      )




	@require_torch_multi_gpu
	@unittest.skip(
	    reason=(
	        '`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'
	        ' `nn.DataParallel`'
	    )      )
	def   lowercase__   (       self     :  Union[str, Any]      ):
							pass




	def   lowercase__   (       self     :  Optional[int]      ):
							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   lowercase__   (       self     :  Dict      ):
							return




	def   lowercase__   (       self     :  Union[str, Any]      ):
							__snake_case						 =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__lowerCAmelCase      )




	def   lowercase__   (       self     :  Optional[int]      ):
							__snake_case						 =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*__lowerCAmelCase      )




	@unittest.skip('Swin does not use inputs_embeds'      )
	def   lowercase__   (       self     :  Any      ):
							pass




	@unittest.skip('Swin does not support feedforward chunking'      )
	def   lowercase__   (       self     :  str      ):
							pass




	def   lowercase__   (       self     :  Any      ):
							__snake_case ,       __snake_case						 =   self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													__snake_case						 =   model_class(__lowerCAmelCase      )
													self.assertIsInstance(model.get_input_embeddings()       ,		(nn.Module)      )
													__snake_case						 =   model.get_output_embeddings()
													self.assertTrue(x is None or isinstance(__lowerCAmelCase       ,		nn.Linear      )      )




	def   lowercase__   (       self     :  List[Any]      ):
							__snake_case ,       __snake_case						 =   self.model_tester.prepare_config_and_inputs_for_common()

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

													__snake_case						 =   ['pixel_values']
													self.assertListEqual(arg_names[:1]       ,		__lowerCAmelCase      )




	@unittest.skip(reason='MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'      )
	def   lowercase__   (       self     :  Optional[int]      ):
							pass




	@unittest.skip(reason='MaskFormerSwin is only used as an internal backbone'      )
	def   lowercase__   (       self     :  Any      ):
							pass




	def   lowercase__   (       self     :  Any       ,		__lowerCAmelCase     :  Any       ,		__lowerCAmelCase     :  int       ,		__lowerCAmelCase     :  int       ,		__lowerCAmelCase     :  str      ):
							__snake_case						 =   model_class(__lowerCAmelCase      )
							model.to(__lowerCAmelCase      )
							model.eval()

							with torch.no_grad():
													__snake_case						 =   model(**self._prepare_for_class(__lowerCAmelCase       ,		__lowerCAmelCase      )      )

							__snake_case						 =   outputs.hidden_states

							__snake_case						 =   getattr(
							    self.model_tester       ,		'expected_num_hidden_layers'       ,		len(self.model_tester.depths      ) + 1      )
							self.assertEqual(len(__lowerCAmelCase      )       ,		__lowerCAmelCase      )

							# Swin has a different seq_length
							__snake_case						 =   (
							    config.patch_size
							    if isinstance(config.patch_size       ,		collections.abc.Iterable      )
							    else (config.patch_size, config.patch_size)
							)

							__snake_case						 =   (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]       ,		)




	def   lowercase__   (       self     :  int      ):
							__snake_case ,       __snake_case						 =   self.model_tester.prepare_config_and_inputs_for_common()

							__snake_case						 =   (
							    self.model_tester.image_size
							    if isinstance(self.model_tester.image_size       ,		collections.abc.Iterable      )
							    else (self.model_tester.image_size, self.model_tester.image_size)
							)

							for model_class in self.all_model_classes:
													__snake_case						 =   True
													self.check_hidden_states_output(__lowerCAmelCase       ,		__lowerCAmelCase       ,		__lowerCAmelCase       ,		__lowerCAmelCase      )

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

													self.check_hidden_states_output(__lowerCAmelCase       ,		__lowerCAmelCase       ,		__lowerCAmelCase       ,		__lowerCAmelCase      )




	def   lowercase__   (       self     :  Tuple      ):
							__snake_case ,       __snake_case						 =   self.model_tester.prepare_config_and_inputs_for_common()
							__snake_case						 =   3

							__snake_case						 =   (
							    self.model_tester.image_size
							    if isinstance(self.model_tester.image_size       ,		collections.abc.Iterable      )
							    else (self.model_tester.image_size, self.model_tester.image_size)
							)
							__snake_case						 =   (
							    config.patch_size
							    if isinstance(config.patch_size       ,		collections.abc.Iterable      )
							    else (config.patch_size, config.patch_size)
							)

							__snake_case						 =   image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
							__snake_case						 =   image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

							for model_class in self.all_model_classes:
													__snake_case						 =   True
													self.check_hidden_states_output(__lowerCAmelCase       ,		__lowerCAmelCase       ,		__lowerCAmelCase       ,		(padded_height, padded_width)      )

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




	@unittest.skip(reason='MaskFormerSwin doesn\'t have pretrained checkpoints'      )
	def   lowercase__   (       self     :  Union[str, Any]      ):
							pass




	@unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'      )
	def   lowercase__   (       self     :  str      ):
							pass




	@unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'      )
	def   lowercase__   (       self     :  Dict      ):
							pass




	def   lowercase__   (       self     :  List[Any]      ):
							__snake_case ,       __snake_case						 =   self.model_tester.prepare_config_and_inputs_for_common()

							def set_nan_tensor_to_zero(__lowerCAmelCase     :  str      ):
													__snake_case						 =   0
													return t

							def check_equivalence(__lowerCAmelCase     :  str       ,		__lowerCAmelCase     :  Optional[int]       ,		__lowerCAmelCase     :  Tuple       ,		__lowerCAmelCase     :  Any={}      ):
													with torch.no_grad():
																			__snake_case						 =   model(**__lowerCAmelCase       ,		return_dict=__lowerCAmelCase       ,		**__lowerCAmelCase      )
																			__snake_case						 =   model(**__lowerCAmelCase       ,		return_dict=__lowerCAmelCase       ,		**__lowerCAmelCase      ).to_tuple()

																			def recursive_check(__lowerCAmelCase     :  Optional[int]       ,		__lowerCAmelCase     :  Union[str, Any]      ):
																									if isinstance(__lowerCAmelCase       ,		(List, Tuple)      ):
																															for tuple_iterable_value, dict_iterable_value in zip(__lowerCAmelCase       ,		__lowerCAmelCase      ):
																																					recursive_check(__lowerCAmelCase       ,		__lowerCAmelCase      )
																									elif isinstance(__lowerCAmelCase       ,		__lowerCAmelCase      ):
																															for tuple_iterable_value, dict_iterable_value in zip(
																															    tuple_object.values()       ,		dict_object.values()      ):
																																					recursive_check(__lowerCAmelCase       ,		__lowerCAmelCase      )
																									elif tuple_object is None:
																															return
																									else:
																															self.assertTrue(
																															    torch.allclose(
																															        set_nan_tensor_to_zero(__lowerCAmelCase      )       ,		set_nan_tensor_to_zero(__lowerCAmelCase      )       ,		atol=1E-5      )       ,		msg=(
																															        'Tuple and dict output are not equal. Difference:'
																															        F' {torch.max(torch.abs(tuple_object - dict_object      )      )}. Tuple has `nan`:'
																															        F' {torch.isnan(__lowerCAmelCase      ).any()} and `inf`: {torch.isinf(__lowerCAmelCase      )}. Dict has'
																															        F' `nan`: {torch.isnan(__lowerCAmelCase      ).any()} and `inf`: {torch.isinf(__lowerCAmelCase      )}.'
																															    )       ,		)

																			recursive_check(__lowerCAmelCase       ,		__lowerCAmelCase      )

							for model_class in self.all_model_classes:
													__snake_case						 =   model_class(__lowerCAmelCase      )
													model.to(__lowerCAmelCase      )
													model.eval()

													__snake_case						 =   self._prepare_for_class(__lowerCAmelCase       ,		__lowerCAmelCase      )
													__snake_case						 =   self._prepare_for_class(__lowerCAmelCase       ,		__lowerCAmelCase      )
													check_equivalence(__lowerCAmelCase       ,		__lowerCAmelCase       ,		__lowerCAmelCase      )

													__snake_case						 =   self._prepare_for_class(__lowerCAmelCase       ,		__lowerCAmelCase       ,		return_labels=__lowerCAmelCase      )
													__snake_case						 =   self._prepare_for_class(__lowerCAmelCase       ,		__lowerCAmelCase       ,		return_labels=__lowerCAmelCase      )
													check_equivalence(__lowerCAmelCase       ,		__lowerCAmelCase       ,		__lowerCAmelCase      )

													__snake_case						 =   self._prepare_for_class(__lowerCAmelCase       ,		__lowerCAmelCase      )
													__snake_case						 =   self._prepare_for_class(__lowerCAmelCase       ,		__lowerCAmelCase      )
													check_equivalence(__lowerCAmelCase       ,		__lowerCAmelCase       ,		__lowerCAmelCase       ,		{'output_hidden_states': True}      )

													__snake_case						 =   self._prepare_for_class(__lowerCAmelCase       ,		__lowerCAmelCase       ,		return_labels=__lowerCAmelCase      )
													__snake_case						 =   self._prepare_for_class(__lowerCAmelCase       ,		__lowerCAmelCase       ,		return_labels=__lowerCAmelCase      )
													check_equivalence(__lowerCAmelCase       ,		__lowerCAmelCase       ,		__lowerCAmelCase       ,		{'output_hidden_states': True}      )





@require_torch
class 						a_				(			unittest.TestCase     ,						UpperCAmelCase__						):
	lowercase_       :     Union[str, Any]			  =      (MaskFormerSwinBackbone,) if is_torch_available() else ()
	lowercase_       :     str			  =      MaskFormerSwinConfig




	def   lowercase__   (       self     :  List[str]      ):
							__snake_case						 =   MaskFormerSwinModelTester(self      )




	def   lowercase__   (       self     :  Dict      ):
							__snake_case ,       __snake_case						 =   self.model_tester.prepare_config_and_inputs_for_common()
							__snake_case						 =   inputs_dict['pixel_values'].shape[0]

							for backbone_class in self.all_model_classes:
													__snake_case						 =   backbone_class(__lowerCAmelCase      )
													backbone.to(__lowerCAmelCase      )
													backbone.eval()

													__snake_case						 =   backbone(**__lowerCAmelCase      )

													# Test default outputs and verify feature maps
													self.assertIsInstance(outputs.feature_maps       ,		__lowerCAmelCase      )
													self.assertTrue(len(outputs.feature_maps      ) == len(backbone.channels      )      )
													for feature_map, n_channels in zip(outputs.feature_maps       ,		backbone.channels      ):
																			self.assertTrue(feature_map.shape[:2]       ,		(batch_size, n_channels)      )
													self.assertIsNone(outputs.hidden_states      )
													self.assertIsNone(outputs.attentions      )

													# Test output_hidden_states=True
													__snake_case						 =   backbone(**__lowerCAmelCase       ,		output_hidden_states=__lowerCAmelCase      )
													self.assertIsNotNone(outputs.hidden_states      )
													self.assertTrue(len(outputs.hidden_states      )       ,		len(backbone.stage_names      )      )
													# We skip the stem layer
													for hidden_states, n_channels in zip(outputs.hidden_states[1:]       ,		backbone.channels      ):
																			for hidden_state in hidden_states:
																									# Hidden states are in the format (batch_size, (height * width), n_channels)
																									__snake_case ,       __snake_case ,       __snake_case						 =   hidden_state.shape
																									self.assertTrue((h_batch_size, h_n_channels)       ,		(batch_size, n_channels)      )

            # Test output_attentions=True
													if self.has_attentions:
																			__snake_case						 =   backbone(**__lowerCAmelCase       ,		output_attentions=__lowerCAmelCase      )
																			self.assertIsNotNone(outputs.attentions      )







'''simple docstring'''


from collections import defaultdict
def 						lowerCamelCase__   (				a    ,	a							):
						__snake_case						 =   first_str.lower().strip()
						__snake_case						 =   second_str.lower().strip()

						# Remove whitespace
						__snake_case						 =   first_str.replace(' '    ,	''							)
						__snake_case						 =   second_str.replace(' '    ,	''							)

						# Strings of different lengths are not anagrams
						if len(a							) != len(a							):
												return False

						# Default values for count should be 0
						__snake_case						 =   defaultdict(a							)

						# For each character in input strings,
						# increment count in the corresponding
						for i in range(len(a							)							):
												count[first_str[i]] += 1
												count[second_str[i]] -= 1

						return all(_count == 0 for _count in count.values()							)


if __name__ == "__main__":
	from doctest import testmod

	testmod()
	_lowercase  =			input("""Enter the first string """).strip()
	_lowercase  =			input("""Enter the second string """).strip()

	_lowercase  =			check_anagrams(input_a, input_b)
	print(f'''{input_a} and {input_b} are {'' if status else 'not '}anagrams.''')

