Category AI

pip install -q -U google-generativeai

import pathlib
import textwrap
import csv
import time
import google.generativeai as genai

# THIS PRODUCES LINKED CONVERSATIONAL CHATS

#  !!! CAUTION: Hardcoding API keys is highly discouraged !!!
api_key = "YOUR-API-KEY"
genai.configure(api_key=api_key)
model = genai.GenerativeModel('gemini-pro')
chat = model.start_chat(history=[])
chat

# Rate limiting (adjust sleep time if needed)
RATE_LIMIT_SLEEP_SECONDS = 5  

def process_query(query):
    """Sends a query to Gemini and handles potential rate limiting"""
    try:
        response = chat.send_message(query)
        return response.text
    except genai.exceptions.RateLimitExceededError as e:
        print(f"Rate limit exceeded. Waiting {RATE_LIMIT_SLEEP_SECONDS} seconds...")
        time.sleep(RATE_LIMIT_SLEEP_SECONDS)
        return process_query(query)  # Retry the query

# Load queries from input.csv
input_filepath = pathlib.Path("chat.csv")
with input_filepath.open('r', newline='', encoding='utf-8') as csvfile:
    reader = csv.reader(csvfile)
    queries = list(reader)  

# Process queries and save responses
output_filepath = pathlib.Path("chatoutput.csv")
with output_filepath.open('w', newline='', encoding='utf-8') as csvfile:
    writer = csv.writer(csvfile)
    for query in queries:
        response = process_query(query[0])  # Assume query in the first column
        writer.writerow([query[0], response])
        print(f"Query: {query[0]}\nResponse: {textwrap.shorten(response, width=80)}\n")

pip install -q -U google-generativeai

import pathlib
import textwrap
import csv
import time

import google.generativeai as genai

#  !!! CAUTION: Hardcoding API keys is highly discouraged !!!
api_key = "YOU_API_KEY"
genai.configure(api_key=api_key)
model = genai.GenerativeModel('gemini-pro')

# Rate limiting (adjust sleep time if needed)
RATE_LIMIT_SLEEP_SECONDS = 5  

def process_query(query):
    """Sends a query to Gemini and handles potential rate limiting"""
    try:
        response = model.generate_content(query)
        return response.text
    except genai.exceptions.RateLimitExceededError as e:
        print(f"Rate limit exceeded. Waiting {RATE_LIMIT_SLEEP_SECONDS} seconds...")
        time.sleep(RATE_LIMIT_SLEEP_SECONDS)
        return process_query(query)  # Retry the query

# Load queries from input.csv
input_filepath = pathlib.Path("input.csv")
with input_filepath.open('r', newline='') as csvfile:
    reader = csv.reader(csvfile)
    queries = list(reader)  

# Process queries and save responses
output_filepath = pathlib.Path("output.csv")
with output_filepath.open('w', newline='') as csvfile:
    writer = csv.writer(csvfile)
    for query in queries:
        response = process_query(query[0])  # Assume query in the first column
        writer.writerow([query[0], response])
        print(f"Query: {query[0]}\nResponse: {textwrap.shorten(response, width=80)}\n")

pip install requests
pip install bardapi

import csv
from bardapi import Bard
import time
import os
import re
import requests

# Set up a reusable session
session = requests.Session()
session.headers = {
    "Host": "bard.google.com",
    "X-Same-Domain": "1",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36",
    "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
    "Origin": "https://bard.google.com",
    "Referer": "https://bard.google.com/",
}

# Set cookies for the session
token = 'your_Bard_cookie_very_long_string_of_digits_etc_etc_etc.'  
session.cookies.set("__Secure-1PSID", token)

# Create a Bard instance with the reusable session
bard_instance = Bard(token=token, session=session, timeout=30)

# Open input and output CSV files with error handling
input_file = open('input.csv', 'r', encoding='utf-8', errors='replace')
output_file = open('output.csv', 'w', encoding='utf-8', newline='')

# Create CSV writers
input_csv = csv.reader(input_file)
output_csv = csv.writer(output_file)

# Write headers to output CSV
# output_csv.writerow(['Prompt', 'Response'])

# Set the desired API call rate (2 calls per minute)
calls_per_minute = 1
interval = 60 / calls_per_minute

# Regular expression pattern to match file paths in prompts
file_path_pattern = r"C:/Users/Steve/.*?\.txt"

context = ""

# Iterate through prompts and generate responses
for row in input_csv:
    prompt = row[0]

    # Check if the prompt contains a file path
    file_paths = re.findall(file_path_pattern, prompt)

    if file_paths:
        # Upload and generate a response for each file path found
        for file_path in file_paths:
            # Read the content of the file with the specified encoding and error handling
            with open(file_path, 'r', encoding='utf-8', errors='replace') as file:
                file_content = file.read()

            # Replace the file path with the content in the prompt
            prompt = prompt.replace(file_path, file_content)

    if not context:
        # If context is empty, set the prompt without the previous conversation context
        full_prompt = "Please answer this question: " + prompt
        print("Prompt:", full_prompt)
    else:
        # Otherwise, include the previous conversation context
        full_prompt = (
            "Please consider the previous conversation we have had, which I am recording for you here within the <context> tags: <context> "
            + context
            + " </context> Now, bearing in mind the conversation so far within the context tags which you have already responded to - no need to answer any of those questions again -  please answer this question: "
            + prompt
        )
        print("Prompt:", full_prompt)

    # Send an API request and get a response - print to check.
    response = bard_instance.get_answer(full_prompt)
    response_content = response['content']
    print(response_content)

    # Update context after each loop - depracated in Bard
    # context = response_content

    # Write to file
    output_csv.writerow([response_content])

    # Introduce a delay to limit the rate of API calls
    time.sleep(interval)

# Close files
input_file.close()
output_file.close()

pip install openai

import csv
import openai
import time
# Try importing OpenAIError using the package's full path
from openai import OpenAIError

# Replace 'YOUR_API_KEY' with your actual OpenAI API key
openai.api_key = 'YOUR API KEY'

# PRICING
# gpt-4-1106-preview	$0.01 / 1K tokens	$0.03 / 1K tokens
# gpt-4-1106-vision-preview	$0.01 / 1K tokens	$0.03 / 1K tokens
# gpt-4	$0.03 / 1K tokens	$0.06 / 1K tokens
# gpt-4-32k	$0.06 / 1K tokens	$0.12 / 1K tokens
# gpt-3.5-turbo-1106	$0.0010 / 1K tokens	$0.0020 / 1K tokens
# gpt-3.5-turbo-instruct	$0.0015 / 1K tokens	$0.0020 / 1K tokens

# more here: https://openai.com/pricing


# Cost per token information (per thousand tokens)
input_token_cost_per_thousand = 0.01
output_token_cost_per_thousand = 0.03
###########################################



# Function to interact with ChatGPT and save responses to a CSV file with retries and rate limiting
def process_queries_with_retries_and_rate_limit(input_file, output_file, max_retries=3, retry_delay=5, max_requests_per_minute=60):
    with open(input_file, 'r') as input_csv, open(output_file, 'w', newline='') as output_csv:
        input_reader = csv.reader(input_csv)
        output_writer = csv.writer(output_csv)
        output_writer.writerow(['Input', 'Response', 'Input Tokens', 'Output Tokens', 'Total Cost'])
        
        conversation_state = []  # List to maintain conversation state including system and user messages
        total_cost = 0.0
        
        # Calculate how many seconds to wait between requests to stay under the rate limit
        min_time_between_requests = 60.0 / max_requests_per_minute

        last_request_time = None

        for row in input_reader:
            if not row:
                continue

            input_query = row[0]
            print(f"Processing query: {input_query}")
            
            for retry in range(max_retries):
                try:
                    # Implement rate limiting logic
                    if last_request_time is not None:
                        elapsed_time = time.time() - last_request_time
                        if elapsed_time < min_time_between_requests:
                            time_to_wait = min_time_between_requests - elapsed_time
                            print(f"Rate limited. Waiting for {time_to_wait:.2f} seconds.")
                            time.sleep(time_to_wait)
                    
                    response = openai.ChatCompletion.create(
                        model="gpt-4-1106-preview", ###EDIT HERE TO CHANGE THE LANGUAGE MODEL
                        messages=conversation_state + [
                            {"role": "user", "content": input_query}
                        ]
                    )
                    
                    if 'choices' in response and response['choices']:
                        # Append the latest user and assistant messages to the conversation state
                        conversation_state.append({"role": "user", "content": input_query})
                        conversation_state.append(response['choices'][0]['message'])

                    output_tokens = response['usage']['total_tokens']
                    input_tokens = response['usage']['prompt_tokens']
                    output_cost = (output_tokens / 1000) * output_token_cost_per_thousand
                    total_cost += output_cost

                    output_writer.writerow([
                        input_query,
                        response['choices'][0]['message']['content'],
                        input_tokens,
                        output_tokens,
                        output_cost
                    ])

                    last_request_time = time.time()
                    break
############

  # Catch OpenAI's API exception using the correct reference
                except OpenAIError as e:
                    print(f"OpenAI API Error: {e}")
                    time.sleep(retry_delay)
                    if retry == max_retries - 1:
                        print(f"Max retries reached for query: {input_query}. Skipping.")

                
        print(f"Total cost of the routine: ${total_cost:.2f}")

if __name__ == "__main__":
    input_file_path = "input.csv"
    output_file_path = "output.csv"

    process_queries_with_retries_and_rate_limit(input_file_path, output_file_path)