






'''simple docstring'''




class       __lowercase					:

	def __init__(      self   :						str):
			UpperCamelCase__				:					Union[str, Any]					=					0
			UpperCamelCase__				:					Any					=					0
			UpperCamelCase__				:					int					=					{}

	def      __UpperCamelCase							(      self   :						Union[str, Any]  ,					UpperCAmelCase_   :						int):
			if vertex not in self.adjacency:
					UpperCamelCase__				:					Tuple					=					{}
					self.num_vertices += 1

	def      __UpperCamelCase							(      self   :						str  ,					UpperCAmelCase_   :						str  ,					UpperCAmelCase_   :						List[Any]  ,					UpperCAmelCase_   :						Tuple):
			self.add_vertex(UpperCAmelCase_)
			self.add_vertex(UpperCAmelCase_)

			if head == tail:
					return

			UpperCamelCase__				:					Tuple					=					weight
			UpperCamelCase__				:					Optional[int]					=					weight

	def      __UpperCamelCase							(      self   :						Union[str, Any]):
			UpperCamelCase__				:					List[Any]					=					self.get_edges()
			for edge in edges:
					UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__				:					str					=					edge
					edges.remove((tail, head, weight))
			for i in range(len(UpperCAmelCase_)):
					UpperCamelCase__				:					Any					=					list(edges[i])

			edges.sort(key=lambda UpperCAmelCase_: e[2])
			for i in range(len(UpperCAmelCase_) - 1):
					if edges[i][2] >= edges[i + 1][2]:
							UpperCamelCase__				:					Optional[int]					=					edges[i][2] + 1
			for edge in edges:
					UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__				:					List[Any]					=					edge
					UpperCamelCase__				:					Dict					=					weight
					UpperCamelCase__				:					List[Any]					=					weight

	def __str__(      self   :						Any):
			UpperCamelCase__				:					List[Any]					=					''
			for tail in self.adjacency:
					for head in self.adjacency[tail]:
							UpperCamelCase__				:					Union[str, Any]					=					self.adjacency[head][tail]
							string += F'{head} -> {tail} == {weight}\n'
			return string.rstrip('\n')

	def      __UpperCamelCase							(      self   :						Optional[Any]):
			UpperCamelCase__				:					Optional[Any]					=					[]
			for tail in self.adjacency:
					for head in self.adjacency[tail]:
							output.append((tail, head, self.adjacency[head][tail]))
			return output

	def      __UpperCamelCase							(      self   :						List[str]):
			return self.adjacency.keys()

	@staticmethod
	def      __UpperCamelCase							(      UpperCAmelCase_   :						Any=None  ,					UpperCAmelCase_   :						str=None):
			UpperCamelCase__				:					Tuple					=					Graph()
			if vertices is None:
					UpperCamelCase__				:					Tuple					=					[]
			if edges is None:
					UpperCamelCase__				:					List[str]					=					[]
			for vertex in vertices:
					g.add_vertex(UpperCAmelCase_)
			for edge in edges:
					g.add_edge(*UpperCAmelCase_)
			return g







	class       __lowercase					:

		def __init__(      self   :						Tuple):
				UpperCamelCase__				:					int					=					{}
				UpperCamelCase__				:					List[str]					=					{}

		def __len__(      self   :						Any):
				return len(self.parent)

		def      __UpperCamelCase							(      self   :						Union[str, Any]  ,					UpperCAmelCase_   :						Optional[Any]):
				if item in self.parent:
						return self.find(UpperCAmelCase_)

				UpperCamelCase__				:					List[Any]					=					item
				UpperCamelCase__				:					Dict					=					0
				return item

		def      __UpperCamelCase							(      self   :						Dict  ,					UpperCAmelCase_   :						Optional[int]):
				if item not in self.parent:
						return self.make_set(UpperCAmelCase_)
				if item != self.parent[item]:
						UpperCamelCase__				:					List[str]					=					self.find(self.parent[item])
				return self.parent[item]





		def      __UpperCamelCase							(      self   :						List[Any]  ,					UpperCAmelCase_   :						Any  ,					UpperCAmelCase_   :						int):
				UpperCamelCase__				:					List[str]					=					self.find(UpperCAmelCase_)
				UpperCamelCase__				:					Tuple					=					self.find(UpperCAmelCase_)

				if roota == roota:
						return roota

				if self.rank[roota] > self.rank[roota]:
						UpperCamelCase__				:					Union[str, Any]					=					roota
						return roota

				if self.rank[roota] < self.rank[roota]:
						UpperCamelCase__				:					Any					=					roota
						return roota

				if self.rank[roota] == self.rank[roota]:
						self.rank[roota] += 1
						UpperCamelCase__				:					Dict					=					roota
						return roota
				return None


	@staticmethod
	def      __UpperCamelCase							(      UpperCAmelCase_   :						Optional[Any]):
			UpperCamelCase__				:					Optional[Any]					=					graph.num_vertices

			UpperCamelCase__				:					Tuple					=					Graph.UnionFind()
			UpperCamelCase__				:					Optional[int]					=					[]
			while num_components > 1:
					UpperCamelCase__				:					Tuple					=					{}
					for vertex in graph.get_vertices():
							UpperCamelCase__				:					Optional[Any]					=					-1

					UpperCamelCase__				:					int					=					graph.get_edges()
					for edge in edges:
							UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__				:					str					=					edge
							edges.remove((tail, head, weight))
					for edge in edges:
							UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__				:					Optional[Any]					=					edge
							UpperCamelCase__				:					Union[str, Any]					=					union_find.find(UpperCAmelCase_)
							UpperCamelCase__				:					List[Any]					=					union_find.find(UpperCAmelCase_)
							if seta != seta:
									if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
											UpperCamelCase__				:					Optional[Any]					=					[head, tail, weight]

									if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
											UpperCamelCase__				:					Tuple					=					[head, tail, weight]
					for vertex in cheap_edge:
							if cheap_edge[vertex] != -1:
									UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__				:					Union[str, Any]					=					cheap_edge[vertex]
									if union_find.find(UpperCAmelCase_) != union_find.find(UpperCAmelCase_):
											union_find.union(UpperCAmelCase_  ,					UpperCAmelCase_)
											mst_edges.append(cheap_edge[vertex])
											UpperCamelCase__				:					int					=					num_components - 1
			UpperCamelCase__				:					Dict					=					Graph.build(edges=UpperCAmelCase_)
			return mst












'''simple docstring'''




import requests
from bsa import BeautifulSoup







def       __UpperCAmelCase						(  lowerCamelCase_ = "AAPL")							->     str:
		UpperCamelCase__				:					str					=					f'https://in.finance.yahoo.com/quote/{symbol}?s={symbol}'
		UpperCamelCase__				:					Optional[Any]					=					BeautifulSoup(requests.get(lowerCamelCase_).text     ,      'html.parser')
		UpperCamelCase__				:					Union[str, Any]					=					'My(6px) Pos(r) smartphone_Mt(6px)'
		return soup.find('div'     ,      class_=class_).find('span').text


if __name__ == "__main__":
		for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
				print(f'''Current {symbol:<4} stock price is {stock_price(symbol):>8}''')




