





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     A     :
			'''simple docstring'''




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







					"""simple docstring"""






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






			def   a_			(     self  :       Any  )      ->      Union[str, Any]:







					"""simple docstring"""






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

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

					A__     =  None

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

					A__     =  self.get_config()

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






			def   a_			(     self  :       List[str]  )      ->      Optional[Any]:







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






			def   a_			(     self  :       str				,      __lowerCAmelCase  :       int				,      __lowerCAmelCase  :       Dict				,      __lowerCAmelCase  :       Union[str, Any]				,      __lowerCAmelCase  :       str				,      __lowerCAmelCase  :       Any				,      __lowerCAmelCase  :       Any				,      __lowerCAmelCase  :       List[str]  )      ->      str:







					"""simple docstring"""






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






			def   a_			(     self  :       int				,      __lowerCAmelCase  :       Tuple				,      __lowerCAmelCase  :       List[str]				,      __lowerCAmelCase  :       List[Any]				,      __lowerCAmelCase  :       Any				,      __lowerCAmelCase  :       Union[str, Any]				,      __lowerCAmelCase  :       Optional[Any]				,      __lowerCAmelCase  :       int				,      __lowerCAmelCase  :       List[str]				,      __lowerCAmelCase  :       Union[str, Any]				,      )      ->      Tuple:







					"""simple docstring"""






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






			def   a_			(     self  :       Tuple				,      __lowerCAmelCase  :       Any				,      __lowerCAmelCase  :       Optional[Any]				,      __lowerCAmelCase  :       Dict				,      __lowerCAmelCase  :       Optional[Any]				,      __lowerCAmelCase  :       Any				,      __lowerCAmelCase  :       Union[str, Any]				,      __lowerCAmelCase  :       Dict				,      __lowerCAmelCase  :       Any				,      __lowerCAmelCase  :       List[str]				,      )      ->      Dict:







					"""simple docstring"""






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






			def   a_			(     self  :       Tuple				,      __lowerCAmelCase  :       List[str]				,      __lowerCAmelCase  :       Any				,      __lowerCAmelCase  :       Any				,      __lowerCAmelCase  :       Tuple				,      __lowerCAmelCase  :       Any				,      __lowerCAmelCase  :       List[Any]				,      __lowerCAmelCase  :       str				,      __lowerCAmelCase  :       Union[str, Any]				,      __lowerCAmelCase  :       int				,      )      ->      Tuple:







					"""simple docstring"""






					A__     =  True
					A__     =  True
					A__     =  FalconForCausalLM(config=__lowerCAmelCase  )
					model.to(__lowerCAmelCase  )
					model.eval()

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

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

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

					A__     =  model(
					    __lowerCAmelCase				,      attention_mask=__lowerCAmelCase				,      encoder_hidden_states=__lowerCAmelCase				,      encoder_attention_mask=__lowerCAmelCase				,      output_hidden_states=__lowerCAmelCase				,      )["""hidden_states"""][0]
					A__     =  model(
					    __lowerCAmelCase				,      attention_mask=__lowerCAmelCase				,      encoder_hidden_states=__lowerCAmelCase				,      encoder_attention_mask=__lowerCAmelCase				,      past_key_values=__lowerCAmelCase				,      output_hidden_states=__lowerCAmelCase				,      )["""hidden_states"""][0]

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







			def   a_			(     self  :       Union[str, Any]  )      ->      Union[str, Any]:







					"""simple docstring"""






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


@require_torch
class     A     (SCREAMING_SNAKE_CASE  ,	SCREAMING_SNAKE_CASE  ,	SCREAMING_SNAKE_CASE  ,	unittest.TestCase       ):
			'''simple docstring'''




			__lowerCamelCase      :			Dict							     =       (
			    (
			        FalconModel,
			        FalconForCausalLM,
			        FalconForSequenceClassification,
			        FalconForTokenClassification,
			        FalconForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			__lowerCamelCase      :			Optional[Any]							     =       (FalconForCausalLM,) if is_torch_available() else ()
			__lowerCamelCase      :			int							     =       (
			    {
			        '''feature-extraction''': FalconModel,
			        '''text-classification''': FalconForSequenceClassification,
			        '''text-generation''': FalconForCausalLM,
			        '''question-answering''': FalconForQuestionAnswering,
			        '''token-classification''': FalconForTokenClassification,
			        '''zero-shot''': FalconForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			__lowerCamelCase      :			Dict							     =       False
			__lowerCamelCase      :			Any							     =       False






			def   a_			(     self  :       Any  )      ->      str:







					"""simple docstring"""






					A__     =  FalconModelTester(self  )
					A__     =  ConfigTester(self				,      config_class=__lowerCAmelCase				,      hidden_size=37  )






			def   a_			(     self  :       int  )      ->      int:







					"""simple docstring"""






					self.config_tester.run_common_tests()






			def   a_			(     self  :       Union[str, Any]  )      ->      List[str]:







					"""simple docstring"""






					A__     =  self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*__lowerCAmelCase  )






			def   a_			(     self  :       int  )      ->      Optional[int]:







					"""simple docstring"""






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






			def   a_			(     self  :       Any  )      ->      Union[str, Any]:







					"""simple docstring"""






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






			def   a_			(     self  :       int  )      ->      Optional[int]:







					"""simple docstring"""






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






			def   a_			(     self  :       Any  )      ->      Any:







					"""simple docstring"""






					A__ ,     A__     =  self.model_tester.prepare_config_and_inputs_for_common()
					A__     =  input_dict["""input_ids"""]
					A__     =  FalconForCausalLM(__lowerCAmelCase  )
					model.to(__lowerCAmelCase  )
					model.eval()
					A__     =  model(__lowerCAmelCase				,      use_cache=__lowerCAmelCase  )
					A__     =  input_ids.shape[0]
					A__     =  model._convert_to_rw_cache(result.past_key_values  )
					A__     =  model._convert_cache_to_standard_format(__lowerCAmelCase				,      __lowerCAmelCase  )
					for layer in range(len(__lowerCAmelCase  )  ):
							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  :       Any  )      ->      Tuple:







					"""simple docstring"""






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







			def   a_			(     self  :       Any  )      ->      Optional[Any]:







					"""simple docstring"""






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

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

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

							# 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

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

							A__     =  outputs["""past_key_values"""]
							self.assertEqual(len(__lowerCAmelCase  )				,      __lowerCAmelCase  )

							A__ ,     A__     =  inputs["""input_ids"""].shape
							for i in range(__lowerCAmelCase  ):
									if config.new_decoder_architecture:
											A__     =  config.num_attention_heads
									elif config.multi_query:
											A__     =  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     A     (unittest.TestCase       ):
			'''simple docstring'''




			@slow
			def   a_			(     self  :       int  )      ->      List[str]:







					"""simple docstring"""






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

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

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

					self.assertEqual(__lowerCAmelCase				,      __lowerCAmelCase  )






			@slow
			def   a_			(     self  :       Optional[int]  )      ->      List[str]:







					"""simple docstring"""






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

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







			@slow
			def   a_			(     self  :       Union[str, Any]  )      ->      int:







					"""simple docstring"""






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

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










def   __lowerCamelCase   (				__a  :Dict       )						->							Optional[int]:






		"""simple docstring"""

		A__     =  []
		A__     =  []
		A__     =  {
		    """^""": 3,
		    """*""": 2,
		    """/""": 2,
		    """%""": 2,
		    """+""": 1,
		    """-""": 1,
		}  # Priority of each operator
		A__     =  len(__a       ) if (len(__a       ) > 7) else 7

		# Print table header for output
		print(
		    """Symbol""".center(8       )       ,	"""Stack""".center(__a       )       ,	"""Postfix""".center(__a       )       ,	sep=""" | """       ,	)
		print("""-""" * (print_width * 3 + 7)       )

		for x in infix:
				if x.isalpha() or x.isdigit():
						post_fix.append(__a       )  # if x is Alphabet / Digit, add it to Postfix
				elif x == "(":
						stack.append(__a       )  # if x is "(" push to Stack
				elif x == ")":  # if x is ")" pop stack until "(" is encountered
						while stack[-1] != "(":
								post_fix.append(stack.pop()       )  # Pop stack & add the content to Postfix
						stack.pop()
				else:
						if len(__a       ) == 0:
								stack.append(__a       )  # If stack is empty, push x to stack
						else:  # while priority of x is not > priority of element in the stack
								while len(__a       ) > 0 and priority[x] <= priority[stack[-1]]:
										post_fix.append(stack.pop()       )  # pop stack & add to Postfix
								stack.append(__a       )  # push x to stack

				print(
				    x.center(8       )       ,	("""""".join(__a       )).ljust(__a       )       ,	("""""".join(__a       )).ljust(__a       )       ,	sep=""" | """       ,	)  # Output in tabular format

		while len(__a       ) > 0:  # while stack is not empty
				post_fix.append(stack.pop()       )  # pop stack & add to Postfix
				print(
				    """ """.center(8       )       ,	("""""".join(__a       )).ljust(__a       )       ,	("""""".join(__a       )).ljust(__a       )       ,	sep=""" | """       ,	)  # Output in tabular format

		return "".join(__a       )  # return Postfix as str







def   __lowerCamelCase   (				__a  :List[str]       )						->							Union[str, Any]:






		"""simple docstring"""

		A__     =  list(infix[::-1]       )  # reverse the infix equation

		for i in range(len(__a       )       ):
				if infix[i] == "(":
						A__     =  """)"""  # change "(" to ")"
				elif infix[i] == ")":
						A__     =  """("""  # change ")" to "("

		return (infix_2_postfix("""""".join(__a       )       ))[
		    ::-1
		]  # call infix_2_postfix on Infix, return reverse of Postfix


if __name__ == "__main__":
					A       :   Union[str, Any]					= input('''\nEnter an Infix Equation = ''')  # Input an Infix equation
					A       :   Dict					= ''''''.join(Infix.split())  # Remove spaces from the input
					print('''\n\t''', Infix, '''(Infix) -> ''', infix_2_prefix(Infix), '''(Prefix)''')



