



from __future__ import annotations
def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	list[float]     ,				_SCREAMING_SNAKE_CASE   :	Any				)->Tuple:
      print(f'''Vertex\tShortest Distance from vertex {src}'''				)
      for i, d in enumerate(__UpperCamelCase				):
            print(f'''{i}\t\t{d}'''				)
def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	list[dict[str, int]]     ,				_SCREAMING_SNAKE_CASE   :	list[float]     ,				_SCREAMING_SNAKE_CASE   :	int				)->int:






      for j in range(__UpperCamelCase				):
            _lowerCAmelCase 			=  (graph[j][k] for k in ["""src""", """dst""", """weight"""])
            if distance[u] != float('''inf'''				) and distance[u] + w < distance[v]:
                  return True
      return False
def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	list[dict[str, int]]     ,				_SCREAMING_SNAKE_CASE   :	int     ,				_SCREAMING_SNAKE_CASE   :	int     ,				_SCREAMING_SNAKE_CASE   :	int				)->Dict:
      _lowerCAmelCase 			=  [float('''inf'''				)] * vertex_count
      _lowerCAmelCase 			=  0.0

      for _ in range(vertex_count - 1				):
            for j in range(__UpperCamelCase				):
                  _lowerCAmelCase 			=  (graph[j][k] for k in ["""src""", """dst""", """weight"""])

                  if distance[u] != float('''inf'''				) and distance[u] + w < distance[v]:
                        _lowerCAmelCase 			=  distance[u] + w

      _lowerCAmelCase 			=  check_negative_cycle(__UpperCamelCase     ,				__UpperCamelCase     ,				__UpperCamelCase				)
      if negative_cycle_exists:
            raise Exception('''Negative cycle found'''				)

      return distance


if __name__ == "__main__":
    import doctest

    doctest.testmod()

    UpperCAmelCase_									=							int(input("Enter number of vertices: ").strip())
    UpperCAmelCase_									=							int(input("Enter number of edges: ").strip())

    UpperCAmelCase_									=							[{} for _ in range(E)]

    for i in range(E):
        print("Edge ", i + 1)
        UpperCAmelCase_									=							(
            int(x)
            for x in input("Enter source, destination, weight: ").strip().split(" ")
        )
        UpperCAmelCase_									=							{'''src''': src, '''dst''': dest, '''weight''': weight}

    UpperCAmelCase_									=							int(input("\nEnter shortest path source:").strip())
    UpperCAmelCase_									=							bellman_ford(graph, V, E, source)
    print_distance(shortest_distance, 0)




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 = }""")