メモ: GPT-5の新しいパラメータとツール

!pip install --quiet --upgrade openai pandas && \
echo -n "openai " && pip show openai | grep '^Version:' | cut -d' ' -f2 && \
echo -n "pandas " && pip show pandas | grep '^Version:' | cut -d' ' -f2

openai 1.99.4
pandas 2.3.1

from google.colab import userdata
import os

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from openai import OpenAI
import pandas as pd
from IPython.display import display

client = OpenAI()

question = "少年と彼の初めてのペットの犬について詩を書いて。"

data = []

for verbosity in ["low", "medium", "high"]:
    response = client.responses.create(
        model="gpt-5-mini",
        input=question,
        text={"verbosity": verbosity}
    )

    # テキストを抽出
    # 注: ドキュメントどおりだとエラーになるので修正
    #     （response.output_textを使うほうがいいと思う）
    output_text = ""
    for item in response.output:
        if hasattr(item, "content") and item.content is not None:
            for content in item.content:
                if hasattr(content, "text") and content.text is not None:
                    for text in content.text:
                        output_text += text

    usage = response.usage
    data.append({
        "verbosity": verbosity,
        "サンプル出力": output_text,
        "出力トークン": usage.output_tokens
    })

# データフレームを作成
df = pd.DataFrame(data)

# ヘッダーを中央寄せして表示
pd.set_option('display.max_colwidth', None)
styled_df = df.style.set_table_styles(
    [
        {'selector': 'th', 'props': [('text-align', 'center')]},  # 絡むヘッダを中央寄せ
        {'selector': 'td', 'props': [('text-align', 'left')]}     # テーブルセルを左寄せ
    ]
)

display(styled_df)

from openai import OpenAI

client = OpenAI()

prompt = "100万個のランダムな数字のリストをソートするPythonプログラムを生成して。"

def ask_with_verbosity(verbosity: str, question: str):
    response = client.responses.create(
        model="gpt-5-mini",
        input=question,
        text={
            "verbosity": verbosity
        }
    )

    # アシスタントのテキスト生成を抽出
    output_text = ""
    for item in response.output:
        if hasattr(item, "content") and item.content is not None:
            for content in item.content:
                if hasattr(content, "text") and content.text is not None:
                    for text in content.text:
                        output_text += text

    # トークン使用状況の詳細
    usage = response.usage

    print("--------------------------------")
    print(f"Verbosity: {verbosity}")
    print("Output:")
    print(output_text)
    print("Tokens => input: {} | output: {}".format(
        usage.input_tokens, usage.output_tokens
    ))

# 使い方:
ask_with_verbosity("low", prompt)

ask_with_verbosity("low", prompt)

--------------------------------
Verbosity: low
Output:
以下は100万個のランダムな数を生成してソートする簡単なPythonプログラムです。

```python
import random
import time

N = 1_000_000
random.seed(0)

# ランダムな浮動小数点数を生成
data = [random.random() for _ in range(N)]

# ソート（インプレース）
start = time.perf_counter()
data.sort()
elapsed = time.perf_counter() - start

print(f"Sorted {N} numbers in {elapsed:.3f} seconds")
print("First 10:", data[:10])
```

実行: python3 your_script.py
Tokens => input: 30 | output: 594

ask_with_verbosity("medium", prompt)

--------------------------------
Verbosity: medium
Output:
以下は、100万個のランダムな数を生成してソートするシンプルな Python プログラム例です（組み込みの list.sort() を使用）。実行時間も計測します。

1) 純粋な Python（random + list.sort）
```python
import random
import time

def main():
    N = 1_000_000
    random.seed(42)  # 再現性が欲しい場合に設定
    print("生成中...")
    arr = [random.random() for _ in range(N)]  # 0.0〜1.0 の浮動小数点
    print("ソート開始...")
    t0 = time.perf_counter()
    arr.sort()  # Timsort（O(n log n)）
    t1 = time.perf_counter()
    print(f"ソート完了: {t1 - t0:.4f} 秒")
    print("最小10:", arr[:10])
    print("最大10:", arr[-10:])

if __name__ == "__main__":
    main()
```

2) より高速にしたい場合（NumPy を使うとメモリと速度の点で有利になることがあります）
```python
import numpy as np
import time

def main():
    N = 1_000_000
    rng = np.random.default_rng(42)
    print("生成中...")
    arr = rng.random(N)  # NumPy 配列（float64）
    print("ソート開始...")
    t0 = time.perf_counter()
    arr.sort()  # NumPy の in-place ソート（Quicksort など）
    t1 = time.perf_counter()
    print(f"ソート完了: {t1 - t0:.4f} 秒")
    print("最小10:", arr[:10])
    print("最大10:", arr[-10:])

if __name__ == "__main__":
    main()
```

注意点：
- Python の float はオブジェクトなので list にするとオーバーヘッドが大きくなります（1,000,000 要素でも数十MB程度消費）。NumPy の場合はメモリ効率が良いです。
- 真に巨大なデータ（メモリに乗らない場合）は外部ソート（チャンクに分けて部分ソート→マージ）やデータベース／分散処理を検討してください。
Tokens => input: 30 | output: 1241

ask_with_verbosity("high", prompt)

--------------------------------
Verbosity: high
Output:
以下は「100万個のランダムな数字のリストをソートするPythonプログラム」です。まずは最もシンプルで実用的な方法（組み込みの list.sort() を使う）を示します。その後、時間計測や NumPy を使った高速生成・ソート、さらにデータがメモリに乗らない場合の外部ソート（外部マージソート）のサンプルも説明します。

注意：
- Pythonの list.sort() は Timsort（安定で高速）で、1,000,000 個程度の要素なら普通にメモリに収まります（目安：Python の int は各オブジェクトで約28 bytes、ポインタが 8 bytes/要素のオーバーヘッド等あり、合計数十MB程度）。環境によって時間は変わります（数百ミリ秒〜数秒程度が多い）。
- 大きなデータ（メモリに乗らない）場合は後半の外部ソートの方法を使ってください。

1) シンプルなプログラム（組み込み sort）
以下をファイル（例: sort_one_million.py）として保存して実行してください。

# sort_one_million.py
import random
import time

def main():
    N = 1_000_000  # 100万
    seed = 12345   # 再現性が欲しい場合はシードを設定（任意）
    random.seed(seed)

    print(f"Generating {N:,} random floats...")
    t0 = time.perf_counter()
    data = [random.random() for _ in range(N)]  # 0.0 <= x < 1.0 の float
    t1 = time.perf_counter()
    print(f"Generation done in {t1 - t0:.3f} s")

    print("Sorting ...")
    t0 = time.perf_counter()
    data.sort()  # インプレースでソート（Timsort）
    t1 = time.perf_counter()
    print(f"Sorted {N:,} items in {t1 - t0:.3f} s")

    # 簡単な検証（O(N)）
    ok = all(data[i] <= data[i+1] for i in range(len(data)-1))
    print("Verified sorted:" , ok)
    print("Min:", data[0], "Max:", data[-1])

if __name__ == "__main__":
    main()

実行例:
$ python3 sort_one_million.py
Generating 1,000,000 random floats...
Generation done in 0.30 s
Sorting ...
Sorted 1,000,000 items in 0.80 s
Verified sorted: True
Min: 1.617... Max: 0.999...

（時間は環境に依存します）

2) NumPy を使う場合（大量の乱数生成で速く、ソートも高速）
NumPy がインストールされていると、大量の乱数生成は速く、配列ベースのソート（numpy.sort）はメモリ効率が良いことがあります。NumPy をインストールしていれば次のようにできます。

# sort_with_numpy.py
import time
try:
    import numpy as np
except ImportError:
    raise SystemExit("NumPy が必要です: pip install numpy")

def main():
    N = 1_000_000
    print(f"Generating {N:,} random floats with NumPy...")
    t0 = time.perf_counter()
    a = np.random.random(N)  # ndarray of floats
    t1 = time.perf_counter()
    print(f"Generation done in {t1 - t0:.3f} s")

    print("Sorting with numpy.sort() ...")
    t0 = time.perf_counter()
    b = np.sort(a)  # returns sorted copy
    t1 = time.perf_counter()
    print(f"Sorted {N:,} items in {t1 - t0:.3f} s")

    # 簡単な検証
    print("Min:", b[0], "Max:", b[-1])
    print("Is sorted (sample check):", (b[:-1] <= b[1:]).all())

if __name__ == "__main__":
    main()

3) メモリに乗らない場合：外部マージソート（chunkごとにソートしてマージ）
もしデータが非常に大きくメモリに乗らない場合は、次のような外部ソート戦略が有効です：
- 元データをチャンク（例えば 100k 行ずつ）に分ける。
- 各チャンクをメモリ内でソートして一時ファイルに書く。
- 最後に heapq.merge を使って複数ソート済みファイルをマージ（ストリームマージ）する。

簡易サンプル（整数をテキスト行に保存する想定）：

# external_sort_example.py
import random
import os
import tempfile
import heapq

def write_sorted_chunk(numbers, dirpath):
    numbers.sort()
    fd, path = tempfile.mkstemp(dir=dirpath, text=True)
    os.close(fd)
    with open(path, "w") as f:
        for n in numbers:
            f.write(f"{n}\n")
    return path

def iter_file_numbers(path):
    with open(path) as f:
        for line in f:
            yield int(line.strip())

def external_sort_generate_and_sort(total=10**6, chunk_size=100_000):
    # 例: total が非常に大きい場合にチャンクごとにソートして一時ファイルへ
    tmpdir = tempfile.mkdtemp()
    chunk_paths = []
    remaining = total
    while remaining > 0:
        size = min(chunk_size, remaining)
        chunk = [random.randint(0, 10**9) for _ in range(size)]
        path = write_sorted_chunk(chunk, tmpdir)
        chunk_paths.append(path)
        remaining -= size
        print(f"Written chunk {path}, {size} items")
    # マージして最終出力（ここでは stdout に書くかわりにファイルに）
    out_path = os.path.join(tmpdir, "merged.txt")
    with open(out_path, "w") as out_f:
        iterators = [iter_file_numbers(p) for p in chunk_paths]
        for val in heapq.merge(*iterators):
            out_f.write(f"{val}\n")
    print("Merged into", out_path)
    # 後片付け（必要であれば）
    # for p in chunk_paths: os.remove(p)
    # os.remove(out_path)
    # os.rmdir(tmpdir)

if __name__ == "__main__":
    external_sort_generate_and_sort(total=200_000, chunk_size=50_000)
    # 上の total/ chunk_size を変更してテストしてください。

外部ソートはディスクI/Oが支配的なので、チャンクサイズの調整や一時ファイルの配置（SSDが速い）などでパフォーマンスが変わります。

補足とアドバイス
- list.sort() はほとんどの場合最速で簡単なので、まずはこれを使うのが良いです。
- 大量生成がボトルネックなら NumPy を検討してください（生成が圧倒的に速い）。
- データが本当に大きくメモリに乗らない場合は外部ソート／データベース／分散処理（Spark 等）を検討してください。
- ソートの時間計測は time.perf_counter() を使うと良いです。
- メモリ使用量に敏感なら、整数でも Python の int はオーバーヘッドが大きいので、numpy の int32/float32 などを使うとメモリ効率が上がります。

必要なら、用途に合わせて（整数か浮動小数点か、メモリに収まるか否か、速度重視かメモリ重視か）サンプルを調整してファイルを作成します。どの形式（int/float）、どの範囲／分布の乱数を使いたいか、また実行環境（メモリ量、NumPyの有無）を教えてください。最適化したスクリプトを用意します。
Tokens => input: 30 | output: 2959

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5-mini",
    input="code_exec ツールを使用して、'strawberry' に含まれる 'r' の文字数に等しい半径を持つ円の面積を計算して。",
    text={"format": {"type": "text"}},
    tools=[
        {
            "type": "custom",
            "name": "code_exec",
            "description": "任意のPythonコードを実行する",
        }
    ]
)
print(response.output)

[
    ResponseReasoningItem(
        id='rs_689616fc19fc8194b56d1ef99d297018088abb66addf7573',
        summary=[],
        type='reasoning',
        content=None,
        encrypted_content=None,
        status=None
    ),
    ResponseCustomToolCall(
        call_id='call_vQTTLJN8XC46qZrK4LRSZmMD',
        input="# Python code to count 'r' in 'strawberry' and compute area of circle with that radius\nimport math\ns = 'strawberry'\nr = s.count('r')\narea = math.pi * (r ** 2)\nr, area\n",
        name='code_exec',
        type='custom_tool_call',
        id='ctc_689616fea70c8194905f39220d53043c088abb66addf7573',
        status='completed'
    )
]

from openai import OpenAI
from typing import List, Optional

MODEL_NAME = "gpt-5"

# モデルの実行ごとに渡されるツール
# これらのツールを一度だけ定義すれば、設定を一箇所に集中させることができる
TOOLS = [
    {
        "type": "custom",
        "name": "code_exec_python",
        "description": "Pythonコードを実行する。",
    },
    {
        "type": "custom",
        "name": "code_exec_cpp",
        "description": "C++コードを実行する。",
    },
    {
        "type": "custom",
        "name": "code_exec_java",
        "description": "Javaコードを実行する。",
    },
]

client = OpenAI()

def create_response(
    input_messages: List[dict],
    previous_response_id: Optional[str] = None,
):
    """ ``client.responses.create``のラッパー関数。

    Parameters
    ----------
    input_messages: List[dict]
        モデルに与えられる実行中の会話履歴。
    previous_response_id: str | None
        *前回*の呼び出し時の ``response.id`` を渡して、モデルが会話のスレッドを保持できるようにする。
        最初のリクエストでは省略可能。
    """
    kwargs = {
        "model": MODEL_NAME,
        "input": input_messages,
        "text": {"format": {"type": "text"}},
        "tools": TOOLS,
    }
    if previous_response_id:
        kwargs["previous_response_id"] = previous_response_id

    return client.responses.create(**kwargs)

# 再帰
def run_conversation(
    input_messages: List[dict],
    previous_response_id: Optional[str] = None,
):

    response = create_response(input_messages, previous_response_id)

    # ``response.output`` は、要素 0 がモデルメッセージとなっているリストであることが期待される。
    # 要素 1（存在する場合）はツール呼び出しを表す。モデルがツール呼び出しを完了すると、その要素は省略される。
    tool_call = response.output[1] if len(response.output) > 1 else None

    if tool_call and tool_call.type == "custom_tool_call":
        print("--- ツール名 ---")
        print(tool_call.name)
        print("--- ツール呼び出し引数（生成されたコード） ---")
        print(tool_call.input)

        # モデルがスレッドを継続できるように、合成された「ツール結果」を追加する。
        
        input_messages.append(
            {
                "type": "function_call_output",
                "call_id": tool_call.call_id,
                "output": "done", # <-- ツール呼び出しの実行結果で置き換える
            }
        )

        # 更新された会話で再帰処理を行い、応答IDを追跡してモデルが前のターンを認識できる
        # ようにする。
        return run_conversation(input_messages, previous_response_id=response.id)
    else:
        # 基本ケース: 追加のツール呼び出しなし - return
        return


prompt = """
数値の配列を10回ソートするコードを、3つの言語（C++、Python、Java）を使って、code_exec 関数群を使用して作成してください。

**必ず次の3つの関数を正確に1回ずつ呼び出してください**: code_exec_python code_exec_cpp および code_exec_java
これらの関数は、各言語で配列をソートするためのツールである。各言語でこれらの3つの関数を1回ずつ呼び出したら、処理を停止してください。

配列のソートに要した時間をミリ秒単位で表示してください

[448, 986, 255, 884, 632, 623, 246, 439, 936, 925, 644, 159, 777, 986, 706, 723, 534, 862, 195, 686, 846, 880, 970, 276, 613, 736, 329, 622, 870, 284, 945, 708, 267, 327, 678, 807, 687, 890, 907, 645, 364, 333, 385, 262, 730, 603, 945, 358, 923, 930, 761, 504, 870, 561, 517, 928, 994, 949, 233, 137, 670, 555, 149, 870, 997, 809, 180, 498, 914, 508, 411, 378, 394, 368, 766, 486, 757, 319, 338, 159, 585, 934, 654, 194, 542, 188, 934, 163, 889, 736, 792, 737, 667, 772, 198, 971, 459, 402, 989, 949]
"""

# 初期の開発者メッセージ
messages = [
    {
        "role": "developer",
        "content": prompt,
    }
]

run_conversation(messages)

--- ツール名 ---
code_exec_python
--- ツール呼び出し引数（生成されたコード） ---
# Python: Sort the array 10 times and measure the elapsed time in milliseconds
import time

arr = [448, 986, 255, 884, 632, 623, 246, 439, 936, 925, 644, 159, 777, 986, 706, 723, 534, 862, 195, 686, 846, 880, 970, 276, 613, 736, 329, 622, 870, 284, 945, 708, 267, 327, 678, 807, 687, 890, 907, 645, 364, 333, 385, 262, 730, 603, 945, 358, 923, 930, 761, 504, 870, 561, 517, 928, 994, 949, 233, 137, 670, 555, 149, 870, 997, 809, 180, 498, 914, 508, 411, 378, 394, 368, 766, 486, 757, 319, 338, 159, 585, 934, 654, 194, 542, 188, 934, 163, 889, 736, 792, 737, 667, 772, 198, 971, 459, 402, 989, 949]

start = time.perf_counter()
for _ in range(10):
    v = arr[:]  # copy
    v.sort()
end = time.perf_counter()

ms = (end - start) * 1000.0
print(f"Python: {ms:.3f} ms")
--- ツール名 ---
code_exec_cpp
--- ツール呼び出し引数（生成されたコード） ---
// C++: Sort the array 10 times and measure the elapsed time in milliseconds
#include <iostream>
#include <vector>
#include <algorithm>
#include <chrono>

int main() {
    std::vector<int> arr = {448, 986, 255, 884, 632, 623, 246, 439, 936, 925, 644, 159, 777, 986, 706, 723, 534, 862, 195, 686, 846, 880, 970, 276, 613, 736, 329, 622, 870, 284, 945, 708, 267, 327, 678, 807, 687, 890, 907, 645, 364, 333, 385, 262, 730, 603, 945, 358, 923, 930, 761, 504, 870, 561, 517, 928, 994, 949, 233, 137, 670, 555, 149, 870, 997, 809, 180, 498, 914, 508, 411, 378, 394, 368, 766, 486, 757, 319, 338, 159, 585, 934, 654, 194, 542, 188, 934, 163, 889, 736, 792, 737, 667, 772, 198, 971, 459, 402, 989, 949};

    auto start = std::chrono::steady_clock::now();
    for (int i = 0; i < 10; ++i) {
        auto v = arr; // copy
        std::sort(v.begin(), v.end());
    }
    auto end = std::chrono::steady_clock::now();

    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    std::cout << "C++: " << ms << " ms" << std::endl;
    return 0;
}
--- ツール名 ---
code_exec_java
--- ツール呼び出し引数（生成されたコード） ---
// Java: Sort the array 10 times and measure the elapsed time in milliseconds
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = new int[]{448, 986, 255, 884, 632, 623, 246, 439, 936, 925, 644, 159, 777, 986, 706, 723, 534, 862, 195, 686, 846, 880, 970, 276, 613, 736, 329, 622, 870, 284, 945, 708, 267, 327, 678, 807, 687, 890, 907, 645, 364, 333, 385, 262, 730, 603, 945, 358, 923, 930, 761, 504, 870, 561, 517, 928, 994, 949, 233, 137, 670, 555, 149, 870, 997, 809, 180, 498, 914, 508, 411, 378, 394, 368, 766, 486, 757, 319, 338, 159, 585, 934, 654, 194, 542, 188, 934, 163, 889, 736, 792, 737, 667, 772, 198, 971, 459, 402, 989, 949};

        long start = System.nanoTime();
        for (int i = 0; i < 10; i++) {
            int[] v = Arrays.copyOf(arr, arr.length); // copy
            Arrays.sort(v);
        }
        long end = System.nanoTime();

        long ms = (end - start) / 1_000_000L;
        System.out.println("Java: " + ms + " ms");
    }
}

start: SENTENCE
SENTENCE: /[A-Za-z, ](the hero|a dragon)[A-Za-z, ](fought|saved)[A-Za-z, ](a treasure|the kingdom)[A-Za-z, ]./

start: sentence
sentence: /[A-Za-z, ]+/ subject /[A-Za-z, ]+/ verb /[A-Za-z, ]+/ object /[A-Za-z, ]+/

import textwrap

# ----------------- MS SQL 方言の文法 -----------------
mssql_grammar = textwrap.dedent(r"""
            // ---------- Punctuation & operators ----------
            SP: " "
            COMMA: ","
            GT: ">"
            EQ: "="
            SEMI: ";"

            // ---------- Start ----------
            start: "SELECT" SP "TOP" SP NUMBER SP select_list SP "FROM" SP table SP "WHERE" SP amount_filter SP "AND" SP date_filter SP "ORDER" SP "BY" SP sort_cols SEMI

            // ---------- Projections ----------
            select_list: column (COMMA SP column)*
            column: IDENTIFIER

            // ---------- Tables ----------
            table: IDENTIFIER

            // ---------- Filters ----------
            amount_filter: "total_amount" SP GT SP NUMBER
            date_filter: "order_date" SP GT SP DATE

            // ---------- Sorting ----------
            sort_cols: "order_date" SP "DESC"

            // ---------- Terminals ----------
            IDENTIFIER: /[A-Za-z_][A-Za-z0-9_]*/
            NUMBER: /[0-9]+/
            DATE: /'[0-9]{4}-[0-9]{2}-[0-9]{2}'/
    """)

# ----------------- PostgreSQL 方言の文法 -----------------
postgres_grammar = textwrap.dedent(r"""
            // ---------- Punctuation & operators ----------
            SP: " "
            COMMA: ","
            GT: ">"
            EQ: "="
            SEMI: ";"

            // ---------- Start ----------
            start: "SELECT" SP select_list SP "FROM" SP table SP "WHERE" SP amount_filter SP "AND" SP date_filter SP "ORDER" SP "BY" SP sort_cols SP "LIMIT" SP NUMBER SEMI

            // ---------- Projections ----------
            select_list: column (COMMA SP column)*
            column: IDENTIFIER

            // ---------- Tables ----------
            table: IDENTIFIER

            // ---------- Filters ----------
            amount_filter: "total_amount" SP GT SP NUMBER
            date_filter: "order_date" SP GT SP DATE

            // ---------- Sorting ----------
            sort_cols: "order_date" SP "DESC"

            // ---------- Terminals ----------
            IDENTIFIER: /[A-Za-z_][A-Za-z0-9_]*/
            NUMBER: /[0-9]+/
            DATE: /'[0-9]{4}-[0-9]{2}-[0-9]{2}'/
    """)

from openai import OpenAI

client = OpenAI()

sql_prompt_mssql = (
    "mssql_grammarを使って、Microsoft SQL Server用のクエリを生成してください。"
    "各顧客ごとに最新の注文5件を取得し、customer_id、order_id、order_date、total_amount を表示する。"
    "total_amount が500より大きく、order_date が '2025-01-01' 以降のものを対象とする。"
)

response_mssql = client.responses.create(
    model="gpt-5",
    input=sql_prompt_mssql,
    text={"format": {"type": "text"}},
    tools=[
        {
            "type": "custom",
            "name": "mssql_grammar",
            "description": "SELECT文のTOP句と基本的なWHERE/ORDER BYのみを使った、Microsoft SQL Server用の読み取り専用クエリを実行する。**クエリが文法に従っているか十分に考慮すること。**",
            "format": {
                "type": "grammar",
                "syntax": "lark",
                "definition": mssql_grammar
            }
        },
    ],
    parallel_tool_calls=False
)

print("--- MS SQL クエリ ---")
print(response_mssql.output[1].input)

--- MS SQL クエリ ---
SELECT TOP 5 customer_id, order_id, order_date, total_amount
FROM orders
WHERE total_amount > 500 AND order_date > '2025-01-01' ORDER BY order_date DESC;

sql_prompt_pg = (
    "postgres_grammar を使って、PostgreSQL用のクエリを生成してください。"
    "各顧客ごとに最新の注文5件を取得し、customer_id、order_id、order_date、total_amount を表示する。"
    "total_amount が500より大きく、order_date が '2025-01-01' 以降のものを対象とする。"
)

response_pg = client.responses.create(
    model="gpt-5",
    input=sql_prompt_pg,
    text={"format": {"type": "text"}},
    tools=[
        {
            "type": "custom",
            "name": "postgres_grammar",
            "description": "SELECT文のLIMIT句と基本的なWHERE/ORDER BYのみを使った、PostgreSQL用の読み取り専用クエリを実行する。**クエリが文法に従っているか十分に考慮すること。**",
            "format": {
                "type": "grammar",
                "syntax": "lark",
                "definition": postgres_grammar
            }
        },
    ],
    parallel_tool_calls=False,
)

print("--- PG SQL クエリ ---")
print(response_pg.output[1].input)

--- PG SQL クエリ ---
SELECT customer_id, order_id, order_date, total_amount
FROM orders
WHERE total_amount > 500 AND order_date > '2025-01-01' ORDER BY order_date DESC
LIMIT 5;

from openai import OpenAI

client = OpenAI()

timestamp_grammar_definition = r"^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01]) (?:[01]\d|2[0-3]):[0-5]\d$"

timestamp_prompt = (
    "timestamp_grammarを使って、2025年8月7日10時のタイムスタンプを保存してください。"
)

response_mssql = client.responses.create(
    model="gpt-5",
    input=timestamp_prompt,
    text={"format": {"type": "text"}},
    tools=[
        {
            "type": "custom",
            "name": "timestamp_grammar",
            "description": "日付＋時刻（24時間表記）のタイムスタンプを保存する。",
            "format": {
                "type": "grammar",
                "syntax": "regex",
                "definition": timestamp_grammar_definition
            }
        },
    ],
    parallel_tool_calls=False
)

print("--- タイムスタンプ ---")
print(response_mssql.output[1].input)

--- タイムスタンプ ---
2025-08-07 10:00

from openai import OpenAI
import time
import json

client = OpenAI()

prompt = "レビューの感情を positive・neutral・negative のいずれかで分類し、1語だけ返してください。"

start_time = time.perf_counter()

response = client.responses.create(
    model="gpt-5",
    input= [
        {
            'role': 'developer',
            'content': prompt
        },
        {
            'role': 'user',
            'content': 'そのレストランの料理は素晴らしかった！みんなにおすすめします。'
        }
    ],
    reasoning = {"effort": "minimal"},
)

# モデルのテキスト出力を抽出
output_text = ""
for item in response.output:
    if hasattr(item, "content") and item.content is not None:
        for content in item.content:
            if hasattr(content, "text") and content.text is not None:
                for text in content.text:
                    output_text += text

end_time = time.perf_counter()

# トークン消費の詳細
usage = response.usage

print("--------------------------------")
print("出力:")
print(output_text)
print("--------------------------------")
print("トークン消費:")
print(json.dumps(usage.model_dump(), indent=2))
print("--------------------------------")
print("実行時間:")
print("{:.5f} 秒".format(end_time - start_time))

--------------------------------
出力:
positive
--------------------------------
トークン消費:
{
  "input_tokens": 54,
  "input_tokens_details": {
    "cached_tokens": 0
  },
  "output_tokens": 7,
  "output_tokens_details": {
    "reasoning_tokens": 0
  },
  "total_tokens": 61
}
--------------------------------
実行時間:
1.28887 秒

(snip)
    #reasoning = {"effort": "minimal"},
(snip)

--------------------------------
出力:
positive
--------------------------------
トークン消費:
{
  "input_tokens": 54,
  "input_tokens_details": {
    "cached_tokens": 0
  },
  "output_tokens": 135,
  "output_tokens_details": {
    "reasoning_tokens": 128
  },
  "total_tokens": 189
}
--------------------------------
実行時間:
11.20310 秒