






import inspect
import unittest

from transformers import BitConfig
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_backbone_common import BackboneTesterMixin
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 torch import nn

     from transformers import BitBackbone, BitForImageClassification, BitImageProcessor, BitModel
     from transformers.models.bit.modeling_bit import BIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image






class 						lowercase_   :






      '''simple docstring'''




      def __init__( self :		List[Any]					,   __UpperCAmelCase :		Dict					,   __UpperCAmelCase :		Optional[Any]=3					,   __UpperCAmelCase :		Optional[int]=32					,   __UpperCAmelCase :		Dict=3					,   __UpperCAmelCase :		Tuple=10					,   __UpperCAmelCase :		Tuple=[8, 16, 32, 64]					,   __UpperCAmelCase :		Optional[int]=[1, 1, 2, 1]					,   __UpperCAmelCase :		int=True					,   __UpperCAmelCase :		Dict=True					,   __UpperCAmelCase :		Union[str, Any]="relu"					,   __UpperCAmelCase :		Dict=3					,   __UpperCAmelCase :		Optional[int]=None					,   __UpperCAmelCase :		int=["stage2", "stage3", "stage4"]					,   __UpperCAmelCase :		Tuple=[2, 3, 4]					,   __UpperCAmelCase :		List[str]=1					,   )       ->str:




       """simple docstring"""


       a						    = parent
       a						    = batch_size
       a						    = image_size
       a						    = num_channels
       a						    = embeddings_size
       a						    = hidden_sizes
       a						    = depths
       a						    = is_training
       a						    = use_labels
       a						    = hidden_act
       a						    = num_labels
       a						    = scope
       a						    = len(A_    )
       a						    = out_features
       a						    = out_indices
       a						    = num_groups







      def  __lowerCAmelCase   ( self :		Tuple    )       ->int:




       """simple docstring"""


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

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

       a						    = self.get_config()

       return config, pixel_values, labels







      def  __lowerCAmelCase   ( self :		Optional[Any]    )       ->Any:




       """simple docstring"""


       return BitConfig(
           num_channels=self.num_channels					,   embeddings_size=self.embeddings_size					,   hidden_sizes=self.hidden_sizes					,   depths=self.depths					,   hidden_act=self.hidden_act					,   num_labels=self.num_labels					,   out_features=self.out_features					,   out_indices=self.out_indices					,   num_groups=self.num_groups					,   )







      def  __lowerCAmelCase   ( self :		Optional[int]					,   __UpperCAmelCase :		Union[str, Any]					,   __UpperCAmelCase :		Any					,   __UpperCAmelCase :		List[Any]    )       ->Optional[Any]:




       """simple docstring"""


       a						    = BitModel(config=A_    )
       model.to(A_    )
       model.eval()
       a						    = model(A_    )
       self.parent.assertEqual(
           result.last_hidden_state.shape					,   (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)					,   )







      def  __lowerCAmelCase   ( self :		Optional[Any]					,   __UpperCAmelCase :		Union[str, Any]					,   __UpperCAmelCase :		int					,   __UpperCAmelCase :		Tuple    )       ->Tuple:




       """simple docstring"""


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







      def  __lowerCAmelCase   ( self :		Optional[int]					,   __UpperCAmelCase :		Union[str, Any]					,   __UpperCAmelCase :		str					,   __UpperCAmelCase :		Optional[Any]    )       ->str:




       """simple docstring"""


       a						    = BitBackbone(config=A_    )
       model.to(A_    )
       model.eval()
       a						    = model(A_    )

       # verify feature maps
       self.parent.assertEqual(len(result.feature_maps    )					,   len(config.out_features    )    )
       self.parent.assertListEqual(list(result.feature_maps[0].shape    )					,   [self.batch_size, self.hidden_sizes[1], 4, 4]    )

       # verify channels
       self.parent.assertEqual(len(model.channels    )					,   len(config.out_features    )    )
       self.parent.assertListEqual(model.channels					,   config.hidden_sizes[1:]    )

       # verify backbone works with out_features=None
       a						    = None
       a						    = BitBackbone(config=A_    )
       model.to(A_    )
       model.eval()
       a						    = model(A_    )

       # verify feature maps
       self.parent.assertEqual(len(result.feature_maps    )					,   1    )
       self.parent.assertListEqual(list(result.feature_maps[0].shape    )					,   [self.batch_size, self.hidden_sizes[-1], 1, 1]    )

       # verify channels
       self.parent.assertEqual(len(model.channels    )					,   1    )
       self.parent.assertListEqual(model.channels					,   [config.hidden_sizes[-1]]    )







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




       """simple docstring"""


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






@require_torch
class 						lowercase_   (      _lowercase					,    _lowercase					,    unittest.TestCase  ):






      '''simple docstring'''




      __snake_case	    =    (BitModel, BitForImageClassification, BitBackbone) if is_torch_available() else ()
      __snake_case	    =    (
          {'''feature-extraction''': BitModel, '''image-classification''': BitForImageClassification}
          if is_torch_available()
          else {}
      )

      __snake_case	    =    False
      __snake_case	    =    False
      __snake_case	    =    False
      __snake_case	    =    False
      __snake_case	    =    False







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




       """simple docstring"""


       a						    = BitModelTester(self    )
       a						    = ConfigTester(self					,   config_class=A_					,   has_text_modality=A_    )







      def  __lowerCAmelCase   ( self :		int    )       ->Optional[int]:




       """simple docstring"""


       self.create_and_test_config_common_properties()
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.create_and_test_config_with_num_labels()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()







      def  __lowerCAmelCase   ( self :		Optional[Any]    )       ->Optional[Any]:




       """simple docstring"""


       return







      @unittest.skip(reason='''Bit does not output attentions'''    )
      def  __lowerCAmelCase   ( self :		Optional[int]    )       ->List[str]:




       """simple docstring"""


       pass







      @unittest.skip(reason='''Bit does not use inputs_embeds'''    )
      def  __lowerCAmelCase   ( self :		List[str]    )       ->Union[str, Any]:




       """simple docstring"""


       pass







      @unittest.skip(reason='''Bit does not support input and output embeddings'''    )
      def  __lowerCAmelCase   ( self :		Union[str, Any]    )       ->Dict:




       """simple docstring"""


       pass







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




       """simple docstring"""


       a    ,	a						    = self.model_tester.prepare_config_and_inputs_for_common()

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

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







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




       """simple docstring"""


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







      def  __lowerCAmelCase   ( self :		List[str]    )       ->Tuple:




       """simple docstring"""


       a						    = self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_backbone(*A_    )







      def  __lowerCAmelCase   ( self :		Any    )       ->int:




       """simple docstring"""


       a    ,	a						    = self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
        a						    = model_class(config=A_    )
        for name, module in model.named_modules():
         if isinstance(A_					,   (nn.BatchNormad, nn.GroupNorm)    ):
          self.assertTrue(
              torch.all(module.weight == 1    )					,   msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""					,   )
          self.assertTrue(
              torch.all(module.bias == 0    )					,   msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""					,   )







      def  __lowerCAmelCase   ( self :		Tuple    )       ->int:




       """simple docstring"""


       def check_hidden_states_output(__UpperCAmelCase :		Any					,   __UpperCAmelCase :		List[str]					,   __UpperCAmelCase :		int    ):
        a						    = model_class(A_    )
        model.to(A_    )
        model.eval()

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

        a						    = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

        a						    = self.model_tester.num_stages
        self.assertEqual(len(A_    )					,   expected_num_stages + 1    )

        # Bit's feature maps are of shape (batch_size, num_channels, height, width)
        self.assertListEqual(
            list(hidden_states[0].shape[-2:]    )					,   [self.model_tester.image_size // 4, self.model_tester.image_size // 4]					,   )

       a    ,	a						    = self.model_tester.prepare_config_and_inputs_for_common()
       a						    = ['''preactivation''', '''bottleneck''']
       for model_class in self.all_model_classes:
        for layer_type in layers_type:
         a						    = layer_type
         a						    = True
         check_hidden_states_output(A_					,   A_					,   A_    )

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

         check_hidden_states_output(A_					,   A_					,   A_    )







      @unittest.skip(reason='''Bit does not use feedforward chunking'''    )
      def  __lowerCAmelCase   ( self :		List[Any]    )       ->Optional[Any]:




       """simple docstring"""


       pass







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




       """simple docstring"""


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







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




       """simple docstring"""


       for model_name in BIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        a						    = BitModel.from_pretrained(A_    )
        self.assertIsNotNone(A_    )
def 		_a       ( )				->     int:
 a						    = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''					)
 return image






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






      '''simple docstring'''




      @cached_property
      def  __lowerCAmelCase   ( self :		List[Any]    )       ->int:




       """simple docstring"""


       return (
           BitImageProcessor.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ) if is_vision_available() else None
       )







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




       """simple docstring"""


       a						    = BitForImageClassification.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(A_    )

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

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

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

       a						    = torch.tensor([[-0.6526, -0.5263, -1.4398]]    ).to(A_    )

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






@require_torch
class 						lowercase_   (      _lowercase					,    unittest.TestCase  ):






      '''simple docstring'''




      __snake_case	    =    (BitBackbone,) if is_torch_available() else ()
      __snake_case	    =    BitConfig

      __snake_case	    =    False







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




       """simple docstring"""


       a						    = BitModelTester(self    )




"""simple docstring"""


import pytest
import requests

from datasets.utils.file_utils import http_head

from .utils import OfflineSimulationMode, RequestWouldHangIndefinitelyError, offline






@pytest.mark.integration
def    _snake_case					(		):
	with offline(OfflineSimulationMode.CONNECTION_TIMES_OUT  ):
		with pytest.raises(snake_case__  ):
			requests.request('GET'						,   'https://huggingface.co'  )
		with pytest.raises(requests.exceptions.ConnectTimeout  ):
			requests.request('GET'						,   'https://huggingface.co'						,   timeout=1.0  )






@pytest.mark.integration
def    _snake_case					(		):
	with offline(OfflineSimulationMode.CONNECTION_FAILS  ):
		with pytest.raises(requests.exceptions.ConnectionError  ):
			requests.request('GET'						,   'https://huggingface.co'  )






def    _snake_case					(		):
	with offline(OfflineSimulationMode.HF_DATASETS_OFFLINE_SET_TO_1  ):
		with pytest.raises(snake_case__  ):
			http_head('https://huggingface.co'  )