



import requests

a_   :Tuple        =      "YOUR API KEY"
def        lowercase_							(A : str		,					A : str = giphy_api_key      ):
       snake_case__							:	Optional[int]   	=	'+'.join(query.split()      )
       snake_case__							:	List[str]   	=	F'''https://api.giphy.com/v1/gifs/search?q={formatted_query}&api_key={api_key}'''
       snake_case__							:	Any   	=	requests.get(A      ).json()['data']
       return [gif["url"] for gif in gifs]


if __name__ == "__main__":
 print("\n".join(get_gifs("space ship")))











import unittest

from transformers import 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
     OpenAIGPTConfig,
     OpenAIGPTDoubleHeadsModel,
     OpenAIGPTForSequenceClassification,
     OpenAIGPTLMHeadModel,
     OpenAIGPTModel,
 )




class 					snake_case__						:






     """simple docstring"""


     def __init__(       self  :  List[str], _snake_case  :  Any, _snake_case  :  int=1_3, _snake_case  :  Optional[int]=7, _snake_case  :  int=True, _snake_case  :  Optional[Any]=True, _snake_case  :  Optional[Any]=True, _snake_case  :  Union[str, Any]=9_9, _snake_case  :  Optional[Any]=3_2, _snake_case  :  Tuple=5, _snake_case  :  str=4, _snake_case  :  Any=3_7, _snake_case  :  int="gelu", _snake_case  :  Optional[Any]=0.1, _snake_case  :  str=0.1, _snake_case  :  str=5_1_2, _snake_case  :  Dict=1_6, _snake_case  :  str=2, _snake_case  :  Union[str, Any]=0.0_2, _snake_case  :  Optional[int]=3, _snake_case  :  Union[str, Any]=4, _snake_case  :  Tuple=None, )   ->Optional[Any]:
            snake_case__							:	Optional[int]   	=	parent
            snake_case__							:	List[Any]   	=	batch_size
            snake_case__							:	Tuple   	=	seq_length
            snake_case__							:	str   	=	is_training
            snake_case__							:	Optional[int]   	=	use_token_type_ids
            snake_case__							:	Any   	=	use_labels
            snake_case__							:	Dict   	=	vocab_size
            snake_case__							:	str   	=	hidden_size
            snake_case__							:	Union[str, Any]   	=	num_hidden_layers
            snake_case__							:	List[str]   	=	num_attention_heads
            snake_case__							:	Union[str, Any]   	=	intermediate_size
            snake_case__							:	List[Any]   	=	hidden_act
            snake_case__							:	int   	=	hidden_dropout_prob
            snake_case__							:	str   	=	attention_probs_dropout_prob
            snake_case__							:	Any   	=	max_position_embeddings
            snake_case__							:	Union[str, Any]   	=	type_vocab_size
            snake_case__							:	Optional[Any]   	=	type_sequence_label_size
            snake_case__							:	Optional[int]   	=	initializer_range
            snake_case__							:	Optional[int]   	=	num_labels
            snake_case__							:	str   	=	num_choices
            snake_case__							:	int   	=	scope
            snake_case__							:	List[str]   	=	self.vocab_size - 1






     def    lowercase_   (       self  :  Union[str, Any]					)   ->Tuple:
            snake_case__							:	List[str]   	=	ids_tensor([self.batch_size, self.seq_length], self.vocab_size					)

            snake_case__							:	List[str]   	=	None
            if self.use_token_type_ids:
                   snake_case__							:	Optional[Any]   	=	ids_tensor([self.batch_size, self.seq_length], self.type_vocab_size					)

            snake_case__							:	Tuple   	=	None
            snake_case__							:	str   	=	None
            snake_case__							:	List[Any]   	=	None
            if self.use_labels:
                   snake_case__							:	Dict   	=	ids_tensor([self.batch_size], self.type_sequence_label_size					)
                   snake_case__							:	int   	=	ids_tensor([self.batch_size, self.seq_length], self.num_labels					)
                   snake_case__							:	List[str]   	=	ids_tensor([self.batch_size], self.num_choices					)

            snake_case__							:	Union[str, Any]   	=	OpenAIGPTConfig(
                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, pad_token_id=self.pad_token_id, )

            snake_case__							:	List[str]   	=	ids_tensor([self.num_hidden_layers, self.num_attention_heads], 2					)

            return (
                config,
                input_ids,
                head_mask,
                token_type_ids,
                sequence_labels,
                token_labels,
                choice_labels,
            )






     def    lowercase_   (       self  :  Any, _snake_case  :  List[str], _snake_case  :  Any, _snake_case  :  List[Any], _snake_case  :  Tuple, *_snake_case  :  Optional[Any]					)   ->Tuple:
            snake_case__							:	Union[str, Any]   	=	OpenAIGPTModel(config=_snake_case					)
            model.to(_snake_case					)
            model.eval()

            snake_case__							:	Optional[Any]   	=	model(_snake_case, token_type_ids=_snake_case, head_mask=_snake_case					)
            snake_case__							:	Union[str, Any]   	=	model(_snake_case, token_type_ids=_snake_case					)
            snake_case__							:	Optional[Any]   	=	model(_snake_case					)

            self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size)					)






     def    lowercase_   (       self  :  Optional[int], _snake_case  :  Optional[Any], _snake_case  :  Union[str, Any], _snake_case  :  Optional[int], _snake_case  :  List[Any], *_snake_case  :  Dict					)   ->Optional[int]:
            snake_case__							:	Optional[Any]   	=	OpenAIGPTLMHeadModel(_snake_case					)
            model.to(_snake_case					)
            model.eval()

            snake_case__							:	Tuple   	=	model(_snake_case, token_type_ids=_snake_case, labels=_snake_case					)
            self.parent.assertEqual(result.loss.shape, ()					)
            self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.vocab_size)					)






     def    lowercase_   (       self  :  int, _snake_case  :  Tuple, _snake_case  :  List[str], _snake_case  :  List[Any], _snake_case  :  List[Any], *_snake_case  :  List[Any]					)   ->Optional[int]:
            snake_case__							:	List[str]   	=	OpenAIGPTDoubleHeadsModel(_snake_case					)
            model.to(_snake_case					)
            model.eval()

            snake_case__							:	Optional[Any]   	=	model(_snake_case, token_type_ids=_snake_case, labels=_snake_case					)
            self.parent.assertEqual(result.loss.shape, ()					)
            self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.vocab_size)					)






     def    lowercase_   (       self  :  Optional[int], _snake_case  :  Tuple, _snake_case  :  Dict, _snake_case  :  List[str], _snake_case  :  Optional[Any], *_snake_case  :  Union[str, Any]					)   ->str:
            snake_case__							:	List[str]   	=	self.num_labels
            snake_case__							:	Dict   	=	OpenAIGPTForSequenceClassification(_snake_case					)
            model.to(_snake_case					)
            model.eval()

            snake_case__							:	List[str]   	=	ids_tensor([self.batch_size], self.type_sequence_label_size					)
            snake_case__							:	List[str]   	=	model(_snake_case, token_type_ids=_snake_case, labels=_snake_case					)
            self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)					)






     def    lowercase_   (       self  :  Dict					)   ->int:
            snake_case__							:	List[Any]   	=	self.prepare_config_and_inputs()
            (
                (
                snake_case__
            )	,				(
                snake_case__
            )	,				(
                snake_case__
            )	,				(
                snake_case__
            )	,				(
                snake_case__
            )	,				(
                snake_case__
            )	,				(
                snake_case__
            )	,				
            )							:	Optional[Any]   	=	config_and_inputs
            snake_case__							:	str   	=	{
                'input_ids': input_ids,
                'token_type_ids': token_type_ids,
                'head_mask': head_mask,
            }

            return config, inputs_dict




@require_torch
class 					snake_case__						(       lowerCAmelCase_				,     lowerCAmelCase_				,     lowerCAmelCase_				,     unittest.TestCase     ):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE						=	(
         (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
         if is_torch_available()
         else ()
     )
     _SCREAMING_SNAKE_CASE						=	(
         (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
     )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
     _SCREAMING_SNAKE_CASE						=	(
         {
             """feature-extraction""": OpenAIGPTModel,
             """text-classification""": OpenAIGPTForSequenceClassification,
             """text-generation""": OpenAIGPTLMHeadModel,
             """zero-shot""": OpenAIGPTForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )






     def    lowercase_   (       self  :  Optional[int], _snake_case  :  Union[str, Any], _snake_case  :  int, _snake_case  :  Tuple, _snake_case  :  Tuple, _snake_case  :  List[str]					)   ->Optional[Any]:
            if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
                   # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
                   # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
                   # tiny config could not be created.
                   return True

            return False






     def    lowercase_   (       self  :  Optional[Any], _snake_case  :  Union[str, Any], _snake_case  :  List[str], _snake_case  :  Any=False					)   ->Tuple:
            snake_case__							:	Optional[int]   	=	super()._prepare_for_class(_snake_case, _snake_case, return_labels=_snake_case					)

            if return_labels:
                   if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
                          snake_case__							:	Union[str, Any]   	=	torch.zeros(
                              (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length), dtype=torch.long, device=_snake_case, )
                          snake_case__							:	List[Any]   	=	inputs_dict['labels']
                          snake_case__							:	List[Any]   	=	inputs_dict['labels']
                          snake_case__							:	Any   	=	torch.zeros(
                              (self.model_tester.batch_size, self.model_tester.num_choices), dtype=torch.long, device=_snake_case, )
                          snake_case__							:	Tuple   	=	torch.zeros(
                              self.model_tester.batch_size, dtype=torch.long, device=_snake_case					)
            return inputs_dict






     def    lowercase_   (       self  :  Union[str, Any]					)   ->List[str]:
            snake_case__							:	List[str]   	=	OpenAIGPTModelTester(self					)
            snake_case__							:	Any   	=	ConfigTester(self, config_class=_snake_case, n_embd=3_7					)






     def    lowercase_   (       self  :  Optional[int]					)   ->str:
            self.config_tester.run_common_tests()






     def    lowercase_   (       self  :  int					)   ->Tuple:
            snake_case__							:	str   	=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_openai_gpt_model(*_snake_case					)






     def    lowercase_   (       self  :  Tuple					)   ->List[str]:
            snake_case__							:	Optional[int]   	=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_lm_head_model(*_snake_case					)






     def    lowercase_   (       self  :  Dict					)   ->int:
            snake_case__							:	Optional[Any]   	=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_double_lm_head_model(*_snake_case					)






     def    lowercase_   (       self  :  int					)   ->str:
            snake_case__							:	List[Any]   	=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_snake_case					)






     @slow
     def    lowercase_   (       self  :  Optional[Any]					)   ->str:
            for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   snake_case__							:	Optional[int]   	=	OpenAIGPTModel.from_pretrained(_snake_case					)
                   self.assertIsNotNone(_snake_case					)




@require_torch
class 					snake_case__						(       unittest.TestCase     ):






     """simple docstring"""


     @slow
     def    lowercase_   (       self  :  Tuple					)   ->Optional[int]:
            snake_case__							:	Union[str, Any]   	=	OpenAIGPTLMHeadModel.from_pretrained('openai-gpt'					)
            model.to(_snake_case					)
            snake_case__							:	Tuple   	=	torch.tensor([[4_8_1, 4_7_3_5, 5_4_4]], dtype=torch.long, device=_snake_case					)  # the president is
            snake_case__							:	int   	=	[
                4_8_1,
                4_7_3_5,
                5_4_4,
                2_4_6,
                9_6_3,
                8_7_0,
                7_6_2,
                2_3_9,
                2_4_4,
                4_0_4_7_7,
                2_4_4,
                2_4_9,
                7_1_9,
                8_8_1,
                4_8_7,
                5_4_4,
                2_4_0,
                2_4_4,
                6_0_3,
                4_8_1,
            ]  # the president is a very good man. " \n " i\'m sure he is, " said the

            snake_case__							:	Optional[int]   	=	model.generate(_snake_case, do_sample=_snake_case					)
            self.assertListEqual(output_ids[0].tolist(), _snake_case					)






