
"""simple docstring"""

import unittest

from transformers import SqueezeBertConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, 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 (
						    SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
						    SqueezeBertForMaskedLM,
						    SqueezeBertForMultipleChoice,
						    SqueezeBertForQuestionAnswering,
						    SqueezeBertForSequenceClassification,
						    SqueezeBertForTokenClassification,
						    SqueezeBertModel,
						)

class __lowerCAmelCase	(   UpperCAmelCase_    ):





					def __init__(			self			,  __UpperCAmelCase			,  __UpperCAmelCase=13			,  __UpperCAmelCase=7			,  __UpperCAmelCase=True			,  __UpperCAmelCase=True			,  __UpperCAmelCase=False			,  __UpperCAmelCase=True			,  __UpperCAmelCase=99			,  __UpperCAmelCase=32			,  __UpperCAmelCase=5			,  __UpperCAmelCase=4			,  __UpperCAmelCase=64			,  __UpperCAmelCase="gelu"			,  __UpperCAmelCase=0.1			,  __UpperCAmelCase=0.1			,  __UpperCAmelCase=512			,  __UpperCAmelCase=16			,  __UpperCAmelCase=2			,  __UpperCAmelCase=0.0_2			,  __UpperCAmelCase=3			,  __UpperCAmelCase=4			,  __UpperCAmelCase=None			,  __UpperCAmelCase=2			,  __UpperCAmelCase=2			,  __UpperCAmelCase=2			,  __UpperCAmelCase=2			,  __UpperCAmelCase=4			,  __UpperCAmelCase=1			,  ):

						'''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       						= 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       						= type_vocab_size
						__UpperCamelCase       						= type_sequence_label_size
						__UpperCamelCase       						= initializer_range
						__UpperCamelCase       						= num_labels
						__UpperCamelCase       						= num_choices
						__UpperCamelCase       						= scope
						__UpperCamelCase       						= q_groups
						__UpperCamelCase       						= k_groups
						__UpperCamelCase       						= v_groups
						__UpperCamelCase       						= post_attention_groups
						__UpperCamelCase       						= intermediate_groups
						__UpperCamelCase       						= output_groups





					def 		UpperCAmelCase      (			self   ):

						'''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
						__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, input_mask, sequence_labels, token_labels, choice_labels





					def 		UpperCAmelCase      (			self   ):

						'''simple docstring'''




						return SqueezeBertConfig(
						    embedding_size=self.hidden_size			,  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			,  attention_probs_dropout_prob=self.hidden_dropout_prob			,  attention_dropout=self.attention_probs_dropout_prob			,  max_position_embeddings=self.max_position_embeddings			,  initializer_range=self.initializer_range			,  q_groups=self.q_groups			,  k_groups=self.k_groups			,  v_groups=self.v_groups			,  post_attention_groups=self.post_attention_groups			,  intermediate_groups=self.intermediate_groups			,  output_groups=self.output_groups			,  )





					def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

						'''simple docstring'''




						__UpperCamelCase       						= SqueezeBertModel(config=_lowercase   )
						model.to(_lowercase   )
						model.eval()
						__UpperCamelCase       						= model(_lowercase			,  _lowercase   )
						__UpperCamelCase       						= model(_lowercase   )
						self.parent.assertEqual(result.last_hidden_state.shape			,  (self.batch_size, self.seq_length, self.hidden_size)   )





					def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

						'''simple docstring'''




						__UpperCamelCase       						= SqueezeBertForMaskedLM(config=_lowercase   )
						model.to(_lowercase   )
						model.eval()
						__UpperCamelCase       						= model(_lowercase			,  attention_mask=_lowercase			,  labels=_lowercase   )
						self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.seq_length, self.vocab_size)   )





					def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

						'''simple docstring'''




						__UpperCamelCase       						= SqueezeBertForQuestionAnswering(config=_lowercase   )
						model.to(_lowercase   )
						model.eval()
						__UpperCamelCase       						= model(
						    _lowercase			,  attention_mask=_lowercase			,  start_positions=_lowercase			,  end_positions=_lowercase   )
						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			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

						'''simple docstring'''




						__UpperCamelCase       						= self.num_labels
						__UpperCamelCase       						= SqueezeBertForSequenceClassification(_lowercase   )
						model.to(_lowercase   )
						model.eval()
						__UpperCamelCase       						= model(_lowercase			,  attention_mask=_lowercase			,  labels=_lowercase   )
						self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.num_labels)   )





					def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

						'''simple docstring'''




						__UpperCamelCase       						= self.num_labels
						__UpperCamelCase       						= SqueezeBertForTokenClassification(config=_lowercase   )
						model.to(_lowercase   )
						model.eval()

						__UpperCamelCase       						= model(_lowercase			,  attention_mask=_lowercase			,  labels=_lowercase   )
						self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.seq_length, self.num_labels)   )





					def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

						'''simple docstring'''




						__UpperCamelCase       						= self.num_choices
						__UpperCamelCase       						= SqueezeBertForMultipleChoice(config=_lowercase   )
						model.to(_lowercase   )
						model.eval()
						__UpperCamelCase       						= input_ids.unsqueeze(1   ).expand(-1			,  self.num_choices			,  -1   ).contiguous()
						__UpperCamelCase       						= input_mask.unsqueeze(1   ).expand(-1			,  self.num_choices			,  -1   ).contiguous()
						__UpperCamelCase       						= model(
						    _lowercase			,  attention_mask=_lowercase			,  labels=_lowercase			,  )
						self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.num_choices)   )







					def 		UpperCAmelCase      (			self   ):

						'''simple docstring'''




						__UpperCamelCase       						= self.prepare_config_and_inputs()
						(__UpperCamelCase)       						= config_and_inputs
						__UpperCamelCase       						= {'input_ids': input_ids, 'attention_mask': input_mask}
						return config, inputs_dict


@require_torch
class __lowerCAmelCase	(   UpperCAmelCase_    ,						UpperCAmelCase_    ,						unittest.TestCase    ):
					lowercase		     =		(
					    (
					        SqueezeBertModel,
					        SqueezeBertForMaskedLM,
					        SqueezeBertForMultipleChoice,
					        SqueezeBertForQuestionAnswering,
					        SqueezeBertForSequenceClassification,
					        SqueezeBertForTokenClassification,
					    )
					    if is_torch_available()
					    else None
					)
					lowercase		     =		(
					    {
					        'feature-extraction': SqueezeBertModel,
					        'fill-mask': SqueezeBertForMaskedLM,
					        'question-answering': SqueezeBertForQuestionAnswering,
					        'text-classification': SqueezeBertForSequenceClassification,
					        'token-classification': SqueezeBertForTokenClassification,
					        'zero-shot': SqueezeBertForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					lowercase		     =		False
					lowercase		     =		True
					lowercase		     =		False





					def 		UpperCAmelCase      (			self   ):

						'''simple docstring'''




						__UpperCamelCase       						= SqueezeBertModelTester(self   )
						__UpperCamelCase       						= ConfigTester(self			,  config_class=_lowercase			,  dim=37   )





					def 		UpperCAmelCase      (			self   ):

						'''simple docstring'''




						self.config_tester.run_common_tests()





					def 		UpperCAmelCase      (			self   ):

						'''simple docstring'''




						__UpperCamelCase       						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_squeezebert_model(*_lowercase   )





					def 		UpperCAmelCase      (			self   ):

						'''simple docstring'''




						__UpperCamelCase       						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_squeezebert_for_masked_lm(*_lowercase   )





					def 		UpperCAmelCase      (			self   ):

						'''simple docstring'''




						__UpperCamelCase       						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_squeezebert_for_question_answering(*_lowercase   )





					def 		UpperCAmelCase      (			self   ):

						'''simple docstring'''




						__UpperCamelCase       						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_squeezebert_for_sequence_classification(*_lowercase   )





					def 		UpperCAmelCase      (			self   ):

						'''simple docstring'''




						__UpperCamelCase       						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_squeezebert_for_token_classification(*_lowercase   )





					def 		UpperCAmelCase      (			self   ):

						'''simple docstring'''




						__UpperCamelCase       						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_squeezebert_for_multiple_choice(*_lowercase   )







					@slow
					def 		UpperCAmelCase      (			self   ):

						'''simple docstring'''




						for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__UpperCamelCase       						= SqueezeBertModel.from_pretrained(_lowercase   )
							self.assertIsNotNone(_lowercase   )


@require_sentencepiece
@require_tokenizers
@require_torch
class __lowerCAmelCase	(   unittest.TestCase    ):





					@slow
					def 		UpperCAmelCase      (			self   ):

						'''simple docstring'''




						__UpperCamelCase       						= SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli'   )

						__UpperCamelCase       						= torch.tensor([[1, 2_9414, 232, 328, 740, 1140, 1_2695, 69, 13, 1588, 2]]   )
						__UpperCamelCase       						= model(_lowercase   )[0]
						__UpperCamelCase       						= torch.Size((1, 3)   )
						self.assertEqual(output.shape			,  _lowercase   )
						__UpperCamelCase       						= torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]]   )
						self.assertTrue(torch.allclose(_lowercase			,  _lowercase			,  atol=1E-4   )   )





"""simple docstring"""

from __future__ import annotations

import os
from typing import Any

import requests

UpperCamelCase			:       Union[str, Any]									=				"https://api.github.com"

# https://docs.github.com/en/free-pro-team@latest/rest/reference/users#get-the-authenticated-user
UpperCamelCase			:       Union[str, Any]									=				BASE_URL + "/user"

# https://github.com/settings/tokens
UpperCamelCase			:       Optional[int]									=				os.environ.get("USER_TOKEN", "")






def 							A		(       snake_case   :str	)   ->			dict[Any, Any]:
 __UpperCamelCase       						= {
     'Authorization': f'token {auth_token}',
     'Accept': 'application/vnd.github.v3+json',
 }
 return requests.get(snake_case       ,      headers=snake_case	).json()


if __name__ == "__main__":  # pragma: no cover
      if USER_TOKEN:
            for key, value in fetch_github_info(USER_TOKEN).items():
                  print(f'''{key}: {value}''')
      else:
            raise ValueError("'USER_TOKEN' field cannot be empty.")



