Salt la conținutul principal
Română— Alege o limbă
Meniu

Code Interpreter: Executați cod în API

Lecția 10 din 20 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Code Interpreter: Executați cod în API
  2. Activarea Code Interpreter
  3. Inspectarea codului executat
  4. Furnizarea fișierelor ca intrare
  5. Recuperarea fișierelor generate
  6. Container și mediu
  7. Înlănțuirea mai multor execuții
  8. Combinarea cu alte instrumente
  9. Model: Pipeline complet de analiză
  10. Puncte cheie

Actualizat la 2 noiembrie 2026 pe baza ghidului oficial Code Interpreter și a SDK-ului openai: instrumentul necesită un parametru container (lipsă din toate exemplele anterioare, care ar fi eșuat), fișierele generate apar în adnotările de tip container_file_citation și sunt descărcate prin API-ul Containers (nu prin client.files.content), iar rezultatele apelurilor sunt denumite outputs (nu results). Părțile de text de intrare folosesc tipul input_text. Fișierele atașate unui mesaj sunt încărcate cu scopul user_data, ceea ce OpenAI recomandă pentru intrările modelului (File inputs). Surse: Code Interpreter · File inputs.

Code Interpreter: Executați cod în API

Un model lingvistic prezice text; nu calculează. Dacă îi cereți rădăcina pătrată a lui 1764, va produce rezultatul cel mai probabil bazat pe antrenamentul său – adesea corect, uneori greșit, fără nicio modalitate de a face diferența. Code Interpreter elimină această incertitudine oferind modelului un interpretor Python: acesta scrie calculul, îl execută și returnează un rezultat obținut, nu o ghicitoare.

Schimbarea este mai profundă decât pare. Modelul vede ieșirea propriului său cod, inclusiv erorile, astfel încât se poate corecta și poate reîncerca. Pe un fișier de date unde nimeni nu cunoaște structura exactă, această buclă bate orice instrucțiune pre-scrisă.

Activarea Code Interpreter

Îl activați adăugând instrumentul în tabloul tools – nimic de instalat, niciun mediu de provisionat. Modelul decide când să scrie cod: răspunde direct la întrebările factuale, dar trece la execuție pentru calcule sau manipularea datelor.

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)

Modelul scrie codul Python, îl execută într-un sandbox și integrează rezultatele în răspunsul său.

Inspectarea codului executat

Obișnuiți-vă să citiți acest cod, cel puțin în timpul dezvoltării. Este singura modalitate de a distinge un rezultat bun de unul care este corect din întâmplare: o medie calculată ignorând silențios valorile lipsă este numeric corectă, dar analitic falsă. Răspunsul nu vă va spune acest lucru; codul o va face.

Răspunsul conține codul generat și rezultatele sale:

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)

Furnizarea fișierelor ca intrare

Instrumentul își livrează întreaga valoare atunci când lucrează cu fișiere. Încărcați fișierul, faceți referire la el în apel, iar modelul îl deschide efectiv – citește coloanele reale, tipurile reale și valorile aberante reale, în loc să raționeze despre o descriere pe care ați fi putut-o furniza.

# 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)

Recuperarea fișierelor generate

Calea inversă funcționează, de asemenea: codul produce un CSV curățat, un grafic sau un registru Excel, iar aceste fișiere vă sunt returnate. Ele rămân în container, iar mesajul de răspuns le citează în adnotările sale de tip container_file_citation, incluzând ID-ul containerului, ID-ul fișierului și numele fișierului. Apoi le descărcați prin API-ul Containers. Două funcții mici, reutilizate în lecțiile ulterioare, encapsulează acest flux:

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

Fișierele pe care le furnizați ca intrare (input_file) sunt copiate automat în container: nu trebuie să încărcați nimic altceva.

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)

Container și mediu

Cunoașterea regulilor containerului vă economisește timp depanând ceea ce nu poate funcționa. Conform documentației OpenAI:

  • este o mașină virtuală complet izolată (sandbox) în care modelul execută Python;
  • instrumentul necesită un parametru container: {"type": "auto"} creează un container (sau îl reutilizează pe unul dintr-un apel anterior prezent în context), în timp ce un ID obținut prin client.containers.create(...) forțează un container specific;
  • memoria este setată cu memory_limit: 1g (implicit), 4g, 16g sau 64g, nivelurile superioare fiind facturate la tarifele pentru instrumente integrate;
  • un container expiră după 20 de minute de inactivitate; datele sale se pierd apoi, așa că descărcați orice fișier pe care doriți să îl păstrați cât timp este activ.

Nu contați pe accesul la rețea din cod: furnizați datele ca intrare sau delegați cercetarea instrumentului Web Search.

# 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"}}]
)

Înlănțuirea mai multor execuții

Execuțiile succesive partajează aceeași sesiune: variabilele, DataFrame-urile și importurile din primul bloc rămân disponibile în următorul, exact ca într-un notebook. Modelul valorifică acest lucru în mod natural – încarcă, inspectează, apoi procesează – făcând posibilă analiza în mai mulți pași fără a reîncărca totul la fiecare etapă.

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

Combinarea cu alte instrumente

Cea mai utilă combinație asociază o sursă de date cu capacitatea de a o procesa: File Search găsește pasajul relevant din documentele dumneavoastră, Web Search aduce date de piață, iar Code Interpreter compară cele două într-un tabel sau grafic. Niciunul dintre aceste instrumente nu poate face treaba celorlalte.

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"}}
    ]
)

Model: Pipeline complet de analiză

Ultimul exemplu înlănțuiește totul de mai sus într-un caz realist: un fișier de intrare, analiză în mai mulți pași și livrabile de ieșire. Acordați o atenție deosebită formatului promptului – numerotat, explicit privind ieșirea așteptată – deoarece acesta, mult mai mult decât codul Python care îl însoțește, determină calitatea rezultatului.

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?"
])

Puncte cheie

  • Code Interpreter rulează Python într-un container izolat; parametrul container este obligatoriu ({"type": "auto"} sau un ID)
  • Fișierele furnizate ca input_file sunt copiate automat în container
  • Fișierele generate sunt citate ca container_file_citation și descărcate prin client.containers.files.content.retrieve
  • Un container expiră după 20 de minute de inactivitate: descărcați ceea ce doriți să păstrați
  • Combinați cu Web Search și File Search pentru o analiză îmbogățită