Olulisemad punktid

• Ekraanitõmmise-tegevuse tsükkel on põhimuster: Teie skript teeb ekraanitõmmise, saadab selle GPT-5.4-le Responses API kaudu, kus on lubatud computer_use, saab struktureeritud tegevuskäsud (click, type, scroll) ja täidab need PyAutoGUI abil tsüklis.
• GPT-5.4 ületas inimeksperte OSWorld testis 75% tulemusega: See on esimene AI mudel, mis ületab inimeste sooritust töölaua automatiseerimise võrdlustestides, muutes praktilise automatiseerimise reaalsete töövoogude jaoks elujõuliseks.
• Maksumus on üllatavalt madal: Tüüpiline automatiseerimisseanss 10-20 ekraanitõmmisega maksab $0.10-0.50, arveldatuna GPT-5.4 standardtasude alusel (~$10/$30 miljoni sisend/väljund tokens kohta).
• Turvalisus nõuab, et teie kood täidaks tegevusi: GPT-5.4 saadab ainult tegevuskäske -- teie rakendus otsustab, kas neid täita, muutes sandboxed testimise ja tegevuste ülevaatamise hädavajalikuks enne järelevalveta käivitamist.
• Kolm eeltingimust alustamiseks: Python 3.10+, OpenAI API võti Tier 1 juurdepääsuga (minimaalselt $5 eelnev kulu) ja ekraaniga töölauakeskkond.

GPT-5.4 saavutas OSWorld võrdlustestis 75%, ületades esimest korda inimeksperte töölaua automatiseerimises. Kuid võrdlustesti tulemuste teadmine ja Computer Use'i tegelik kasutamine on kaks väga erinevat asja.

See juhend täidab selle lünga. Lõpuks on teil töötav Python skript, mis teeb teie töölauast ekraanitõmmiseid, saadab need GPT-5.4-le, saab struktureeritud tegevuskäsud ja täidab need automaatselt. Ei mingit teooriat ega ülespuhutud juttu — ainult kood, mida saate täna käivitada.

---

Mida te ehitate

Te ehitate täieliku töölaua automatiseerimise tsükli, mis töötab järgmiselt:

1. Teie skript teeb teie ekraanist ekraanitõmmise
2. See saadab selle ekraanitõmmise GPT-5.4-le OpenAI Responses API kaudu, kus on sisse lülitatud computer_use tööriist
3. GPT-5.4 analüüsib ekraanitõmmist ja tagastab struktureeritud tegevused (click, type, scroll, keypress)
4. Teie skript täidab need tegevused PyAutoGUI abil
5. Tsükkel kordub, kuni ülesanne on lõpetatud

Selle õpetuse lõpuks on teil kaks töötavat näidet: üks, mis täidab automaatselt veebivormi, ja teine, mis eraldab andmed töölauarakendusest CSV faili.

---

Eeltingimused

Enne alustamist veenduge, et teil on järgnev:

• Python 3.10 või uuem installitud teie masinasse
• OpenAI API võti juurdepääsuga GPT-5.4-le (nõuab tasulist kontot vähemalt Tier 1 juurdepääsuga — minimaalselt $5 eelnev kulu)
• Töölauakeskkond — Computer Use töötab macOS, Windows ja Linux süsteemides, millel on ekraan. Ilma ekraanita (headless) serverite puhul vajate virtuaalset ekraani nagu Xvfb
• Põhiline Pythoni tundmine (te ei pea olema ekspert — kogu kood on lisatud)

---

Samm 1: Seadistage oma keskkond

Alustage projekti kataloogi loomisest ja vajalike pakettide installimisest.

mkdir gpt54-computer-use && cd gpt54-computer-use
python -m venv venv
source venv/bin/activate  # Windowsis: venv\Scripts\activate

pip install openai pyautogui pillow

Mida iga pakett teeb:

• openai — Ametlik OpenAI Python SDK GPT-5.4 API kutsumiseks
• pyautogui — Platvormiülene teek hiire ja klaviatuuri juhtimiseks
• pillow — Pilditöötluse teek ekraanitõmmiste käitlemiseks

Järgmiseks määrake oma API võti keskkonnamuutujana:

export OPENAI_API_KEY="sk-your-api-key-here"

Windowsis kasutage selle asemel set OPENAI_API_KEY=sk-your-api-key-here.

Looge fail nimega automation.py ja lisage põhiseadistus:

import os
import base64
import json
import pyautogui
from openai import OpenAI

client = OpenAI()  # Loeb OPENAI_API_KEY keskkonnamuutujast

# Safety: add a short pause before actions so you can move the mouse
# to a corner to trigger PyAutoGUI's fail-safe and abort
pyautogui.PAUSE = 0.5
pyautogui.FAILSAFE = True

SCREEN_WIDTH, SCREEN_HEIGHT = pyautogui.size()
print(f"Screen resolution: {SCREEN_WIDTH}x{SCREEN_HEIGHT}")

Käivitage see, et kontrollida, kas kõik on õigesti installitud:

python automation.py

Te peaksite nägema oma ekraani resolutsiooni väljastatuna. Kui saate importimise vigu, kontrollige üle, kas aktiveerisite virtuaalkeskkonna ja installisite kõik paketid.

---

Samm 2: Tehke ekraanitõmmis

Computer Use töötab ekraanitõmmiste analüüsimise kaudu. Teie kood jäädvustab ekraani ja teisendab selle base64-kodeeritud stringiks, mida API vastu võtab.

Lisage see funktsioon faili automation.py:

def take_screenshot():
    """Capture the screen and return it as a base64-encoded PNG string."""
    screenshot = pyautogui.screenshot()
    # Save to a buffer instead of disk for speed
    import io
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8")

Testige seda, lisades faili lõppu kiire kontrolli:

if __name__ == "__main__":
    img_data = take_screenshot()
    print(f"Screenshot captured: {len(img_data)} characters (base64)")

See peaks väljastama midagi sarnast nagu Screenshot captured: 2847392 characters (base64). Täpne arv sõltub teie ekraani resolutsioonist ja sellest, mis ekraanil on.

---

Samm 3: Saatke ekraanitõmmis GPT-5.4-le

Nüüd jõuame Computer Use'i tuumani: ekraanitõmmise saatmine GPT-5.4-le koos sisselülitatud computer_use tööriistaga ja struktureeritud tegevuskäskude vastuvõtmine.

Lisage see funktsioon:

def send_to_gpt54(screenshot_b64, task_description, previous_response_id=None):
    """
    Send a screenshot to GPT-5.4 with computer_use enabled.
    Returns the API response with action commands.
    """
    tools = [
        {
            "type": "computer_use_preview",
            "display_width": SCREEN_WIDTH,
            "display_height": SCREEN_HEIGHT,
            "environment": "mac"  # Change to "windows" or "linux" as needed
        }
    ]

    input_content = [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": task_description
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{screenshot_b64}"
                    }
                }
            ]
        }
    ]

    params = {
        "model": "gpt-5.4",
        "tools": tools,
        "input": input_content,
        "reasoning": {"effort": "medium"}
    }

    if previous_response_id:
        params["previous_response_id"] = previous_response_id

    response = client.responses.create(**params)
    return response

Olulisemad parameetrid selgitatuna:

• computer_use_preview — Ütleb GPT-5.4-le, et see analüüsiks ekraanitõmmist ja tagastaks töölaua tegevused
• display_width / display_height — Teie ekraani resolutsioon, et GPT-5.4 tagastaks koordinaadid, mis vastavad teie tegelikule ekraanile
• environment — Määratud kui "mac", "windows" või "linux", et GPT-5.4 kasutaks õigeid klaviatuuri otseteid ja UI konventsioone
• reasoning.effort — Määrab, kui palju GPT-5.4 analüüsib. Kasutage "medium" tavaliste ülesannete jaoks, "high" keeruliste mitmeetapiliste töövoogude jaoks
• previous_response_id — Ühendab mitu kutset omavahel, et GPT-5.4 mäletaks, mida ta on juba teinud

---

Samm 4: Täitke tegevused

GPT-5.4 tagastab oma vastuses struktureeritud tegevuskäsud. Te peate need parsima ja PyAutoGUI abil täitma.

Lisage tegevuste täitja:

def execute_action(action):
    """Execute a single computer_use action using PyAutoGUI."""
    action_type = action.type

    if action_type == "click":
        x, y = action.x, action.y
        button = getattr(action, "button", "left")
        print(f"  -> Click ({button}) at ({x}, {y})")
        pyautogui.click(x, y, button=button)

    elif action_type == "double_click":
        x, y = action.x, action.y
        print(f"  -> Double-click at ({x}, {y})")
        pyautogui.doubleClick(x, y)

    elif action_type == "type":
        text = action.text
        print(f"  -> Type: {text[:50]}{'...' if len(text) > 50 else ''}")
        pyautogui.write(text, interval=0.03)

    elif action_type == "keypress":
        keys = action.keys
        print(f"  -> Keypress: {keys}")
        for key in keys:
            pyautogui.press(key)

    elif action_type == "scroll":
        x, y = action.x, action.y
        scroll_x = getattr(action, "scroll_x", 0)
        scroll_y = getattr(action, "scroll_y", 0)
        print(f"  -> Scroll at ({x}, {y}): x={scroll_x}, y={scroll_y}")
        pyautogui.scroll(scroll_y, x=x, y=y)

    elif action_type == "drag":
        start_x, start_y = action.start_x, action.start_y
        end_x, end_y = action.end_x, action.end_y
        print(f"  -> Drag from ({start_x}, {start_y}) to ({end_x}, {end_y})")
        pyautogui.moveTo(start_x, start_y)
        pyautogui.drag(end_x - start_x, end_y - start_y, duration=0.5)

    elif action_type == "screenshot":
        print("  -> Model requested a new screenshot")
        return "screenshot_requested"

    else:
        print(f"  -> Unknown action type: {action_type}")

    return "executed"


def process_response(response):
    """Parse GPT-5.4's response and execute all actions."""
    needs_screenshot = False

    for item in response.output:
        if item.type == "computer_call":
            action = item.action
            result = execute_action(action)
            if result == "screenshot_requested":
                needs_screenshot = True
        elif item.type == "text":
            print(f"  GPT-5.4 says: {item.text}")

    return needs_screenshot, response.id

See käsitleb kõiki tegevustüüpe, mida GPT-5.4 saab tagastada: klikkimine, topeltklikkimine, tippimine, klahvivajutused, kerimine ja lohistamine.

---

Samm 5: Ehitage automatiseerimistsükkel

Nüüd siduge kõik kokku terviklikuks automatiseerimistsükliks. See on peamine mootor, mis teie ülesandeid käivitab:

import time

def run_automation(task_description, max_steps=25):
    """
    Run a complete automation loop:
    screenshot -> send to GPT-5.4 -> execute actions -> repeat.
    """
    print(f"Starting automation: {task_description}")
    print(f"Max steps: {max_steps}")
    print("-" * 60)

    previous_response_id = None

    for step in range(1, max_steps + 1):
        print(f"\nStep {step}/{max_steps}")

        # 1. Take a screenshot
        print("  Capturing screenshot...")
        screenshot_b64 = take_screenshot()

        # 2. Send to GPT-5.4
        print("  Sending to GPT-5.4...")
        response = send_to_gpt54(
            screenshot_b64,
            task_description if step == 1 else "Continue the task based on the current screen state.",
            previous_response_id
        )

        # 3. Check if the model thinks we're done
        has_actions = False
        for item in response.output:
            if item.type == "computer_call":
                has_actions = True
                break

        if not has_actions:
            # Check if model sent a text response (likely done or needs input)
            for item in response.output:
                if item.type == "text":
                    print(f"\n  GPT-5.4: {item.text}")
            print("\n" + "=" * 60)
            print("Automation complete (no more actions to perform).")
            return True

        # 4. Execute the actions
        print("  Executing actions...")
        needs_screenshot, previous_response_id = process_response(response)

        # 5. Brief pause to let UI update
        time.sleep(1.0)

    print("\n" + "=" * 60)
    print(f"Reached maximum steps ({max_steps}). Stopping.")
    return False

Saate nüüd käivitada mis tahes automatiseerimisülesande ühe funktsioonikutsuniga:

if __name__ == "__main__":
    run_automation("Open the Calculator app and compute 1234 * 5678")

See jäädvustab teie ekraani, saadab selle GPT-5.4-le ning GPT-5.4 mõtleb välja, kuidas avada Calculator, teha korrutustehe — klikkides nuppudele, lugedes tulemust ja lõpetades, kui valmis.

---

Praktiline näide 1: Veebivormi automaatne täitmine

Siin on täielik töötav näide, mis täidab veebikontakti vormi. Salvestage see nimega autofill_form.py:

import os
import base64
import io
import time
import pyautogui
from openai import OpenAI

client = OpenAI()
pyautogui.PAUSE = 0.5
pyautogui.FAILSAFE = True
SCREEN_WIDTH, SCREEN_HEIGHT = pyautogui.size()


def take_screenshot():
    screenshot = pyautogui.screenshot()
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8")


def autofill_contact_form():
    """
    Auto-fill a contact form with sample data.
    Open the web page with the form before running this script.
    """
    form_data = {
        "First Name": "Jane",
        "Last Name": "Doe",
        "Email": "jane.doe@example.com",
        "Phone": "555-0123",
        "Company": "Acme Corp",
        "Message": "I am interested in learning more about your enterprise plan."
    }

    task = f"""Fill out the contact form visible on the screen with this data:
{chr(10).join(f'- {k}: {v}' for k, v in form_data.items())}

Click each field, clear any existing text, type the value, then move to the next field.
After filling all fields, click the Submit button.
Do NOT press Enter to submit — click the Submit button instead."""

    print("Starting form auto-fill...")
    print(f"Data to fill: {json.dumps(form_data, indent=2)}")

    previous_response_id = None

    for step in range(1, 20):
        print(f"\nStep {step}")
        screenshot_b64 = take_screenshot()

        tools = [{
            "type": "computer_use_preview",
            "display_width": SCREEN_WIDTH,
            "display_height": SCREEN_HEIGHT,
            "environment": "mac"
        }]

        input_content = [{
            "role": "user",
            "content": [
                {"type": "text", "text": task if step == 1 else "Continue filling the form."},
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}}
            ]
        }]

        params = {
            "model": "gpt-5.4",
            "tools": tools,
            "input": input_content,
            "reasoning": {"effort": "medium"}
        }
        if previous_response_id:
            params["previous_response_id"] = previous_response_id

        response = client.responses.create(**params)

        has_actions = False
        for item in response.output:
            if item.type == "computer_call":
                has_actions = True
                action = item.action
                if action.type == "click":
                    pyautogui.click(action.x, action.y)
                elif action.type == "type":
                    pyautogui.write(action.text, interval=0.03)
                elif action.type == "keypress":
                    for key in action.keys:
                        pyautogui.press(key)
                elif action.type == "scroll":
                    pyautogui.scroll(action.scroll_y, x=action.x, y=action.y)

        if not has_actions:
            for item in response.output:
                if item.type == "text":
                    print(f"GPT-5.4: {item.text}")
            print("Form filling complete.")
            return

        previous_response_id = response.id
        time.sleep(0.8)


if __name__ == "__main__":
    import json
    print("Make sure the web form is visible on your screen.")
    print("Starting in 3 seconds...")
    time.sleep(3)
    autofill_contact_form()

Kuidas seda kasutada:

1. Avage oma brauseris veebileht kontaktvormiga
2. Veenduge, et vorm on täielikult ekraanil nähtav (esimesi välju ei pea kerima)
3. Käivitage python autofill_form.py
4. Vaadake, kuidas GPT-5.4 tuvastab iga välja, klikib sellel ja sisestab õige väärtuse

---

Praktiline näide 2: Andmete eraldamine töölauarakendusest

See näide loeb andmeid nähtavast tabelarvutusest või tabelirakendusest ja salvestab need CSV faili. Salvestage see nimega extract_data.py:

import os
import base64
import io
import csv
import time
import pyautogui
from openai import OpenAI

client = OpenAI()
pyautogui.PAUSE = 0.3
pyautogui.FAILSAFE = True
SCREEN_WIDTH, SCREEN_HEIGHT = pyautogui.size()


def take_screenshot():
    screenshot = pyautogui.screenshot()
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8")


def extract_table_data(output_file="extracted_data.csv"):
    """
    Look at the current screen, identify any table or spreadsheet,
    and extract its contents to a CSV file.
    """
    screenshot_b64 = take_screenshot()

    response = client.responses.create(
        model="gpt-5.4",
        input=[{
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": """Look at this screenshot carefully. There is a table or spreadsheet visible.
Extract ALL the data from the visible table into a structured JSON format.
Return ONLY a JSON object with this structure:
{
  "headers": ["Column1", "Column2", ...],
  "rows": [["value1", "value2", ...], ...]
}
Include every visible row. Do not summarize or skip any data."""
                },
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}
                }
            ]
        }],
        reasoning={"effort": "high"}
    )

    # Parse the JSON response
    response_text = response.output_text
    # Clean up markdown code fences if present
    if "```json" in response_text:
        response_text = response_text.split("```json")[1].split("```")[0]
    elif "```" in response_text:
        response_text = response_text.split("```")[1].split("```")[0]

    import json
    data = json.loads(response_text.strip())

    # Write to CSV
    with open(output_file, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(data["headers"])
        writer.writerows(data["rows"])

    row_count = len(data["rows"])
    col_count = len(data["headers"])
    print(f"Extracted {row_count} rows x {col_count} columns to {output_file}")
    return output_file


def extract_multi_page_data(output_file="full_data.csv", max_pages=10):
    """
    Extract data from a table that spans multiple pages.
    Scrolls down and extracts each page, then combines results.
    """
    all_rows = []
    headers = None

    for page in range(max_pages):
        print(f"Extracting page {page + 1}...")
        screenshot_b64 = take_screenshot()

        prompt = "Extract ALL table data visible on screen as JSON: {\"headers\": [...], \"rows\": [[...], ...]}"
        if page > 0:
            prompt += " Do NOT include the header row if it is repeated from the previous page."

        response = client.responses.create(
            model="gpt-5.4",
            input=[{
                "role": "user",
                "content": [
                    {"type": "text", "text": prompt},
                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}}
                ]
            }],
            reasoning={"effort": "high"}
        )

        response_text = response.output_text
        if "```json" in response_text:
            response_text = response_text.split("```json")[1].split("```")[0]
        elif "```" in response_text:
            response_text = response_text.split("```")[1].split("```")[0]

        import json
        data = json.loads(response_text.strip())

        if headers is None:
            headers = data["headers"]

        if not data["rows"]:
            print("No more data found. Stopping.")
            break

        all_rows.extend(data["rows"])
        print(f"  Found {len(data['rows'])} rows (total: {len(all_rows)})")

        # Scroll down for next page
        pyautogui.scroll(-5)
        time.sleep(1.0)

    # Write combined CSV
    with open(output_file, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(headers)
        writer.writerows(all_rows)

    print(f"\nDone. Extracted {len(all_rows)} total rows to {output_file}")
    return output_file


if __name__ == "__main__":
    print("Make sure a spreadsheet or table is visible on your screen.")
    print("Starting extraction in 3 seconds...")
    time.sleep(3)
    extract_table_data()

Kuidas seda kasutada:

1. Avage tabelarvutus, andmebaasi vaatur või mis tahes rakendus, kus on ekraanil nähtavad tabeliandmed
2. Käivitage python extract_data.py
3. Kontrollige loodud faili extracted_data.csv eraldatud sisu leidmiseks

Tabelite puhul, mis ulatuvad mitmele leheküljele, kutsuge selle asemel extract_multi_page_data(). See kerib automaatselt ja ühendab kõik leheküljed üheks CSV-ks.

---

Turvalisuse parimad tavad

Computer Use annab GPT-5.4-le võime juhtida teie hiirt ja klaviatuuri. See võim nõuab ettevaatust.

Kasutage alati esmalt liivakasti. Enne automatiseerimise käivitamist oma tegelikul töölaual, testige seda virtuaalmasinas või virtuaalse ekraaniga Docker konteineris. See isoleerib vead ja hoiab ära juhuslikud kahjustused.

Vaadake tegevused enne täitmist üle. Muutke execute_action funktsiooni nii, et see prindiks iga tegevuse ja ootaks enne täitmist teie kinnitust:

def execute_action_safe(action):
    """Execute action only after user confirmation."""
    print(f"  Proposed action: {action.type}", end="")
    if hasattr(action, "x"):
        print(f" at ({action.x}, {action.y})", end="")
    if hasattr(action, "text"):
        print(f" text='{action.text[:30]}'", end="")
    print()

    confirm = input("  Execute? (y/n): ").strip().lower()
    if confirm == "y":
        execute_action(action)
    else:
        print("  Skipped.")

Seadke piirangud. Lisage maksimaalne tegevuste arv seansi kohta ja maksimaalne eelarve. run_automation funktsioonis olev parameeter max_steps piirab juba tsüklite arvu. Kulude jälgimiseks saate ka vastusobjektist jälgida tokenite kasutust.

Ärge kunagi automatiseerige tundlikke kontosid ilma järelevalveta. Ärge suunake Computer Use'i oma pangarakendusele, tundlike andmetega e-mailile või administraatori konsoolidele ilma iga tegevust jälgimata. GPT-5.4 võib teha valeklikke, lugeda UI elemente valesti või valida soovimatuid teid.

Kasutage PyAutoGUI turvakatkestust. Kui pyautogui.FAILSAFE = True (mis on vaikeseade), saate mis tahes automatiseerimise katkestada, liigutades hiire kiiresti ekraani vasakusse ülanurka. Hoidke see alati sisse lülitatud.

---

Levinud probleemide lahendamine

"Mudel ei tagasta ühtegi tegevust" -- Veenduge, et kasutate tööriista tüübina computer_use_preview, mitte lihtsalt computer_use. Kontrollige ka, et teie display_width ja display_height vastavad teie tegelikule ekraani resolutsioonile. Kui väärtused on valed, ei pruugi GPT-5.4 suuta ekraanitõmmist õigesti tõlgendada.

"Klikid maanduvad vales kohas" -- See juhtub tavaliselt skaleerimisega ekraanidel (nt Retina ekraanid macOS-is). PyAutoGUI töötab pikslikoordinaatides, kuid teie ekraan võib kasutada loogilisi koordinaate. Proovige jäädvustada oma resolutsioon pyautogui.size() abil ja võrrelda seda oma tegeliku piksliresolutsiooniga. Retina ekraaniga macOS-is võib teil tekkida vajadus jagada koordinaadid oma skaleerimisteguriga.

"PyAutoGUI ei leia ekraani" -- Ilma ekraanita Linuxi serverites installige ja käivitage Xvfb: Xvfb :99 -screen 0 1920x1080x24 & ja seejärel export DISPLAY=:99. macOS-is peate andma Terminalile (või oma IDE-le) juurdepääsuõigused menüüs System Settings > Privacy & Security > Accessibility.

"API tagastab 429 rate limit vea" -- Lisage API kutsete vahele time.sleep(2) või rakendage eksponentsiaalne tagasilangus. GPT-5.4 Computer Use seansid võivad tabada rate limiite, kui saadate ekraanitõmmiseid liiga kiiresti.

"Kõrged tokenite kulud" -- Täisresolutsiooniga ekraanitõmmised tarbivad palju tokeneid. Vähendage kulusid, muutes ekraanitõmmiste suurust enne nende kodeerimist:

def take_screenshot_resized(max_width=1280):
    screenshot = pyautogui.screenshot()
    ratio = max_width / screenshot.width
    new_size = (max_width, int(screenshot.height * ratio))
    screenshot = screenshot.resize(new_size)
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8"), ratio

Suurust muudetud ekraanitõmmiste kasutamisel ärge unustage korrutada GPT-5.4 poolt tagastatud koordinaate suhtarvu pöördväärtusega enne nende edastamist PyAutoGUI-le.

"GPT-5.4 jääb tsüklisse kinni" -- Kui mudel kordab pidevalt sama tegevust, võib ta olla UI olekust segaduses. Lisage loogika korduvate tegevuste tuvastamiseks ja tsükli katkestamiseks või suurendage analüüsi pingutust "high" peale parema otsustusprotsessi saavutamiseks.

---

Mis edasi

Kui teil on põhiline automatiseerimistsükkel töötamas, on siin viisid selle laiendamiseks:

Ühendage mitu ülesannet. Ehitage töövoog, mis avab teie e-maili, laadib alla manuse, avab selle tabelarvutuses, eraldab konkreetsed lahtrid ja kleebib väärtused aruande malli. Iga etapp kasutab sama ekraanitõmmise-analüüsi-tegevuse tsüklit.

Lisage vigade taastamine. Kontrollige igat ekraanitõmmist veadialoogide või ootamatute olekute suhtes. Kui GPT-5.4 tuvastab, et midagi läks valesti, saab ta üritada taastuda, klikkides "Cancel", vajutades Escape või proovides viimast tegevust uuesti.

Kombineerige Playwright-iga brauseriülesannete jaoks. Ainult veebipõhise automatiseerimise jaoks saab GPT-5.4 kirjutada ka Playwright koodi, et brauseritega programmiliselt suhelda. See on kiirem ja usaldusväärsem kui ekraanitõmmisel põhinev klikkimine struktureeritud veebilehtede puhul. Kasutage Computer Use'i töölauarakenduste jaoks ja Playwright brauseri automatiseerimiseks.

Ehitage ülesannete raamatukogu. Salvestage tavalised juhised ja töövood korduvkasutatavate funktsioonidena. Looge tasks/ kataloog skriptidega nagu fill_invoice.py, export_report.py ja update_crm.py, mida teie meeskond saab nõudmisel käivitada.

Ajastage automatiseerimised. Kasutage cron-i (Linux/macOS) või Task Scheduler-it (Windows), et käivitada oma automatiseerimisskripte määratud aegadel. Kombineerige virtuaalse ekraaniga täielikult järelevalveta tööks.

GPT-5.4 Computer Use on veel uus funktsionaalsus ja API pind areneb edasi. Hoidke oma openai pakett ajakohasena käsuga pip install --upgrade openai, et saada uusimaid tööriistatüüpe ja parameetreid, kui OpenAI funktsiooni täiustab.

Selles õpetuses olev kood annab teile töötava aluse. Alustage lihtsatest, madala riskiga ülesannetest, veenduge, et automatiseerimine töötab õigesti, ja seejärel laiendage keerukamate töövoogudeni, kui teie usaldus süsteemi vastu kasvab.