L2: How To Use Structured Outputs

# The user class from the slides
from pydantic import BaseModel
from typing import Optional


class User(BaseModel):
    name: str
    age: int
    email: Optional[str] = None

completion = client.beta.chat.completions.parse(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Make up a user."},
    ],
    response_format=User,
)

user = completion.choices[0].message.parsed
user

from pydantic import BaseModel
from typing import List, Optional, Literal
from openai import OpenAI


class Mention(BaseModel):
    # The model chooses the product the mention is about,
    # as well as the social media post's sentiment
    product: Literal["app", "website", "not_applicable"]
    sentiment: Literal["positive", "negative", "neutral"]

    # Model can choose to respond to the user
    needs_response: bool
    response: Optional[str]

    # If a support ticket needs to be opened,
    # the model can write a description for the
    # developers
    support_ticket_description: Optional[str]

# Example mentions
mentions = [
    # About the app
    "@techcorp your app is amazing! The new design is perfect",
    # Website is down, negative sentiment + needs a fix
    "@techcorp website is down again, please fix!",
    # Nothing to respond to
    "hey @techcorp you're so evil",
]

def analyze_mention(mention: str, personality: str = "friendly") -> Mention:
    completion = client.beta.chat.completions.parse(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": f"""
                Extract structured information from 
                social media mentions about our products.

                Provide
                - The product mentioned (website, app, not applicable)
                - The mention sentiment (positive, negative, neutral)
                - Whether to respond (true/false). Don't respond to 
                  inflammatory messages or bait.
                - A customized response to send to the user if we need 
                  to respond.
                - An optional support ticket description to create.

                Your personality is {personality}.
            """,
            },
            {"role": "user", "content": mention},
        ],
        response_format=Mention,
    )
    return completion.choices[0].message.parsed

print("User post:", mentions[0])
processed_mention = analyze_mention(mentions[0])
processed_mention

rude_mention = analyze_mention(mentions[0], personality="rude")
rude_mention.response

mention_json_string = processed_mention.model_dump_json(indent=2)
print(mention_json_string)

class UserPost(BaseModel):
    message: str


def make_post(output_class):
    completion = client.beta.chat.completions.parse(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": """
                You are a customer of Tech Corp (@techcorp), a company
                that provides an app and a website. Create a small 
                microblog-style post to them that sends some kind of 
                feedback, positive or negative.
            """,
            },
            {"role": "user", "content": "Please write a post."},
        ],
        response_format=output_class,
    )
    return completion.choices[0].message.parsed


new_post = make_post(UserPost)
new_post

analyze_mention(new_post.message)

class UserPostWithExtras(BaseModel):
    user_mood: Literal["awful", "bad", "evil"]
    product: Literal["app", "website", "not_applicable"]
    sentiment: Literal["positive", "negative", "neutral"]
    internal_monologue: List[str]
    message: str


new_post = make_post(UserPostWithExtras)
new_post

analyze_mention(new_post.message)

from helper import print_mention

# Loop through posts that tagged us and store the results in a list
rows = []
for mention in mentions:
    # Call the LLM to get a Mention object we can program with
    processed_mention = analyze_mention(mention)

    # Print out some information
    print_mention(processed_mention, mention)

    # Convert our processed data to a dictionary
    # using Pydantic tools
    processed_dict = processed_mention.model_dump()

    # Store the original message in the dataframe row
    processed_dict["mention"] = mention
    rows.append(processed_dict)

    print("")  # Add separator to make it easier to read

import pandas as pd

df = pd.DataFrame(rows)
df