






"""simple docstring"""



import tempfile
import unittest

import numpy as np

import transformers
from transformers import GPTaConfig, GPTaTokenizer, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, 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.gpta.modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel

if is_torch_available():
 import torch




class        lowerCAmelCase__       :
   def __init__(						self	:     Tuple				,       snake_case__	:     List[Any]				,       snake_case__	:     int=1_4				,       snake_case__	:     Optional[int]=7				,       snake_case__	:     Union[str, Any]=True				,       snake_case__	:     Union[str, Any]=True				,       snake_case__	:     str=False				,       snake_case__	:     Union[str, Any]=True				,       snake_case__	:     Dict=9_9				,       snake_case__	:     List[Any]=3_2				,       snake_case__	:     List[Any]=5				,       snake_case__	:     Tuple=4				,       snake_case__	:     Tuple=3_7				,       snake_case__	:     str="gelu"				,       snake_case__	:     Union[str, Any]=0.1				,       snake_case__	:     Dict=0.1				,       snake_case__	:     Dict=5_1_2				,       snake_case__	:     Dict=0.02				,       ):


        '''simple docstring'''
        UpperCAmelCase__		:  Optional[int]				=				parent
        UpperCAmelCase__		:  Tuple				=				batch_size
        UpperCAmelCase__		:  Any				=				seq_length
        UpperCAmelCase__		:  int				=				is_training
        UpperCAmelCase__		:  Optional[Any]				=				use_input_mask
        UpperCAmelCase__		:  int				=				use_token_type_ids
        UpperCAmelCase__		:  Any				=				use_labels
        UpperCAmelCase__		:  Union[str, Any]				=				vocab_size
        UpperCAmelCase__		:  int				=				hidden_size
        UpperCAmelCase__		:  List[str]				=				num_hidden_layers
        UpperCAmelCase__		:  List[str]				=				num_attention_heads
        UpperCAmelCase__		:  Union[str, Any]				=				intermediate_size
        UpperCAmelCase__		:  List[str]				=				hidden_act
        UpperCAmelCase__		:  List[Any]				=				hidden_dropout_prob
        UpperCAmelCase__		:  str				=				attention_probs_dropout_prob
        UpperCAmelCase__		:  Union[str, Any]				=				max_position_embeddings
        UpperCAmelCase__		:  Tuple				=				initializer_range
        UpperCAmelCase__		:  List[str]				=				None
        UpperCAmelCase__		:  Optional[int]				=				vocab_size - 1
        UpperCAmelCase__		:  Union[str, Any]				=				vocab_size - 1
        UpperCAmelCase__		:  Optional[Any]				=				vocab_size - 1
   def 	__a				(						self	:     Optional[Any]				):


        '''simple docstring'''
        UpperCAmelCase__		:  Tuple				=				ids_tensor([self.batch_size, self.seq_length]				,       self.vocab_size				)

        UpperCAmelCase__		:  Dict				=				None
        if self.use_input_mask:
             UpperCAmelCase__		:  int				=				random_attention_mask([self.batch_size, self.seq_length]				)

        UpperCAmelCase__		:  Dict				=				GPTaConfig(
            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=snake_case__				,       bos_token_id=self.bos_token_id				,       eos_token_id=self.eos_token_id				,       pad_token_id=self.pad_token_id				,       )

        return (config, input_ids, input_mask)
   def 	__a				(						self	:     Any				):


        '''simple docstring'''
        UpperCAmelCase__		:  int				=				self.prepare_config_and_inputs()
        UpperCAmelCase__				,							UpperCAmelCase__				,							UpperCAmelCase__		:  List[str]				=				config_and_inputs
        UpperCAmelCase__		:  Tuple				=				{"input_ids": input_ids, "attention_mask": attention_mask}
        return config, inputs_dict
   def 	__a				(						self	:     List[str]				):


        '''simple docstring'''
        UpperCAmelCase__				,							UpperCAmelCase__				,							UpperCAmelCase__		:  str				=				self.prepare_config_and_inputs()

        UpperCAmelCase__		:  Optional[Any]				=				floats_tensor([self.batch_size, self.seq_length, self.hidden_size]				)
        UpperCAmelCase__		:  Any				=				ids_tensor([self.batch_size, self.seq_length]				,       vocab_size=2				)

        return (
            config,
            input_ids,
            attention_mask,
            encoder_hidden_states,
            encoder_attention_mask,
        )
   def 	__a				(						self	:     Tuple				,       snake_case__	:     str				,       snake_case__	:     Optional[Any]				,       snake_case__	:     Optional[int]				,       snake_case__	:     str				):


        '''simple docstring'''
        UpperCAmelCase__		:  Dict				=				2_0
        UpperCAmelCase__		:  Dict				=				model_class_name(snake_case__				)

        UpperCAmelCase__		:  str				=				model.init_cache(input_ids.shape[0]				,       snake_case__				)
        UpperCAmelCase__		:  List[Any]				=				jnp.ones((input_ids.shape[0], max_decoder_length)				,       dtype="i4"				)

        UpperCAmelCase__		:  Union[str, Any]				=				jnp.broadcast_to(
            jnp.arange(input_ids.shape[-1] - 1				)[None, :]				,       (input_ids.shape[0], input_ids.shape[-1] - 1)				)
        UpperCAmelCase__		:  str				=				model(
            input_ids[:, :-1]				,       attention_mask=snake_case__				,       past_key_values=snake_case__				,       position_ids=snake_case__				,       )

        UpperCAmelCase__		:  str				=				jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]				,       dtype="i4"				)
        UpperCAmelCase__		:  List[Any]				=				model(
            input_ids[:, -1:]				,       attention_mask=snake_case__				,       past_key_values=outputs_cache.past_key_values				,       position_ids=snake_case__				,       )

        UpperCAmelCase__		:  List[Any]				=				model(snake_case__				)

        UpperCAmelCase__		:  Tuple				=				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 	__a				(						self	:     Union[str, Any]				,       snake_case__	:     Optional[Any]				,       snake_case__	:     Tuple				,       snake_case__	:     Optional[int]				,       snake_case__	:     Dict				):


        '''simple docstring'''
        UpperCAmelCase__		:  str				=				2_0
        UpperCAmelCase__		:  List[str]				=				model_class_name(snake_case__				)

        UpperCAmelCase__		:  Optional[Any]				=				jnp.concatenate(
            [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])				)]				,       axis=-1				,       )

        UpperCAmelCase__		:  Any				=				model.init_cache(input_ids.shape[0]				,       snake_case__				)
        UpperCAmelCase__		:  int				=				jnp.broadcast_to(
            jnp.arange(input_ids.shape[-1] - 1				)[None, :]				,       (input_ids.shape[0], input_ids.shape[-1] - 1)				)

        UpperCAmelCase__		:  List[Any]				=				model(
            input_ids[:, :-1]				,       attention_mask=snake_case__				,       past_key_values=snake_case__				,       position_ids=snake_case__				,       )
        UpperCAmelCase__		:  Tuple				=				jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]				,       dtype="i4"				)
        UpperCAmelCase__		:  List[str]				=				model(
            input_ids[:, -1:]				,       past_key_values=outputs_cache.past_key_values				,       attention_mask=snake_case__				,       position_ids=snake_case__				,       )

        UpperCAmelCase__		:  Optional[int]				=				model(snake_case__				,       attention_mask=snake_case__				)

        UpperCAmelCase__		:  Optional[Any]				=				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        lowerCAmelCase__       (  __magic_name__				,		__magic_name__				,		unittest.TestCase					):
   SCREAMING_SNAKE_CASE_					      =(FlaxGPTaModel, FlaxGPTaLMHeadModel) if is_flax_available() else ()
   SCREAMING_SNAKE_CASE_					      =(FlaxGPTaLMHeadModel,) if is_flax_available() else ()
   def 	__a				(						self	:     Optional[Any]				):


        '''simple docstring'''
        UpperCAmelCase__		:  int				=				FlaxGPTaModelTester(self				)
   def 	__a				(						self	:     Union[str, Any]				):


        '''simple docstring'''
        for model_class_name in self.all_model_classes:
             UpperCAmelCase__				,							UpperCAmelCase__				,							UpperCAmelCase__		:  Optional[int]				=				self.model_tester.prepare_config_and_inputs()
             self.model_tester.check_use_cache_forward(snake_case__				,       snake_case__				,       snake_case__				,       snake_case__				)
   def 	__a				(						self	:     Tuple				):


        '''simple docstring'''
        for model_class_name in self.all_model_classes:
             UpperCAmelCase__				,							UpperCAmelCase__				,							UpperCAmelCase__		:  List[str]				=				self.model_tester.prepare_config_and_inputs()
             self.model_tester.check_use_cache_forward_with_attn_mask(
                 snake_case__				,       snake_case__				,       snake_case__				,       snake_case__				)
   @slow
   def 	__a				(						self	:     Optional[int]				):


        '''simple docstring'''
        UpperCAmelCase__		:  Dict				=				GPTaTokenizer.from_pretrained("gpt2"				,       pad_token="</s>"				,       padding_side="left"				)
        UpperCAmelCase__		:  Optional[int]				=				tokenizer(["Hello this is a long string", "Hey"]				,       return_tensors="np"				,       padding=snake_case__				,       truncation=snake_case__				)

        UpperCAmelCase__		:  Optional[Any]				=				FlaxGPTaLMHeadModel.from_pretrained("gpt2"				)
        UpperCAmelCase__		:  List[Any]				=				False
        UpperCAmelCase__		:  Dict				=				model.config.eos_token_id

        UpperCAmelCase__		:  str				=				jax.jit(model.generate				)

        UpperCAmelCase__		:  Optional[int]				=				jit_generate(inputs["input_ids"]				,       attention_mask=inputs["attention_mask"]				).sequences

        UpperCAmelCase__		:  Optional[Any]				=				tokenizer.batch_decode(snake_case__				,       skip_special_tokens=snake_case__				)

        UpperCAmelCase__		:  str				=				[
            "Hello this is a long string of words. I'm going to start with the first one.\n",
            "Hey, I'm not sure if I'm going to be able to do",
        ]

        self.assertListEqual(snake_case__				,       snake_case__				)
   @is_pt_flax_cross_test
   def 	__a				(						self	:     Union[str, Any]				):


        '''simple docstring'''
        UpperCAmelCase__				,							UpperCAmelCase__		:  List[str]				=				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__		:  Optional[Any]				=				self._prepare_for_class(snake_case__				,       snake_case__				)
                  UpperCAmelCase__		:  Dict				=				{k: torch.tensor(v.tolist()				) for k, v in prepared_inputs_dict.items()}

                  # load corresponding PyTorch class
                  UpperCAmelCase__		:  str				=				model_class.__name__[4:]  # Skip the "Flax" at the beginning
                  UpperCAmelCase__		:  Optional[Any]				=				getattr(snake_case__				,       snake_case__				)

                  UpperCAmelCase__				,							UpperCAmelCase__		:  List[Any]				=				pt_inputs["input_ids"].shape
                  UpperCAmelCase__		:  Any				=				np.random.randint(0				,       seq_length - 1				,       size=(batch_size,)				)
                  for batch_idx, start_index in enumerate(snake_case__				):
                       UpperCAmelCase__		:  Optional[Any]				=				0
                       UpperCAmelCase__		:  Optional[int]				=				1
                       UpperCAmelCase__		:  Optional[Any]				=				0
                       UpperCAmelCase__		:  Union[str, Any]				=				1
                  UpperCAmelCase__		:  Optional[int]				=				pt_model_class(snake_case__				).eval()
                  UpperCAmelCase__		:  Any				=				model_class(snake_case__				,       dtype=jnp.floataa				)

                  UpperCAmelCase__		:  int				=				convert_pytorch_state_dict_to_flax(pt_model.state_dict()				,       snake_case__				)
                  UpperCAmelCase__		:  List[str]				=				fx_state

                  with torch.no_grad():
                       UpperCAmelCase__		:  str				=				pt_model(**snake_case__				).to_tuple()

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

                  with tempfile.TemporaryDirectory() as tmpdirname:
                       pt_model.save_pretrained(snake_case__				)
                       UpperCAmelCase__		:  List[Any]				=				model_class.from_pretrained(snake_case__				,       from_pt=snake_case__				)

                  UpperCAmelCase__		:  Dict				=				fx_model_loaded(**snake_case__				).to_tuple()
                  self.assertEqual(
                      len(snake_case__				)				,       len(snake_case__				)				,       "Output lengths differ between Flax and PyTorch"				)
                  for fx_output_loaded, pt_output in zip(snake_case__				,       snake_case__				):
                       self.assert_almost_equals(fx_output_loaded[:, -1]				,       pt_output[:, -1].numpy()				,       4e-2				)
   @is_pt_flax_cross_test
   def 	__a				(						self	:     str				):


        '''simple docstring'''
        UpperCAmelCase__				,							UpperCAmelCase__		:  str				=				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__		:  Optional[Any]				=				self._prepare_for_class(snake_case__				,       snake_case__				)
                  UpperCAmelCase__		:  Tuple				=				{k: torch.tensor(v.tolist()				) for k, v in prepared_inputs_dict.items()}

                  # load corresponding PyTorch class
                  UpperCAmelCase__		:  Union[str, Any]				=				model_class.__name__[4:]  # Skip the "Flax" at the beginning
                  UpperCAmelCase__		:  Union[str, Any]				=				getattr(snake_case__				,       snake_case__				)

                  UpperCAmelCase__		:  Dict				=				pt_model_class(snake_case__				).eval()
                  UpperCAmelCase__		:  Union[str, Any]				=				model_class(snake_case__				,       dtype=jnp.floataa				)

                  UpperCAmelCase__		:  Optional[Any]				=				load_flax_weights_in_pytorch_model(snake_case__				,       fx_model.params				)
                  UpperCAmelCase__				,							UpperCAmelCase__		:  Dict				=				pt_inputs["input_ids"].shape
                  UpperCAmelCase__		:  Optional[Any]				=				np.random.randint(0				,       seq_length - 1				,       size=(batch_size,)				)
                  for batch_idx, start_index in enumerate(snake_case__				):
                       UpperCAmelCase__		:  List[Any]				=				0
                       UpperCAmelCase__		:  str				=				1
                       UpperCAmelCase__		:  List[Any]				=				0
                       UpperCAmelCase__		:  Dict				=				1

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

                  with torch.no_grad():
                       UpperCAmelCase__		:  Dict				=				pt_model(**snake_case__				).to_tuple()

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

                  with tempfile.TemporaryDirectory() as tmpdirname:
                       fx_model.save_pretrained(snake_case__				)
                       UpperCAmelCase__		:  List[str]				=				pt_model_class.from_pretrained(snake_case__				,       from_flax=snake_case__				)

                  with torch.no_grad():
                       UpperCAmelCase__		:  Dict				=				pt_model_loaded(**snake_case__				).to_tuple()

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




   @slow
   def 	__a				(						self	:     Optional[int]				):


        '''simple docstring'''
        for model_class_name in self.all_model_classes:
             UpperCAmelCase__		:  Any				=				model_class_name.from_pretrained("gpt2"				,       from_pt=snake_case__				)
             UpperCAmelCase__		:  Any				=				model(np.ones((1, 1)				)				)
             self.assertIsNotNone(snake_case__				)










"""simple docstring"""



import shutil

import requests


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      str       , snake_case    :      bool = False       , snake_case    :      str = "."							)->						dict:






     '''simple docstring'''



     UpperCAmelCase__		:  Union[str, Any]				=				"https://api.nasa.gov/planetary/apod"
     return requests.get(snake_case       , params={"api_key": api_key}							).json()


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      str       , snake_case    :      str = "."							)->						dict:






     '''simple docstring'''



     UpperCAmelCase__		:  List[Any]				=				get_apod_data(snake_case							)
     UpperCAmelCase__		:  str				=				apod_data["url"]
     UpperCAmelCase__		:  Tuple				=				img_url.split("/"							)[-1]
     UpperCAmelCase__		:  Dict				=				requests.get(snake_case       , stream=snake_case							)

     with open(f'{path}/{img_name}'       , "wb+"							) as img_file:
          shutil.copyfileobj(response.raw       , snake_case							)
     del response
     return apod_data


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      str							)->						dict:






     '''simple docstring'''



     UpperCAmelCase__		:  List[str]				=				"https://images-api.nasa.gov/search"
     return requests.get(snake_case       , params={"q": query}							).json()


if __name__ == "__main__":
 print(save_apod("""YOUR API KEY"""))
 _lowerCAmelCase     :     List[Any]            =	get_archive_data("""apollo 2011""")["""collection"""]["""items"""]
 print(apollo_aaaa_items[0]["""data"""][0]["""description"""])


