"""simple docstring"""




import pytest
import requests

from datasets.utils.file_utils import http_head

from .utils import OfflineSimulationMode, RequestWouldHangIndefinitelyError, offline






@pytest.mark.integration
def      UpperCAmelCase    (		):






							"""simple docstring"""





							with offline(OfflineSimulationMode.CONNECTION_TIMES_OUT ):
														with pytest.raises(UpperCamelCase__ ):
																					requests.request('GET'				,			'https://huggingface.co' )
														with pytest.raises(requests.exceptions.ConnectTimeout ):
																					requests.request('GET'				,			'https://huggingface.co'				,			timeout=1.0 )






@pytest.mark.integration
def      UpperCAmelCase    (		):






							"""simple docstring"""





							with offline(OfflineSimulationMode.CONNECTION_FAILS ):
														with pytest.raises(requests.exceptions.ConnectionError ):
																					requests.request('GET'				,			'https://huggingface.co' )






def      UpperCAmelCase    (		):






							"""simple docstring"""





							with offline(OfflineSimulationMode.HF_DATASETS_OFFLINE_SET_TO_1 ):
														with pytest.raises(UpperCamelCase__ ):
																					http_head('https://huggingface.co' )






"""simple docstring"""




import unittest

from parameterized import parameterized

from transformers import AutoTokenizer, GPTNeoXConfig, is_torch_available, set_seed
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 (
				    GPTNeoXForCausalLM,
				    GPTNeoXForQuestionAnswering,
				    GPTNeoXForSequenceClassification,
				    GPTNeoXForTokenClassification,
				    GPTNeoXModel,
				)
class 			UpperCamelCase__:





						def __init__(				self						,__UpperCAmelCase						,__UpperCAmelCase=13						,__UpperCAmelCase=7						,__UpperCAmelCase=True						,__UpperCAmelCase=True						,__UpperCAmelCase=True						,__UpperCAmelCase=True						,__UpperCAmelCase=99						,__UpperCAmelCase=64						,__UpperCAmelCase=5						,__UpperCAmelCase=4						,__UpperCAmelCase=37						,__UpperCAmelCase="gelu"						,__UpperCAmelCase=0.1						,__UpperCAmelCase=0.1						,__UpperCAmelCase=5_12						,__UpperCAmelCase=16						,__UpperCAmelCase=2						,__UpperCAmelCase=0.0_2						,__UpperCAmelCase=3						,__UpperCAmelCase=4						,__UpperCAmelCase=None						,)    -> List[Any]:
													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
													A__		   =							vocab_size - 1





						def  snake_case__		(				self   )    -> str:
													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
													if self.use_labels:
																				A__		   =							ids_tensor([self.batch_size, self.seq_length]						,self.num_labels   )

													A__		   =							self.get_config()

													return config, input_ids, input_mask, token_labels





						def  snake_case__		(				self   )    -> List[str]:
													return GPTNeoXConfig(
													    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=self.pad_token_id						,)





						def  snake_case__		(				self   )    -> List[str]:
													A__   ,     A__   ,     A__   ,     A__		   =							self.prepare_config_and_inputs()

													A__		   =							True

													return config, input_ids, input_mask, token_labels





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )    -> Union[str, Any]:
													A__		   =							GPTNeoXModel(config=__UpperCAmelCase   )
													model.to(__UpperCAmelCase   )
													model.eval()
													A__		   =							model(__UpperCAmelCase						,attention_mask=__UpperCAmelCase   )
													A__		   =							model(__UpperCAmelCase   )
													self.parent.assertEqual(result.last_hidden_state.shape						,(self.batch_size, self.seq_length, self.hidden_size)   )





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )    -> Optional[Any]:
													A__		   =							True
													A__		   =							GPTNeoXModel(__UpperCAmelCase   )
													model.to(__UpperCAmelCase   )
													model.eval()
													A__		   =							model(__UpperCAmelCase						,attention_mask=__UpperCAmelCase   )
													self.parent.assertEqual(result.last_hidden_state.shape						,(self.batch_size, self.seq_length, self.hidden_size)   )





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )    -> Dict:
													A__		   =							GPTNeoXForCausalLM(config=__UpperCAmelCase   )
													model.to(__UpperCAmelCase   )
													model.eval()
													A__		   =							model(__UpperCAmelCase						,attention_mask=__UpperCAmelCase						,labels=__UpperCAmelCase   )
													self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.seq_length, self.vocab_size)   )





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )    -> Dict:
													A__		   =							self.num_labels
													A__		   =							GPTNeoXForQuestionAnswering(__UpperCAmelCase   )
													model.to(__UpperCAmelCase   )
													model.eval()
													A__		   =							model(__UpperCAmelCase						,attention_mask=__UpperCAmelCase   )
													self.parent.assertEqual(result.start_logits.shape						,(self.batch_size, self.seq_length)   )
													self.parent.assertEqual(result.end_logits.shape						,(self.batch_size, self.seq_length)   )





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )    -> str:
													A__		   =							self.num_labels
													A__		   =							GPTNeoXForSequenceClassification(__UpperCAmelCase   )
													model.to(__UpperCAmelCase   )
													model.eval()
													A__		   =							ids_tensor([self.batch_size]						,self.type_sequence_label_size   )
													A__		   =							model(__UpperCAmelCase						,attention_mask=__UpperCAmelCase						,labels=__UpperCAmelCase   )
													self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.num_labels)   )





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )    -> Dict:
													A__		   =							self.num_labels
													A__		   =							GPTNeoXForTokenClassification(__UpperCAmelCase   )
													model.to(__UpperCAmelCase   )
													model.eval()
													A__		   =							model(__UpperCAmelCase						,attention_mask=__UpperCAmelCase						,labels=__UpperCAmelCase   )
													self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.seq_length, self.num_labels)   )





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )    -> Dict:
													A__		   =							True
													A__		   =							GPTNeoXForCausalLM(config=__UpperCAmelCase   )
													model.to(__UpperCAmelCase   )
													model.eval()

													# first forward pass
													A__		   =							model(__UpperCAmelCase						,attention_mask=__UpperCAmelCase						,use_cache=__UpperCAmelCase   )
													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(__UpperCAmelCase						,attention_mask=__UpperCAmelCase						,output_hidden_states=__UpperCAmelCase   )
													A__		   =							output_from_no_past['hidden_states'][0]
													A__		   =							model(
													    __UpperCAmelCase						,attention_mask=__UpperCAmelCase						,past_key_values=__UpperCAmelCase						,output_hidden_states=__UpperCAmelCase						,)['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(__UpperCAmelCase						,__UpperCAmelCase						,atol=1e-3   )   )





						def  snake_case__		(				self   )    -> Dict:
													A__		   =							self.prepare_config_and_inputs()
													A__   ,     A__   ,     A__   ,     A__		   =							config_and_inputs
													A__		   =							{'input_ids': input_ids, 'attention_mask': input_mask}
													return config, inputs_dict






@require_torch
class 			UpperCamelCase__(	__A						,  __A						,  __A						,  unittest.TestCase       ):
						lowerCAmelCase__     :  Optional[int]  							=						(
						    (
						        GPTNeoXModel,
						        GPTNeoXForCausalLM,
						        GPTNeoXForQuestionAnswering,
						        GPTNeoXForSequenceClassification,
						        GPTNeoXForTokenClassification,
						    )
						    if is_torch_available()
						    else ()
						)
						lowerCAmelCase__     :  List[Any]  							=						(GPTNeoXForCausalLM,) if is_torch_available() else ()
						lowerCAmelCase__     :  List[str]  							=						(
						    {
						        'feature-extraction': GPTNeoXModel,
						        'question-answering': GPTNeoXForQuestionAnswering,
						        'text-classification': GPTNeoXForSequenceClassification,
						        'text-generation': GPTNeoXForCausalLM,
						        'token-classification': GPTNeoXForTokenClassification,
						        'zero-shot': GPTNeoXForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)
						lowerCAmelCase__     :  Union[str, Any]  							=						False
						lowerCAmelCase__     :  str  							=						False
						lowerCAmelCase__     :  Any  							=						False
						lowerCAmelCase__     :  str  							=						False





						def  snake_case__		(				self   )    -> Tuple:
													A__		   =							GPTNeoXModelTester(self   )
													A__		   =							ConfigTester(self						,config_class=__UpperCAmelCase						,hidden_size=64						,num_attention_heads=8   )





						def  snake_case__		(				self   )    -> str:
													self.config_tester.run_common_tests()





						def  snake_case__		(				self   )    -> List[str]:
													A__   ,     A__   ,     A__   ,     A__		   =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )





						def  snake_case__		(				self   )    -> Dict:
													A__   ,     A__   ,     A__   ,     A__		   =							self.model_tester.prepare_config_and_inputs_for_decoder()
													self.model_tester.create_and_check_model_as_decoder(__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )





						def  snake_case__		(				self   )    -> Optional[int]:
													# This regression test was failing with PyTorch < 1.3
													A__   ,     A__   ,     A__   ,     A__		   =							self.model_tester.prepare_config_and_inputs_for_decoder()

													A__		   =							None

													self.model_tester.create_and_check_model_as_decoder(__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )





						def  snake_case__		(				self   )    -> str:
													A__   ,     A__   ,     A__   ,     A__		   =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_decoder_model_past_large_inputs(__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )





						def  snake_case__		(				self   )    -> Optional[int]:
													A__		   =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_causal_lm(*__UpperCAmelCase   )





						def  snake_case__		(				self   )    -> List[str]:
													A__		   =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_question_answering(*__UpperCAmelCase   )





						def  snake_case__		(				self   )    -> Any:
													A__		   =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_sequence_classification(*__UpperCAmelCase   )





						def  snake_case__		(				self   )    -> List[Any]:
													A__		   =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_token_classification(*__UpperCAmelCase   )





						@unittest.skip(reason='Feed forward chunking is not implemented'   )
						def  snake_case__		(				self   )    -> str:
													pass





						@parameterized.expand([('linear',), ('dynamic',)]   )
						def  snake_case__		(				self						,__UpperCAmelCase   )    -> Tuple:
													A__   ,     A__		   =							self.model_tester.prepare_config_and_inputs_for_common()
													A__		   =							ids_tensor([1, 10]						,config.vocab_size   )
													A__		   =							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
													A__		   =							GPTNeoXModel(__UpperCAmelCase   )
													original_model.to(__UpperCAmelCase   )
													original_model.eval()
													A__		   =							original_model(__UpperCAmelCase   ).last_hidden_state
													A__		   =							original_model(__UpperCAmelCase   ).last_hidden_state

													set_seed(42   )  # Fixed seed at init time so the two models get the same random weights
													A__		   =							{'type': scaling_type, 'factor': 1_0.0}
													A__		   =							GPTNeoXModel(__UpperCAmelCase   )
													scaled_model.to(__UpperCAmelCase   )
													scaled_model.eval()
													A__		   =							scaled_model(__UpperCAmelCase   ).last_hidden_state
													A__		   =							scaled_model(__UpperCAmelCase   ).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(__UpperCAmelCase						,__UpperCAmelCase						,atol=1e-5   )   )
													else:
																				self.assertFalse(torch.allclose(__UpperCAmelCase						,__UpperCAmelCase						,atol=1e-5   )   )

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






@require_torch
class 			UpperCamelCase__(	unittest.TestCase       ):





						@slow
						def  snake_case__		(				self   )    -> int:
													A__		   =							AutoTokenizer.from_pretrained('EleutherAI/pythia-410m-deduped'   )
													for checkpointing in [True, False]:
																				A__		   =							GPTNeoXForCausalLM.from_pretrained('EleutherAI/pythia-410m-deduped'   )

																				if checkpointing:
																											model.gradient_checkpointing_enable()
																				else:
																											model.gradient_checkpointing_disable()
																				model.to(__UpperCAmelCase   )

																				A__		   =							tokenizer('My favorite food is'						,return_tensors='pt'   ).to(__UpperCAmelCase   )
																				# The hub repo. is updated on 2023-04-04, resulting in poor outputs.
																				# See: https://github.com/huggingface/transformers/pull/24193
																				A__		   =							'My favorite food is a good old-fashioned, old-fashioned, old-fashioned.\n\nI\'m not sure'

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

																				self.assertEqual(__UpperCAmelCase						,__UpperCAmelCase   )





