




import inspect
import unittest

from transformers import MobileNetVaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import MobileNetVaForImageClassification, MobileNetVaModel
 from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import MobileNetVaImageProcessor







class 						A(		UpperCamelCase     ):



 '''simple docstring'''


 def        a__				(       self      :						int						)     ->			int:

       """simple docstring"""






       lowerCamelCase_	  =					self.config_class(**self.inputs_dict						)
       self.parent.assertTrue(hasattr(A_		,							'tf_padding'						)						)
       self.parent.assertTrue(hasattr(A_		,							'depth_multiplier'						)						)







class 						A:



 '''simple docstring'''


 def __init__(       self      :						List[str]		,							A_      :						str		,							A_      :						Optional[int]=13		,							A_      :						Optional[Any]=3		,							A_      :						Any=32		,							A_      :						Dict=0.25		,							A_      :						Optional[int]=8		,							A_      :						Any=True		,							A_      :						Dict=1024		,							A_      :						Optional[Any]=32		,							A_      :						Optional[int]="relu6"		,							A_      :						Optional[Any]=0.1		,							A_      :						Tuple=0.02		,							A_      :						Optional[Any]=True		,							A_      :						List[Any]=True		,							A_      :						Any=10		,							A_      :						str=None		,							)     ->			Optional[int]:

       """simple docstring"""






       lowerCamelCase_	  =					parent
       lowerCamelCase_	  =					batch_size
       lowerCamelCase_	  =					num_channels
       lowerCamelCase_	  =					image_size
       lowerCamelCase_	  =					depth_multiplier
       lowerCamelCase_	  =					min_depth
       lowerCamelCase_	  =					tf_padding
       lowerCamelCase_	  =					int(last_hidden_size * depth_multiplier						)
       lowerCamelCase_	  =					output_stride
       lowerCamelCase_	  =					hidden_act
       lowerCamelCase_	  =					classifier_dropout_prob
       lowerCamelCase_	  =					use_labels
       lowerCamelCase_	  =					is_training
       lowerCamelCase_	  =					num_labels
       lowerCamelCase_	  =					initializer_range
       lowerCamelCase_	  =					scope

 def        a__				(       self      :						int						)     ->			List[str]:

       """simple docstring"""






       lowerCamelCase_	  =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

       lowerCamelCase_	  =					None
       lowerCamelCase_	  =					None
       if self.use_labels:
             lowerCamelCase_	  =					ids_tensor([self.batch_size]		,							self.num_labels						)
             lowerCamelCase_	  =					ids_tensor([self.batch_size, self.image_size, self.image_size]		,							self.num_labels						)

       lowerCamelCase_	  =					self.get_config()

       return config, pixel_values, labels, pixel_labels

 def        a__				(       self      :						str						)     ->			str:

       """simple docstring"""






       return MobileNetVaConfig(
           num_channels=self.num_channels		,							image_size=self.image_size		,							depth_multiplier=self.depth_multiplier		,							min_depth=self.min_depth		,							tf_padding=self.tf_padding		,							hidden_act=self.hidden_act		,							classifier_dropout_prob=self.classifier_dropout_prob		,							initializer_range=self.initializer_range		,							)

 def        a__				(       self      :						List[Any]		,							A_      :						str		,							A_      :						Dict		,							A_      :						Union[str, Any]		,							A_      :						List[Any]						)     ->			Dict:

       """simple docstring"""






       lowerCamelCase_	  =					MobileNetVaModel(config=A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_						)
       self.parent.assertEqual(
           result.last_hidden_state.shape		,							(
               self.batch_size,
               self.last_hidden_size,
               self.image_size // self.output_stride,
               self.image_size // self.output_stride,
           )		,							)

 def        a__				(       self      :						Union[str, Any]		,							A_      :						Optional[Any]		,							A_      :						str		,							A_      :						str		,							A_      :						Optional[int]						)     ->			Any:

       """simple docstring"""






       lowerCamelCase_	  =					self.num_labels
       lowerCamelCase_	  =					MobileNetVaForImageClassification(A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_		,							labels=A_						)
       self.parent.assertEqual(result.logits.shape		,							(self.batch_size, self.num_labels)						)





 def        a__				(       self      :						int						)     ->			Dict:

       """simple docstring"""






       lowerCamelCase_	  =					self.prepare_config_and_inputs()
       lowerCamelCase_  ,       lowerCamelCase_  ,       lowerCamelCase_  ,       lowerCamelCase_	  =					config_and_inputs
       lowerCamelCase_	  =					{'pixel_values': pixel_values}
       return config, inputs_dict







@require_torch
class 						A(		UpperCamelCase							,   UpperCamelCase							,   unittest.TestCase     ):



 '''simple docstring'''


 UpperCamelCase		     =		(MobileNetVaModel, MobileNetVaForImageClassification) if is_torch_available() else ()
 UpperCamelCase		     =		(
     {'''feature-extraction''': MobileNetVaModel, '''image-classification''': MobileNetVaForImageClassification}
     if is_torch_available()
     else {}
 )

 UpperCamelCase		     =		False
 UpperCamelCase		     =		False
 UpperCamelCase		     =		False
 UpperCamelCase		     =		False

 def        a__				(       self      :						Any						)     ->			int:

       """simple docstring"""






       lowerCamelCase_	  =					MobileNetVaModelTester(self						)
       lowerCamelCase_	  =					MobileNetVaConfigTester(self		,							config_class=A_		,							has_text_modality=A_						)

 def        a__				(       self      :						Optional[int]						)     ->			Any:

       """simple docstring"""






       self.config_tester.run_common_tests()

 @unittest.skip(reason='MobileNetV1 does not use inputs_embeds'						)
 def        a__				(       self      :						Tuple						)     ->			Any:

       """simple docstring"""






       pass

 @unittest.skip(reason='MobileNetV1 does not support input and output embeddings'						)
 def        a__				(       self      :						List[Any]						)     ->			Any:

       """simple docstring"""






       pass

 @unittest.skip(reason='MobileNetV1 does not output attentions'						)
 def        a__				(       self      :						Union[str, Any]						)     ->			List[Any]:

       """simple docstring"""






       pass

 def        a__				(       self      :						Optional[int]						)     ->			Tuple:

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             lowerCamelCase_	  =					model_class(A_						)
             lowerCamelCase_	  =					inspect.signature(model.forward						)
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             lowerCamelCase_	  =					[*signature.parameters.keys()]

             lowerCamelCase_	  =					['pixel_values']
             self.assertListEqual(arg_names[:1]		,							A_						)

 def        a__				(       self      :						int						)     ->			str:

       """simple docstring"""






       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*A_						)

 def        a__				(       self      :						Union[str, Any]						)     ->			Any:

       """simple docstring"""






       def check_hidden_states_output(A_      :						str		,							A_      :						Optional[Any]		,							A_      :						List[str]						):
             lowerCamelCase_	  =					model_class(A_						)
             model.to(A_						)
             model.eval()

             with torch.no_grad():
                   lowerCamelCase_	  =					model(**self._prepare_for_class(A_		,							A_						)						)

             lowerCamelCase_	  =					outputs.hidden_states

             lowerCamelCase_	  =					26
             self.assertEqual(len(A_						)		,							A_						)

       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             lowerCamelCase_	  =					True
             check_hidden_states_output(A_		,							A_		,							A_						)

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             lowerCamelCase_	  =					True

             check_hidden_states_output(A_		,							A_		,							A_						)

 def        a__				(       self      :						List[Any]						)     ->			str:

       """simple docstring"""






       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*A_						)





 @slow
 def        a__				(       self      :						Optional[int]						)     ->			Any:

       """simple docstring"""






       for model_name in MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowerCamelCase_	  =					MobileNetVaModel.from_pretrained(A_						)
             self.assertIsNotNone(A_						)

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      lowerCamelCase_	  =					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
      return image







@require_torch
@require_vision
class 						A(		unittest.TestCase     ):



 '''simple docstring'''


 @cached_property
 def        a__				(       self      :						Optional[Any]						)     ->			Any:

       """simple docstring"""






       return (
           MobileNetVaImageProcessor.from_pretrained('google/mobilenet_v1_1.0_224'						) if is_vision_available() else None
       )





 @slow
 def        a__				(       self      :						Tuple						)     ->			int:

       """simple docstring"""






       lowerCamelCase_	  =					MobileNetVaForImageClassification.from_pretrained('google/mobilenet_v1_1.0_224'						).to(A_						)

       lowerCamelCase_	  =					self.default_image_processor
       lowerCamelCase_	  =					prepare_img()
       lowerCamelCase_	  =					image_processor(images=A_		,							return_tensors='pt'						).to(A_						)

       # forward pass
       with torch.no_grad():
             lowerCamelCase_	  =					model(**A_						)

       # verify the logits
       lowerCamelCase_	  =					torch.Size((1, 1001)						)
       self.assertEqual(outputs.logits.shape		,							A_						)

       lowerCamelCase_	  =					torch.tensor([-4.1739, -1.1233, 3.1205]						).to(A_						)

       self.assertTrue(torch.allclose(outputs.logits[0, :3]		,							A_		,							atol=1E-4						)						)









from __future__ import annotations

import copy
import tempfile
import unittest

from transformers import CONFIG_MAPPING, AutoConfig, BertConfig, GPTaConfig, TaConfig, TapasConfig, is_tf_available
from transformers.testing_utils import (
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tensorflow_probability,
    require_tf,
    slow,
)

from ..bert.test_modeling_bert import BertModelTester


if is_tf_available():
 from transformers import (
     TFAutoModel,
     TFAutoModelForCausalLM,
     TFAutoModelForMaskedLM,
     TFAutoModelForPreTraining,
     TFAutoModelForQuestionAnswering,
     TFAutoModelForSeqaSeqLM,
     TFAutoModelForSequenceClassification,
     TFAutoModelForTableQuestionAnswering,
     TFAutoModelForTokenClassification,
     TFAutoModelWithLMHead,
     TFBertForMaskedLM,
     TFBertForPreTraining,
     TFBertForQuestionAnswering,
     TFBertForSequenceClassification,
     TFBertModel,
     TFFunnelBaseModel,
     TFFunnelModel,
     TFGPTaLMHeadModel,
     TFRobertaForMaskedLM,
     TFTaForConditionalGeneration,
     TFTapasForQuestionAnswering,
 )
 from transformers.models.auto.modeling_tf_auto import (
     TF_MODEL_FOR_CAUSAL_LM_MAPPING,
     TF_MODEL_FOR_MASKED_LM_MAPPING,
     TF_MODEL_FOR_PRETRAINING_MAPPING,
     TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
     TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
     TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
     TF_MODEL_MAPPING,
 )
 from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
 from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
 from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST
 from transformers.models.tapas.modeling_tf_tapas import TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST







class 						A(		UpperCamelCase     ):



 '''simple docstring'''


 UpperCamelCase		     =		'''new-model'''


if is_tf_available():







 class 						A(		UpperCamelCase     ):



  '''simple docstring'''


  UpperCamelCase		     =		NewModelConfig







@require_tf
class 						A(		unittest.TestCase     ):



 '''simple docstring'''


 @slow
 def        a__				(       self      :						str						)     ->			Union[str, Any]:

       """simple docstring"""






       lowerCamelCase_	  =					'bert-base-cased'
       lowerCamelCase_	  =					AutoConfig.from_pretrained(A_						)
       self.assertIsNotNone(A_						)
       self.assertIsInstance(A_		,							A_						)

       lowerCamelCase_	  =					TFAutoModel.from_pretrained(A_						)
       self.assertIsNotNone(A_						)
       self.assertIsInstance(A_		,							A_						)

 @slow
 def        a__				(       self      :						List[Any]						)     ->			Dict:

       """simple docstring"""






       lowerCamelCase_	  =					'bert-base-cased'
       lowerCamelCase_	  =					AutoConfig.from_pretrained(A_						)
       self.assertIsNotNone(A_						)
       self.assertIsInstance(A_		,							A_						)

       lowerCamelCase_	  =					TFAutoModelForPreTraining.from_pretrained(A_						)
       self.assertIsNotNone(A_						)
       self.assertIsInstance(A_		,							A_						)

 @slow
 def        a__				(       self      :						Union[str, Any]						)     ->			str:

       """simple docstring"""






       for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowerCamelCase_	  =					AutoConfig.from_pretrained(A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

             lowerCamelCase_	  =					TFAutoModelForCausalLM.from_pretrained(A_						)
             lowerCamelCase_  ,       lowerCamelCase_	  =					TFAutoModelForCausalLM.from_pretrained(A_		,							output_loading_info=A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

 @slow
 def        a__				(       self      :						List[Any]						)     ->			Dict:

       """simple docstring"""






       for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowerCamelCase_	  =					AutoConfig.from_pretrained(A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

             lowerCamelCase_	  =					TFAutoModelWithLMHead.from_pretrained(A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

 @slow
 def        a__				(       self      :						int						)     ->			str:

       """simple docstring"""






       for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowerCamelCase_	  =					AutoConfig.from_pretrained(A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

             lowerCamelCase_	  =					TFAutoModelForMaskedLM.from_pretrained(A_						)
             lowerCamelCase_  ,       lowerCamelCase_	  =					TFAutoModelForMaskedLM.from_pretrained(A_		,							output_loading_info=A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

 @slow
 def        a__				(       self      :						Any						)     ->			List[Any]:

       """simple docstring"""






       for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowerCamelCase_	  =					AutoConfig.from_pretrained(A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

             lowerCamelCase_	  =					TFAutoModelForSeqaSeqLM.from_pretrained(A_						)
             lowerCamelCase_  ,       lowerCamelCase_	  =					TFAutoModelForSeqaSeqLM.from_pretrained(A_		,							output_loading_info=A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

 @slow
 def        a__				(       self      :						Tuple						)     ->			str:

       """simple docstring"""






       for model_name in ["bert-base-uncased"]:
             lowerCamelCase_	  =					AutoConfig.from_pretrained(A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

             lowerCamelCase_	  =					TFAutoModelForSequenceClassification.from_pretrained(A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

 @slow
 def        a__				(       self      :						List[Any]						)     ->			Any:

       """simple docstring"""






       for model_name in ["bert-base-uncased"]:
             lowerCamelCase_	  =					AutoConfig.from_pretrained(A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

             lowerCamelCase_	  =					TFAutoModelForQuestionAnswering.from_pretrained(A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

 @slow
 @require_tensorflow_probability
 def        a__				(       self      :						int						)     ->			Union[str, Any]:

       """simple docstring"""






       for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
             lowerCamelCase_	  =					AutoConfig.from_pretrained(A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

             lowerCamelCase_	  =					TFAutoModelForTableQuestionAnswering.from_pretrained(A_						)
             lowerCamelCase_  ,       lowerCamelCase_	  =					TFAutoModelForTableQuestionAnswering.from_pretrained(
                 A_		,							output_loading_info=A_						)
             self.assertIsNotNone(A_						)
             self.assertIsInstance(A_		,							A_						)

 def        a__				(       self      :						int						)     ->			Union[str, Any]:

       """simple docstring"""






       lowerCamelCase_	  =					TFAutoModelWithLMHead.from_pretrained(A_						)
       self.assertIsInstance(A_		,							A_						)
       self.assertEqual(model.num_parameters()		,							14410						)
       self.assertEqual(model.num_parameters(only_trainable=A_						)		,							14410						)

 def        a__				(       self      :						Optional[int]						)     ->			List[Any]:

       """simple docstring"""






       lowerCamelCase_	  =					TFAutoModelWithLMHead.from_pretrained(A_						)
       self.assertIsInstance(A_		,							A_						)
       self.assertEqual(model.num_parameters()		,							14410						)
       self.assertEqual(model.num_parameters(only_trainable=A_						)		,							14410						)

 def        a__				(       self      :						Tuple						)     ->			Optional[Any]:

       """simple docstring"""






       lowerCamelCase_	  =					TFAutoModel.from_pretrained('sgugger/funnel-random-tiny'						)
       self.assertIsInstance(A_		,							A_						)

       lowerCamelCase_	  =					copy.deepcopy(model.config						)
       lowerCamelCase_	  =					['FunnelBaseModel']
       lowerCamelCase_	  =					TFAutoModel.from_config(A_						)
       self.assertIsInstance(A_		,							A_						)

       with tempfile.TemporaryDirectory() as tmp_dir:
             model.save_pretrained(A_						)
             lowerCamelCase_	  =					TFAutoModel.from_pretrained(A_						)
             self.assertIsInstance(A_		,							A_						)

 def        a__				(       self      :						Any						)     ->			Tuple:

       """simple docstring"""






       try:
             AutoConfig.register('new-model'		,							A_						)

             lowerCamelCase_	  =					[
                 TFAutoModel,
                 TFAutoModelForCausalLM,
                 TFAutoModelForMaskedLM,
                 TFAutoModelForPreTraining,
                 TFAutoModelForQuestionAnswering,
                 TFAutoModelForSequenceClassification,
                 TFAutoModelForTokenClassification,
             ]

             for auto_class in auto_classes:
                   with self.subTest(auto_class.__name__						):
                         # Wrong config class will raise an error
                         with self.assertRaises(A_						):
                               auto_class.register(A_		,							A_						)
                         auto_class.register(A_		,							A_						)
                         # Trying to register something existing in the Transformers library will raise an error
                         with self.assertRaises(A_						):
                               auto_class.register(A_		,							A_						)

                         # Now that the config is registered, it can be used as any other config with the auto-API
                         lowerCamelCase_	  =					BertModelTester(self						).get_config()
                         lowerCamelCase_	  =					NewModelConfig(**tiny_config.to_dict()						)
                         lowerCamelCase_	  =					auto_class.from_config(A_						)
                         self.assertIsInstance(A_		,							A_						)

                         with tempfile.TemporaryDirectory() as tmp_dir:
                               model.save_pretrained(A_						)
                               lowerCamelCase_	  =					auto_class.from_pretrained(A_						)
                               self.assertIsInstance(A_		,							A_						)

       finally:
             if "new-model" in CONFIG_MAPPING._extra_content:
                   del CONFIG_MAPPING._extra_content["new-model"]
             for mapping in (
                 TF_MODEL_MAPPING,
                 TF_MODEL_FOR_PRETRAINING_MAPPING,
                 TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
                 TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
                 TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
                 TF_MODEL_FOR_CAUSAL_LM_MAPPING,
                 TF_MODEL_FOR_MASKED_LM_MAPPING,
             ):
                   if NewModelConfig in mapping._extra_content:
                         del mapping._extra_content[NewModelConfig]

 def        a__				(       self      :						int						)     ->			int:

       """simple docstring"""






       with self.assertRaisesRegex(
           A_		,							'bert-base is not a local folder and is not a valid model identifier'						):
             lowerCamelCase_	  =					TFAutoModel.from_pretrained('bert-base'						)

 def        a__				(       self      :						Any						)     ->			Dict:

       """simple docstring"""






       with self.assertRaisesRegex(
           A_		,							r'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'						):
             lowerCamelCase_	  =					TFAutoModel.from_pretrained(A_		,							revision='aaaaaa'						)

 def        a__				(       self      :						str						)     ->			int:

       """simple docstring"""






       with self.assertRaisesRegex(
           A_		,							'hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin'		,							):
             lowerCamelCase_	  =					TFAutoModel.from_pretrained('hf-internal-testing/config-no-model'						)

 def        a__				(       self      :						Any						)     ->			List[Any]:

       """simple docstring"""






       with self.assertRaisesRegex(A_		,							'Use `from_pt=True` to load this model'						):
             lowerCamelCase_	  =					TFAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only'						)





 def        a__				(       self      :						Tuple						)     ->			Union[str, Any]:

       """simple docstring"""






       lowerCamelCase_	  =					TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'						)
       with RequestCounter() as counter:
             lowerCamelCase_	  =					TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'						)
             self.assertEqual(counter.get_request_count		,							0						)
             self.assertEqual(counter.head_request_count		,							1						)
             self.assertEqual(counter.other_request_count		,							0						)

       # With a sharded checkpoint
       lowerCamelCase_	  =					TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'						)
       with RequestCounter() as counter:
             lowerCamelCase_	  =					TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'						)
             self.assertEqual(counter.get_request_count		,							0						)
             self.assertEqual(counter.head_request_count		,							1						)
             self.assertEqual(counter.other_request_count		,							0						)



