

'''simple docstring'''
import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from timm import create_model
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import BitConfig, BitForImageClassification, BitImageProcessor
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
lowerCamelCase			:				List[Any] 			=					logging.get_logger(__name__)


def 	_lowerCAmelCase (						_UpperCamelCase						:					List[str]    )				->      int:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   ='huggingface/label-files'
     _SCREAMING_SNAKE_CASE							   ='imagenet-1k-id2label.json'
     _SCREAMING_SNAKE_CASE							   =json.load(open(hf_hub_download(_UpperCamelCase							,			_UpperCamelCase							,			repo_type='dataset'    )							,			'r'    )    )
     _SCREAMING_SNAKE_CASE							   ={int(_UpperCamelCase    ): v for k, v in idalabel.items()}
     _SCREAMING_SNAKE_CASE							   ={v: k for k, v in idalabel.items()}

     _SCREAMING_SNAKE_CASE							   ='std_conv' if 'bit' in model_name else False

     # note that when using BiT as backbone for ViT-hybrid checkpoints,
     # one needs to additionally set config.layer_type = "bottleneck", config.stem_type = "same",
     # config.conv_layer = "std_conv_same"
     _SCREAMING_SNAKE_CASE							   =BitConfig(
         conv_layer=_UpperCamelCase							,			num_labels=10_00							,			idalabel=_UpperCamelCase							,			labelaid=_UpperCamelCase							,			)

     return config


def 	_lowerCAmelCase (						_UpperCamelCase						:					Dict    )				->      Tuple:
     """simple docstring"""




     if "stem.conv" in name:
          _SCREAMING_SNAKE_CASE							   =name.replace('stem.conv'							,			'bit.embedder.convolution'    )
     if "blocks" in name:
          _SCREAMING_SNAKE_CASE							   =name.replace('blocks'							,			'layers'    )
     if "head.fc" in name:
          _SCREAMING_SNAKE_CASE							   =name.replace('head.fc'							,			'classifier.1'    )
     if name.startswith('norm'    ):
          _SCREAMING_SNAKE_CASE							   ='bit.' + name
     if "bit" not in name and "classifier" not in name:
          _SCREAMING_SNAKE_CASE							   ='bit.encoder.' + name

     return name


def 	_lowerCAmelCase (						)				->      List[Any]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   ='http://images.cocodataset.org/val2017/000000039769.jpg'
     _SCREAMING_SNAKE_CASE							   =Image.open(requests.get(_UpperCamelCase							,			stream=_UpperCamelCase    ).raw    )
     return im


@torch.no_grad()
def 	_lowerCAmelCase (						_UpperCamelCase						:					int							,			_UpperCamelCase						:					Optional[Any]							,			_UpperCamelCase						:					str=False    )				->      Union[str, Any]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =get_config(_UpperCamelCase    )

     # load original model from timm
     _SCREAMING_SNAKE_CASE							   =create_model(_UpperCamelCase							,			pretrained=_UpperCamelCase    )
     timm_model.eval()

     # load state_dict of original model
     _SCREAMING_SNAKE_CASE							   =timm_model.state_dict()
     for key in state_dict.copy().keys():
          _SCREAMING_SNAKE_CASE							   =state_dict.pop(_UpperCamelCase    )
          _SCREAMING_SNAKE_CASE							   =val.squeeze() if 'head' in key else val

     # load HuggingFace model
     _SCREAMING_SNAKE_CASE							   =BitForImageClassification(_UpperCamelCase    )
     model.eval()
     model.load_state_dict(_UpperCamelCase    )

     # create image processor
     _SCREAMING_SNAKE_CASE							   =create_transform(**resolve_data_config({}							,			model=_UpperCamelCase    )    )
     _SCREAMING_SNAKE_CASE							   =transform.transforms

     _SCREAMING_SNAKE_CASE							   ={
         'bilinear': PILImageResampling.BILINEAR,
         'bicubic': PILImageResampling.BICUBIC,
         'nearest': PILImageResampling.NEAREST,
     }

     _SCREAMING_SNAKE_CASE							   =BitImageProcessor(
         do_resize=_UpperCamelCase							,			size={'shortest_edge': timm_transforms[0].size}							,			resample=pillow_resamplings[timm_transforms[0].interpolation.value]							,			do_center_crop=_UpperCamelCase							,			crop_size={'height': timm_transforms[1].size[0], 'width': timm_transforms[1].size[1]}							,			do_normalize=_UpperCamelCase							,			image_mean=timm_transforms[-1].mean.tolist()							,			image_std=timm_transforms[-1].std.tolist()							,			)

     _SCREAMING_SNAKE_CASE							   =prepare_img()
     _SCREAMING_SNAKE_CASE							   =transform(_UpperCamelCase    ).unsqueeze(0    )
     _SCREAMING_SNAKE_CASE							   =processor(_UpperCamelCase							,			return_tensors='pt'    ).pixel_values

     # verify pixel values
     assert torch.allclose(_UpperCamelCase							,			_UpperCamelCase    )

     # verify logits
     with torch.no_grad():
          _SCREAMING_SNAKE_CASE							   =model(_UpperCamelCase    )
          _SCREAMING_SNAKE_CASE							   =outputs.logits

     print('Logits:'							,			logits[0, :3]    )
     print('Predicted class:'							,			model.config.idalabel[logits.argmax(-1    ).item()]    )
     _SCREAMING_SNAKE_CASE							   =timm_model(_UpperCamelCase    )
     assert timm_logits.shape == outputs.logits.shape
     assert torch.allclose(_UpperCamelCase							,			outputs.logits							,			atol=1E-3    )
     print('Looks ok!'    )

     if pytorch_dump_folder_path is not None:
          Path(_UpperCamelCase    ).mkdir(exist_ok=_UpperCamelCase    )
          print(f"Saving model {model_name} and processor to {pytorch_dump_folder_path}"    )
          model.save_pretrained(_UpperCamelCase    )
          processor.save_pretrained(_UpperCamelCase    )

     if push_to_hub:
          print(f"Pushing model {model_name} and processor to the hub"    )
          model.push_to_hub(f"ybelkada/{model_name}"    )
          processor.push_to_hub(f"ybelkada/{model_name}"    )


if __name__ == "__main__":
     lowerCamelCase			:				List[Any] 			=					argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         "--model_name",
         default="resnetv2_50x1_bitm",
         type=str,
         help="Name of the BiT timm model you'd like to convert.",
     )
     parser.add_argument(
         "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
     )
     parser.add_argument(
         "--push_to_hub",
         action="store_true",
         help="Whether to push the model to the hub.",
     )

     lowerCamelCase			:				Tuple 			=					parser.parse_args()
     convert_bit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)



'''simple docstring'''
from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

lowerCamelCase			:				List[str] 			=					{"UserAgent": UserAgent().random}


def 	_lowerCAmelCase (						_UpperCamelCase						:					str    )				->      dict:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =script.contents[0]
     _SCREAMING_SNAKE_CASE							   =json.loads(data[data.find('{"config"'    ) : -1]    )
     return info["entry_data"]["ProfilePage"][0]["graphql"]["user"]







class 							A__   :





  def __init__(		self				:     int							, _a				:     List[Any]			)     ->   Optional[int]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =f"https://www.instagram.com/{username}/"
       _SCREAMING_SNAKE_CASE							   =self.get_json()





  def 						A  (		self				:     Optional[int]			)     ->   dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =requests.get(self.url							, headers=_a			).text
       _SCREAMING_SNAKE_CASE							   =BeautifulSoup(_a							, '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				:     str			)     ->   str:





       '''simple docstring'''






       return f"{self.__class__.__name__}('{self.username}')"





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





       '''simple docstring'''






       return f"{self.fullname} ({self.username}) is {self.biography}"





  @property
  def 						A  (		self				:     List[Any]			)     ->   str:





       '''simple docstring'''






       return self.user_data["username"]





  @property
  def 						A  (		self				:     str			)     ->   str:





       '''simple docstring'''






       return self.user_data["full_name"]





  @property
  def 						A  (		self				:     Any			)     ->   str:





       '''simple docstring'''






       return self.user_data["biography"]





  @property
  def 						A  (		self				:     Optional[Any]			)     ->   str:





       '''simple docstring'''






       return self.user_data["business_email"]





  @property
  def 						A  (		self				:     Tuple			)     ->   str:





       '''simple docstring'''






       return self.user_data["external_url"]





  @property
  def 						A  (		self				:     Optional[int]			)     ->   int:





       '''simple docstring'''






       return self.user_data["edge_followed_by"]["count"]





  @property
  def 						A  (		self				:     Union[str, Any]			)     ->   int:





       '''simple docstring'''






       return self.user_data["edge_follow"]["count"]





  @property
  def 						A  (		self				:     List[str]			)     ->   int:





       '''simple docstring'''






       return self.user_data["edge_owner_to_timeline_media"]["count"]





  @property
  def 						A  (		self				:     Union[str, Any]			)     ->   str:





       '''simple docstring'''






       return self.user_data["profile_pic_url_hd"]





  @property
  def 						A  (		self				:     Dict			)     ->   bool:





       '''simple docstring'''






       return self.user_data["is_verified"]





  @property
  def 						A  (		self				:     Tuple			)     ->   bool:





       '''simple docstring'''






       return self.user_data["is_private"]


def 	_lowerCAmelCase (						_UpperCamelCase						:					str = "github"    )				->      None:
     """simple docstring"""




     import os

     if os.environ.get('CI'    ):
          return  # test failing on GitHub Actions
     _SCREAMING_SNAKE_CASE							   =InstagramUser(_UpperCamelCase    )
     assert instagram_user.user_data
     assert isinstance(instagram_user.user_data							,			_UpperCamelCase    )
     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_50
     assert instagram_user.number_of_followers > 12_00_00
     assert instagram_user.number_of_followings > 15
     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()
     lowerCamelCase			:				Optional[int] 			=					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 = }''')
