
import unittest

from transformers import AlbertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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 (
					    MODEL_FOR_PRETRAINING_MAPPING,
					    AlbertForMaskedLM,
					    AlbertForMultipleChoice,
					    AlbertForPreTraining,
					    AlbertForQuestionAnswering,
					    AlbertForSequenceClassification,
					    AlbertForTokenClassification,
					    AlbertModel,
					)
					from transformers.models.albert.modeling_albert import ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST


class     lowercase :



		def __init__(			self    ,				A_    ,				A_=13    ,				A_=7    ,				A_=True    ,				A_=True    ,				A_=True    ,				A_=True    ,				A_=99    ,				A_=16    ,				A_=36    ,				A_=6    ,				A_=6    ,				A_=6    ,				A_=37    ,				A_="gelu"    ,				A_=0.1    ,				A_=0.1    ,				A_=512    ,				A_=16    ,				A_=2    ,				A_=0.02    ,				A_=3    ,				A_=4    ,				A_=None    ,				)  -> Union[str, 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          =					embedding_size
			UpperCamelCase          =					hidden_size
			UpperCamelCase          =					num_hidden_layers
			UpperCamelCase          =					num_hidden_groups
			UpperCamelCase          =					num_attention_heads
			UpperCamelCase          =					intermediate_size
			UpperCamelCase          =					hidden_act
			UpperCamelCase          =					hidden_dropout_prob
			UpperCamelCase          =					attention_probs_dropout_prob
			UpperCamelCase          =					max_position_embeddings
			UpperCamelCase          =					type_vocab_size
			UpperCamelCase          =					type_sequence_label_size
			UpperCamelCase          =					initializer_range
			UpperCamelCase          =					num_labels
			UpperCamelCase          =					num_choices
			UpperCamelCase          =					scope



		def __UpperCamelCase			(			self	)  -> Union[str, 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          =					None
			if self.use_token_type_ids:
				UpperCamelCase          =					ids_tensor([self.batch_size, self.seq_length]    ,				self.type_vocab_size	)

			UpperCamelCase          =					None
			UpperCamelCase          =					None
			UpperCamelCase          =					None
			if self.use_labels:
				UpperCamelCase          =					ids_tensor([self.batch_size]    ,				self.type_sequence_label_size	)
				UpperCamelCase          =					ids_tensor([self.batch_size, self.seq_length]    ,				self.num_labels	)
				UpperCamelCase          =					ids_tensor([self.batch_size]    ,				self.num_choices	)

			UpperCamelCase          =					self.get_config()

			return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



		def __UpperCamelCase			(			self	)  -> Any:
			"""simple docstring"""
			return AlbertConfig(
			    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    ,				initializer_range=self.initializer_range    ,				num_hidden_groups=self.num_hidden_groups    ,				)



		def __UpperCamelCase			(			self    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_	)  -> Tuple:
			"""simple docstring"""
			UpperCamelCase          =					AlbertModel(config=_lowerCAmelCase	)
			model.to(_lowerCAmelCase	)
			model.eval()
			UpperCamelCase          =					model(_lowerCAmelCase    ,				attention_mask=_lowerCAmelCase    ,				token_type_ids=_lowerCAmelCase	)
			UpperCamelCase          =					model(_lowerCAmelCase    ,				token_type_ids=_lowerCAmelCase	)
			UpperCamelCase          =					model(_lowerCAmelCase	)
			self.parent.assertEqual(result.last_hidden_state.shape    ,				(self.batch_size, self.seq_length, self.hidden_size)	)
			self.parent.assertEqual(result.pooler_output.shape    ,				(self.batch_size, self.hidden_size)	)



		def __UpperCamelCase			(			self    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_	)  -> List[str]:
			"""simple docstring"""
			UpperCamelCase          =					AlbertForPreTraining(config=_lowerCAmelCase	)
			model.to(_lowerCAmelCase	)
			model.eval()
			UpperCamelCase          =					model(
			    _lowerCAmelCase    ,				attention_mask=_lowerCAmelCase    ,				token_type_ids=_lowerCAmelCase    ,				labels=_lowerCAmelCase    ,				sentence_order_label=_lowerCAmelCase    ,				)
			self.parent.assertEqual(result.prediction_logits.shape    ,				(self.batch_size, self.seq_length, self.vocab_size)	)
			self.parent.assertEqual(result.sop_logits.shape    ,				(self.batch_size, config.num_labels)	)



		def __UpperCamelCase			(			self    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_	)  -> Tuple:
			"""simple docstring"""
			UpperCamelCase          =					AlbertForMaskedLM(config=_lowerCAmelCase	)
			model.to(_lowerCAmelCase	)
			model.eval()
			UpperCamelCase          =					model(_lowerCAmelCase    ,				attention_mask=_lowerCAmelCase    ,				token_type_ids=_lowerCAmelCase    ,				labels=_lowerCAmelCase	)
			self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.seq_length, self.vocab_size)	)



		def __UpperCamelCase			(			self    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_	)  -> Optional[int]:
			"""simple docstring"""
			UpperCamelCase          =					AlbertForQuestionAnswering(config=_lowerCAmelCase	)
			model.to(_lowerCAmelCase	)
			model.eval()
			UpperCamelCase          =					model(
			    _lowerCAmelCase    ,				attention_mask=_lowerCAmelCase    ,				token_type_ids=_lowerCAmelCase    ,				start_positions=_lowerCAmelCase    ,				end_positions=_lowerCAmelCase    ,				)
			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 __UpperCamelCase			(			self    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_	)  -> List[Any]:
			"""simple docstring"""
			UpperCamelCase          =					self.num_labels
			UpperCamelCase          =					AlbertForSequenceClassification(_lowerCAmelCase	)
			model.to(_lowerCAmelCase	)
			model.eval()
			UpperCamelCase          =					model(_lowerCAmelCase    ,				attention_mask=_lowerCAmelCase    ,				token_type_ids=_lowerCAmelCase    ,				labels=_lowerCAmelCase	)
			self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.num_labels)	)



		def __UpperCamelCase			(			self    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_	)  -> List[Any]:
			"""simple docstring"""
			UpperCamelCase          =					self.num_labels
			UpperCamelCase          =					AlbertForTokenClassification(config=_lowerCAmelCase	)
			model.to(_lowerCAmelCase	)
			model.eval()
			UpperCamelCase          =					model(_lowerCAmelCase    ,				attention_mask=_lowerCAmelCase    ,				token_type_ids=_lowerCAmelCase    ,				labels=_lowerCAmelCase	)
			self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.seq_length, self.num_labels)	)



		def __UpperCamelCase			(			self    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_	)  -> Optional[Any]:
			"""simple docstring"""
			UpperCamelCase          =					self.num_choices
			UpperCamelCase          =					AlbertForMultipleChoice(config=_lowerCAmelCase	)
			model.to(_lowerCAmelCase	)
			model.eval()
			UpperCamelCase          =					input_ids.unsqueeze(1	).expand(-1    ,				self.num_choices    ,				-1	).contiguous()
			UpperCamelCase          =					token_type_ids.unsqueeze(1	).expand(-1    ,				self.num_choices    ,				-1	).contiguous()
			UpperCamelCase          =					input_mask.unsqueeze(1	).expand(-1    ,				self.num_choices    ,				-1	).contiguous()
			UpperCamelCase          =					model(
			    _lowerCAmelCase    ,				attention_mask=_lowerCAmelCase    ,				token_type_ids=_lowerCAmelCase    ,				labels=_lowerCAmelCase    ,				)
			self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.num_choices)	)



		def __UpperCamelCase			(			self	)  -> Optional[Any]:
			"""simple docstring"""
			UpperCamelCase          =					self.prepare_config_and_inputs()
			(
			    UpperCamelCase				
			)          =					config_and_inputs
			UpperCamelCase          =					{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
			return config, inputs_dict






@require_torch
class     lowercase (		__UpperCamelCase  ,       __UpperCamelCase  ,       unittest.TestCase       ):
		__lowercase	:	List[str]     					=    (
		    (
		        AlbertModel,
		        AlbertForPreTraining,
		        AlbertForMaskedLM,
		        AlbertForMultipleChoice,
		        AlbertForSequenceClassification,
		        AlbertForTokenClassification,
		        AlbertForQuestionAnswering,
		    )
		    if is_torch_available()
		    else ()
		)
		__lowercase	:	Any     					=    (
		    {
		        "feature-extraction": AlbertModel,
		        "fill-mask": AlbertForMaskedLM,
		        "question-answering": AlbertForQuestionAnswering,
		        "text-classification": AlbertForSequenceClassification,
		        "token-classification": AlbertForTokenClassification,
		        "zero-shot": AlbertForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		__lowercase	:	Tuple     					=    True



		def __UpperCamelCase			(			self    ,				A_    ,				A_    ,				A_=False	)  -> Dict:
			"""simple docstring"""
			UpperCamelCase          =					super()._prepare_for_class(_lowerCAmelCase    ,				_lowerCAmelCase    ,				return_labels=_lowerCAmelCase	)

			if return_labels:
				if model_class in get_values(_lowerCAmelCase	):
					UpperCamelCase          =					torch.zeros(
					    (self.model_tester.batch_size, self.model_tester.seq_length)    ,				dtype=torch.long    ,				device=_lowerCAmelCase	)
					UpperCamelCase          =					torch.zeros(
					    self.model_tester.batch_size    ,				dtype=torch.long    ,				device=_lowerCAmelCase	)
			return inputs_dict



		def __UpperCamelCase			(			self	)  -> Optional[Any]:
			"""simple docstring"""
			UpperCamelCase          =					AlbertModelTester(self	)
			UpperCamelCase          =					ConfigTester(self    ,				config_class=_lowerCAmelCase    ,				hidden_size=37	)



		def __UpperCamelCase			(			self	)  -> Union[str, Any]:
			"""simple docstring"""
			self.config_tester.run_common_tests()



		def __UpperCamelCase			(			self	)  -> List[Any]:
			"""simple docstring"""
			UpperCamelCase          =					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_model(*_lowerCAmelCase	)



		def __UpperCamelCase			(			self	)  -> Union[str, Any]:
			"""simple docstring"""
			UpperCamelCase          =					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_pretraining(*_lowerCAmelCase	)



		def __UpperCamelCase			(			self	)  -> Tuple:
			"""simple docstring"""
			UpperCamelCase          =					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_masked_lm(*_lowerCAmelCase	)



		def __UpperCamelCase			(			self	)  -> List[Any]:
			"""simple docstring"""
			UpperCamelCase          =					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_multiple_choice(*_lowerCAmelCase	)



		def __UpperCamelCase			(			self	)  -> str:
			"""simple docstring"""
			UpperCamelCase          =					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_question_answering(*_lowerCAmelCase	)



		def __UpperCamelCase			(			self	)  -> str:
			"""simple docstring"""
			UpperCamelCase          =					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_sequence_classification(*_lowerCAmelCase	)



		def __UpperCamelCase			(			self	)  -> Optional[int]:
			"""simple docstring"""
			UpperCamelCase          =					self.model_tester.prepare_config_and_inputs()
			for type in ["absolute", "relative_key", "relative_key_query"]:
				UpperCamelCase          =					type
				self.model_tester.create_and_check_model(*_lowerCAmelCase	)



		@slow
		def __UpperCamelCase			(			self	)  -> Optional[Any]:
			"""simple docstring"""
			for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
				UpperCamelCase          =					AlbertModel.from_pretrained(_lowerCAmelCase	)
				self.assertIsNotNone(_lowerCAmelCase	)






@require_torch
class     lowercase (		unittest.TestCase       ):



		@slow
		def __UpperCamelCase			(			self	)  -> Any:
			"""simple docstring"""
			UpperCamelCase          =					AlbertModel.from_pretrained('albert-base-v2'	)
			UpperCamelCase          =					torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]]	)
			UpperCamelCase          =					torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]	)
			with torch.no_grad():
				UpperCamelCase          =					model(_lowerCAmelCase    ,				attention_mask=_lowerCAmelCase	)[0]
			UpperCamelCase          =					torch.Size((1, 11, 768)	)
			self.assertEqual(output.shape    ,				_lowerCAmelCase	)
			UpperCamelCase          =					torch.tensor(
			    [[[-0.6513, 1.5035, -0.2766], [-0.6515, 1.5046, -0.2780], [-0.6512, 1.5049, -0.2784]]]	)

			self.assertTrue(torch.allclose(output[:, 1:4, 1:4]    ,				_lowerCAmelCase    ,				atol=1e-4	)	)


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)
