Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Code Interpreter: Käivita koodi API-s

Õppetund 10 / 20 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Code Interpreter: Käivita koodi API-s
  2. Luba Code Interpreter
  3. Kontrolli käivitatud koodi
  4. Esita faile sisendina
  5. Hangi genereeritud failid
  6. Konteiner ja keskkond
  7. Ahelda mitu täitmist
  8. Kombineeri teiste tööriistadega
  9. Muster: täielik analüüsitorustik
  10. Peamised punktid

Uuendatud 2. novembril 2026 ametliku Code Interpreteri juhendi ja openai SDK põhjal: tööriist nõuab parameetrit container (puudus kõigist varasematest näidetest, mis oleksid seetõttu nurjunud), genereeritud failid ilmuvad annotatsioonidesse tüübiga container_file_citation ja need laaditakse alla Containers API kaudu (mitte client.files.content), ning väljakutsete tulemused kannavad nime outputs (mitte results). Sisendteksti osad kasutavad tüüpi input_text. Sõnumile lisatud failid laaditakse üles eesmärgiga user_data, mida OpenAI soovitab mudeli sisendite jaoks (File inputs). Allikad: Code Interpreter · File inputs.

Code Interpreter: Käivita koodi API-s

Keelemudel ennustab teksti; see ei arvuta. Küsi temalt arvu 1764 ruutjuurt ja ta toodab oma treeningu põhjal kõige tõenäolisema tulemuse – sageli õige, mõnikord vale, ilma võimaluseta neid eristada. Code Interpreter kõrvaldab selle määramatuse, andes mudelile Pythoni interpretaatori: ta kirjutab arvutuse, käivitab selle ja tagab saadud tulemuse, mitte aimduse.

Muutus on sügavam, kui esmapilgul paistab. Mudel näeb oma koodi väljundit, sealhulgas vigu, nii et ta saab ennast parandada ja uuesti proovida. Andmefaili puhul, mille täpset struktuuri keegi ei tea, lööb see tsükkel iga eelnevalt kirjutatud juhise.

Luba Code Interpreter

Sa lubad selle, lisades tööriista massiivi tools – midagi pole vaja installida ega keskkonda ette valmistada. Mudel otsustab ise, millal koodi kirjutada: ta vastab faktilistele küsimustele otse, kuid lülitub arvutuste või andmete manipuleerimise korral täitmisele.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Calculate the Fibonacci sequence up to the 20th term",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

print(response.output_text)

Mudel kirjutab Pythoni koodi, käivitab selle liivakastis ja integreerib tulemused oma vastusesse.

Kontrolli käivitatud koodi

Harjuta end vähemalt arenduse faasis seda koodi lugema. See on ainus viis eristada head tulemust sellisest, mis on juhuslikult õige: keskmine, mis on arvutatud, ignoreerides vaikselt puuduvaid väärtusi, on numbriliselt õige, kuid analüütiliselt vale. Vastus seda ei ütle; kood ütleb.

Vastus sisaldab genereeritud koodi ja selle tulemusi:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is the square root of 1764? Verify by squaring the result.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    include=["code_interpreter_call.outputs"],  # to receive produced logs and images
)

for item in response.output:
    if item.type == "code_interpreter_call":
        print("--- Executed Code ---")
        print(item.code)
        print("--- Outputs ---")
        for output in item.outputs or []:
            print(output.logs if output.type == "logs" else output.url)

Esita faile sisendina

Tööriist annab oma täieliku väärtuse just failidega töötamisel. Sa laadid faili üles, viidad sellele väljakutses ja mudel avab selle tegelikult – ta loeb reaalsed veerud, reaalsed tüübid ja reaalsed hälbed, selle asemel et arutleda kirjelduse üle, mida sa oleksid võinud anda.

# Upload the file
with open("sales_2025.csv", "rb") as f:
    file_obj = client.files.create(file=f, purpose="user_data")

# Use Code Interpreter with the file
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Analyze this sales file. "
                 "Give me the total by category and the best-performing month."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

print(response.output_text)

Hangi genereeritud failid

Pöördtee toimib samuti: kood toodab puhastatud CSV-faili, diagrammi või Exceli töövihiku ja need failid tagastatakse sulle. Need jäävad konteinerisse ja vastussõnum viitab neile oma annotatsioonides tüübiga container_file_citation, kaasates konteineri ID, faili ID ja failinime. Seejärel laadid need alla Containers API kaudu. Kaks väikest funktsiooni, mida kasutatakse hilisemates tundides, kapseldavad selle voogu:

def generated_files(response):
    """Files created by Code Interpreter, cited in message annotations."""
    for item in response.output:
        if item.type == "message":
            for part in item.content:
                for ann in getattr(part, "annotations", None) or []:
                    if ann.type == "container_file_citation":
                        yield ann


def download(client, ann, path):
    """Downloads a file from the container and returns its local path."""
    content = client.containers.files.content.retrieve(ann.file_id, container_id=ann.container_id)
    with open(path, "wb") as out:
        out.write(content.read())
    return path

Sisendina esitatud failid (input_file) kopeeritakse automaatselt konteinerisse: sa ei pea midagi muud üles laadima.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Create a chart of sales by month "
                 "and export the cleaned data as a CSV."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# Retrieve generated files
for ann in generated_files(response):
    print(f"Generated file: {ann.filename}")
    download(client, ann, ann.filename)

Konteiner ja keskkond

Konteineri reeglite tundmine säästab aega veaotsingul selle üle, mis ei saa toimida. OpenAI dokumentatsiooni kohaselt:

  • see on täielikult isoleeritud virtuaalmasin (liivakast), kus mudel käivitab Pythoni;
  • tööriist nõuab parameetrit container: {"type": "auto"} loob konteineri (või kasutab uuesti kontekstis olevat eelmisest väljakutsest pärit konteinerit), samas kui ID, mis on saadud client.containers.create(...) kaudu, sunnib kasutama kindlat konteinerit;
  • mälu määratakse parameetriga memory_limit: 1g (vaikimisi), 4g, 16g või 64g, kus kõrgemaid tasemeid arveldatakse integreeritud tööriistade hindade järgi;
  • konteiner aegub pärast 20-minutilist tegevusetust; selle andmed lähevad seejärel kaduma, seega laadi alla kõik failid, mida soovid säilitada, kuni see on aktiivne.

Ära looda koodist võrguühendusele: esita andmed sisendina või delegeeri uurimistöö Web Searchi tööriistale.

# Example: the model can use pandas directly
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Load this CSV with pandas, "
                 "calculate descriptive statistics, and identify outliers."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Ahelda mitu täitmist

Järjestikused täitmised jagavad sama sessiooni: muutujad, DataFrame’id ja impordid esimesest plokist jäävad järgmisesse kättesaadavaks, täpselt nagu märkmikus. Mudel kasutab seda loomulikult – ta laeb, kontrollib ja seejärel töötleb –, muutes mitmeastmelise analüüsi võimalikuks ilma kõike igas etapis uuesti laadimata.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="1. Generate 1000 random points from a normal distribution. "
          "2. Calculate the mean and standard deviation. "
          "3. Create a histogram. "
          "4. Perform a Shapiro-Wilk normality test.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# The model executes 4 code blocks sequentially
# Each block has access to variables from previous ones

Kombineeri teiste tööriistadega

Kasulikuim kombinatsioon ühendab andmeallika võimekusega seda töödelda: File Search leiab asjakohase lõigu sinu dokumentidest, Web Search toob turuandmed ja Code Interpreter võrdleb neid kahest tabelis või diagrammis. Ükski neist tööriistadest ei saa teiste tööd teha.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Search the web for French GDP data from the last 10 years, "
          "then create a trend chart with a linear regression.",
    tools=[
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}}
    ]
)

Muster: täielik analüüsitorustik

Viimane näide ühendab kõik eelneva realistlikuks juhtumiks: sisendfail, mitmeastmeline analüüs ja väljundfailid. Pööra erilist tähelepanu vihje (prompt) formaadile – nummerdatud, selge oodatava väljundi osas –, sest just see, palju rohkem kui kaasnev Pythoni kood, määrab tulemuse kvaliteedi.

def analyze_data(file_path: str, questions: list[str]) -> dict:
    """Data analysis pipeline with Code Interpreter."""
    # Upload
    with open(file_path, "rb") as f:
        file_obj = client.files.create(file=f, purpose="user_data")

    results = {}

    for question in questions:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=[
                {
                    "role": "user",
                    "content": [
                        {"type": "input_text", "text": question},
                        {"type": "input_file", "file_id": file_obj.id}
                    ]
                }
            ],
            tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
            instructions="Write clean, commented Python code. "
                        "Display intermediate results."
        )

        results[question] = response.output_text

    return results

# Usage
results = analyze_data("sales.csv", [
    "Give descriptive statistics for each numeric column",
    "What are the top 5 best-selling products?",
    "Is there seasonality in sales?"
])

Peamised punktid

  • Code Interpreter käivitab Pythoni isoleeritud konteineris; parameeter container on kohustuslik ({"type": "auto"} või ID)
  • Sisendina input_file esitatud failid kopeeritakse automaatselt konteinerisse
  • Genereeritud failidele viidatakse kui container_file_citation ja need laaditakse alla client.containers.files.content.retrieve kaudu
  • Konteiner aegub pärast 20-minutilist tegevusetust: laadi alla see, mida soovid säilitada
  • Kombineeri Web Searchi ja File Searchiga rikastatud analüüsi jaoks