





'''simple docstring'''



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      ,  A_      ,  A_=3      ,  A_=7      ,  A_=True      ,  A_=True      ,  A_=False      ,  A_=True      ,  A_=99      ,  A_=32      ,  A_=5      ,  A_=4      ,  A_=37      ,  A_="gelu"      ,  A_=0.1      ,  A_=0.1      ,  A_=5_12      ,  A_=16      ,  A_=2      ,  A_=0.02      ,  A_=3      ,  A_=4      ,  A_=None      ,  ):
								_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    a						(       self ):
								_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    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=UpperCAmelCase__      ,  initializer_range=self.initializer_range      ,  pad_token_id=1      ,  new_decoder_architecture=UpperCAmelCase__      ,  )




			def    a						(       self      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_ ):
								_UpperCamelCase									= FalconModel(config=UpperCAmelCase__ )
								model.to(UpperCAmelCase__ )
								model.eval()
								_UpperCamelCase									= model(UpperCAmelCase__      ,  attention_mask=UpperCAmelCase__ )
								_UpperCamelCase									= model(UpperCAmelCase__ )
								self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.hidden_size) )




			def    a						(       self      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  ):
								_UpperCamelCase									= True
								_UpperCamelCase									= FalconModel(UpperCAmelCase__ )
								model.to(UpperCAmelCase__ )
								model.eval()
								_UpperCamelCase									= model(
								    UpperCAmelCase__      ,  attention_mask=UpperCAmelCase__      ,  encoder_hidden_states=UpperCAmelCase__      ,  encoder_attention_mask=UpperCAmelCase__      ,  )
								_UpperCamelCase									= model(
								    UpperCAmelCase__      ,  attention_mask=UpperCAmelCase__      ,  encoder_hidden_states=UpperCAmelCase__      ,  )
								_UpperCamelCase									= model(UpperCAmelCase__      ,  attention_mask=UpperCAmelCase__ )
								self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.hidden_size) )




			def    a						(       self      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  ):
								_UpperCamelCase									= FalconForCausalLM(config=UpperCAmelCase__ )
								model.to(UpperCAmelCase__ )
								model.eval()
								_UpperCamelCase									= model(UpperCAmelCase__      ,  attention_mask=UpperCAmelCase__      ,  labels=UpperCAmelCase__ )
								self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.vocab_size) )




			def    a						(       self      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  A_      ,  ):
								_UpperCamelCase									= True
								_UpperCamelCase									= True
								_UpperCamelCase									= FalconForCausalLM(config=UpperCAmelCase__ )
								model.to(UpperCAmelCase__ )
								model.eval()

								# first forward pass
								_UpperCamelCase									= model(
								    UpperCAmelCase__      ,  attention_mask=UpperCAmelCase__      ,  encoder_hidden_states=UpperCAmelCase__      ,  encoder_attention_mask=UpperCAmelCase__      ,  use_cache=UpperCAmelCase__      ,  )
								_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(
								    UpperCAmelCase__      ,  attention_mask=UpperCAmelCase__      ,  encoder_hidden_states=UpperCAmelCase__      ,  encoder_attention_mask=UpperCAmelCase__      ,  output_hidden_states=UpperCAmelCase__      ,  )["hidden_states"][0]
								_UpperCamelCase									= model(
								    UpperCAmelCase__      ,  attention_mask=UpperCAmelCase__      ,  encoder_hidden_states=UpperCAmelCase__      ,  encoder_attention_mask=UpperCAmelCase__      ,  past_key_values=UpperCAmelCase__      ,  output_hidden_states=UpperCAmelCase__      ,  )["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(UpperCAmelCase__      ,  UpperCAmelCase__      ,  atol=1e-3 ) )




			def    a						(       self ):
								_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      A_			(	UpperCAmelCase__     ,      UpperCAmelCase__     ,      UpperCAmelCase__     ,      unittest.TestCase	):

			'''simple docstring'''





			_lowerCAmelCase							=     (
			    (
			        FalconModel,
			        FalconForCausalLM,
			        FalconForSequenceClassification,
			        FalconForTokenClassification,
			        FalconForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			_lowerCAmelCase							=     (FalconForCausalLM,) if is_torch_available() else ()
			_lowerCAmelCase							=     (
			    {
			        """feature-extraction""": FalconModel,
			        """text-classification""": FalconForSequenceClassification,
			        """text-generation""": FalconForCausalLM,
			        """question-answering""": FalconForQuestionAnswering,
			        """token-classification""": FalconForTokenClassification,
			        """zero-shot""": FalconForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			_lowerCAmelCase							=     False
			_lowerCAmelCase							=     False




			def    a						(       self ):
								_UpperCamelCase									= FalconModelTester(self )
								_UpperCamelCase									= ConfigTester(self      ,  config_class=UpperCAmelCase__      ,  hidden_size=37 )




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




			def    a						(       self ):
								_UpperCamelCase									= self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*UpperCAmelCase__ )




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




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




			def    a						(       self ):
								_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(UpperCAmelCase__ )
								_UpperCamelCase									= ids_tensor([self.model_tester.batch_size]      ,  self.model_tester.type_sequence_label_size )
								_UpperCamelCase									= FalconForSequenceClassification(UpperCAmelCase__ )
								model.to(UpperCAmelCase__ )
								model.eval()
								_UpperCamelCase									= model(UpperCAmelCase__      ,  attention_mask=UpperCAmelCase__      ,  labels=UpperCAmelCase__ )
								self.assertEqual(result.logits.shape      ,  (self.model_tester.batch_size, self.model_tester.num_labels) )




			def    a						(       self ):
								_UpperCamelCase					,						_UpperCamelCase									= self.model_tester.prepare_config_and_inputs_for_common()
								_UpperCamelCase									= input_dict["input_ids"]
								_UpperCamelCase									= FalconForCausalLM(UpperCAmelCase__ )
								model.to(UpperCAmelCase__ )
								model.eval()
								_UpperCamelCase									= model(UpperCAmelCase__      ,  use_cache=UpperCAmelCase__ )
								_UpperCamelCase									= input_ids.shape[0]
								_UpperCamelCase									= model._convert_to_rw_cache(result.past_key_values )
								_UpperCamelCase									= model._convert_cache_to_standard_format(UpperCAmelCase__      ,  UpperCAmelCase__ )
								for layer in range(len(UpperCAmelCase__ ) ):
													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 ):
								_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(UpperCAmelCase__ )
								_UpperCamelCase									= ids_tensor(
								    [self.model_tester.batch_size, config.num_labels]      ,  self.model_tester.type_sequence_label_size ).to(torch.float )
								_UpperCamelCase									= FalconForSequenceClassification(UpperCAmelCase__ )
								model.to(UpperCAmelCase__ )
								model.eval()
								_UpperCamelCase									= model(UpperCAmelCase__      ,  attention_mask=UpperCAmelCase__      ,  labels=UpperCAmelCase__ )
								self.assertEqual(result.logits.shape      ,  (self.model_tester.batch_size, self.model_tester.num_labels) )




			def    a						(       self ):

								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(UpperCAmelCase__      ,  "use_cache" ):
																		return

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

													# 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(UpperCAmelCase__      ,  "decoder_layers"      ,  UpperCAmelCase__ )
													    or getattr(UpperCAmelCase__      ,  "num_decoder_layers"      ,  UpperCAmelCase__ )
													    or config.num_hidden_layers
													)
													_UpperCamelCase									= getattr(UpperCAmelCase__      ,  "num_kv_heads"      ,  config.num_attention_heads )
													_UpperCamelCase									= getattr(UpperCAmelCase__      ,  "d_model"      ,  config.hidden_size )
													_UpperCamelCase									= embed_dim // num_attention_heads

													_UpperCamelCase									= outputs["past_key_values"]
													self.assertEqual(len(UpperCAmelCase__ )      ,  UpperCAmelCase__ )

													_UpperCamelCase					,						_UpperCamelCase									= inputs["input_ids"].shape
													for i in range(UpperCAmelCase__ ):
																		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      A_			(	unittest.TestCase	):

			'''simple docstring'''





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

								_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(**UpperCAmelCase__      ,  do_sample=UpperCAmelCase__      ,  max_new_tokens=19 )
								_UpperCamelCase									= tokenizer.batch_decode(UpperCAmelCase__ )[0]

								self.assertEqual(UpperCAmelCase__      ,  UpperCAmelCase__ )




			@slow
			def    a						(       self ):

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

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




			@slow
			def    a						(       self ):

								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(UpperCAmelCase__ )
																		_UpperCamelCase									= FalconForCausalLM.from_pretrained(UpperCAmelCase__ )
																		model.eval()
																		model.to(device=UpperCAmelCase__ )
																		_UpperCamelCase									= tokenizer("My favorite food is"      ,  return_tensors="pt" ).to(UpperCAmelCase__ )

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









def SCREAMING_SNAKE_CASE							(			lowercase_					,							lowercase_		)  ->			int:



       """simple docstring"""

       return int((input_a, input_a).count(1		) != 0		)







def SCREAMING_SNAKE_CASE							(			)  ->			None:



       """simple docstring"""

       assert or_gate(0					,							0		) == 0
       assert or_gate(0					,							1		) == 1
       assert or_gate(1					,							0		) == 1
       assert or_gate(1					,							1		) == 1


if __name__ == "__main__":
  print(or_gate(0, 1))
  print(or_gate(1, 0))
  print(or_gate(0, 0))
  print(or_gate(1, 1))


