import openai
import random
from IPython.display import Image, Audio
from src.utils.data.files import *

mp3_voice_sample_english, _ = download_dataset("audio/voice/samples/voice-sample-female-english-01.mp3")
mp3_voice_sample_spanish, _ = download_dataset("audio/voice/samples/voice-sample-female-spanish-01.mp3")

File 'data/datasets/audio/voice/samples/voice-sample-female-english-01.mp3' already exists (use 'overwrite=True' to overwrite it).
File 'data/datasets/audio/voice/samples/voice-sample-female-spanish-01.mp3' already exists (use 'overwrite=True' to overwrite it).

client = openai.OpenAI()

models = client.models.list()
for model in models:
    print(model.id)

gpt-4-0613
gpt-4
gpt-3.5-turbo
gpt-audio
gpt-5-nano
gpt-audio-2025-08-28
gpt-realtime
gpt-realtime-2025-08-28
davinci-002
babbage-002
gpt-3.5-turbo-instruct
gpt-3.5-turbo-instruct-0914
dall-e-3
dall-e-2
gpt-4-1106-preview
gpt-3.5-turbo-1106
tts-1-hd
tts-1-1106
tts-1-hd-1106
text-embedding-3-small
text-embedding-3-large
gpt-4-0125-preview
gpt-4-turbo-preview
gpt-3.5-turbo-0125
gpt-4-turbo
gpt-4-turbo-2024-04-09
gpt-4o
gpt-4o-2024-05-13
gpt-4o-mini-2024-07-18
gpt-4o-mini
gpt-4o-2024-08-06
chatgpt-4o-latest
o1-mini-2024-09-12
o1-mini
gpt-4o-realtime-preview-2024-10-01
gpt-4o-audio-preview-2024-10-01
gpt-4o-audio-preview
gpt-4o-realtime-preview
omni-moderation-latest
omni-moderation-2024-09-26
gpt-4o-realtime-preview-2024-12-17
gpt-4o-audio-preview-2024-12-17
gpt-4o-mini-realtime-preview-2024-12-17
gpt-4o-mini-audio-preview-2024-12-17
o1-2024-12-17
o1
gpt-4o-mini-realtime-preview
gpt-4o-mini-audio-preview
o3-mini
o3-mini-2025-01-31
gpt-4o-2024-11-20
gpt-4o-search-preview-2025-03-11
gpt-4o-search-preview
gpt-4o-mini-search-preview-2025-03-11
gpt-4o-mini-search-preview
gpt-4o-transcribe
gpt-4o-mini-transcribe
o1-pro-2025-03-19
o1-pro
gpt-4o-mini-tts
o3-2025-04-16
o4-mini-2025-04-16
o3
o4-mini
gpt-4.1-2025-04-14
gpt-4.1
gpt-4.1-mini-2025-04-14
gpt-4.1-mini
gpt-4.1-nano-2025-04-14
gpt-4.1-nano
gpt-image-1
gpt-4o-realtime-preview-2025-06-03
gpt-4o-audio-preview-2025-06-03
gpt-5-chat-latest
gpt-5-2025-08-07
gpt-5
gpt-5-mini-2025-08-07
gpt-5-mini
gpt-5-nano-2025-08-07
gpt-3.5-turbo-16k
tts-1
whisper-1
text-embedding-ada-002

model = "gpt-3.5-turbo"
prompt = "What us the distance between the earth and the moon?"

try:
    # Submit prompt to model
    completion = client.chat.completions.create(model=model, messages=[{"role": "user","content": prompt}]
                 )
    # Return reponse (content only)
    print(completion.choices[0].message.content)
except Exception as e:
    print(f"An error occured: {e}")

The average distance between the Earth and the moon is about 238,855 miles (384,400 kilometers). However, this distance can vary due to the elliptical orbit of the moon around the Earth.

model = "gpt-3.5-turbo"
prompt = "What us the distance between the earth and the moon?"

try:
    # Submit prompt to model by call API endpoint
    response = client.responses.create(model=model, input=prompt)
    # Return reponse (content only)
    print(response.output_text)
except Exception as e:
    print(f"An error occured: {e}")

The average distance between the Earth and the Moon is about 384,400 kilometers (238,855 miles). However, this distance can vary due to the Moon's elliptical orbit around the Earth.

model  = "omni-moderation-latest"

#prompt = "Earth and venus are two planets of very similar size" # (harmless prompt)
prompt = "I wish all my enemies would suffer!"
#prompt = "I hate the world. I wish I wouldn't wake up tomorrow."
#prompt = "Let's hunt those bastards down and give them a beating."

try:
    # Submit prompt to model by call API endpoint
    response = client.moderations.create(model=model, input=prompt)
    # Extract main moderation output from JSON object
    moderation_output = response.results[0]
except Exception as e:
    print(f"An error occured: {e}")

print(f"Response flag: {moderation_output.flagged}")

Response flag: True

for category, score in zip(moderation_output.categories, moderation_output.category_scores):
    print(f"{category[0]}: {category[1]} ({score[1]:.4f})")

harassment: True (0.5244)
harassment_threatening: True (0.4626)
hate: False (0.0084)
hate_threatening: False (0.0046)
illicit: False (0.0166)
illicit_violent: False (0.0002)
self_harm: False (0.0005)
self_harm_instructions: False (0.0002)
self_harm_intent: False (0.0003)
sexual: False (0.0001)
sexual_minors: False (0.0000)
violence: True (0.4232)
violence_graphic: False (0.0016)
harassment/threatening: True (0.4626)
hate/threatening: False (0.0046)
illicit/violent: False (0.0002)
self-harm/intent: False (0.0003)
self-harm/instructions: False (0.0002)
self-harm: False (0.0005)
sexual/minors: False (0.0000)
violence/graphic: False (0.0016)

model  = "text-embedding-3-small"
prompt = "I wish all my enemies would suffer!"

try:
    # Generate embedding vector by calling endpoint
    response = client.embeddings.create(model=model, input=prompt)
    # Extract embedding vector from response object
    embedding_vector = response.data[0].embedding
    # Print the length of the embedding vector and the first 3 elements as examples
    print(f"Length of embedding vector: {len(embedding_vector)}")
    print(f"First 3 vector elements:    {embedding_vector[:3]}")
except Exception as e:
    print(f"An error occured: {e}")

Length of embedding vector: 1536
First 3 vector elements:    [0.0013678136747330427, -0.027956858277320862, 0.017621532082557678]

Audio(mp3_voice_sample_english)

model =  "whisper-1"

try:
    # Read mp3 file as binary file
    audio_file = open(mp3_voice_sample_english, "rb")
    # Generate transcript by calling the endpoint
    response = client.audio.transcriptions.create(model=model, file=audio_file)
    # Show generated transcription
    print(f"Transcription:\n{response.text}")
except Exception as e:
    print(f"An error occured: {e}")

Transcription:
The invention of movable metal letters in the middle of the 15th century may justly be considered as the invention of the art of printing.

Audio(mp3_voice_sample_spanish)

model =  "whisper-1"

try:
    # Read mp3 file as binary file
    audio_file = open(mp3_voice_sample_spanish, "rb")
    # Generate transcript by calling the endpoint
    response = client.audio.translations.create(model=model, file=audio_file)
    # Show generated translation
    print(f"Translation:\n{response.text}")
except Exception as e:
    print(f"An error occured: {e}")

Translation:
Now, he said, the door below is well closed. With keys and locks, Tobias replied. The boards are solid, lined with iron, and the posts, the posts too.

model =  "gpt-image-1"
prompt = "A snowman with an colorful drink standing on a beach."

try:
    # Generate image by calling the endpoint
    response = client.images.generate(model=model, prompt=prompt, size="1024x1024")
    # Print URL pointing to generate image
    print("Generated image URL:", response.data[0].url)
except Exception as e:
    print(f"An error occured: {e}")

An error occured: Error code: 403 - {'error': {'message': 'Your organization must be verified to use the model `gpt-image-1`. Please go to: https://platform.openai.com/settings/organization/general and click on Verify Organization. If you just verified, it can take up to 15 minutes for access to propagate.', 'type': 'invalid_request_error', 'param': None, 'code': None}}

model  = "gpt-3.5-turbo"
prompt = "What us the distance between the earth and the moon?"

try:
    # Generate model response by calling the endpoint
    response = client.responses.create(model=model, input=prompt)
    # Print complete JSON object of response
    print(response.model_dump_json(indent=2))
except Exception as e:
    print(f"An error occured: {e}")

{
  "id": "resp_68bbf28c88f48193a41c12f3cad3dffc0b65059e0aec4874",
  "created_at": 1757147788.0,
  "error": null,
  "incomplete_details": null,
  "instructions": null,
  "metadata": {},
  "model": "gpt-3.5-turbo-0125",
  "object": "response",
  "output": [
    {
      "id": "msg_68bbf28cf9808193aeb04fd45f4eecdc0b65059e0aec4874",
      "content": [
        {
          "annotations": [],
          "text": "The average distance between the Earth and the Moon is about 238,855 miles (384,400 kilometers). However, this distance can vary due to the elliptical orbit of the Moon around the Earth.",
          "type": "output_text",
          "logprobs": []
        }
      ],
      "role": "assistant",
      "status": "completed",
      "type": "message"
    }
  ],
  "parallel_tool_calls": true,
  "temperature": 1.0,
  "tool_choice": "auto",
  "tools": [],
  "top_p": 1.0,
  "background": false,
  "max_output_tokens": null,
  "previous_response_id": null,
  "reasoning": {
    "effort": null,
    "generate_summary": null,
    "summary": null
  },
  "service_tier": "default",
  "status": "completed",
  "text": {
    "format": {
      "type": "text"
    },
    "verbosity": "medium"
  },
  "truncation": "disabled",
  "usage": {
    "input_tokens": 18,
    "input_tokens_details": {
      "cached_tokens": 0
    },
    "output_tokens": 42,
    "output_tokens_details": {
      "reasoning_tokens": 0
    },
    "total_tokens": 60
  },
  "user": null,
  "max_tool_calls": null,
  "prompt_cache_key": null,
  "safety_identifier": null,
  "store": true,
  "top_logprobs": 0
}

model  = "gpt-3.5-turbo"
prompt = "Explain what photosynthesis is."
instructions = "Write all reponses in Internet slang."

try:
    # Create a response with high-level instructions
    response = client.responses.create(model=model, instructions=instructions, input=prompt)
    # Print the model's output
    print(response.output_text)
except Exception as e:
    print(f"An error occured: {e}")

Photosynthesis iz da process by which green plantz, algae, Nd some bacterias convert light energy into chemical energy in da form of glucose. It involves de use of carbon dioxide, water, nd sunlight to produce oxygen nd glucose. Itz basically how plantz make their own food nd release oxygen into da atmosphere. #ScienceIsLit

model   = "gpt-3.5-turbo"
prompt1 = "What is the largest planet in the solar system?"
prompt2 = "And the smallest?"

try:
    # Step 1: Initial prompt
    response1 = client.responses.create(model=model, input=prompt1)
    print(f"Step 1 response:\n{response1.output_text}\n")
    
    # Step 2: Follow-up prompt using previous_response_id to continue the conversation
    response2 = client.responses.create(model=model, input=prompt2, previous_response_id=response1.id)
    print(f"Step 2 response:\n{response2.output_text}")
    
except Exception as e:
    print(f"An error occured: {e}")

Step 1 response:
Jupiter is the largest planet in our solar system.

Step 2 response:
Mercury is the smallest planet in the solar system.

model  = "o4-mini"
prompt = "What is heavier, 1 kg of lead or 1 kg of wood?"

try:
    # Low reasoning effort
    response_low = client.responses.create(model=model, input=prompt, reasoning={"effort": "low"})
    print(f"Low effort response:\n{response_low.output_text}\n")
    
    # Medium reasoning effort
    response_medium = client.responses.create(model=model, input=prompt, reasoning={"effort": "medium"})
    print(f"Medium effort response:\n{response_medium.output_text}\n")
    
    # High reasoning effort
    response_high = client.responses.create(model=model, input=prompt, reasoning={"effort": "high"})
    print("High effort response:\n", response_high.output_text)
except Exception as e:
    print(f"An error occured: {e}")

Low effort response:
Both have the same mass—1 kg—so in that sense neither is heavier.  

(If you put each on a scale in air, the lead will register very slightly heavier, because the bulkier wood displaces more air and so experiences a larger buoyant lift. But by definition of mass, 1 kg of lead = 1 kg of wood.)

Medium effort response:
They weigh the same: 1 kg of lead is 1 kg of wood. 

(If you put them on a scale in air, the wood will actually register a tiny bit less—because it displaces more air and so experiences a slightly larger buoyant force—but their true masses are identical.)

High effort response:
 Neither one is heavier—1 kg of lead and 1 kg of wood both have the same mass (1 kg). The only difference is density: the wood takes up much more volume than the lead. (In air, the wood’s greater volume displaces more air and so experiences a slightly larger buoyant force, which can make it register a tiny bit “lighter” on a scale—but their true masses are identical.)

image_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/7/77/Hazel_the_German_Shepherd_by_a_river.png/330px-Hazel_the_German_Shepherd_by_a_river.png"

Image(url=image_url)

# Define prompt incl. the link to the image to be analyzed
prompt = [
    {
       "role": "user",
        "content": [
            {"type": "input_text", "text": "Please describe this image in 1-2 sentences."},
            {"type": "input_image", "image_url": image_url}
        ]
    }
]

model = "o4-mini"

try:
    # Analyze image by calling the endpoint
    response = client.responses.create(model=model, input=prompt)  
    # Print the generates response text
    print(response.output_text)
except Exception as e:
    print(f"An error occured: {e}")

A tan German Shepherd–type dog stands alert on a rocky bank beside a calm creek, its ears perked as it gazes off-camera. Lush green trees and shrubs line the water’s edge, with sunlight filtering through the foliage and reflecting on the stream.

model  = "gpt-4o-mini"
prompt = "What is the current temperature in Singapore?"

try:
    response = client.responses.create(model=model, input=prompt, tools=[{"type": "web_search"}])

    print(response.output_text)
except Exception as e:
    print(f"An error occured: {e}")

As of 4:36 PM local time in Singapore, the current temperature is 29°C (84°F) with partly cloudy skies.

## Weather for Singapore, Singapore:
Current Conditions: Clouds and sun, 91°F (33°C)

Daily Forecast:
* Saturday, September 6: Low: 80°F (26°C), High: 91°F (33°C), Description: Some sun, then turning cloudy
* Sunday, September 7: Low: 78°F (26°C), High: 87°F (30°C), Description: Cloudy with a thunderstorm in spots
* Monday, September 8: Low: 77°F (25°C), High: 86°F (30°C), Description: Cloudy with a thunderstorm in spots
* Tuesday, September 9: Low: 77°F (25°C), High: 85°F (30°C), Description: Remaining cloudy with a couple of thunderstorms
* Wednesday, September 10: Low: 78°F (26°C), High: 89°F (31°C), Description: Cloudy; a morning thunderstorm in parts of the area followed by a drenching thunderstorm in the afternoon
* Thursday, September 11: Low: 79°F (26°C), High: 87°F (30°C), Description: Remaining cloudy with a couple of thunderstorms, especially early in the day
* Friday, September 12: Low: 79°F (26°C), High: 88°F (31°C), Description: Mostly cloudy with a thunderstorm in spots

def get_crowd_level(location):
    # The proper logic to retreive the crowd level would be here
    return {"location": location, "crowd_level": random.random()}

tools = [
    {
        "type": "function",
        "name": "get_crowd_level",
        "description": "Get the current crowd level at a given location from 0 (low) to 1 (high)",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The public space (shopping mall, museum, train station, parks, tourist spots, etc.)",
                },
            },
            "required": ["location"],
        },
    }
]

model = "gpt-4o-mini"

conversation = [{"role": "user", "content": "How many people are currently in VivoCity?"}]
#conversation = [{"role": "user", "content": "How far is the VivoCity mall from Changi Airport?"}]

try:
    response = client.responses.create(
        model=model,
        input=conversation,
        tools=tools,
        tool_choice="auto"
    )
except Exception as e:
    print(f"An error occured: {e}")

# Check if the model wants to call a function
if response.output and response.output[0].type == "function_call":
    tool_call = response.output[0]
    
    # Check which function the model wants to call
    if tool_call.name == "get_crowd_level":
        # Get extracted arguments and convert to JSON obect
        args = json.loads(tool_call.arguments)
        print(f"Call {tool_call.name} with arguments {args}\n")
        # Call function with extract parameters to get result
        data = get_crowd_level(**args)
        # Add the function call and its result to the conversation
        conversation.append(tool_call)
        conversation.append({
            "type": "function_call_output",
            "call_id": tool_call.call_id,
            "output": json.dumps(data)
        })

    try:
        # Get the final response with the function results incorporated
        final_response = client.responses.create(model=model, input=conversation, tools=tools)
        # Print the final reponse text
        print(f"Final response:\n{final_response.output_text}")
    except Exception as e:
        print(f"An error occured: {e}")
        
else:
    # Just print the response text of not function call was involved
    print(f"Final response:\n{response.output_text}")

Call get_crowd_level with arguments {'location': 'VivoCity'}

Final response:
Currently, the crowd level at VivoCity is approximately 15.6%, indicating a low number of people.

Model Family	Naming Pattern	Examples	Typical Use Cases	Pricing Focus
GPT (Text & Chat)	`gpt-<version>[-variant]`	`gpt-4o`, `gpt-4o-mini`, `gpt-3.5-turbo`	Natural language generation, chatbots, reasoning, coding assistance	Mini/3.5 = cheaper, 4/4o = more powerful
Embeddings	`text-embedding-<generation>-<size>`	`text-embedding-3-small`, `text-embedding-3-large`	Semantic search, clustering, recommendations, similarity comparisons	Small = cost-efficient, Large = higher accuracy
Images	`gpt-image-<version>`	`gpt-image-1`	Text-to-image generation, creative design, visual prototyping	Pay-per-image, higher resolution costs more
Audio	`whisper-<version>`	`whisper-1`	Speech-to-text transcription, audio translation	Flat pricing per minute of audio
Moderation	`<family>-moderation-<version>`	`omni-moderation-latest`, `omni-moderation-dev`	Content safety filtering, compliance, harmful content detection	Free of charge

Feature	`chat.completions.create`	`responses.create`
Context Management	Client-managed message history	Server-managed via `previous_response_id`
Input Format	Array of `messages` (roles + content)	Simple `input` (text or structured list)
Response Format	`choices` array	Structured `output` with semantic events and `output_text`
Tooling / Agent Capabilities	Manual integration	Native support for web search, file search, computer use
Statefulness	Stateless, conversation managed client-side	Stateful, maintained by service
Ease of advanced flows	Requires manual orchestration	Simplified orchestration with built-in support
Status / Future Role	Long-standing standard; remains supported	The new, extensible, forward-looking default for agents

Argument	Purpose
`model` (required)	Chooses which language model to use (e.g., `gpt-3.5-turbo`)
`input` (required)	Main prompt content (text or structured list)
`previous_response_id`	Enables context retention from prior responses
`temperature`	Adjusts randomness and creativity of responses
`top_p`	Alternative sampling parameter to control diversity
`max_output_tokens`	Caps the length of generated output
`stream`	Enables streaming of response data
`tools`	Activates built-in or custom tools like search or function calling
`reasoning`	Controls internal reasoning style or effort
`truncation`	Manages input truncation behavior automatically
`instructions`	Higher-level instructions embedded in the prompt
`metadata`	Attach custom metadata for tracking purposes
`user`	Identifies the end user for logging or policy use

Tool Name	Description
Web Search	Retrieves up-to-date information from the internet.
Function Calling	Give models access to new functionality and data they can use to follow instructions and respond to prompts.
File Search	Searches and retrieves information from uploaded files.
Computer Use	Executes tasks on a computer, such as opening applications or interacting with the file system.
Code Interpreter	Executes code in a sandboxed environment for computations and data analysis.
Image Generation	Generates images from text prompts.
Hosted MCP Tools	Integrates with external Model Context Protocol (MCP) servers to access custom tools.

Working with the OpenAI API — An Introduction¶

Setting up the Notebook¶

Make Required Imports¶

Download Required Data¶

Preliminaries¶

Authentication & API Keys¶

Creating an API Key¶

Storing your API Key¶

Windows¶

MacOS & Linux¶

Creating an Client¶

API Endpoints — Overview¶

Chat / Conversation¶

Responses¶

Moderation¶

Embeddings¶

Audio / Speech¶

Transcriptions¶

Translations¶

Images¶

Files & Fine-tuning¶

Legacy Endpoints¶

Text Completion¶

Edits¶

Responses API — Practical Examples¶

Input Arguments¶

Basic Text Generation¶

Text Generation with Instructions¶

Chaining Responses¶

Reasoning Levels¶

Analyzing Images¶

Tools¶

Web Search¶

Function Calling¶

Summary¶