OpenAI Models

from scrapegraphai.models import OpenAIImageToText

class OpenAIImageToText(ChatOpenAI):
    """
    A wrapper for the OpenAI vision models that converts images to text descriptions.
    
    Args:
        llm_config (dict): Configuration parameters for the language model.
    """

OpenAIImageToText(llm_config: dict)

run(image_url: str) -> str

from scrapegraphai.models import OpenAIImageToText

# Initialize the model
itt_model = OpenAIImageToText({
    "model": "gpt-4-vision-preview",
    "api_key": "your-openai-api-key",
    "temperature": 0.5
})

# Analyze an image
image_url = "https://example.com/product-image.jpg"
description = itt_model.run(image_url)

print(description)
# Output: "This image showing a red bicycle with a basket..."

from scrapegraphai.graphs import OmniScraperGraph

graph_config = {
    "llm": {
        "model": "gpt-4o",
        "api_key": "your-openai-api-key"
    },
    "max_images": 10  # Process up to 10 images
}

omni_scraper = OmniScraperGraph(
    prompt="List all products and describe their images",
    source="https://example.com/shop",
    config=graph_config
)

result = omni_scraper.run()

from scrapegraphai.models import OpenAIImageToText
from langchain_core.messages import HumanMessage

class CustomImageAnalyzer(OpenAIImageToText):
    def analyze_product(self, image_url: str) -> str:
        """Analyze product features in an image."""
        message = HumanMessage(
            content=[
                {
                    "type": "text",
                    "text": "Describe this product's features, colors, and condition in detail."
                },
                {
                    "type": "image_url",
                    "image_url": {"url": image_url, "detail": "high"}
                }
            ]
        )
        return self.invoke([message]).content

# Usage
analyzer = CustomImageAnalyzer({
    "model": "gpt-4o",
    "api_key": "your-api-key"
})

product_details = analyzer.analyze_product("https://example.com/product.jpg")

from scrapegraphai.models import OpenAITextToSpeech

class OpenAITextToSpeech:
    """
    Implements text-to-speech using the OpenAI API.
    
    Attributes:
        client (OpenAI): The OpenAI client instance
        model (str): The TTS model to use
        voice (str): The voice model for generating speech
    
    Args:
        tts_config (dict): Configuration parameters for the TTS model
    """

OpenAITextToSpeech(tts_config: dict)

run(text: str) -> bytes

from scrapegraphai.models import OpenAITextToSpeech

# Initialize the TTS model
tts = OpenAITextToSpeech({
    "api_key": "your-openai-api-key",
    "model": "tts-1-hd",
    "voice": "nova"
})

# Generate speech
text = "Welcome to ScrapeGraphAI. This library makes web scraping intelligent."
audio_bytes = tts.run(text)

# Save to file
with open("output.mp3", "wb") as f:
    f.write(audio_bytes)

from scrapegraphai.graphs import SpeechGraph

graph_config = {
    "llm": {
        "model": "gpt-3.5-turbo",
        "api_key": "your-openai-api-key"
    },
    "tts_model": {
        "api_key": "your-openai-api-key",
        "model": "tts-1",
        "voice": "alloy"
    },
    "output_path": "attractions.mp3"
}

speech_graph = SpeechGraph(
    prompt="List the main attractions in Chioggia and create an audio summary",
    source="https://en.wikipedia.org/wiki/Chioggia",
    config=graph_config
)

# Runs the scraping pipeline and saves audio
result = speech_graph.run()
print(result)  # Text answer
# Audio saved to attractions.mp3

from scrapegraphai.models import OpenAITextToSpeech

text = "This is a sample of the voice."
voices = ["alloy", "echo", "fable", "onyx", "nova", "shimmer"]

for voice in voices:
    tts = OpenAITextToSpeech({
        "api_key": "your-api-key",
        "voice": voice
    })
    
    audio = tts.run(text)
    
    with open(f"sample_{voice}.mp3", "wb") as f:
        f.write(audio)
    
    print(f"Generated sample_{voice}.mp3")

from scrapegraphai.models import OpenAITextToSpeech
import re

def text_to_speech_long(text: str, output_file: str, chunk_size: int = 4000):
    """Convert long text to speech by splitting into chunks."""
    tts = OpenAITextToSpeech({
        "api_key": "your-api-key",
        "model": "tts-1"
    })
    
    # Split on sentence boundaries
    sentences = re.split(r'(?<=[.!?])\s+', text)
    
    chunks = []
    current_chunk = ""
    
    for sentence in sentences:
        if len(current_chunk) + len(sentence) < chunk_size:
            current_chunk += sentence + " "
        else:
            chunks.append(current_chunk.strip())
            current_chunk = sentence + " "
    
    if current_chunk:
        chunks.append(current_chunk.strip())
    
    # Generate audio for each chunk
    all_audio = b""
    for i, chunk in enumerate(chunks):
        print(f"Processing chunk {i+1}/{len(chunks)}...")
        audio = tts.run(chunk)
        all_audio += audio
    
    # Save combined audio
    with open(output_file, "wb") as f:
        f.write(all_audio)
    
    print(f"Saved {output_file}")

# Usage
long_text = """Your very long text here..."""
text_to_speech_long(long_text, "long_output.mp3")

from langchain_core.messages import HumanMessage

message = HumanMessage(
    content=[
        {"type": "text", "text": "What is this image showing"},
        {
            "type": "image_url",
            "image_url": {
                "url": image_url,
                "detail": "auto"  # Can be 'low', 'high', or 'auto'
            }
        }
    ]
)

result = self.invoke([message]).content

from openai import OpenAI

client = OpenAI(api_key=api_key, base_url=base_url)
response = client.audio.speech.create(
    model=model,
    voice=voice,
    input=text
)

return response.content  # Raw MP3 bytes

from scrapegraphai.models import OpenAIImageToText, OpenAITextToSpeech
from openai import OpenAIError

# Image-to-text with error handling
try:
    itt = OpenAIImageToText({
        "model": "gpt-4-vision-preview",
        "api_key": "your-key"
    })
    description = itt.run("https://example.com/image.jpg")
except OpenAIError as e:
    print(f"OpenAI API error: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")

# Text-to-speech with error handling
try:
    tts = OpenAITextToSpeech({
        "api_key": "your-key",
        "voice": "nova"
    })
    audio = tts.run("Hello world")
    
    with open("output.mp3", "wb") as f:
        f.write(audio)
except OpenAIError as e:
    print(f"OpenAI API error: {e}")
except IOError as e:
    print(f"File write error: {e}")