

import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, 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 (
					    FalconForCausalLM,
					    FalconForQuestionAnswering,
					    FalconForSequenceClassification,
					    FalconForTokenClassification,
					    FalconModel,
					)







class  lowercase				:




				def __init__(					self      ,   snake_case      ,   snake_case=3      ,   snake_case=7      ,   snake_case=True      ,   snake_case=True      ,   snake_case=False      ,   snake_case=True      ,   snake_case=99      ,   snake_case=32      ,   snake_case=5      ,   snake_case=4      ,   snake_case=37      ,   snake_case="gelu"      ,   snake_case=0.1      ,   snake_case=0.1      ,   snake_case=512      ,   snake_case=16      ,   snake_case=2      ,   snake_case=0.02      ,   snake_case=3      ,   snake_case=4      ,   snake_case=None      ,   ):
											snake_case_							=    parent
											snake_case_							=    batch_size
											snake_case_							=    seq_length
											snake_case_							=    is_training
											snake_case_							=    use_input_mask
											snake_case_							=    use_token_type_ids
											snake_case_							=    use_labels
											snake_case_							=    vocab_size
											snake_case_							=    hidden_size
											snake_case_							=    num_hidden_layers
											snake_case_							=    num_attention_heads
											snake_case_							=    intermediate_size
											snake_case_							=    hidden_act
											snake_case_							=    hidden_dropout_prob
											snake_case_							=    attention_probs_dropout_prob
											snake_case_							=    max_position_embeddings
											snake_case_							=    type_vocab_size
											snake_case_							=    type_sequence_label_size
											snake_case_							=    initializer_range
											snake_case_							=    num_labels
											snake_case_							=    num_choices
											snake_case_							=    scope




				def     a							(					self       ):
											snake_case_							=    ids_tensor([self.batch_size, self.seq_length]      ,   self.vocab_size       )

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

											snake_case_							=    None

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

											snake_case_							=    self.get_config()

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




				def     a							(					self       ):
											return FalconConfig(
											    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      ,   pad_token_id=1      ,   new_decoder_architecture=snake_case      ,   )




				def     a							(					self      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case       ):
											snake_case_							=    FalconModel(config=snake_case       )
											model.to(snake_case       )
											model.eval()
											snake_case_							=    model(snake_case      ,   attention_mask=snake_case       )
											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      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   ):
											snake_case_							=    True
											snake_case_							=    FalconModel(snake_case       )
											model.to(snake_case       )
											model.eval()
											snake_case_							=    model(
											    snake_case      ,   attention_mask=snake_case      ,   encoder_hidden_states=snake_case      ,   encoder_attention_mask=snake_case      ,   )
											snake_case_							=    model(
											    snake_case      ,   attention_mask=snake_case      ,   encoder_hidden_states=snake_case      ,   )
											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      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   ):
											snake_case_							=    FalconForCausalLM(config=snake_case       )
											model.to(snake_case       )
											model.eval()
											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      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   ):
											snake_case_							=    True
											snake_case_							=    True
											snake_case_							=    FalconForCausalLM(config=snake_case       )
											model.to(snake_case       )
											model.eval()

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

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

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

											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]
											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
											snake_case_							=    ids_tensor((1,)      ,   output_from_past.shape[-1]       ).item()
											snake_case_							=    output_from_no_past[:, -3:, random_slice_idx].detach()
											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       ):
											snake_case_							=    self.prepare_config_and_inputs()
											(
											    (
											    snake_case_
											)				,    (
											    snake_case_
											)				,    (
											    snake_case_
											)				,    (
											    snake_case_
											)				,    (
											    snake_case_
											)				,    (
											    snake_case_
											)				,    (
											    snake_case_
											)				,    
											)							=    config_and_inputs
											snake_case_							=    {'input_ids': input_ids, 'attention_mask': input_mask}
											return config, inputs_dict







@require_torch
class  lowercase				(       lowercase_	,  lowercase_	,  lowercase_	,  unittest.TestCase			):
				__SCREAMING_SNAKE_CASE					: Any       			=			(
				    (
				        FalconModel,
				        FalconForCausalLM,
				        FalconForSequenceClassification,
				        FalconForTokenClassification,
				        FalconForQuestionAnswering,
				    )
				    if is_torch_available()
				    else ()
				)
				__SCREAMING_SNAKE_CASE					: Dict       			=			(FalconForCausalLM,) if is_torch_available() else ()
				__SCREAMING_SNAKE_CASE					: List[Any]       			=			(
				    {
				        '''feature-extraction''': FalconModel,
				        '''text-classification''': FalconForSequenceClassification,
				        '''text-generation''': FalconForCausalLM,
				        '''question-answering''': FalconForQuestionAnswering,
				        '''token-classification''': FalconForTokenClassification,
				        '''zero-shot''': FalconForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				__SCREAMING_SNAKE_CASE					: Dict       			=			False
				__SCREAMING_SNAKE_CASE					: Optional[Any]       			=			False




				def     a							(					self       ):
											snake_case_							=    FalconModelTester(self       )
											snake_case_							=    ConfigTester(self      ,   config_class=snake_case      ,   hidden_size=37       )




				def     a							(					self       ):
											self.config_tester.run_common_tests()




				def     a							(					self       ):
											snake_case_							=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*snake_case       )




				def     a							(					self       ):
											snake_case_				,    *snake_case_							=    self.model_tester.prepare_config_and_inputs()
											for alibi in [True, False]:
																		snake_case_							=    alibi
																		self.model_tester.create_and_check_model(snake_case      ,   *snake_case       )




				def     a							(					self       ):
											snake_case_				,    snake_case_							=    self.model_tester.prepare_config_and_inputs_for_common()
											snake_case_							=    3
											snake_case_							=    input_dict['input_ids']
											snake_case_							=    input_ids.ne(1       ).to(snake_case       )
											snake_case_							=    ids_tensor([self.model_tester.batch_size]      ,   self.model_tester.type_sequence_label_size       )
											snake_case_							=    FalconForSequenceClassification(snake_case       )
											model.to(snake_case       )
											model.eval()
											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       ):
											snake_case_				,    snake_case_							=    self.model_tester.prepare_config_and_inputs_for_common()
											snake_case_							=    3
											snake_case_							=    'single_label_classification'
											snake_case_							=    input_dict['input_ids']
											snake_case_							=    input_ids.ne(1       ).to(snake_case       )
											snake_case_							=    ids_tensor([self.model_tester.batch_size]      ,   self.model_tester.type_sequence_label_size       )
											snake_case_							=    FalconForSequenceClassification(snake_case       )
											model.to(snake_case       )
											model.eval()
											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       ):
											snake_case_				,    snake_case_							=    self.model_tester.prepare_config_and_inputs_for_common()
											snake_case_							=    input_dict['input_ids']
											snake_case_							=    FalconForCausalLM(snake_case       )
											model.to(snake_case       )
											model.eval()
											snake_case_							=    model(snake_case      ,   use_cache=snake_case       )
											snake_case_							=    input_ids.shape[0]
											snake_case_							=    model._convert_to_rw_cache(result.past_key_values       )
											snake_case_							=    model._convert_cache_to_standard_format(snake_case      ,   snake_case       )
											for layer in range(len(snake_case       )       ):
																		for tensor_idx in range(2       ):
																									self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3       )
																									self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4       )
																									self.assertTrue(
																									    torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]       )       )




				def     a							(					self       ):
											snake_case_				,    snake_case_							=    self.model_tester.prepare_config_and_inputs_for_common()
											snake_case_							=    3
											snake_case_							=    'multi_label_classification'
											snake_case_							=    input_dict['input_ids']
											snake_case_							=    input_ids.ne(1       ).to(snake_case       )
											snake_case_							=    ids_tensor(
											    [self.model_tester.batch_size, config.num_labels]      ,   self.model_tester.type_sequence_label_size       ).to(torch.float       )
											snake_case_							=    FalconForSequenceClassification(snake_case       )
											model.to(snake_case       )
											model.eval()
											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       ):
											# Falcon can have different numbers of KV-heads than the number of query heads, so we need
											# to override this test to use the right head counts.
											for model_class in self.all_generative_model_classes:
																		snake_case_				,    snake_case_							=    self.model_tester.prepare_config_and_inputs_for_common()

																		# If it doesn't support cache, pass the test
																		if not hasattr(snake_case      ,   'use_cache'       ):
																									return

																		snake_case_							=    model_class(snake_case       ).to(snake_case       )
																		if "use_cache" not in inputs:
																									snake_case_							=    True
																		snake_case_							=    model(**snake_case       )

																		# If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
																		if "past_key_values" not in outputs:
																									return

																		snake_case_							=    (
																		    getattr(snake_case      ,   'decoder_layers'      ,   snake_case       )
																		    or getattr(snake_case      ,   'num_decoder_layers'      ,   snake_case       )
																		    or config.num_hidden_layers
																		)
																		snake_case_							=    getattr(snake_case      ,   'num_kv_heads'      ,   config.num_attention_heads       )
																		snake_case_							=    getattr(snake_case      ,   'd_model'      ,   config.hidden_size       )
																		snake_case_							=    embed_dim // num_attention_heads

																		snake_case_							=    outputs['past_key_values']
																		self.assertEqual(len(snake_case       )      ,   snake_case       )

																		snake_case_				,    snake_case_							=    inputs['input_ids'].shape
																		for i in range(snake_case       ):
																									if config.new_decoder_architecture:
																																snake_case_							=    config.num_attention_heads
																									elif config.multi_query:
																																snake_case_							=    1
																									self.assertEqual(len(past_kv[0]       )      ,   2       )  # K V for the decoder = 2
																									self.assertEqual(
																									    past_kv[i][0].shape      ,   (batch_size, num_attention_heads, seq_length, per_head_embed_dim)       )
																									self.assertEqual(
																									    past_kv[i][1].shape      ,   (batch_size, num_attention_heads, seq_length, per_head_embed_dim)       )







@require_torch
class  lowercase				(       unittest.TestCase			):




				@slow
				def     a							(					self       ):
											snake_case_							=    AutoTokenizer.from_pretrained('Rocketknight1/falcon-rw-1b'       )
											snake_case_							=    FalconForCausalLM.from_pretrained('Rocketknight1/falcon-rw-1b'       )
											model.eval()
											model.to(snake_case       )
											snake_case_							=    tokenizer('My favorite food is'      ,   return_tensors='pt'       ).to(snake_case       )

											snake_case_							=    (
											    'My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday.'
											)

											snake_case_							=    model.generate(**snake_case      ,   do_sample=snake_case      ,   max_new_tokens=19       )
											snake_case_							=    tokenizer.batch_decode(snake_case       )[0]

											self.assertEqual(snake_case      ,   snake_case       )




				@slow
				def     a							(					self       ):
											# The big models are way too big for the CI, so we use tiny random models that resemble their
											# architectures but with much smaller and fewer layers
											for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
																		snake_case_							=    AutoTokenizer.from_pretrained(snake_case       )
																		snake_case_							=    FalconForCausalLM.from_pretrained(snake_case       )
																		model.eval()
																		model.to(snake_case       )
																		snake_case_							=    tokenizer('My favorite food is'      ,   return_tensors='pt'       ).to(snake_case       )

																		# We just test that these run without errors - the models are randomly initialized
																		# and so the actual text outputs will be garbage
																		model.generate(**snake_case      ,   do_sample=snake_case      ,   max_new_tokens=4       )
																		model.generate(**snake_case      ,   do_sample=snake_case      ,   max_new_tokens=4       )
																		model.generate(**snake_case      ,   num_beams=2      ,   max_new_tokens=4       )




				@slow
				def     a							(					self       ):
											# The big models are way too big for the CI, so we use tiny random models that resemble their
											# architectures but with much smaller and fewer layers
											with torch.no_grad():
																		for repo in [
																		    "Rocketknight1/falcon-rw-1b",
																		    "Rocketknight1/tiny-random-falcon-7b",
																		    "Rocketknight1/tiny-random-falcon-40b",
																		]:
																									snake_case_							=    AutoTokenizer.from_pretrained(snake_case       )
																									snake_case_							=    FalconForCausalLM.from_pretrained(snake_case       )
																									model.eval()
																									model.to(device=snake_case       )
																									snake_case_							=    tokenizer('My favorite food is'      ,   return_tensors='pt'       ).to(snake_case       )

																									# Test results are the same with and without cache
																									snake_case_							=    model.generate(**snake_case      ,   do_sample=snake_case      ,   max_new_tokens=20      ,   use_cache=snake_case       )
																									snake_case_							=    model.generate(**snake_case      ,   do_sample=snake_case      ,   max_new_tokens=20      ,   use_cache=snake_case       )
																									self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0       )







from __future__ import annotations

import collections
import pprint
from pathlib import Path





def 					__lowerCamelCase	( UpperCamelCase__      ):







							'''simple docstring'''






							return "".join(sorted(UpperCamelCase__      )      )





def 					__lowerCamelCase	( UpperCamelCase__      ):







							'''simple docstring'''






							return word_by_signature[signature(UpperCamelCase__      )]


_UpperCAmelCase		:   str										=       Path(__file__).parent.joinpath("""words.txt""").read_text(encoding="""utf-8""")
_UpperCAmelCase		:   Dict										=       sorted({word.strip().lower() for word in data.splitlines()})

_UpperCAmelCase		:   List[str]										=       collections.defaultdict(list)
for word in word_list:
					word_by_signature[signature(word)].append(word)

if __name__ == "__main__":
					_UpperCAmelCase		:   Dict										=       {word: anagram(word) for word in word_list if len(anagram(word)) > 1}

					with open("""anagrams.txt""", """w""") as file:
										file.write("""all_anagrams = \n """)
										file.write(pprint.pformat(all_anagrams))




