
import tempfile
import unittest

import numpy as np

import transformers
from transformers import GPTaTokenizer, GPTJConfig, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, tooslow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
					import jax
					import jax.numpy as jnp

					from transformers.modeling_flax_pytorch_utils import (
					    convert_pytorch_state_dict_to_flax,
					    load_flax_weights_in_pytorch_model,
					)
					from transformers.models.gptj.modeling_flax_gptj import FlaxGPTJForCausalLM, FlaxGPTJModel

if is_torch_available():
					import torch


class     lowercase :



		def __init__(			self    ,				A_    ,				A_=14    ,				A_=7    ,				A_=True    ,				A_=True    ,				A_=False    ,				A_=True    ,				A_=99    ,				A_=32    ,				A_=4    ,				A_=4    ,				A_=4    ,				A_=37    ,				A_="gelu"    ,				A_=0.1    ,				A_=0.1    ,				A_=512    ,				A_=0.02    ,				)  -> Optional[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          =					rotary_dim
				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          =					initializer_range
				UpperCamelCase          =					None
				UpperCamelCase          =					vocab_size - 1
				UpperCamelCase          =					vocab_size - 1
				UpperCamelCase          =					vocab_size - 1



		def __UpperCamelCase			(			self	)  -> List[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          =					GPTJConfig(
				    vocab_size=self.vocab_size    ,				n_embd=self.hidden_size    ,				n_layer=self.num_hidden_layers    ,				n_head=self.num_attention_heads    ,				n_positions=self.max_position_embeddings    ,				use_cache=A_    ,				bos_token_id=self.bos_token_id    ,				eos_token_id=self.eos_token_id    ,				pad_token_id=self.pad_token_id    ,				rotary_dim=self.rotary_dim    ,				)

				return (config, input_ids, input_mask)



		def __UpperCamelCase			(			self	)  -> Tuple:
				"""simple docstring"""
				UpperCamelCase          =					self.prepare_config_and_inputs()
				UpperCamelCase     ,  UpperCamelCase     ,  UpperCamelCase          =					config_and_inputs
				UpperCamelCase          =					{'input_ids': input_ids, 'attention_mask': attention_mask}
				return config, inputs_dict



		def __UpperCamelCase			(			self    ,				A_    ,				A_    ,				A_    ,				A_	)  -> Optional[Any]:
				"""simple docstring"""
				UpperCamelCase          =					20
				UpperCamelCase          =					model_class_name(A_	)

				UpperCamelCase          =					model.init_cache(input_ids.shape[0]    ,				A_	)
				UpperCamelCase          =					jnp.ones((input_ids.shape[0], max_decoder_length)    ,				dtype='i4'	)

				UpperCamelCase          =					jnp.broadcast_to(
				    jnp.arange(input_ids.shape[-1] - 1	)[None, :]    ,				(input_ids.shape[0], input_ids.shape[-1] - 1)	)
				UpperCamelCase          =					model(
				    input_ids[:, :-1]    ,				attention_mask=A_    ,				past_key_values=A_    ,				position_ids=A_    ,				)

				UpperCamelCase          =					jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]    ,				dtype='i4'	)
				UpperCamelCase          =					model(
				    input_ids[:, -1:]    ,				attention_mask=A_    ,				past_key_values=outputs_cache.past_key_values    ,				position_ids=A_    ,				)

				UpperCamelCase          =					model(A_	)

				UpperCamelCase          =					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])	)	)
				self.parent.assertTrue(diff < 1e-3    ,				msg=F'''Max diff is {diff}'''	)



		def __UpperCamelCase			(			self    ,				A_    ,				A_    ,				A_    ,				A_	)  -> str:
				"""simple docstring"""
				UpperCamelCase          =					20
				UpperCamelCase          =					model_class_name(A_	)

				UpperCamelCase          =					jnp.concatenate(
				    [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])	)]    ,				axis=-1    ,				)

				UpperCamelCase          =					model.init_cache(input_ids.shape[0]    ,				A_	)
				UpperCamelCase          =					jnp.broadcast_to(
				    jnp.arange(input_ids.shape[-1] - 1	)[None, :]    ,				(input_ids.shape[0], input_ids.shape[-1] - 1)	)

				UpperCamelCase          =					model(
				    input_ids[:, :-1]    ,				attention_mask=A_    ,				past_key_values=A_    ,				position_ids=A_    ,				)
				UpperCamelCase          =					jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]    ,				dtype='i4'	)
				UpperCamelCase          =					model(
				    input_ids[:, -1:]    ,				past_key_values=outputs_cache.past_key_values    ,				attention_mask=A_    ,				position_ids=A_    ,				)

				UpperCamelCase          =					model(A_    ,				attention_mask=A_	)

				UpperCamelCase          =					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])	)	)
				self.parent.assertTrue(diff < 1e-3    ,				msg=F'''Max diff is {diff}'''	)






@require_flax
class     lowercase (		_SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE  ,       unittest.TestCase       ):
		__lowercase	:	Dict     					=    (FlaxGPTJModel, FlaxGPTJForCausalLM) if is_flax_available() else ()
		__lowercase	:	Optional[int]     					=    (FlaxGPTJForCausalLM,) if is_flax_available() else ()



		def __UpperCamelCase			(			self	)  -> List[str]:
				"""simple docstring"""
				UpperCamelCase          =					FlaxGPTJModelTester(self	)



		def __UpperCamelCase			(			self	)  -> int:
				"""simple docstring"""
				for model_class_name in self.all_model_classes:
						UpperCamelCase     ,  UpperCamelCase     ,  UpperCamelCase          =					self.model_tester.prepare_config_and_inputs()
						self.model_tester.check_use_cache_forward(A_    ,				A_    ,				A_    ,				A_	)



		def __UpperCamelCase			(			self	)  -> List[Any]:
				"""simple docstring"""
				for model_class_name in self.all_model_classes:
						UpperCamelCase     ,  UpperCamelCase     ,  UpperCamelCase          =					self.model_tester.prepare_config_and_inputs()
						self.model_tester.check_use_cache_forward_with_attn_mask(
						    A_    ,				A_    ,				A_    ,				A_	)



		@tooslow
		def __UpperCamelCase			(			self	)  -> int:
				"""simple docstring"""
				UpperCamelCase          =					GPTaTokenizer.from_pretrained('gpt2'    ,				pad_token='<|endoftext|>'    ,				padding_side='left'	)
				UpperCamelCase          =					tokenizer(['Hello this is a long string', 'Hey']    ,				return_tensors='np'    ,				padding=A_    ,				truncation=A_	)

				UpperCamelCase          =					FlaxGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'	)
				UpperCamelCase          =					False
				UpperCamelCase          =					model.config.eos_token_id

				UpperCamelCase          =					jax.jit(model.generate	)

				UpperCamelCase          =					jit_generate(
				    inputs['input_ids']    ,				attention_mask=inputs['attention_mask']    ,				pad_token_id=tokenizer.pad_token_id	).sequences

				UpperCamelCase          =					tokenizer.batch_decode(A_    ,				skip_special_tokens=A_	)

				UpperCamelCase          =					[
				    'Hello this is a long string of text.\n\nI\'m trying to get the text of the',
				    'Hey, I\'m a little late to the party. I\'m going to',
				]

				self.assertListEqual(A_    ,				A_	)



		@is_pt_flax_cross_test
		def __UpperCamelCase			(			self	)  -> Any:
				"""simple docstring"""
				UpperCamelCase     ,  UpperCamelCase          =					self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						with self.subTest(model_class.__name__	):
								# prepare inputs
								UpperCamelCase          =					self._prepare_for_class(A_    ,				A_	)
								UpperCamelCase          =					{k: torch.tensor(v.tolist()	) for k, v in prepared_inputs_dict.items()}

								# load corresponding PyTorch class
								UpperCamelCase          =					model_class.__name__[4:]  # Skip the "Flax" at the beginning
								UpperCamelCase          =					getattr(A_    ,				A_	)

								UpperCamelCase     ,  UpperCamelCase          =					pt_inputs['input_ids'].shape
								UpperCamelCase          =					np.random.randint(0    ,				seq_length - 1    ,				size=(batch_size,)	)
								for batch_idx, start_index in enumerate(A_	):
										UpperCamelCase          =					0
										UpperCamelCase          =					1
										UpperCamelCase          =					0
										UpperCamelCase          =					1
								UpperCamelCase          =					pt_model_class(A_	).eval()
								UpperCamelCase          =					model_class(A_    ,				dtype=jnp.floataa	)

								UpperCamelCase          =					convert_pytorch_state_dict_to_flax(pt_model.state_dict()    ,				A_	)
								UpperCamelCase          =					fx_state

								with torch.no_grad():
										UpperCamelCase          =					pt_model(**A_	).to_tuple()

								UpperCamelCase          =					fx_model(**A_	).to_tuple()
								self.assertEqual(len(A_	)    ,				len(A_	)    ,				'Output lengths differ between Flax and PyTorch'	)
								for fx_output, pt_output in zip(A_    ,				A_	):
										self.assert_almost_equals(fx_output[:, -1]    ,				pt_output[:, -1].numpy()    ,				4e-2	)

								with tempfile.TemporaryDirectory() as tmpdirname:
										pt_model.save_pretrained(A_	)
										UpperCamelCase          =					model_class.from_pretrained(A_    ,				from_pt=A_	)

								UpperCamelCase          =					fx_model_loaded(**A_	).to_tuple()
								self.assertEqual(
								    len(A_	)    ,				len(A_	)    ,				'Output lengths differ between Flax and PyTorch'	)
								for fx_output_loaded, pt_output in zip(A_    ,				A_	):
										self.assert_almost_equals(fx_output_loaded[:, -1]    ,				pt_output[:, -1].numpy()    ,				4e-2	)



		@is_pt_flax_cross_test
		def __UpperCamelCase			(			self	)  -> Optional[int]:
				"""simple docstring"""
				UpperCamelCase     ,  UpperCamelCase          =					self.model_tester.prepare_config_and_inputs_for_common()
				for model_class in self.all_model_classes:
						with self.subTest(model_class.__name__	):
								# prepare inputs
								UpperCamelCase          =					self._prepare_for_class(A_    ,				A_	)
								UpperCamelCase          =					{k: torch.tensor(v.tolist()	) for k, v in prepared_inputs_dict.items()}

								# load corresponding PyTorch class
								UpperCamelCase          =					model_class.__name__[4:]  # Skip the "Flax" at the beginning
								UpperCamelCase          =					getattr(A_    ,				A_	)

								UpperCamelCase          =					pt_model_class(A_	).eval()
								UpperCamelCase          =					model_class(A_    ,				dtype=jnp.floataa	)

								UpperCamelCase          =					load_flax_weights_in_pytorch_model(A_    ,				fx_model.params	)
								UpperCamelCase     ,  UpperCamelCase          =					pt_inputs['input_ids'].shape
								UpperCamelCase          =					np.random.randint(0    ,				seq_length - 1    ,				size=(batch_size,)	)
								for batch_idx, start_index in enumerate(A_	):
										UpperCamelCase          =					0
										UpperCamelCase          =					1
										UpperCamelCase          =					0
										UpperCamelCase          =					1

								# make sure weights are tied in PyTorch
								pt_model.tie_weights()

								with torch.no_grad():
										UpperCamelCase          =					pt_model(**A_	).to_tuple()

								UpperCamelCase          =					fx_model(**A_	).to_tuple()
								self.assertEqual(len(A_	)    ,				len(A_	)    ,				'Output lengths differ between Flax and PyTorch'	)
								for fx_output, pt_output in zip(A_    ,				A_	):
										self.assert_almost_equals(fx_output[:, -1]    ,				pt_output[:, -1].numpy()    ,				4e-2	)

								with tempfile.TemporaryDirectory() as tmpdirname:
										fx_model.save_pretrained(A_	)
										UpperCamelCase          =					pt_model_class.from_pretrained(A_    ,				from_flax=A_	)

								with torch.no_grad():
										UpperCamelCase          =					pt_model_loaded(**A_	).to_tuple()

								self.assertEqual(
								    len(A_	)    ,				len(A_	)    ,				'Output lengths differ between Flax and PyTorch'	)
								for fx_output, pt_output in zip(A_    ,				A_	):
										self.assert_almost_equals(fx_output[:, -1]    ,				pt_output[:, -1].numpy()    ,				4e-2	)



		@tooslow
		def __UpperCamelCase			(			self	)  -> Any:
				"""simple docstring"""
				for model_class_name in self.all_model_classes:
						UpperCamelCase          =					model_class_name.from_pretrained('EleutherAI/gpt-j-6B'	)
						UpperCamelCase          =					model(np.ones((1, 1)	)	)
						self.assertIsNotNone(A_	)


import pprint

import requests

_UpperCAmelCase :			Union[str, Any]              =	"https://zenquotes.io/api"


def 				A	( )       ->  list:
		'''simple docstring'''

		return requests.get(API_ENDPOINT_URL + '/today'			).json()


def 				A	( )       ->  list:
		'''simple docstring'''

		return requests.get(API_ENDPOINT_URL + '/random'			).json()


if __name__ == "__main__":
					_UpperCAmelCase :			str              =	random_quotes()
					pprint.pprint(response)
