



from collections.abc import Iterable
from typing import Any


class 	__snake_case   :
		def __init__(							self    ,a_ = None						):







						"""simple docstring"""
						lowerCAmelCase__		  =  value
						lowerCAmelCase__		  =  None  # Added in order to delete a node easier
						lowerCAmelCase__		  =  None
						lowerCAmelCase__		  =  None



		def __repr__(							self						):







						"""simple docstring"""
						from pprint import pformat

						if self.left is None and self.right is None:
										return str(self.value						)
						return pformat({f'{self.value}': (self.left, self.right)}    ,indent=1						)



class 	__snake_case   :
		def __init__(							self    ,a_ = None						):







						"""simple docstring"""
						lowerCAmelCase__		  =  root
		def __str__(							self						):







						"""simple docstring"""
						return str(self.root						)
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_    ,a_						):







						"""simple docstring"""
						if new_children is not None:  # reset its kids
										lowerCAmelCase__		  =  node.parent
						if node.parent is not None:  # reset its parent
										if self.is_right(a_						):  # If it is the right children
														lowerCAmelCase__		  =  new_children
										else:
														lowerCAmelCase__		  =  new_children
						else:
										lowerCAmelCase__		  =  new_children
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_						):







						"""simple docstring"""
						if node.parent and node.parent.right:
										return node == node.parent.right
						return False
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return self.root is None
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_						):







						"""simple docstring"""
						lowerCAmelCase__		  =  Node(a_						)  # create a new Node
						if self.empty():  # if Tree is empty
										lowerCAmelCase__		  =  new_node  # set its root
						else:  # Tree is not empty
										lowerCAmelCase__		  =  self.root  # from root
										if parent_node is None:
														return
										while True:  # While we don't get to a leaf
														if value < parent_node.value:  # We go left
																		if parent_node.left is None:
																						lowerCAmelCase__		  =  new_node  # We insert the new node in a leaf
																						break
																		else:
																						lowerCAmelCase__		  =  parent_node.left
														else:
																		if parent_node.right is None:
																						lowerCAmelCase__		  =  new_node
																						break
																		else:
																						lowerCAmelCase__		  =  parent_node.right
										lowerCAmelCase__		  =  parent_node
		def 						SCREAMING_SNAKE_CASE_					(							self    ,*a_						):







						"""simple docstring"""
						for value in values:
										self.__insert(a_						)
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_						):







						"""simple docstring"""
						if self.empty():
										raise IndexError('Warning: Tree is empty! please use another.'						)
						else:
										lowerCAmelCase__		  =  self.root
										# use lazy evaluation here to avoid NoneType Attribute error
										while node is not None and node.value is not value:
														lowerCAmelCase__		  =  node.left if value < node.value else node.right
										return node
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_ = None						):







						"""simple docstring"""
						if node is None:
										if self.root is None:
														return None
										lowerCAmelCase__		  =  self.root

						if not self.empty():
										while node.right is not None:
														lowerCAmelCase__		  =  node.right
						return node
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_ = None						):







						"""simple docstring"""
						if node is None:
										lowerCAmelCase__		  =  self.root
						if self.root is None:
										return None
						if not self.empty():
										lowerCAmelCase__		  =  self.root
										while node.left is not None:
														lowerCAmelCase__		  =  node.left
						return node
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_						):







						"""simple docstring"""
						lowerCAmelCase__		  =  self.search(a_						)  # Look for the node with that label
						if node is not None:
										if node.left is None and node.right is None:  # If it has no children
														self.__reassign_nodes(a_    ,a_						)
										elif node.left is None:  # Has only right children
														self.__reassign_nodes(a_    ,node.right						)
										elif node.right is None:  # Has only left children
														self.__reassign_nodes(a_    ,node.left						)
										else:
														lowerCAmelCase__		  =  self.get_max(
														    node.left						)  # Gets the max value of the left branch
														self.remove(tmp_node.value						)  # type: ignore
														lowerCAmelCase__		  =  (
														    tmp_node.value  # type: ignore
														)  # Assigns the value to the node to delete and keep tree structure
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_						):







						"""simple docstring"""
						if node is not None:
										yield node  # Preorder Traversal
										yield from self.preorder_traverse(node.left						)
										yield from self.preorder_traverse(node.right						)
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_=None						):







						"""simple docstring"""
						if traversal_function is None:
										return self.preorder_traverse(self.root						)
						else:
										return traversal_function(self.root						)
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_    ,a_						):







						"""simple docstring"""
						if node:
										self.inorder(a_    ,node.left						)
										arr.append(node.value						)
										self.inorder(a_    ,node.right						)



		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_    ,a_						):







						"""simple docstring"""
						lowerCAmelCase__		  =  []
						self.inorder(a_    ,a_						)  # append all values to list using inorder traversal
						return arr[k - 1]







def     UpperCAmelCase_		(					snake_case__					)	->     list[Node]:



				"""simple docstring"""





				lowerCAmelCase__		  =  []
				if curr_node is not None:
								lowerCAmelCase__		  =  postorder(curr_node.left					) + postorder(curr_node.right					) + [curr_node]
				return node_list







def     UpperCAmelCase_		(					)	->     None:



				"""simple docstring"""





				lowerCAmelCase__		  =  (8, 3, 6, 1, 10, 14, 13, 4, 7)
				lowerCAmelCase__		  =  BinarySearchTree()
				for i in testlist:
								t.insert(snake_case__					)

				# Prints all the elements of the list in order traversal
				print(snake_case__					)

				if t.search(6					) is not None:
								print('The value 6 exists'					)
				else:
								print('The value 6 doesn\'t exist'					)

				if t.search(-1					) is not None:
								print('The value -1 exists'					)
				else:
								print('The value -1 doesn\'t exist'					)

				if not t.empty():
								print('Max Value: '    ,			t.get_max().value					)  # type: ignore
								print('Min Value: '    ,			t.get_min().value					)  # type: ignore

				for i in testlist:
								t.remove(snake_case__					)
								print(snake_case__					)


if __name__ == "__main__":
	import doctest

	doctest.testmod(verbose=True)





from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

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







def     UpperCAmelCase_		(					snake_case__					)	->     dict:



				"""simple docstring"""





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


class 	__snake_case   :
		def __init__(							self    ,a_						):







						"""simple docstring"""
						lowerCAmelCase__		  =  f'https://www.instagram.com/{username}/'
						lowerCAmelCase__		  =  self.get_json()
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						lowerCAmelCase__		  =  requests.get(self.url    ,headers=a_						).text
						lowerCAmelCase__		  =  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						):







						"""simple docstring"""
						return f'{self.__class__.__name__}(\'{self.username}\')'
		def __str__(							self						):







						"""simple docstring"""
						return f'{self.fullname} ({self.username}) is {self.biography}'
		@property
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return self.user_data["username"]
		@property
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return self.user_data["full_name"]
		@property
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return self.user_data["biography"]
		@property
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return self.user_data["business_email"]
		@property
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return self.user_data["external_url"]
		@property
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return self.user_data["edge_followed_by"]["count"]
		@property
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return self.user_data["edge_follow"]["count"]
		@property
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return self.user_data["edge_owner_to_timeline_media"]["count"]
		@property
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return self.user_data["profile_pic_url_hd"]
		@property
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return self.user_data["is_verified"]



		@property
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return self.user_data["is_private"]







def     UpperCAmelCase_		(					snake_case__ = "github"					)	->     None:



				"""simple docstring"""





				import os

				if os.environ.get('CI'					):
								return  # test failing on GitHub Actions
				lowerCAmelCase__		  =  InstagramUser(snake_case__					)
				assert instagram_user.user_data
				assert isinstance(instagram_user.user_data    ,			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 > 120000
				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 = }""")
