



import math
import sys





class  __lowerCAmelCase			:




    def __init__(							self		):



         """simple docstring"""





         _lowerCAmelCase      =   0
         _lowerCAmelCase      =   []
         _lowerCAmelCase      =   {}  # To store the pos of node in array




    def 							snake_case       (							self		):



         """simple docstring"""





         return self.cur_size == 0




    def 							snake_case       (							self						,    _snake_case		):



         """simple docstring"""





         _lowerCAmelCase      =   self.left(lowercase__		)
         _lowerCAmelCase      =   self.right(lowercase__		)
         if lc < self.cur_size and self.array(lowercase__		)[0] < self.array(lowercase__		)[0]:
              _lowerCAmelCase      =   lc
         else:
              _lowerCAmelCase      =   idx
         if rc < self.cur_size and self.array(lowercase__		)[0] < self.array(lowercase__		)[0]:
              _lowerCAmelCase      =   rc
         if smallest != idx:
              self.swap(lowercase__						,    lowercase__		)
              self.min_heapify(lowercase__		)




    def 							snake_case       (							self						,    _snake_case		):



         """simple docstring"""





         _lowerCAmelCase      =   self.cur_size
         self.cur_size += 1
         self.array.append((sys.maxsize, tup[1])		)
         self.decrease_key((sys.maxsize, tup[1])						,    tup[0]		)




    def 							snake_case       (							self		):



         """simple docstring"""





         _lowerCAmelCase      =   self.array[0][1]
         _lowerCAmelCase      =   self.array[self.cur_size - 1]
         self.cur_size -= 1
         self.min_heapify(1		)
         del self.pos[min_node]
         return min_node




    def 							snake_case       (							self						,    _snake_case		):



         """simple docstring"""





         return 2 * i + 1




    def 							snake_case       (							self						,    _snake_case		):



         """simple docstring"""





         return 2 * i + 2




    def 							snake_case       (							self						,    _snake_case		):



         """simple docstring"""





         return math.floor(i / 2		)




    def 							snake_case       (							self						,    _snake_case						,    _snake_case		):



         """simple docstring"""





         _lowerCAmelCase      =   j
         _lowerCAmelCase      =   i
         _lowerCAmelCase      =   self.array[i]
         _lowerCAmelCase      =   self.array[j]
         _lowerCAmelCase      =   temp




    def 							snake_case       (							self						,    _snake_case						,    _snake_case		):



         """simple docstring"""





         _lowerCAmelCase      =   self.pos[tup[1]]
         # assuming the new_d is atmost old_d
         _lowerCAmelCase      =   (new_d, tup[1])
         while idx > 0 and self.array[self.par(lowercase__		)][0] > self.array[idx][0]:
              self.swap(lowercase__						,    self.par(lowercase__		)		)
              _lowerCAmelCase      =   self.par(lowercase__		)





class  __lowerCAmelCase			:




    def __init__(							self						,    _snake_case		):



         """simple docstring"""





         _lowerCAmelCase      =   {}  # To store graph: u -> (v,w)
         _lowerCAmelCase      =   num  # Number of nodes in graph
         # To store the distance from source vertex
         _lowerCAmelCase      =   [0] * self.num_nodes
         _lowerCAmelCase      =   [-1] * self.num_nodes  # To store the path




    def 							snake_case       (							self						,    _snake_case						,    _snake_case						,    _snake_case		):



         """simple docstring"""





         if u in self.adjList:
              self.adjList[u].append((v, w)		)
         else:
              _lowerCAmelCase      =   [(v, w)]

         # Assuming undirected graph
         if v in self.adjList:
              self.adjList[v].append((u, w)		)
         else:
              _lowerCAmelCase      =   [(u, w)]




    def 							snake_case       (							self		):



         """simple docstring"""





         for u in self.adjList:
              print(lowercase__						,    """->"""						,    """ -> """.join(str(F'{v}({w})'		) for v, w in self.adjList[u]		)		)




    def 							snake_case       (							self						,    _snake_case		):



         """simple docstring"""





         _lowerCAmelCase      =   [-1] * self.num_nodes
         # src is the source node
         _lowerCAmelCase      =   0
         _lowerCAmelCase      =   PriorityQueue()
         q.insert((0, src)		)  # (dist from src, node)
         for u in self.adjList:
              if u != src:
                   _lowerCAmelCase      =   sys.maxsize  # Infinity
                   _lowerCAmelCase      =   -1

         while not q.is_empty():
              _lowerCAmelCase      =   q.extract_min()  # Returns node with the min dist from source
              # Update the distance of all the neighbours of u and
              # if their prev dist was INFINITY then push them in Q
              for v, w in self.adjList[u]:
                   _lowerCAmelCase      =   self.dist[u] + w
                   if self.dist[v] > new_dist:
                        if self.dist[v] == sys.maxsize:
                             q.insert((new_dist, v)		)
                        else:
                             q.decrease_key((self.dist[v], v)						,    lowercase__		)
                        _lowerCAmelCase      =   new_dist
                        _lowerCAmelCase      =   u

        # Show the shortest distances from src
         self.show_distances(lowercase__		)




    def 							snake_case       (							self						,    _snake_case		):



         """simple docstring"""





         print(F'Distance from node: {src}'		)
         for u in range(self.num_nodes		):
              print(F'Node {u} has distance: {self.dist[u]}'		)




    def 							snake_case       (							self						,    _snake_case						,    _snake_case		):



         """simple docstring"""





         _lowerCAmelCase      =   []
         _lowerCAmelCase      =   0
         _lowerCAmelCase      =   dest
         # Backtracking from dest to src
         while self.par[temp] != -1:
              path.append(lowercase__		)
              if temp != src:
                   for v, w in self.adjList[temp]:
                        if v == self.par[temp]:
                             cost += w
                             break
              _lowerCAmelCase      =   self.par[temp]
         path.append(lowercase__		)
         path.reverse()

         print(F'----Path to reach {dest} from {src}----'		)
         for u in path:
              print(F'{u}'						,    end=""" """		)
              if u != dest:
                   print("""-> """						,    end=""""""		)

         print("""\nTotal cost of path: """						,    lowercase__		)


if __name__ == "__main__":
 A__     				=	Graph(9)
 graph.add_edge(0, 1, 4)
 graph.add_edge(0, 7, 8)
 graph.add_edge(1, 2, 8)
 graph.add_edge(1, 7, 11)
 graph.add_edge(2, 3, 7)
 graph.add_edge(2, 8, 2)
 graph.add_edge(2, 5, 4)
 graph.add_edge(3, 4, 9)
 graph.add_edge(3, 5, 14)
 graph.add_edge(4, 5, 10)
 graph.add_edge(5, 6, 2)
 graph.add_edge(6, 7, 1)
 graph.add_edge(6, 8, 6)
 graph.add_edge(7, 8, 7)
 graph.show_graph()
 graph.dijkstra(0)
 graph.show_path(0, 4)

# OUTPUT
# 0 -> 1(4) -> 7(8)
# 1 -> 0(4) -> 2(8) -> 7(11)
# 7 -> 0(8) -> 1(11) -> 6(1) -> 8(7)
# 2 -> 1(8) -> 3(7) -> 8(2) -> 5(4)
# 3 -> 2(7) -> 4(9) -> 5(14)
# 8 -> 2(2) -> 6(6) -> 7(7)
# 5 -> 2(4) -> 3(14) -> 4(10) -> 6(2)
# 4 -> 3(9) -> 5(10)
# 6 -> 5(2) -> 7(1) -> 8(6)
# Distance from node: 0
# Node 0 has distance: 0
# Node 1 has distance: 4
# Node 2 has distance: 12
# Node 3 has distance: 19
# Node 4 has distance: 21
# Node 5 has distance: 11
# Node 6 has distance: 9
# Node 7 has distance: 8
# Node 8 has distance: 14
# ----Path to reach 4 from 0----
# 0 -> 7 -> 6 -> 5 -> 4
# Total cost of path:  21








from urllib.error import HTTPError

from bsa import BeautifulSoup
from requests import exceptions, get

A__     				=	"""https://www.wellrx.com/prescriptions/{0}/{1}/?freshSearch=true"""


def 		_UpperCAmelCase    (				snake_case     ,						snake_case      ):





					"""simple docstring"""

					try:
										# Has user provided both inputs?
										if not drug_name or not zip_code:
															return None

										_lowerCAmelCase      =   BASE_URL.format(snake_case     ,						snake_case      )
										_lowerCAmelCase      =   get(snake_case      )

										# Is the response ok?
										response.raise_for_status()

										# Scrape the data using bs4
										_lowerCAmelCase      =   BeautifulSoup(response.text     ,						"""html.parser"""      )

										# This list will store the name and price.
										_lowerCAmelCase      =   []

										# Fetch all the grids that contains the items.
										_lowerCAmelCase      =   soup.find_all("""div"""     ,						{"""class""": """grid-x pharmCard"""}      )
										if grid_list and len(snake_case      ) > 0:
															for grid in grid_list:
																				# Get the pharmacy price.
																				_lowerCAmelCase      =   grid.find("""p"""     ,						{"""class""": """list-title"""}      ).text

																				# Get price of the drug.
																				_lowerCAmelCase      =   grid.find("""span"""     ,						{"""p""", """price price-large"""}      ).text

																				pharmacy_price_list.append(
																				    {
																				        """pharmacy_name""": pharmacy_name,
																				        """price""": price,
																				    }      )

										return pharmacy_price_list

					except (HTTPError, exceptions.RequestException, ValueError):
										return None


if __name__ == "__main__":
	# Enter a drug name and a zip code
	A__     				=	input("""Enter drug name: """).strip()
	A__     				=	input("""Enter zip code: """).strip()

	A__     				=	fetch_pharmacy_and_price_list(
	    drug_name, zip_code
	)

	if pharmacy_price_list:
		print(f"\nSearch results for {drug_name} at location {zip_code}:")
		for pharmacy_price in pharmacy_price_list:
			A__     				=	pharmacy_price["""pharmacy_name"""]
			A__     				=	pharmacy_price["""price"""]

			print(f"Pharmacy: {name} Price: {price}")
	else:
		print(f"No results found for {drug_name}")



