code: 
  
  
  
  
  
  
  from urllib.error import HTTPError
  
  from bsa import BeautifulSoup
  from requests import exceptions, get
  
  lowerCamelCase__           =				'https://www.wellrx.com/prescriptions/{0}/{1}/?freshSearch=true'
  
  
  
  def 							_lowerCamelCase(				__snake_case						,						__snake_case	)  ->   list | None:
  
  
  
  
  
  
  
  		try:
  				# Has user provided both inputs?
  				if not drug_name or not zip_code:
  						return None
  
  				__snake_case		       =     BASE_URL.format(__snake_case						,						__snake_case	)
  				__snake_case		       =     get(__snake_case	)
  
  				# Is the response ok?
  				response.raise_for_status()
  
  				# Scrape the data using bs4
  				__snake_case		       =     BeautifulSoup(response.text						,						"html.parser"	)
  
  				# This list will store the name and price.
  				__snake_case		       =     []
  
  				# Fetch all the grids that contains the items.
  				__snake_case		       =     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.
  								__snake_case		       =     grid.find("p"						,						{"class": "list-title"}	).text
  
  								# Get price of the drug.
  								__snake_case		       =     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__           =				input('Enter drug name: ').strip()
  		lowerCamelCase__           =				input('Enter zip code: ').strip()
  
  		lowerCamelCase__           =				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__           =				pharmacy_price['pharmacy_name']
  						lowerCamelCase__           =				pharmacy_price['price']
  
  						print(F"Pharmacy: {name} Price: {price}")
  		else:
  				print(F"No results found for {drug_name}")
  
  
  
  
  
  
style_context: import os
  from shutil import copyfile
  from typing import Optional, Tuple
  
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import is_sentencepiece_available, logging
  
  
  if is_sentencepiece_available():
  		from .tokenization_reformer import ReformerTokenizer
  else:
  		lowerCamelCase__           =				None
  
  
  lowerCamelCase__           =				logging.get_logger(__name__)
  
  
  lowerCamelCase__           =				'▁'
  
  lowerCamelCase__           =				{'vocab_file': 'spiece.model', 'tokenizer_file': 'tokenizer.json'}
  
  lowerCamelCase__           =				{
      'vocab_file': {
          'google/reformer-crime-and-punishment': (
              'https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/spiece.model'
          )
      },
      'tokenizer_file': {
          'google/reformer-crime-and-punishment': (
              'https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/tokenizer.json'
          )
      },
  }
  
  lowerCamelCase__           =				{
      'google/reformer-crime-and-punishment': 52_42_88,
  }
  
  
  
  
  class 					UpperCamelCase	(     snake_case__      ):
  					__UpperCamelCase						=   VOCAB_FILES_NAMES
  					__UpperCamelCase						=   PRETRAINED_VOCAB_FILES_MAP
  					__UpperCamelCase						=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  					__UpperCamelCase						=   ["""input_ids""", """attention_mask"""]
  					__UpperCamelCase						=   ReformerTokenizer
  
  
  
  
  					def __init__( self :					Tuple      ,_lowerCAmelCase :					Dict=None      ,_lowerCAmelCase :					Union[str, Any]=None      ,_lowerCAmelCase :					int="</s>"      ,_lowerCAmelCase :					Dict="<unk>"      ,_lowerCAmelCase :					Dict=[]      ,**_lowerCAmelCase :					Optional[Any]      ,):
  
  
  							"""simple docstring"""
  
  
  
  
  							super().__init__(
  							    _lowerCAmelCase      ,tokenizer_file=_lowerCAmelCase      ,eos_token=_lowerCAmelCase      ,unk_token=_lowerCAmelCase      ,additional_special_tokens=_lowerCAmelCase      ,**_lowerCAmelCase      ,)
  
  							__snake_case		       =     vocab_file
  							__snake_case		       =     False if not self.vocab_file else True
  
  
  
  
  
  
  
  					def 							UpperCamelCase_						( self :					Dict      ,_lowerCAmelCase :					str      ,_lowerCAmelCase :					Optional[str] = None						):
  
  
  							"""simple docstring"""
  
  
  
  
  							if not self.can_save_slow_tokenizer:
  									raise ValueError(
  									    "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
  									    "tokenizer."						)
  
  							if not os.path.isdir(_lowerCAmelCase						):
  									logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""						)
  									return
  							__snake_case		       =     os.path.join(
  							    _lowerCAmelCase      ,(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]						)
  
  							if os.path.abspath(self.vocab_file						) != os.path.abspath(_lowerCAmelCase						):
  									copyfile(self.vocab_file      ,_lowerCAmelCase						)
  
  							return (out_vocab_file,)
  
  
  
  
  
  