





from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

__UpperCAmelCase	:       Optional[Any]    	=							{"UserAgent": UserAgent().random}







def       A__							(   SCREAMING_SNAKE_CASE__)       ->   dict:
  __snake_case:						int			  =						script.contents[0]
  __snake_case:						int			  =						json.loads(data[data.find("""{\"config\"""") : -1])
  return info["entry_data"]["ProfilePage"][0]["graphql"]["user"]







class    __snake_case	:





       '''simple docstring'''







       def __init__(  self			:   Optional[int]							,    A			:   int		):
         __snake_case:						str			  =						f'''https://www.instagram.com/{username}/'''
         __snake_case:						Optional[int]			  =						self.get_json()




       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[Any]			  =						requests.get(self.url							,    headers=A		).text
         __snake_case:						int			  =						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			:   int		):
         return f'''{self.__class__.__name__}(\'{self.username}\')'''




       def __str__(  self			:   List[Any]		):
         return f'''{self.fullname} ({self.username}) is {self.biography}'''




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




       @property
       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         return self.user_data["full_name"]




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




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




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         return self.user_data["external_url"]




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




       @property
       def 							UpperCAmelCase__			(  self			:   List[str]		):
         return self.user_data["edge_follow"]["count"]




       @property
       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         return self.user_data["edge_owner_to_timeline_media"]["count"]




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




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






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







def       A__							(   SCREAMING_SNAKE_CASE__ = "github")       ->   None:
  import os

  if os.environ.get("""CI"""):
    return  # test failing on GitHub Actions
  __snake_case:						int			  =						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 > 150
  assert instagram_user.number_of_followers > 12_0000
  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()
    __UpperCAmelCase	:       Dict    	=							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 = }')













import math







def       A__							(   SCREAMING_SNAKE_CASE__)       ->   int:

  if not isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__):
    __snake_case:						Optional[int]			  =						F'''Input value of [number={number}] must be an integer'''
    raise TypeError(SCREAMING_SNAKE_CASE__)

  if number < 1:
    __snake_case:						Optional[int]			  =						F'''Input value of [number={number}] must be > 0'''
    raise ValueError(SCREAMING_SNAKE_CASE__)
  elif number == 1:
    return 3
  elif number == 2:
    return 5
  else:
    __snake_case:						List[Any]			  =						int(math.log(number // 3 , 2)) + 2

    __snake_case:						str			  =						[3, 5]
    __snake_case:						int			  =						2
    __snake_case:						List[str]			  =						3
    for block in range(1 , SCREAMING_SNAKE_CASE__):
      for _ in range(SCREAMING_SNAKE_CASE__):
        proth_list.append(2 ** (block + 1) + proth_list[proth_index - 1])
        proth_index += 1
      increment *= 2

  return proth_list[number - 1]


if __name__ == "__main__":
      import doctest

      doctest.testmod()

      for number in range(11):
            __UpperCAmelCase	:       Optional[int]    	=							0
            try:
                  __UpperCAmelCase	:       int    	=							proth(number)
            except ValueError:
                  print(f'ValueError: there is no {number}th Proth number')
                  continue

            print(f'The {number}th Proth number: {value}')






