




import unittest

from parameterized import parameterized

from transformers import OpenLlamaConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch

						from transformers import OpenLlamaForCausalLM, OpenLlamaForSequenceClassification, OpenLlamaModel



class    lowercase_		:



						def __init__(			self	:   Optional[int]					,							snake_case__	:   Any					,							snake_case__	:   Optional[int]=13					,							snake_case__	:   str=7					,							snake_case__	:   List[Any]=True					,							snake_case__	:   Any=True					,							snake_case__	:   Union[str, Any]=False					,							snake_case__	:   Union[str, Any]=True					,							snake_case__	:   int=99					,							snake_case__	:   Union[str, Any]=32					,							snake_case__	:   Optional[int]=5					,							snake_case__	:   Optional[int]=4					,							snake_case__	:   int=37					,							snake_case__	:   Tuple="gelu"					,							snake_case__	:   int=0.1					,							snake_case__	:   Optional[int]=0.1					,							snake_case__	:   Union[str, Any]=5_12					,							snake_case__	:   Dict=16					,							snake_case__	:   List[Any]=2					,							snake_case__	:   Optional[Any]=0.02					,							snake_case__	:   Any=3					,							snake_case__	:   str=4					,							snake_case__	:   Union[str, Any]=None					,							):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							parent
								SCREAMING_SNAKE_CASE_					      =							batch_size
								SCREAMING_SNAKE_CASE_					      =							seq_length
								SCREAMING_SNAKE_CASE_					      =							is_training
								SCREAMING_SNAKE_CASE_					      =							use_input_mask
								SCREAMING_SNAKE_CASE_					      =							use_token_type_ids
								SCREAMING_SNAKE_CASE_					      =							use_labels
								SCREAMING_SNAKE_CASE_					      =							vocab_size
								SCREAMING_SNAKE_CASE_					      =							hidden_size
								SCREAMING_SNAKE_CASE_					      =							num_hidden_layers
								SCREAMING_SNAKE_CASE_					      =							num_attention_heads
								SCREAMING_SNAKE_CASE_					      =							intermediate_size
								SCREAMING_SNAKE_CASE_					      =							hidden_act
								SCREAMING_SNAKE_CASE_					      =							hidden_dropout_prob
								SCREAMING_SNAKE_CASE_					      =							attention_probs_dropout_prob
								SCREAMING_SNAKE_CASE_					      =							max_position_embeddings
								SCREAMING_SNAKE_CASE_					      =							type_vocab_size
								SCREAMING_SNAKE_CASE_					      =							type_sequence_label_size
								SCREAMING_SNAKE_CASE_					      =							initializer_range
								SCREAMING_SNAKE_CASE_					      =							num_labels
								SCREAMING_SNAKE_CASE_					      =							num_choices
								SCREAMING_SNAKE_CASE_					      =							scope



						def 	__a					(			self	:   str  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							ids_tensor([self.batch_size, self.seq_length]					,							self.vocab_size  )

								SCREAMING_SNAKE_CASE_					      =							None
								if self.use_input_mask:
										SCREAMING_SNAKE_CASE_					      =							random_attention_mask([self.batch_size, self.seq_length]  )

								SCREAMING_SNAKE_CASE_					      =							None
								if self.use_token_type_ids:
										SCREAMING_SNAKE_CASE_					      =							ids_tensor([self.batch_size, self.seq_length]					,							self.type_vocab_size  )

								SCREAMING_SNAKE_CASE_					      =							None
								SCREAMING_SNAKE_CASE_					      =							None
								SCREAMING_SNAKE_CASE_					      =							None
								if self.use_labels:
										SCREAMING_SNAKE_CASE_					      =							ids_tensor([self.batch_size]					,							self.type_sequence_label_size  )
										SCREAMING_SNAKE_CASE_					      =							ids_tensor([self.batch_size, self.seq_length]					,							self.num_labels  )
										SCREAMING_SNAKE_CASE_					      =							ids_tensor([self.batch_size]					,							self.num_choices  )

								SCREAMING_SNAKE_CASE_					      =							self.get_config()

								return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



						def 	__a					(			self	:   Optional[int]  ):

								"""simple docstring"""

								return OpenLlamaConfig(
								    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=snake_case__					,							initializer_range=self.initializer_range					,							use_stable_embedding=snake_case__					,							)



						def 	__a					(			self	:   int					,							snake_case__	:   Dict					,							snake_case__	:   Any					,							snake_case__	:   Dict					,							snake_case__	:   Any					,							snake_case__	:   Optional[int]					,							snake_case__	:   Tuple					,							snake_case__	:   Any  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							OpenLlamaModel(config=snake_case__  )
								model.to(snake_case__  )
								model.eval()
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							attention_mask=snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__  )
								self.parent.assertEqual(result.last_hidden_state.shape					,							(self.batch_size, self.seq_length, self.hidden_size)  )



						def 	__a					(			self	:   str					,							snake_case__	:   str					,							snake_case__	:   Optional[Any]					,							snake_case__	:   Optional[Any]					,							snake_case__	:   Optional[int]					,							snake_case__	:   Optional[int]					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   Optional[int]					,							snake_case__	:   str					,							snake_case__	:   Union[str, Any]					,							):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							True
								SCREAMING_SNAKE_CASE_					      =							OpenLlamaModel(snake_case__  )
								model.to(snake_case__  )
								model.eval()
								SCREAMING_SNAKE_CASE_					      =							model(
								    snake_case__					,							attention_mask=snake_case__					,							encoder_hidden_states=snake_case__					,							encoder_attention_mask=snake_case__					,							)
								SCREAMING_SNAKE_CASE_					      =							model(
								    snake_case__					,							attention_mask=snake_case__					,							encoder_hidden_states=snake_case__					,							)
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							attention_mask=snake_case__  )
								self.parent.assertEqual(result.last_hidden_state.shape					,							(self.batch_size, self.seq_length, self.hidden_size)  )



						def 	__a					(			self	:   List[str]					,							snake_case__	:   str					,							snake_case__	:   str					,							snake_case__	:   Dict					,							snake_case__	:   str					,							snake_case__	:   Optional[int]					,							snake_case__	:   Dict					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   Optional[Any]					,							snake_case__	:   Union[str, Any]					,							):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							OpenLlamaForCausalLM(config=snake_case__  )
								model.to(snake_case__  )
								model.eval()
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							attention_mask=snake_case__					,							labels=snake_case__  )
								self.parent.assertEqual(result.logits.shape					,							(self.batch_size, self.seq_length, self.vocab_size)  )



						def 	__a					(			self	:   Optional[int]					,							snake_case__	:   Optional[Any]					,							snake_case__	:   Tuple					,							snake_case__	:   int					,							snake_case__	:   Tuple					,							snake_case__	:   List[str]					,							snake_case__	:   int					,							snake_case__	:   Optional[int]					,							snake_case__	:   Any					,							snake_case__	:   List[Any]					,							):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							True
								SCREAMING_SNAKE_CASE_					      =							True
								SCREAMING_SNAKE_CASE_					      =							OpenLlamaForCausalLM(config=snake_case__  )
								model.to(snake_case__  )
								model.eval()

								# first forward pass
								SCREAMING_SNAKE_CASE_					      =							model(
								    snake_case__					,							attention_mask=snake_case__					,							encoder_hidden_states=snake_case__					,							encoder_attention_mask=snake_case__					,							use_cache=snake_case__					,							)
								SCREAMING_SNAKE_CASE_					      =							outputs.past_key_values

								# create hypothetical multiple next token and extent to next_input_ids
								SCREAMING_SNAKE_CASE_					      =							ids_tensor((self.batch_size, 3)					,							config.vocab_size  )
								SCREAMING_SNAKE_CASE_					      =							ids_tensor((self.batch_size, 3)					,							vocab_size=2  )

								# append to next input_ids and
								SCREAMING_SNAKE_CASE_					      =							torch.cat([input_ids, next_tokens]					,							dim=-1  )
								SCREAMING_SNAKE_CASE_					      =							torch.cat([input_mask, next_mask]					,							dim=-1  )

								SCREAMING_SNAKE_CASE_					      =							model(
								    snake_case__					,							attention_mask=snake_case__					,							encoder_hidden_states=snake_case__					,							encoder_attention_mask=snake_case__					,							output_hidden_states=snake_case__					,							)['hidden_states'][0]
								SCREAMING_SNAKE_CASE_					      =							model(
								    snake_case__					,							attention_mask=snake_case__					,							encoder_hidden_states=snake_case__					,							encoder_attention_mask=snake_case__					,							past_key_values=snake_case__					,							output_hidden_states=snake_case__					,							)['hidden_states'][0]

								# select random slice
								SCREAMING_SNAKE_CASE_					      =							ids_tensor((1,)					,							output_from_past.shape[-1]  ).item()
								SCREAMING_SNAKE_CASE_					      =							output_from_no_past[:, -3:, random_slice_idx].detach()
								SCREAMING_SNAKE_CASE_					      =							output_from_past[:, :, random_slice_idx].detach()

								self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]  )

								# test that outputs are equal for slice
								self.parent.assertTrue(torch.allclose(snake_case__					,							snake_case__					,							atol=1e-3  )  )






						def 	__a					(			self	:   Dict  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.prepare_config_and_inputs()
								(
								    (
								    SCREAMING_SNAKE_CASE_
								)      ,				(
								    SCREAMING_SNAKE_CASE_
								)      ,				(
								    SCREAMING_SNAKE_CASE_
								)      ,				(
								    SCREAMING_SNAKE_CASE_
								)      ,				(
								    SCREAMING_SNAKE_CASE_
								)      ,				(
								    SCREAMING_SNAKE_CASE_
								)      ,				(
								    SCREAMING_SNAKE_CASE_
								)      ,				
								)					      =							config_and_inputs
								SCREAMING_SNAKE_CASE_					      =							{'input_ids': input_ids, 'attention_mask': input_mask}
								return config, inputs_dict



@require_torch
class    lowercase_		(SCREAMING_SNAKE_CASE__							,	SCREAMING_SNAKE_CASE__							,	SCREAMING_SNAKE_CASE__							,	unittest.TestCase ):
						lowerCAmelCase__			      =(
						    (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else ()
						)
						lowerCAmelCase__			      =(OpenLlamaForCausalLM,) if is_torch_available() else ()
						lowerCAmelCase__			      =(
						    {
						        "feature-extraction": OpenLlamaModel,
						        "text-classification": OpenLlamaForSequenceClassification,
						        "text-generation": OpenLlamaForCausalLM,
						        "zero-shot": OpenLlamaForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)
						lowerCAmelCase__			      =False
						lowerCAmelCase__			      =False



						def 	__a					(			self	:   Tuple  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							OpenLlamaModelTester(self  )
								SCREAMING_SNAKE_CASE_					      =							ConfigTester(self					,							config_class=snake_case__					,							hidden_size=37  )



						def 	__a					(			self	:   Optional[int]  ):

								"""simple docstring"""

								self.config_tester.run_common_tests()



						def 	__a					(			self	:   List[str]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case__  )



						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
										SCREAMING_SNAKE_CASE_					      =							type
										self.model_tester.create_and_check_model(*snake_case__  )



						def 	__a					(			self	:   str  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs_for_common()
								SCREAMING_SNAKE_CASE_					      =							3
								SCREAMING_SNAKE_CASE_					      =							input_dict['input_ids']
								SCREAMING_SNAKE_CASE_					      =							input_ids.ne(1  ).to(snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							ids_tensor([self.model_tester.batch_size]					,							self.model_tester.type_sequence_label_size  )
								SCREAMING_SNAKE_CASE_					      =							OpenLlamaForSequenceClassification(snake_case__  )
								model.to(snake_case__  )
								model.eval()
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							attention_mask=snake_case__					,							labels=snake_case__  )
								self.assertEqual(result.logits.shape					,							(self.model_tester.batch_size, self.model_tester.num_labels)  )



						def 	__a					(			self	:   Dict  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs_for_common()
								SCREAMING_SNAKE_CASE_					      =							3
								SCREAMING_SNAKE_CASE_					      =							'single_label_classification'
								SCREAMING_SNAKE_CASE_					      =							input_dict['input_ids']
								SCREAMING_SNAKE_CASE_					      =							input_ids.ne(1  ).to(snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							ids_tensor([self.model_tester.batch_size]					,							self.model_tester.type_sequence_label_size  )
								SCREAMING_SNAKE_CASE_					      =							OpenLlamaForSequenceClassification(snake_case__  )
								model.to(snake_case__  )
								model.eval()
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							attention_mask=snake_case__					,							labels=snake_case__  )
								self.assertEqual(result.logits.shape					,							(self.model_tester.batch_size, self.model_tester.num_labels)  )



						def 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs_for_common()
								SCREAMING_SNAKE_CASE_					      =							3
								SCREAMING_SNAKE_CASE_					      =							'multi_label_classification'
								SCREAMING_SNAKE_CASE_					      =							input_dict['input_ids']
								SCREAMING_SNAKE_CASE_					      =							input_ids.ne(1  ).to(snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							ids_tensor(
								    [self.model_tester.batch_size, config.num_labels]					,							self.model_tester.type_sequence_label_size  ).to(torch.float  )
								SCREAMING_SNAKE_CASE_					      =							OpenLlamaForSequenceClassification(snake_case__  )
								model.to(snake_case__  )
								model.eval()
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							attention_mask=snake_case__					,							labels=snake_case__  )
								self.assertEqual(result.logits.shape					,							(self.model_tester.batch_size, self.model_tester.num_labels)  )



						@unittest.skip('Open-Llama buffers include complex numbers, which breaks this test'  )
						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								pass






						@parameterized.expand([('linear',), ('dynamic',)]  )
						def 	__a					(			self	:   int					,							snake_case__	:   Tuple  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs_for_common()
								SCREAMING_SNAKE_CASE_					      =							ids_tensor([1, 10]					,							config.vocab_size  )
								SCREAMING_SNAKE_CASE_					      =							ids_tensor([1, int(config.max_position_embeddings * 1.5  )]					,							config.vocab_size  )

								set_seed(42  )  # Fixed seed at init time so the two models get the same random weights
								SCREAMING_SNAKE_CASE_					      =							OpenLlamaModel(snake_case__  )
								original_model.to(snake_case__  )
								original_model.eval()
								SCREAMING_SNAKE_CASE_					      =							original_model(snake_case__  ).last_hidden_state
								SCREAMING_SNAKE_CASE_					      =							original_model(snake_case__  ).last_hidden_state

								set_seed(42  )  # Fixed seed at init time so the two models get the same random weights
								SCREAMING_SNAKE_CASE_					      =							{'type': scaling_type, 'factor': 10.0}
								SCREAMING_SNAKE_CASE_					      =							OpenLlamaModel(snake_case__  )
								scaled_model.to(snake_case__  )
								scaled_model.eval()
								SCREAMING_SNAKE_CASE_					      =							scaled_model(snake_case__  ).last_hidden_state
								SCREAMING_SNAKE_CASE_					      =							scaled_model(snake_case__  ).last_hidden_state

								# Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
								# maximum sequence length, so the outputs for the short input should match.
								if scaling_type == "dynamic":
										self.assertTrue(torch.allclose(snake_case__					,							snake_case__					,							atol=1e-5  )  )
								else:
										self.assertFalse(torch.allclose(snake_case__					,							snake_case__					,							atol=1e-5  )  )

								# The output should be different for long inputs
								self.assertFalse(torch.allclose(snake_case__					,							snake_case__					,							atol=1e-5  )  )





from collections import defaultdict


def 					_a							(					lowerCAmelCase    ,						lowerCAmelCase )->	bool:
		SCREAMING_SNAKE_CASE_					      =							first_str.lower().strip()
		SCREAMING_SNAKE_CASE_					      =							second_str.lower().strip()

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

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

		# Default values for count should be 0
		SCREAMING_SNAKE_CASE_					      =							defaultdict(lowerCAmelCase )

		# For each character in input strings,
		# increment count in the corresponding
		for i in range(len(lowerCAmelCase ) ):
				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()
						SCREAMING_SNAKE_CASE:     Dict									= input('''Enter the first string ''').strip()
						SCREAMING_SNAKE_CASE:     str									= input('''Enter the second string ''').strip()

						SCREAMING_SNAKE_CASE:     Optional[Any]									= check_anagrams(input_a, input_b)
						print(f"""{input_a} and {input_b} are {'' if status else 'not '}anagrams.""")