code: 
  
  
  
  
  
  from urllib.error import HTTPError
  
  from bsa import BeautifulSoup
  from requests import exceptions, get
  
  UpperCAmelCase			:			Tuple	  = """https://www.wellrx.com/prescriptions/{0}/{1}/?freshSearch=true"""
  def   _A (	SCREAMING_SNAKE_CASE  :     Dict , SCREAMING_SNAKE_CASE  :     Any		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    try:
      # Has user provided both inputs?
      if not drug_name or not zip_code:
        return None
  
      a__			:      List[Any]            =BASE_URL.format(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)
      a__			:      Optional[Any]            =get(SCREAMING_SNAKE_CASE		)
  
      # Is the response ok?
      response.raise_for_status()
  
      # Scrape the data using bs4
      a__			:      Optional[Any]            =BeautifulSoup(response.text , "html.parser"		)
  
      # This list will store the name and price.
      a__			:      Union[str, Any]            =[]
  
      # Fetch all the grids that contains the items.
      a__			:      Tuple            =soup.find_all("div" , {"class": "grid-x pharmCard"}		)
      if grid_list and len(SCREAMING_SNAKE_CASE		) > 0:
        for grid in grid_list:
          # Get the pharmacy price.
          a__			:      List[str]            =grid.find("p" , {"class": "list-title"}		).text
  
          # Get price of the drug.
          a__			:      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
         UpperCAmelCase			:			List[str]	  = input("""Enter drug name: """).strip()
         UpperCAmelCase			:			Dict	  = input("""Enter zip code: """).strip()
  
         UpperCAmelCase			:			int	  = 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:
                       UpperCAmelCase			:			Optional[int]	  = pharmacy_price["""pharmacy_name"""]
                       UpperCAmelCase			:			Union[str, Any]	  = pharmacy_price["""price"""]
  
                       print(F"""Pharmacy: {name} Price: {price}""")
         else:
                print(F"""No results found for {drug_name}""")
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  import importlib
  import sys
  from argparse import REMAINDER, ArgumentParser
  from pathlib import Path
  
  import torch_xla.distributed.xla_multiprocessing as xmp
  def   _A (	):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      Optional[int]            =ArgumentParser(
        description=(
            "PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes"
        )		)
  
    # Optional arguments for the launch helper
    parser.add_argument("--num_cores" , type=SCREAMING_SNAKE_CASE , default=1 , help="Number of TPU cores to use (1 or 8)."		)
  
    # positional
    parser.add_argument(
        "training_script" , type=SCREAMING_SNAKE_CASE , help=(
            "The full path to the single TPU training "
            "program/script to be launched in parallel, "
            "followed by all the arguments for the "
            "training script"
        ) , )
  
    # rest from the training program
    parser.add_argument("training_script_args" , nargs=SCREAMING_SNAKE_CASE		)
  
    return parser.parse_args()
  def   _A (	):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      Optional[Any]            =parse_args()
  
    # Import training_script as a module.
    a__			:      Tuple            =Path(args.training_script		)
    sys.path.append(str(script_fpath.parent.resolve()		)		)
    a__			:      Tuple            =script_fpath.stem
    a__			:      Any            =importlib.import_module(SCREAMING_SNAKE_CASE		)
  
    # Patch sys.argv
    a__			:      List[str]            =[args.training_script] + args.training_script_args + ["--tpu_num_cores", str(args.num_cores		)]
  
    xmp.spawn(mod._mp_fn , args=() , nprocs=args.num_cores		)
  
  
  if __name__ == "__main__":
       main()
  
  
  
  
  
  
  