



import inspect
import unittest
import warnings

from transformers import DeiTConfig
from transformers.models.auto import get_values
from transformers.testing_utils import (
    require_accelerate,
    require_torch,
    require_torch_gpu,
    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 torch import nn

    from transformers import (
        MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
        MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
        MODEL_MAPPING,
        DeiTForImageClassification,
        DeiTForImageClassificationWithTeacher,
        DeiTForMaskedImageModeling,
        DeiTModel,
    )
    from transformers.models.deit.modeling_deit import DEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import DeiTImageProcessor





class 		UpperCAmelCase						:





   def __init__(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase=13       ,     _lowerCAmelCase=30       ,     _lowerCAmelCase=2       ,     _lowerCAmelCase=3       ,     _lowerCAmelCase=True       ,     _lowerCAmelCase=True       ,     _lowerCAmelCase=32       ,     _lowerCAmelCase=5       ,     _lowerCAmelCase=4       ,     _lowerCAmelCase=37       ,     _lowerCAmelCase="gelu"       ,     _lowerCAmelCase=0.1       ,     _lowerCAmelCase=0.1       ,     _lowerCAmelCase=10       ,     _lowerCAmelCase=0.02       ,     _lowerCAmelCase=3       ,     _lowerCAmelCase=None       ,     _lowerCAmelCase=2       ,     ):
         _lowerCAmelCase 			=  parent
         _lowerCAmelCase 			=  batch_size
         _lowerCAmelCase 			=  image_size
         _lowerCAmelCase 			=  patch_size
         _lowerCAmelCase 			=  num_channels
         _lowerCAmelCase 			=  is_training
         _lowerCAmelCase 			=  use_labels
         _lowerCAmelCase 			=  hidden_size
         _lowerCAmelCase 			=  num_hidden_layers
         _lowerCAmelCase 			=  num_attention_heads
         _lowerCAmelCase 			=  intermediate_size
         _lowerCAmelCase 			=  hidden_act
         _lowerCAmelCase 			=  hidden_dropout_prob
         _lowerCAmelCase 			=  attention_probs_dropout_prob
         _lowerCAmelCase 			=  type_sequence_label_size
         _lowerCAmelCase 			=  initializer_range
         _lowerCAmelCase 			=  scope
         _lowerCAmelCase 			=  encoder_stride

         # in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
         _lowerCAmelCase 			=  (image_size // patch_size) ** 2
         _lowerCAmelCase 			=  num_patches + 2





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

         _lowerCAmelCase 			=  None
         if self.use_labels:
               _lowerCAmelCase 			=  ids_tensor([self.batch_size]       ,     self.type_sequence_label_size			)

         _lowerCAmelCase 			=  self.get_config()

         return config, pixel_values, labels





   def 	__lowerCAmelCase							(	self			):
         return DeiTConfig(
             image_size=self.image_size       ,     patch_size=self.patch_size       ,     num_channels=self.num_channels       ,     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       ,     is_decoder=_lowerCAmelCase       ,     initializer_range=self.initializer_range       ,     encoder_stride=self.encoder_stride       ,     )





   def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase       ,     _lowerCAmelCase			):
         _lowerCAmelCase 			=  DeiTModel(config=_lowerCAmelCase			)
         model.to(_lowerCAmelCase			)
         model.eval()
         _lowerCAmelCase 			=  model(_lowerCAmelCase			)
         self.parent.assertEqual(result.last_hidden_state.shape       ,     (self.batch_size, self.seq_length, self.hidden_size)			)





   def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase       ,     _lowerCAmelCase			):
         _lowerCAmelCase 			=  DeiTForMaskedImageModeling(config=_lowerCAmelCase			)
         model.to(_lowerCAmelCase			)
         model.eval()
         _lowerCAmelCase 			=  model(_lowerCAmelCase			)
         self.parent.assertEqual(
             result.reconstruction.shape       ,     (self.batch_size, self.num_channels, self.image_size, self.image_size)			)

         # test greyscale images
         _lowerCAmelCase 			=  1
         _lowerCAmelCase 			=  DeiTForMaskedImageModeling(_lowerCAmelCase			)
         model.to(_lowerCAmelCase			)
         model.eval()

         _lowerCAmelCase 			=  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
         _lowerCAmelCase 			=  model(_lowerCAmelCase			)
         self.parent.assertEqual(result.reconstruction.shape       ,     (self.batch_size, 1, self.image_size, self.image_size)			)





   def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase       ,     _lowerCAmelCase			):
         _lowerCAmelCase 			=  self.type_sequence_label_size
         _lowerCAmelCase 			=  DeiTForImageClassification(_lowerCAmelCase			)
         model.to(_lowerCAmelCase			)
         model.eval()
         _lowerCAmelCase 			=  model(_lowerCAmelCase       ,     labels=_lowerCAmelCase			)
         self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.type_sequence_label_size)			)

         # test greyscale images
         _lowerCAmelCase 			=  1
         _lowerCAmelCase 			=  DeiTForImageClassification(_lowerCAmelCase			)
         model.to(_lowerCAmelCase			)
         model.eval()

         _lowerCAmelCase 			=  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
         _lowerCAmelCase 			=  model(_lowerCAmelCase       ,     labels=_lowerCAmelCase			)
         self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.type_sequence_label_size)			)





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






@require_torch
class 		UpperCAmelCase						(						snake_case_       ,snake_case_       ,unittest.TestCase				):
   SCREAMING_SNAKE_CASE__							=     (
       (
           DeiTModel,
           DeiTForImageClassification,
           DeiTForImageClassificationWithTeacher,
           DeiTForMaskedImageModeling,
       )
       if is_torch_available()
       else ()
   )
   SCREAMING_SNAKE_CASE__							=     (
       {
           '''feature-extraction''': DeiTModel,
           '''image-classification''': (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
       }
       if is_torch_available()
       else {}
   )

   SCREAMING_SNAKE_CASE__							=     False
   SCREAMING_SNAKE_CASE__							=     False
   SCREAMING_SNAKE_CASE__							=     False





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  DeiTModelTester(self			)
         _lowerCAmelCase 			=  ConfigTester(self       ,     config_class=_lowerCAmelCase       ,     has_text_modality=_lowerCAmelCase       ,     hidden_size=37			)





   def 	__lowerCAmelCase							(	self			):
         self.config_tester.run_common_tests()





   @unittest.skip(reason='''DeiT does not use inputs_embeds'''			)
   def 	__lowerCAmelCase							(	self			):
         pass





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
               _lowerCAmelCase 			=  model_class(_lowerCAmelCase			)
               self.assertIsInstance(model.get_input_embeddings()       ,     (nn.Module)			)
               _lowerCAmelCase 			=  model.get_output_embeddings()
               self.assertTrue(x is None or isinstance(_lowerCAmelCase       ,     nn.Linear			)			)





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
               _lowerCAmelCase 			=  model_class(_lowerCAmelCase			)
               _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]       ,     _lowerCAmelCase			)





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_lowerCAmelCase			)





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_image_modeling(*_lowerCAmelCase			)





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase			)





   def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase       ,     _lowerCAmelCase=False			):
         _lowerCAmelCase 			=  super()._prepare_for_class(_lowerCAmelCase       ,     _lowerCAmelCase       ,     return_labels=_lowerCAmelCase			)

         if return_labels:
               if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
                     del inputs_dict["labels"]

         return inputs_dict





   def 	__lowerCAmelCase							(	self			):
         if not self.model_tester.is_training:
               return

         _lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()
         _lowerCAmelCase 			=  True

         for model_class in self.all_model_classes:
               # DeiTForImageClassificationWithTeacher supports inference-only
               if (
                   model_class in get_values(_lowerCAmelCase			)
                   or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
               ):
                     continue
               _lowerCAmelCase 			=  model_class(_lowerCAmelCase			)
               model.to(_lowerCAmelCase			)
               model.train()
               _lowerCAmelCase 			=  self._prepare_for_class(_lowerCAmelCase       ,     _lowerCAmelCase       ,     return_labels=_lowerCAmelCase			)
               _lowerCAmelCase 			=  model(**_lowerCAmelCase			).loss
               loss.backward()





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()
         if not self.model_tester.is_training:
               return

         _lowerCAmelCase 			=  False
         _lowerCAmelCase 			=  True

         for model_class in self.all_model_classes:
               if model_class in get_values(_lowerCAmelCase			) or not model_class.supports_gradient_checkpointing:
                     continue
               # DeiTForImageClassificationWithTeacher supports inference-only
               if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
                     continue
               _lowerCAmelCase 			=  model_class(_lowerCAmelCase			)
               model.gradient_checkpointing_enable()
               model.to(_lowerCAmelCase			)
               model.train()
               _lowerCAmelCase 			=  self._prepare_for_class(_lowerCAmelCase       ,     _lowerCAmelCase       ,     return_labels=_lowerCAmelCase			)
               _lowerCAmelCase 			=  model(**_lowerCAmelCase			).loss
               loss.backward()





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()

         _lowerCAmelCase 			=  [
             {'''title''': '''multi_label_classification''', '''num_labels''': 2, '''dtype''': torch.float},
             {'''title''': '''single_label_classification''', '''num_labels''': 1, '''dtype''': torch.long},
             {'''title''': '''regression''', '''num_labels''': 1, '''dtype''': torch.float},
         ]

         for model_class in self.all_model_classes:
               if (
                   model_class
                   not in [
                       *get_values(_lowerCAmelCase			),
                       *get_values(_lowerCAmelCase			),
                   ]
                   or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
               ):
                     continue

               for problem_type in problem_types:
                     with self.subTest(msg=F'''Testing {model_class} with {problem_type["title"]}'''			):
                           _lowerCAmelCase 			=  problem_type['''title''']
                           _lowerCAmelCase 			=  problem_type['''num_labels''']

                           _lowerCAmelCase 			=  model_class(_lowerCAmelCase			)
                           model.to(_lowerCAmelCase			)
                           model.train()

                           _lowerCAmelCase 			=  self._prepare_for_class(_lowerCAmelCase       ,     _lowerCAmelCase       ,     return_labels=_lowerCAmelCase			)

                           if problem_type["num_labels"] > 1:
                                 _lowerCAmelCase 			=  inputs['''labels'''].unsqueeze(1			).repeat(1       ,     problem_type['''num_labels''']			)

                           _lowerCAmelCase 			=  inputs['''labels'''].to(problem_type['''dtype''']			)

                           # This tests that we do not trigger the warning form PyTorch "Using a target size that is different
                           # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
                           # they have the same size." which is a symptom something in wrong for the regression problem.
                           # See https://github.com/huggingface/transformers/issues/11780
                           with warnings.catch_warnings(record=_lowerCAmelCase			) as warning_list:
                                 _lowerCAmelCase 			=  model(**_lowerCAmelCase			).loss
                           for w in warning_list:
                                 if "Using a target size that is different to the input size" in str(w.message			):
                                       raise ValueError(
                                           F'''Something is going wrong in the regression problem: intercepted {w.message}'''			)

                           loss.backward()





   @slow
   def 	__lowerCAmelCase							(	self			):
         for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _lowerCAmelCase 			=  DeiTModel.from_pretrained(_lowerCAmelCase			)
               self.assertIsNotNone(_lowerCAmelCase			)






def 							UpperCAmelCase__		(				)->List[str]:
      _lowerCAmelCase 			=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
      return image





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





   @cached_property
   def 	__lowerCAmelCase							(	self			):
         return (
             DeiTImageProcessor.from_pretrained('''facebook/deit-base-distilled-patch16-224'''			)
             if is_vision_available()
             else None
         )





   @slow
   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  DeiTForImageClassificationWithTeacher.from_pretrained('''facebook/deit-base-distilled-patch16-224'''			).to(
             _lowerCAmelCase			)

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

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

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

         _lowerCAmelCase 			=  torch.tensor([-1.0_266, 0.1_912, -1.2_861]			).to(_lowerCAmelCase			)

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





   @slow
   @require_accelerate
   @require_torch_gpu
   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  DeiTModel.from_pretrained(
             '''facebook/deit-base-distilled-patch16-224'''       ,     torch_dtype=torch.floataa       ,     device_map='''auto'''			)
         _lowerCAmelCase 			=  self.default_image_processor

         _lowerCAmelCase 			=  prepare_img()
         _lowerCAmelCase 			=  image_processor(images=_lowerCAmelCase       ,     return_tensors='''pt'''			)
         _lowerCAmelCase 			=  inputs.pixel_values.to(_lowerCAmelCase			)

         # forward pass to make sure inference works in fp16
         with torch.no_grad():
               _lowerCAmelCase 			=  model(_lowerCAmelCase			)




from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

UpperCAmelCase_									=							{"UserAgent": UserAgent().random}
def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	Dict				)->dict:
      _lowerCAmelCase 			=  script.contents[0]
      _lowerCAmelCase 			=  json.loads(data[data.find('''{"config"'''				) : -1]				)
      return info["entry_data"]["ProfilePage"][0]["graphql"]["user"]





class 		UpperCAmelCase						:





   def __init__(	self       ,     _lowerCAmelCase			):
         _lowerCAmelCase 			=  F'''https://www.instagram.com/{username}/'''
         _lowerCAmelCase 			=  self.get_json()





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  requests.get(self.url       ,     headers=_lowerCAmelCase			).text
         _lowerCAmelCase 			=  BeautifulSoup(_lowerCAmelCase       ,     '''html.parser'''			).find_all('''script'''			)
         try:
               return extract_user_profile(scripts[4]			)
         except (json.decoder.JSONDecodeError, KeyError):
               return extract_user_profile(scripts[3]			)





   def __repr__(	self			):
         return F'''{self.__class__.__name__}(\'{self.username}\')'''





   def __str__(	self			):
         return F'''{self.fullname} ({self.username}) is {self.biography}'''





   @property
   def 	__lowerCAmelCase							(	self			):
         return self.user_data["username"]





   @property
   def 	__lowerCAmelCase							(	self			):
         return self.user_data["full_name"]





   @property
   def 	__lowerCAmelCase							(	self			):
         return self.user_data["biography"]





   @property
   def 	__lowerCAmelCase							(	self			):
         return self.user_data["business_email"]





   @property
   def 	__lowerCAmelCase							(	self			):
         return self.user_data["external_url"]





   @property
   def 	__lowerCAmelCase							(	self			):
         return self.user_data["edge_followed_by"]["count"]





   @property
   def 	__lowerCAmelCase							(	self			):
         return self.user_data["edge_follow"]["count"]





   @property
   def 	__lowerCAmelCase							(	self			):
         return self.user_data["edge_owner_to_timeline_media"]["count"]





   @property
   def 	__lowerCAmelCase							(	self			):
         return self.user_data["profile_pic_url_hd"]





   @property
   def 	__lowerCAmelCase							(	self			):
         return self.user_data["is_verified"]





   @property
   def 	__lowerCAmelCase							(	self			):
         return self.user_data["is_private"]






def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	str = "github"				)->None:
      import os

      if os.environ.get('''CI'''				):
            return  # test failing on GitHub Actions
      _lowerCAmelCase 			=  InstagramUser(_SCREAMING_SNAKE_CASE				)
      assert instagram_user.user_data
      assert isinstance(instagram_user.user_data     ,				_SCREAMING_SNAKE_CASE				)
      assert instagram_user.username == username
      if username != "github":
            return
      assert instagram_user.fullname == "GitHub"
      assert instagram_user.biography == "Built for developers."
      assert instagram_user.number_of_posts > 1_5_0
      assert instagram_user.number_of_followers > 1_2_0_0_0_0
      assert instagram_user.number_of_followings > 1_5
      assert instagram_user.email == "support@github.com"
      assert instagram_user.website == "https://github.com/readme"
      assert instagram_user.profile_picture_url.startswith('''https://instagram.'''				)
      assert instagram_user.is_verified is True
      assert instagram_user.is_private is False


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    UpperCAmelCase_									=							InstagramUser("github")
    print(instagram_user)
    print(F"""{instagram_user.number_of_posts = }""")
    print(F"""{instagram_user.number_of_followers = }""")
    print(F"""{instagram_user.number_of_followings = }""")
    print(F"""{instagram_user.email = }""")
    print(F"""{instagram_user.website = }""")
    print(F"""{instagram_user.profile_picture_url = }""")
    print(F"""{instagram_user.is_verified = }""")
    print(F"""{instagram_user.is_private = }""")