



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 			__magic_name__ :






		def __init__(    self   :  Any					,		UpperCamelCase__   :  str					,		UpperCamelCase__   :  Optional[int]=3					,		UpperCamelCase__   :  str=7					,		UpperCamelCase__   :  str=True					,		UpperCamelCase__   :  Optional[Any]=True					,		UpperCamelCase__   :  Tuple=False					,		UpperCamelCase__   :  List[Any]=True					,		UpperCamelCase__   :  Dict=99					,		UpperCamelCase__   :  Optional[Any]=32					,		UpperCamelCase__   :  Any=5					,		UpperCamelCase__   :  Optional[Any]=4					,		UpperCamelCase__   :  str=37					,		UpperCamelCase__   :  Optional[Any]="gelu"					,		UpperCamelCase__   :  Any=0.1					,		UpperCamelCase__   :  Dict=0.1					,		UpperCamelCase__   :  int=5_12					,		UpperCamelCase__   :  List[str]=16					,		UpperCamelCase__   :  str=2					,		UpperCamelCase__   :  int=0.02					,		UpperCamelCase__   :  Tuple=3					,		UpperCamelCase__   :  List[Any]=4					,		UpperCamelCase__   :  List[Any]=None					,		)					->       List[Any]:
								'''simple docstring'''







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






		def SCREAMING_SNAKE_CASE_      (    self   :  Dict   )					->       Optional[Any]:
								'''simple docstring'''







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

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

								UpperCAmelCase								=  None

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

								UpperCAmelCase								=  self.get_config()

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






		def SCREAMING_SNAKE_CASE_      (    self   :  Any   )					->       Dict:
								'''simple docstring'''







								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=__a					,		initializer_range=self.initializer_range					,		pad_token_id=1					,		new_decoder_architecture=__a					,		)






		def SCREAMING_SNAKE_CASE_      (    self   :  Optional[int]					,		UpperCamelCase__   :  str					,		UpperCamelCase__   :  Union[str, Any]					,		UpperCamelCase__   :  Tuple					,		UpperCamelCase__   :  Tuple					,		UpperCamelCase__   :  List[Any]					,		UpperCamelCase__   :  int					,		UpperCamelCase__   :  Any   )					->       Any:
								'''simple docstring'''







								UpperCAmelCase								=  FalconModel(config=__a   )
								model.to(__a   )
								model.eval()
								UpperCAmelCase								=  model(__a					,		attention_mask=__a   )
								UpperCAmelCase								=  model(__a   )
								self.parent.assertEqual(result.last_hidden_state.shape					,		(self.batch_size, self.seq_length, self.hidden_size)   )






		def SCREAMING_SNAKE_CASE_      (    self   :  List[str]					,		UpperCamelCase__   :  List[Any]					,		UpperCamelCase__   :  List[str]					,		UpperCamelCase__   :  List[str]					,		UpperCamelCase__   :  Tuple					,		UpperCamelCase__   :  Tuple					,		UpperCamelCase__   :  Optional[Any]					,		UpperCamelCase__   :  Tuple					,		UpperCamelCase__   :  List[str]					,		UpperCamelCase__   :  str					,		)					->       List[Any]:
								'''simple docstring'''







								UpperCAmelCase								=  True
								UpperCAmelCase								=  FalconModel(__a   )
								model.to(__a   )
								model.eval()
								UpperCAmelCase								=  model(
								    __a					,		attention_mask=__a					,		encoder_hidden_states=__a					,		encoder_attention_mask=__a					,		)
								UpperCAmelCase								=  model(
								    __a					,		attention_mask=__a					,		encoder_hidden_states=__a					,		)
								UpperCAmelCase								=  model(__a					,		attention_mask=__a   )
								self.parent.assertEqual(result.last_hidden_state.shape					,		(self.batch_size, self.seq_length, self.hidden_size)   )






		def SCREAMING_SNAKE_CASE_      (    self   :  Any					,		UpperCamelCase__   :  str					,		UpperCamelCase__   :  int					,		UpperCamelCase__   :  Any					,		UpperCamelCase__   :  Union[str, Any]					,		UpperCamelCase__   :  Any					,		UpperCamelCase__   :  int					,		UpperCamelCase__   :  Optional[int]					,		UpperCamelCase__   :  Dict					,		UpperCamelCase__   :  List[Any]					,		)					->       Tuple:
								'''simple docstring'''







								UpperCAmelCase								=  FalconForCausalLM(config=__a   )
								model.to(__a   )
								model.eval()
								UpperCAmelCase								=  model(__a					,		attention_mask=__a					,		labels=__a   )
								self.parent.assertEqual(result.logits.shape					,		(self.batch_size, self.seq_length, self.vocab_size)   )






		def SCREAMING_SNAKE_CASE_      (    self   :  Dict					,		UpperCamelCase__   :  Dict					,		UpperCamelCase__   :  str					,		UpperCamelCase__   :  List[str]					,		UpperCamelCase__   :  List[Any]					,		UpperCamelCase__   :  Union[str, Any]					,		UpperCamelCase__   :  Any					,		UpperCamelCase__   :  Union[str, Any]					,		UpperCamelCase__   :  Optional[Any]					,		UpperCamelCase__   :  Optional[int]					,		)					->       List[str]:
								'''simple docstring'''







								UpperCAmelCase								=  True
								UpperCAmelCase								=  True
								UpperCAmelCase								=  FalconForCausalLM(config=__a   )
								model.to(__a   )
								model.eval()

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

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

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

								UpperCAmelCase								=  model(
								    __a					,		attention_mask=__a					,		encoder_hidden_states=__a					,		encoder_attention_mask=__a					,		output_hidden_states=__a					,		)["hidden_states"][0]
								UpperCAmelCase								=  model(
								    __a					,		attention_mask=__a					,		encoder_hidden_states=__a					,		encoder_attention_mask=__a					,		past_key_values=__a					,		output_hidden_states=__a					,		)["hidden_states"][0]

								# select random slice
								UpperCAmelCase								=  ids_tensor((1,)					,		output_from_past.shape[-1]   ).item()
								UpperCAmelCase								=  output_from_no_past[:, -3:, random_slice_idx].detach()
								UpperCAmelCase								=  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(__a					,		__a					,		atol=1e-3   )   )







		def SCREAMING_SNAKE_CASE_      (    self   :  str   )					->       List[str]:
								'''simple docstring'''







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





@require_torch
class 			__magic_name__ (				lowerCAmelCase__,	lowerCAmelCase__,	lowerCAmelCase__,	unittest.TestCase    ):
		lowercase   :							int        =(
		    (
		        FalconModel,
		        FalconForCausalLM,
		        FalconForSequenceClassification,
		        FalconForTokenClassification,
		        FalconForQuestionAnswering,
		    )
		    if is_torch_available()
		    else ()
		)
		lowercase   :							Union[str, Any]        =(FalconForCausalLM,) if is_torch_available() else ()
		lowercase   :							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 {}
		)
		lowercase   :							Any        =False
		lowercase   :							Tuple        =False






		def SCREAMING_SNAKE_CASE_      (    self   :  str   )					->       str:
								'''simple docstring'''







								UpperCAmelCase								=  FalconModelTester(self   )
								UpperCAmelCase								=  ConfigTester(self					,		config_class=__a					,		hidden_size=37   )






		def SCREAMING_SNAKE_CASE_      (    self   :  Tuple   )					->       List[str]:
								'''simple docstring'''







								self.config_tester.run_common_tests()






		def SCREAMING_SNAKE_CASE_      (    self   :  Any   )					->       Optional[Any]:
								'''simple docstring'''







								UpperCAmelCase								=  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__a   )






		def SCREAMING_SNAKE_CASE_      (    self   :  Union[str, Any]   )					->       List[Any]:
								'''simple docstring'''







								UpperCAmelCase							,		*UpperCAmelCase								=  self.model_tester.prepare_config_and_inputs()
								for alibi in [True, False]:
														UpperCAmelCase								=  alibi
														self.model_tester.create_and_check_model(__a					,		*__a   )






		def SCREAMING_SNAKE_CASE_      (    self   :  int   )					->       Dict:
								'''simple docstring'''







								UpperCAmelCase							,		UpperCAmelCase								=  self.model_tester.prepare_config_and_inputs_for_common()
								UpperCAmelCase								=  3
								UpperCAmelCase								=  input_dict["input_ids"]
								UpperCAmelCase								=  input_ids.ne(1   ).to(__a   )
								UpperCAmelCase								=  ids_tensor([self.model_tester.batch_size]					,		self.model_tester.type_sequence_label_size   )
								UpperCAmelCase								=  FalconForSequenceClassification(__a   )
								model.to(__a   )
								model.eval()
								UpperCAmelCase								=  model(__a					,		attention_mask=__a					,		labels=__a   )
								self.assertEqual(result.logits.shape					,		(self.model_tester.batch_size, self.model_tester.num_labels)   )






		def SCREAMING_SNAKE_CASE_      (    self   :  Dict   )					->       str:
								'''simple docstring'''







								UpperCAmelCase							,		UpperCAmelCase								=  self.model_tester.prepare_config_and_inputs_for_common()
								UpperCAmelCase								=  3
								UpperCAmelCase								=  "single_label_classification"
								UpperCAmelCase								=  input_dict["input_ids"]
								UpperCAmelCase								=  input_ids.ne(1   ).to(__a   )
								UpperCAmelCase								=  ids_tensor([self.model_tester.batch_size]					,		self.model_tester.type_sequence_label_size   )
								UpperCAmelCase								=  FalconForSequenceClassification(__a   )
								model.to(__a   )
								model.eval()
								UpperCAmelCase								=  model(__a					,		attention_mask=__a					,		labels=__a   )
								self.assertEqual(result.logits.shape					,		(self.model_tester.batch_size, self.model_tester.num_labels)   )






		def SCREAMING_SNAKE_CASE_      (    self   :  Optional[int]   )					->       int:
								'''simple docstring'''







								UpperCAmelCase							,		UpperCAmelCase								=  self.model_tester.prepare_config_and_inputs_for_common()
								UpperCAmelCase								=  input_dict["input_ids"]
								UpperCAmelCase								=  FalconForCausalLM(__a   )
								model.to(__a   )
								model.eval()
								UpperCAmelCase								=  model(__a					,		use_cache=__a   )
								UpperCAmelCase								=  input_ids.shape[0]
								UpperCAmelCase								=  model._convert_to_rw_cache(result.past_key_values   )
								UpperCAmelCase								=  model._convert_cache_to_standard_format(__a					,		__a   )
								for layer in range(len(__a   )   ):
														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 SCREAMING_SNAKE_CASE_      (    self   :  int   )					->       List[Any]:
								'''simple docstring'''







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







		def SCREAMING_SNAKE_CASE_      (    self   :  str   )					->       Union[str, Any]:
								'''simple docstring'''







								for model_class in self.all_generative_model_classes:
														UpperCAmelCase							,		UpperCAmelCase								=  self.model_tester.prepare_config_and_inputs_for_common()

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

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

														# 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

														UpperCAmelCase								=  (
														    getattr(__a					,		"decoder_layers"					,		__a   )
														    or getattr(__a					,		"num_decoder_layers"					,		__a   )
														    or config.num_hidden_layers
														)
														UpperCAmelCase								=  getattr(__a					,		"num_kv_heads"					,		config.num_attention_heads   )
														UpperCAmelCase								=  getattr(__a					,		"d_model"					,		config.hidden_size   )
														UpperCAmelCase								=  embed_dim // num_attention_heads

														UpperCAmelCase								=  outputs["past_key_values"]
														self.assertEqual(len(__a   )					,		__a   )

														UpperCAmelCase							,		UpperCAmelCase								=  inputs["input_ids"].shape
														for i in range(__a   ):
																				if config.new_decoder_architecture:
																										UpperCAmelCase								=  config.num_attention_heads
																				elif config.multi_query:
																										UpperCAmelCase								=  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 			__magic_name__ (				unittest.TestCase    ):






		@slow
		def SCREAMING_SNAKE_CASE_      (    self   :  Optional[int]   )					->       Dict:
								'''simple docstring'''







								UpperCAmelCase								=  AutoTokenizer.from_pretrained("Rocketknight1/falcon-rw-1b"   )
								UpperCAmelCase								=  FalconForCausalLM.from_pretrained("Rocketknight1/falcon-rw-1b"   )
								model.eval()
								model.to(__a   )
								UpperCAmelCase								=  tokenizer("My favorite food is"					,		return_tensors="pt"   ).to(__a   )

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

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

								self.assertEqual(__a					,		__a   )






		@slow
		def SCREAMING_SNAKE_CASE_      (    self   :  int   )					->       str:
								'''simple docstring'''







								for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
														UpperCAmelCase								=  AutoTokenizer.from_pretrained(__a   )
														UpperCAmelCase								=  FalconForCausalLM.from_pretrained(__a   )
														model.eval()
														model.to(__a   )
														UpperCAmelCase								=  tokenizer("My favorite food is"					,		return_tensors="pt"   ).to(__a   )

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







		@slow
		def SCREAMING_SNAKE_CASE_      (    self   :  Tuple   )					->       List[Any]:
								'''simple docstring'''







								with torch.no_grad():
														for repo in [
														    "Rocketknight1/falcon-rw-1b",
														    "Rocketknight1/tiny-random-falcon-7b",
														    "Rocketknight1/tiny-random-falcon-40b",
														]:
																				UpperCAmelCase								=  AutoTokenizer.from_pretrained(__a   )
																				UpperCAmelCase								=  FalconForCausalLM.from_pretrained(__a   )
																				model.eval()
																				model.to(device=__a   )
																				UpperCAmelCase								=  tokenizer("My favorite food is"					,		return_tensors="pt"   ).to(__a   )

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







"""simple docstring"""


from __future__ import annotations
class     _UpperCamelCase    :
							'''simple docstring'''







							def __init__(	self       ,  __a=None      ):
										__lowerCAmelCase							       =     data
										__lowerCAmelCase							       =     None



							def __repr__(	self      ):
										__lowerCAmelCase							       =     []
										__lowerCAmelCase							       =     self
										while temp:
													string_rep.append(f"{temp.data}"      )
													__lowerCAmelCase							       =     temp.next
										return "->".join(__a      )


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			if not elements_list:
						raise Exception("The Elements List is empty" )

			__lowerCAmelCase							       =     __lowerCAmelCase							       =     Node(elements_list[0] )
			for i in range(1       ,					len(_UpperCamelCase ) ):
						__lowerCAmelCase							       =     Node(elements_list[i] )
						__lowerCAmelCase							       =     current.next
			return head


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			if head_node is not None and isinstance(_UpperCamelCase       ,					_UpperCamelCase ):
						print_reverse(head_node.next )
						print(head_node.data )


def _lowerCamelCase      (						):

			'''simple docstring'''




			from doctest import testmod

			testmod()

			__lowerCAmelCase							       =     make_linked_list([14, 52, 14, 12, 43] )
			print("Linked List:" )
			print(_UpperCamelCase )
			print("Elements in Reverse:" )
			print_reverse(_UpperCamelCase )


if __name__ == "__main__":
	main()




