


from urllib.error import HTTPError

from bsa import BeautifulSoup
from requests import exceptions, get

lowerCAmelCase__				:   List[str]		= "https://www.wellrx.com/prescriptions/{0}/{1}/?freshSearch=true"

def 				lowercase_		(		_A      :   str   , _A      :   str						):

      """simple docstring"""




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

            lowerCamelCase__		:    List[str]   =  BASE_URL.format(_A   , _A						)
            lowerCamelCase__		:    int   =  get(_A						)

            # Is the response ok?
            response.raise_for_status()

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

            # This list will store the name and price.
            lowerCamelCase__		:    int   =  []

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

                        # Get price of the drug.
                        lowerCamelCase__		:    Union[str, Any]   =  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
    lowerCAmelCase__				:   Any		= input("Enter drug name: ").strip()
    lowerCAmelCase__				:   Union[str, Any]		= input("Enter zip code: ").strip()

    lowerCAmelCase__				:   list | None		= 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:
            lowerCAmelCase__				:   Dict		= pharmacy_price["pharmacy_name"]
            lowerCAmelCase__				:   Optional[int]		= pharmacy_price["price"]

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






import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import EfficientNetImageProcessor







class       _lowercase			(							unittest.TestCase):


       """simple docstring"""




       def __init__(       self							:      Optional[Any] ,				__lowerCamelCase							:      List[str] ,				__lowerCamelCase							:      int=13 ,				__lowerCamelCase							:      Tuple=3 ,				__lowerCamelCase							:      Optional[Any]=18 ,				__lowerCamelCase							:      List[Any]=30 ,				__lowerCamelCase							:      Union[str, Any]=400 ,				__lowerCamelCase							:      Union[str, Any]=True ,				__lowerCamelCase							:      Union[str, Any]=None ,				__lowerCamelCase							:      Optional[Any]=True ,				__lowerCamelCase							:      str=[0.5, 0.5, 0.5] ,				__lowerCamelCase							:      Dict=[0.5, 0.5, 0.5] ,				):


             '''simple docstring'''



             lowerCamelCase__		:    Dict   =  size if size is not None else {"height": 18, "width": 18}
             lowerCamelCase__		:    Dict   =  parent
             lowerCamelCase__		:    str   =  batch_size
             lowerCamelCase__		:    Tuple   =  num_channels
             lowerCamelCase__		:    Tuple   =  image_size
             lowerCamelCase__		:    Any   =  min_resolution
             lowerCamelCase__		:    Dict   =  max_resolution
             lowerCamelCase__		:    Tuple   =  do_resize
             lowerCamelCase__		:    List[str]   =  size
             lowerCamelCase__		:    Optional[Any]   =  do_normalize
             lowerCamelCase__		:    Union[str, Any]   =  image_mean
             lowerCamelCase__		:    Optional[Any]   =  image_std





       def 						lowerCAmelCase					(       self							:      Dict	):


             '''simple docstring'''



             return {
                 "image_mean": self.image_mean,
                 "image_std": self.image_std,
                 "do_normalize": self.do_normalize,
                 "do_resize": self.do_resize,
                 "size": self.size,
             }







@require_torch
@require_vision
class       _lowercase			(							lowercase__							,  unittest.TestCase):


       """simple docstring"""




       A__ 						=      EfficientNetImageProcessor if is_vision_available() else None





       def 						lowerCAmelCase					(       self							:      Optional[Any]	):


             '''simple docstring'''



             lowerCamelCase__		:    Optional[Any]   =  EfficientNetImageProcessorTester(self	)





       @property
       def 						lowerCAmelCase					(       self							:      Union[str, Any]	):


             '''simple docstring'''



             return self.image_processor_tester.prepare_image_processor_dict()





       def 						lowerCAmelCase					(       self							:      Dict	):


             '''simple docstring'''



             lowerCamelCase__		:    Union[str, Any]   =  self.image_processing_class(**self.image_processor_dict	)
             self.assertTrue(hasattr(__lowerCamelCase ,				"image_mean"	)	)
             self.assertTrue(hasattr(__lowerCamelCase ,				"image_std"	)	)
             self.assertTrue(hasattr(__lowerCamelCase ,				"do_normalize"	)	)
             self.assertTrue(hasattr(__lowerCamelCase ,				"do_resize"	)	)
             self.assertTrue(hasattr(__lowerCamelCase ,				"size"	)	)





       def 						lowerCAmelCase					(       self							:      Any	):


             '''simple docstring'''



             lowerCamelCase__		:    Optional[Any]   =  self.image_processing_class.from_dict(self.image_processor_dict	)
             self.assertEqual(image_processor.size ,				{"height": 18, "width": 18}	)

             lowerCamelCase__		:    Optional[int]   =  self.image_processing_class.from_dict(self.image_processor_dict ,				size=42	)
             self.assertEqual(image_processor.size ,				{"height": 42, "width": 42}	)





       def 						lowerCAmelCase					(       self							:      Dict	):


             '''simple docstring'''



             lowerCamelCase__		:    Any   =  self.image_processing_class(**self.image_processor_dict	)
             # create random PIL images
             lowerCamelCase__		:    Any   =  prepare_image_inputs(self.image_processor_tester ,				equal_resolution=__lowerCamelCase	)
             for image in image_inputs:
                   self.assertIsInstance(__lowerCamelCase ,				Image.Image	)

             # Test not batched input
             lowerCamelCase__		:    Union[str, Any]   =  image_processing(image_inputs[0] ,				return_tensors="pt"	).pixel_values
             self.assertEqual(
                 encoded_images.shape ,				(
                     1,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 ) ,				)

             # Test batched
             lowerCamelCase__		:    Dict   =  image_processing(__lowerCamelCase ,				return_tensors="pt"	).pixel_values
             self.assertEqual(
                 encoded_images.shape ,				(
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 ) ,				)





       def 						lowerCAmelCase					(       self							:      List[Any]	):


             '''simple docstring'''



             lowerCamelCase__		:    Dict   =  self.image_processing_class(**self.image_processor_dict	)
             # create random numpy tensors
             lowerCamelCase__		:    List[Any]   =  prepare_image_inputs(self.image_processor_tester ,				equal_resolution=__lowerCamelCase ,				numpify=__lowerCamelCase	)
             for image in image_inputs:
                   self.assertIsInstance(__lowerCamelCase ,				np.ndarray	)

             # Test not batched input
             lowerCamelCase__		:    List[str]   =  image_processing(image_inputs[0] ,				return_tensors="pt"	).pixel_values
             self.assertEqual(
                 encoded_images.shape ,				(
                     1,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 ) ,				)

             # Test batched
             lowerCamelCase__		:    Union[str, Any]   =  image_processing(__lowerCamelCase ,				return_tensors="pt"	).pixel_values
             self.assertEqual(
                 encoded_images.shape ,				(
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 ) ,				)





       def 						lowerCAmelCase					(       self							:      List[str]	):


             '''simple docstring'''



             lowerCamelCase__		:    int   =  self.image_processing_class(**self.image_processor_dict	)
             # create random PyTorch tensors
             lowerCamelCase__		:    int   =  prepare_image_inputs(self.image_processor_tester ,				equal_resolution=__lowerCamelCase ,				torchify=__lowerCamelCase	)
             for image in image_inputs:
                   self.assertIsInstance(__lowerCamelCase ,				torch.Tensor	)

             # Test not batched input
             lowerCamelCase__		:    Dict   =  image_processing(image_inputs[0] ,				return_tensors="pt"	).pixel_values
             self.assertEqual(
                 encoded_images.shape ,				(
                     1,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 ) ,				)

             # Test batched
             lowerCamelCase__		:    List[Any]   =  image_processing(__lowerCamelCase ,				return_tensors="pt"	).pixel_values
             self.assertEqual(
                 encoded_images.shape ,				(
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 ) ,				)


