import os, json, time from datetime import datetime import requests from openai import OpenAI from transformers import GPT2Tokenizer import cdx_toolkit from selenium import webdriver from selenium.webdriver.firefox.options import Options from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.common.by import By from .file_utils import csv_to_dict # Setup tokenizer for truncating long inputs tokenizer = GPT2Tokenizer.from_pretrained("gpt2") # Load OpenAI client openai_client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY")) # Google Custon Search Engine ID and API Key CSE_ID = '91b031290f09844c8' # 'a201862aec58741ab' CSE_API_KEY = os.getenv('GOOGLE_API_KEY_2') # Load URL lookup table os.makedirs('html_pages', exist_ok=True) url_table = csv_to_dict('html_pages/url_table.csv') def fetch_html( url: str, use_buffer: bool = True, cc_fetch: bool = True, browser: str = 'chrome' ): """ Fetch the URL and return the response Args: url (str): The URL to fetch use_buffer (bool): Whether to load from buffer. Defaults to True cc_fetch (bool): Whether to fetch from Common Crawl. Defaults to True browser (str): The browser to use. Defaults to 'chrome' Returns: Response: The response object """ url = url.replace(' ', '') new_url = url_table.get(url, url) new_url_noslash = new_url.replace('/', '\\') buffer_path = f"html_pages/pages/{new_url_noslash}.html"[:200] if not os.path.exists('html_pages/pages'): os.makedirs('html_pages/pages', exist_ok=True) if use_buffer and os.path.exists(buffer_path): # Load from buffer if the page has already been fetched print(f"Loaded from buffer: {url}") with open(buffer_path, 'r') as bfr: return new_url, bfr.read() else: try: if cc_fetch: print(f'Fetching from common crawl: {url}') cdx = cdx_toolkit.CDXFetcher(source='cc') timestamp = datetime.utcnow().strftime('%Y%m%d%H%M%S') for obj in cdx.iter( url, limit=1, to=timestamp, filter=['status:200', 'mimetype:text/html'] ): # Convert bytes to string html = obj.content.decode('utf-8') assert html is not None else: print(f"Fetching with {browser}: {url}") # Set preferences to ensure cookies and JavaScript are enabled if browser == 'chrome': web_driver = webdriver.Chrome() elif browser == 'firefox': options = Options() options.set_preference("javascript.enabled", True) options.set_preference("network.cookie.cookieBehavior", 0) web_driver = webdriver.Firefox(options=options) else: raise ValueError(f"Invalid browser: {browser}") # Fetch the URL. Wait until all images are loaded and an extra .5 seconds web_driver.get(url) WebDriverWait(web_driver, timeout=10).until( EC.presence_of_all_elements_located((By.TAG_NAME, 'img')) ) time.sleep(0.5) # Save the redirected URL and the HTML content new_url = web_driver.current_url html = web_driver.page_source new_url = new_url.replace(' ', '') new_url_noslash = new_url.replace('/', '\\') # Save the redirected URL and HTML content to the buffer if use_buffer: if new_url != url: url_table[url] = new_url with open('html_pages/url_table.csv', 'a') as tbl: tbl.write(f"{url}|{new_url}\n") with open(buffer_path, 'w') as bfr: bfr.write(html) return new_url, html except Exception as e: print(f"Failed to fetch: {url}") print(f"Error message: {e}") return None, None finally: if 'web_driver' in locals(): web_driver.quit() def query_openai_llm( content: str, buffer_path: str, llm_model: str = 'gpt-3.5-turbo', use_buffer: bool = True, recursion_depth: int = 0 ): """ Query the LLM model to check if the text is a product page Args: content (str): The content to feed to the OpenAI LLM model buffer_path (str): The path to the buffer file to store the response llm_model (str, optional): The model to use. Defaults to 'gpt-3.5-turbo' use_buffer (bool): Whether to skip loading from buffer. Defaults to True Returns: str: The response from the LLM bool: True if the response is loaded from buffer, False otherwise """ buffer_path = buffer_path[:200] if not os.path.exists(os.path.dirname(buffer_path)): # Create the buffer directory if it does not exist os.makedirs(os.path.dirname(buffer_path), exist_ok=True) if use_buffer and os.path.exists(buffer_path): # Load from buffer if the response has already been fetched from_buffer = True with open(buffer_path, 'r') as file: response = file.read() else: try: from_buffer = False # Query the LLM model if the response is not found in the buffer chat_completion = openai_client.chat.completions.create( messages=[{"role": "user", "content": content}], model=llm_model, ) response = chat_completion.choices[0].message.content with open(buffer_path, 'w') as file: file.write(response) except Exception as e: if "maximum context length" in str(e): # If the input is too long, truncate and retry print(f"Input too long. Truncating input to OpenAI LLM.") inputs = tokenizer( content, return_tensors="pt", max_length=16385, truncation=True ) content_tr = tokenizer.decode(inputs['input_ids'][0]) if recursion_depth < 1: return query_openai_llm( content_tr, buffer_path, llm_model, use_buffer, recursion_depth + 1 ) print(f"Failed to query OpenAI LLM: {e}") response, from_buffer = None, False return response, from_buffer def query_google_cse(query: str, verbose: bool = True): """ Query the Google Custom Search API for a given product, brand, and model Args: query (str): The query to search Returns: dict: The JSON response from the Google Custom Search API """ # Google Custom Search endpoint cse_url = "https://www.googleapis.com/customsearch/v1" params = {'key': CSE_API_KEY, 'cx': CSE_ID, 'q': query} buffer_path = f"google_responses/{query}"[:200] if os.path.exists(buffer_path): # If the query has already been searched, return the saved result with open(buffer_path, 'r') as file: results = json.load(file) if "error" not in results.keys(): print(f"Google search results loaded from buffer: {query}") return results # Otherwise, make a Google Search API request to fetch results response = requests.get(cse_url, params=params) results = response.json() if response.status_code in [403, 429]: print(f"**** Google API rate limit exceeded ({response.status_code}). ****") elif response.status_code != 200: print(f"**** Google API request failed ({response.status_code}). ****") elif verbose: print(f"Google API request successful for {query}.") try: with open(buffer_path, 'w') as file: json.dump(results, file, indent=4) except: print(f"**** Failed to save the Google API response. ****") return results