

from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
			import numpy as np
			import tensorflow as tf

			from transformers import (
			    TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
			    FlaubertConfig,
			    TFFlaubertForMultipleChoice,
			    TFFlaubertForQuestionAnsweringSimple,
			    TFFlaubertForSequenceClassification,
			    TFFlaubertForTokenClassification,
			    TFFlaubertModel,
			    TFFlaubertWithLMHeadModel,
			)

class 				UpperCAmelCase_		:
							"""simple docstring"""







							def __init__(			self       ,							_a       ,							)    ->    str:
												_a	:    Optional[Any]         =		parent
												_a	:    Tuple         =		1_3
												_a	:    Union[str, Any]         =		7
												_a	:    Union[str, Any]         =		True
												_a	:    Tuple         =		True
												_a	:    List[Any]         =		True
												_a	:    int         =		True
												_a	:    Optional[int]         =		True
												_a	:    Dict         =		False
												_a	:    Union[str, Any]         =		False
												_a	:    List[Any]         =		False
												_a	:    Optional[Any]         =		2
												_a	:    List[str]         =		9_9
												_a	:    Optional[Any]         =		0
												_a	:    int         =		3_2
												_a	:    Optional[Any]         =		2
												_a	:    Tuple         =		4
												_a	:    List[str]         =		0.1
												_a	:    int         =		0.1
												_a	:    str         =		5_1_2
												_a	:    Dict         =		1_6
												_a	:    Optional[Any]         =		2
												_a	:    Optional[int]         =		0.02
												_a	:    int         =		3
												_a	:    Union[str, Any]         =		4
												_a	:    List[Any]         =		'''last'''
												_a	:    Dict         =		True
												_a	:    List[Any]         =		None
												_a	:    Optional[int]         =		0


							def 				__lowercase				(			self       )    ->    Any:
												_a	:    Any         =		ids_tensor([self.batch_size, self.seq_length]       ,							self.vocab_size       )
												_a	:    Tuple         =		random_attention_mask([self.batch_size, self.seq_length]       ,							dtype=tf.floataa       )

												_a	:    Optional[int]         =		None
												if self.use_input_lengths:
																	_a	:    Any         =		(
																	    ids_tensor([self.batch_size]       ,							vocab_size=2       ) + self.seq_length - 2
																	)  # small variation of seq_length

												_a	:    Tuple         =		None
												if self.use_token_type_ids:
																	_a	:    Dict         =		ids_tensor([self.batch_size, self.seq_length]       ,							self.n_langs       )

												_a	:    Optional[Any]         =		None
												_a	:    Optional[int]         =		None
												_a	:    Dict         =		None
												if self.use_labels:
																	_a	:    List[Any]         =		ids_tensor([self.batch_size]       ,							self.type_sequence_label_size       )
																	_a	:    Union[str, Any]         =		ids_tensor([self.batch_size, self.seq_length]       ,							self.num_labels       )
																	_a	:    List[str]         =		ids_tensor([self.batch_size]       ,							2       ,							dtype=tf.floataa       )
																	_a	:    List[str]         =		ids_tensor([self.batch_size]       ,							self.num_choices       )

												_a	:    List[Any]         =		FlaubertConfig(
												    vocab_size=self.vocab_size       ,							n_special=self.n_special       ,							emb_dim=self.hidden_size       ,							n_layers=self.num_hidden_layers       ,							n_heads=self.num_attention_heads       ,							dropout=self.hidden_dropout_prob       ,							attention_dropout=self.attention_probs_dropout_prob       ,							gelu_activation=self.gelu_activation       ,							sinusoidal_embeddings=self.sinusoidal_embeddings       ,							asm=self.asm       ,							causal=self.causal       ,							n_langs=self.n_langs       ,							max_position_embeddings=self.max_position_embeddings       ,							initializer_range=self.initializer_range       ,							summary_type=self.summary_type       ,							use_proj=self.use_proj       ,							bos_token_id=self.bos_token_id       ,							)

												return (
												    config,
												    input_ids,
												    token_type_ids,
												    input_lengths,
												    sequence_labels,
												    token_labels,
												    is_impossible_labels,
												    choice_labels,
												    input_mask,
												)


							def 				__lowercase				(			self       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							)    ->    Union[str, Any]:
												_a	:    Any         =		TFFlaubertModel(config=_a       )
												_a	:    Union[str, Any]         =		{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
												_a	:    List[Any]         =		model(_a       )

												_a	:    List[str]         =		[input_ids, input_mask]
												_a	:    Tuple         =		model(_a       )
												self.parent.assertEqual(result.last_hidden_state.shape       ,							(self.batch_size, self.seq_length, self.hidden_size)       )


							def 				__lowercase				(			self       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							)    ->    Optional[Any]:
												_a	:    Optional[int]         =		TFFlaubertWithLMHeadModel(_a       )

												_a	:    List[Any]         =		{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
												_a	:    str         =		model(_a       )

												self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, self.seq_length, self.vocab_size)       )


							def 				__lowercase				(			self       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							)    ->    Optional[Any]:
												_a	:    Union[str, Any]         =		TFFlaubertForQuestionAnsweringSimple(_a       )

												_a	:    Dict         =		{'''input_ids''': input_ids, '''lengths''': input_lengths}

												_a	:    Union[str, Any]         =		model(_a       )

												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 				__lowercase				(			self       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							)    ->    Any:
												_a	:    Optional[int]         =		TFFlaubertForSequenceClassification(_a       )

												_a	:    Any         =		{'''input_ids''': input_ids, '''lengths''': input_lengths}

												_a	:    int         =		model(_a       )

												self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, self.type_sequence_label_size)       )


							def 				__lowercase				(			self       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							)    ->    Optional[Any]:
												_a	:    int         =		self.num_labels
												_a	:    Any         =		TFFlaubertForTokenClassification(config=_a       )
												_a	:    List[str]         =		{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
												_a	:    Optional[Any]         =		model(_a       )
												self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, self.seq_length, self.num_labels)       )


							def 				__lowercase				(			self       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       ,							)    ->    List[Any]:
												_a	:    List[str]         =		self.num_choices
												_a	:    Tuple         =		TFFlaubertForMultipleChoice(config=_a       )
												_a	:    Any         =		tf.tile(tf.expand_dims(_a       ,							1       )       ,							(1, self.num_choices, 1)       )
												_a	:    Dict         =		tf.tile(tf.expand_dims(_a       ,							1       )       ,							(1, self.num_choices, 1)       )
												_a	:    Dict         =		tf.tile(tf.expand_dims(_a       ,							1       )       ,							(1, self.num_choices, 1)       )
												_a	:    List[Any]         =		{
												    '''input_ids''': multiple_choice_inputs_ids,
												    '''attention_mask''': multiple_choice_input_mask,
												    '''token_type_ids''': multiple_choice_token_type_ids,
												}
												_a	:    Any         =		model(_a       )
												self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, self.num_choices)       )




							def 				__lowercase				(			self       )    ->    List[Any]:
												_a	:    str         =		self.prepare_config_and_inputs()
												(
												    (
												    _a
												)      ,					(
												    _a
												)      ,					(
												    _a
												)      ,					(
												    _a
												)      ,					(
												    _a
												)      ,					(
												    _a
												)      ,					(
												    _a
												)      ,					(
												    _a
												)      ,					(
												    _a
												)      ,					
												)	:    Union[str, Any]         =		config_and_inputs
												_a	:    Dict         =		{
												    '''input_ids''': input_ids,
												    '''token_type_ids''': token_type_ids,
												    '''langs''': token_type_ids,
												    '''lengths''': input_lengths,
												}
												return config, inputs_dict



@require_tf
class 				UpperCAmelCase_		(			__lowercase				,       __lowercase				,       unittest.TestCase   ):
							"""simple docstring"""







							UpperCAmelCase__       :						Optional[Any]	    =    (
							    (
							        TFFlaubertModel,
							        TFFlaubertWithLMHeadModel,
							        TFFlaubertForSequenceClassification,
							        TFFlaubertForQuestionAnsweringSimple,
							        TFFlaubertForTokenClassification,
							        TFFlaubertForMultipleChoice,
							    )
							    if is_tf_available()
							    else ()
							)
							UpperCAmelCase__       :						Optional[int]	    =    (
							    (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
							)  # TODO (PVP): Check other models whether language generation is also applicable
							UpperCAmelCase__       :						Optional[int]	    =    (
							    {
							        "feature-extraction": TFFlaubertModel,
							        "fill-mask": TFFlaubertWithLMHeadModel,
							        "question-answering": TFFlaubertForQuestionAnsweringSimple,
							        "text-classification": TFFlaubertForSequenceClassification,
							        "token-classification": TFFlaubertForTokenClassification,
							        "zero-shot": TFFlaubertForSequenceClassification,
							    }
							    if is_tf_available()
							    else {}
							)
							UpperCAmelCase__       :						str	    =    False
							UpperCAmelCase__       :						List[Any]	    =    False


							def 				__lowercase				(			self       ,							_a       ,							_a       ,							_a       ,							_a       ,							_a       )    ->    Dict:
												if (
												    pipeline_test_casse_name == "QAPipelineTests"
												    and tokenizer_name is not None
												    and not tokenizer_name.endswith('''Fast'''       )
												):
																	# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
																	# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
																	# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
																	return True

												return False


							def 				__lowercase				(			self       )    ->    str:
												_a	:    Tuple         =		TFFlaubertModelTester(self       )
												_a	:    Tuple         =		ConfigTester(self       ,							config_class=_a       ,							emb_dim=3_7       )


							def 				__lowercase				(			self       )    ->    Dict:
												self.config_tester.run_common_tests()


							def 				__lowercase				(			self       )    ->    int:
												_a	:    Any         =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_flaubert_model(*_a       )


							def 				__lowercase				(			self       )    ->    Optional[Any]:
												_a	:    List[str]         =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_flaubert_lm_head(*_a       )


							def 				__lowercase				(			self       )    ->    List[str]:
												_a	:    str         =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_flaubert_qa(*_a       )


							def 				__lowercase				(			self       )    ->    Any:
												_a	:    Union[str, Any]         =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_flaubert_sequence_classif(*_a       )


							def 				__lowercase				(			self       )    ->    str:
												_a	:    Optional[Any]         =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_flaubert_for_token_classification(*_a       )


							def 				__lowercase				(			self       )    ->    Tuple:
												_a	:    Union[str, Any]         =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_flaubert_for_multiple_choice(*_a       )




							@slow
							def 				__lowercase				(			self       )    ->    str:
												for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	_a	:    int         =		TFFlaubertModel.from_pretrained(_a       )
																	self.assertIsNotNone(_a       )



@require_tf
@require_sentencepiece
@require_tokenizers
class 				UpperCAmelCase_		(			unittest.TestCase   ):
							"""simple docstring"""







							@slow
							def 				__lowercase				(			self       )    ->    List[Any]:
												_a	:    List[Any]         =		TFFlaubertModel.from_pretrained('''jplu/tf-flaubert-small-cased'''       )

												_a	:    Dict         =		tf.convert_to_tensor(
												    [[0, 1_5_8, 7_3_5, 2_5_9_2, 1_4_2_4, 6_7_2_7, 8_2, 1]]       ,							dtype=tf.intaa       ,							)  # "J'aime flaubert !"

												_a	:    Any         =		model(_a       )[0]
												_a	:    Optional[int]         =		tf.TensorShape((1, 8, 5_1_2)       )
												self.assertEqual(output.shape       ,							_a       )
												# compare the actual values for a slice.
												_a	:    Any         =		tf.convert_to_tensor(
												    [
												        [
												            [-1.876_8773, -1.56_6555, 0.2707_2418],
												            [-1.692_0038, -0.587_3505, 1.932_9599],
												            [-2.956_3985, -1.699_3835, 1.797_2052],
												        ]
												    ]       ,							dtype=tf.floataa       ,							)

												self.assertTrue(np.allclose(output[:, :3, :3].numpy()       ,							expected_slice.numpy()       ,							atol=1e-4       )       )






import requests

a__				=		'''YOUR API KEY'''



def    __UpperCAmelCase (	__a      :			str		,__a      :			str = giphy_api_key	)			->     list:

					"""simple docstring"""

					_a	:    Optional[Any]         =		'''+'''.join(query.split()	)
					_a	:    Union[str, Any]         =		F"""https://api.giphy.com/v1/gifs/search?q={formatted_query}&api_key={api_key}"""
					_a	:    List[Any]         =		requests.get(__a	).json()['''data''']
					return [gif["url"] for gif in gifs]


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



