Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Uathoibriú sreabha oibre ilchéime

Ceacht 9 as 14 Nuashonraithe 3 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Castachtaí a eagrú i sreabha oibre
  2. Ailtireacht bunaithe ar chéimeanna
  3. An t-orchestraí
  4. Sonraí a rith idir céimeanna
  5. Sreabha oibre coinníollacha
  6. Comhthreomharú
  7. Príomhphointí

An ceacht nuashonraithe an 3 Samhain 2026 de réir treoirlínte comhtháthaithe Úsáid Ríomhaire OpenAI: ní láimhseálann an gníomhaire an t-iontráil a thuilleadh; éilíonn bailíochtú orduithe agus craobhacha a chuireann an t-úsáideoir faoi dhliteanas (léirmheasanna, orduithe nua) deimhniú daonna; seiceálann an t-orchestraí an critéar success_text_contains nár thug sé aird air roimhe seo, cuireann sé céimeanna teipthe in iúl in ionad iad a scipeáil, agus ní dhéanann sé athsheinm ar chéim a chruthaíonn sonraí riamh. Foinse: Confirmation and consent.

Castachtaí a eagrú i sreabha oibre

Is annamh a bhíonn sreabha oibre sa saol mór comhdhéanta d’aon ghníomh amháin. Baineann CRM a líonadh le nascleanúint idir leathanaigh, teagmháil a aimsiú, a chuid faisnéise a nuashonrú, agus ansin deis a chruthú—ceithre oibríocht slabhraithe, ar féidir le gach ceann acu teip ar chúiseanna ar leith. An bloc iomlán seo a thabhairt do ghníomhaire in aon leid amháin, oibríonn sé uaireanta, ach ní bheidh a fhios agat riamh cá háit ar theip sé. Múineann an ceacht seo duit na huathoibrithe ilchéime seo a struchtúrú ionas go mbeidh gach nasc inbhraite agus in-athsheinmte.

Ailtireacht bunaithe ar chéimeanna

Tosaigh tríd an sreabhadh oibre a bhriseadh síos ina chéimeanna adamhacha, gach ceann acu le cuspóir soiléir agus critéar ratha. Is é an critéar seo a dhéanann idirdhealú idir liosta le déanamh agus fíor-shreabhadh oibre: gan é, ní féidir le d’orchestraí a rá an raibh an gníomhaire rathúil i ndáiríre nó an stop sé ar leathanach earráide. Sa sampla thíos, déantar seiceáil ar oscailt an mhodúil tríd an URL, agus ar an gcuardach trí ainm an teagmhálaí a bheith ar an scáileán. Níl an t-iontráil san áireamh anseo: láimhseáil do chód é sin roimh ré, gan an pasfhocal a nochtadh don mhúnla (Ceacht 8). Tá "retry": False ar an gcéim dheireanach toisc go gcruthaíonn sí sonraí: d’fhéadfadh athsheinm tar éis teip pháirteach cóip dhúbailte a chruthú.

workflow = [
    {
        "name": "open_contacts",
        "task": "Open the Contacts module in the CRM.",
        "success_url_contains": "/contacts",
    },
    {
        "name": "search_contact",
        "task": "Search for contact 'Jean Dupont' in the search bar.",
        "success_text_contains": "Jean Dupont",
    },
    {
        "name": "update_record",
        "task": "Open Jean Dupont's profile and update their phone number: 06 98 76 54 32.",
    },
    {
        "name": "create_opportunity",
        "task": "Create an opportunity: 'Cloud Migration Q2 2026', amount 50000 EUR, probability 60%.",
        "retry": False,  # non-replayable step: creates data
    },
]

An t-orchestraí

Anois, ní mór duit an liosta seo a fhorghníomhú. Siúlann an t-orchestraí tríd na céimeanna go seicheamhach, gach ceann acu timfhilleadh i lúb athiarrachta: déantar iarracht arís ar chéim a ardaíonn eisceacht nó a theipeann ar a critéar ratha suas le max_retries uair, mura marcáiltear í mar neamh-in-athsheinmte. Tá tábhacht leis an mionsonra seo sa táirgeadh, toisc go minic a bhíonn teipeanna gníomhairí amhairc sealadach—leathanach mall, léiriú neamhiomlán ag am an scáileáin. Stopann céim a theipeann go cinntitheach an sreabhadh oibre, ós rud é go mbraitheann na céimeanna ina dhiaidh sin uirthi. Ar deireadh, filleann an t-orchestraí loga struchtúrtha a léiríonn, do gach céim, a stádas agus líon na n-iarrachtaí a úsáideadh: do chéad uirlis diagnóise.

def run_workflow(workflow: list, page, max_retries: int = 2):
    """Executes a multi-step workflow with retries."""
    results = []

    for step in workflow:
        step_name = step["name"]
        print(f"\n--- Step: {step_name} ---")
        attempts = max_retries + 1 if step.get("retry", True) else 1
        error = "success criterion not met"

        for attempt in range(attempts):
            try:
                run_agent(step["task"], page=page)

                # Optional checks: URL, then visible text
                url_check = step.get("success_url_contains")
                if url_check and url_check not in page.url:
                    print("  Expected URL not found")
                    continue
                text_check = step.get("success_text_contains")
                if text_check and text_check not in page.locator("body").inner_text():
                    print("  Expected text not found")
                    continue

                print(f"  Success (attempt {attempt + 1})")
                results.append({"step": step_name, "status": "success", "attempts": attempt + 1})
                break

            except Exception as e:
                print(f"  Error: {e}")
                error = str(e)
        else:
            # No attempt succeeded: subsequent steps depend on this one
            results.append({"step": step_name, "status": "failed", "error": error})
            break

    return results

Sonraí a rith idir céimeanna

Go minic, cruthaíonn céim amháin sonraí atá ag teastáil don chéad eile: ní mór an praghas a léadh ar leathanach ciseáin a fhíorú ag an gcéim seiceála; feidhmíonn an uimhir cháis a cruthaíodh i gcéim 2 mar thagairt i gcéim 5. Réitíonn comhthéacs roinnte an riachtanas seo gan do chód a thiontú ina fhíor-chorrach d’athróga domhanda. Stopann an sampla thíos d’aon ghnó roimh an íocaíocht: aicmíonn OpenAI deimhniú idirbhirt airgeadais mar ghníomh a éilíonn bailíochtú úsáideora ag an am feidhmithe. Stórálann an rang thíos péirí eochair-luacha agus nochtann sé modh inject a chuireann marcóirí {key} in ionad i dteimpléad leid, rud a ligeann duit do chuid tascanna a scríobh mar theimpléid pharaiméadraithe.

class WorkflowContext:
    """Stores data shared between steps."""

    def __init__(self):
        self.data = {}

    def set(self, key: str, value):
        self.data[key] = value

    def get(self, key: str, default=None):
        return self.data.get(key, default)

    def inject(self, template: str) -> str:
        """Replaces {key} variables in the template."""
        task = template
        for key, value in self.data.items():
            task = task.replace("{" + key + "}", str(value))
        return task


# Usage example
ctx = WorkflowContext()

# Step 1: agent reads a price
extracted_price = run_agent(
    "Read the total price displayed and return only the number.",
    page=page
)
ctx.set("price", extracted_price.strip())

# Step 2: agent verifies, without validating anything
verdict = run_agent(ctx.inject(
    "The expected amount is {price} EUR. Compare it to the total on the payment page "
    "and answer only OK or MISMATCH. Do not validate anything."
), page=page)

# Step 3: a transaction is confirmed at the moment of action, by a human
if verdict.strip() == "OK":
    if input(f"Confirm order for {ctx.get('price')} EUR? [y/N] ").strip().lower() == "y":
        run_agent("Click the order confirmation button.", page=page)

Sreabha oibre coinníollacha

Buaileann seichimh líneacha a dteorainneacha go tapa, toisc go mbraitheann an chéad chéim eile ar an toradh roimhe. Is é seo an patrún le cuimhneamh air: iarr ar an ngníomhaire ar dtús staid a léamh trí iallach a chur air freagairt le luach ó shraith dhúnta, ansin déan craobhú i bPython. Maidir le rianú ordaithe, tugann stádas “próiseáil” ar rianú pacáiste, tugann “seachadta” ar fháil dáta an tseachadta, agus tugann “cealaithe” ar fháil an chúis. Tá srianta formáide sa leid riachtanach: gan iad, filleann an gníomhaire abairt a chailleann do chuid comparáidí go minic. Fanann na trí chraobh inléite amháin: d’fhéadfadh postáil léirmheasa nó athordú an t-úsáideoir a chur faoi dhliteanas agus éilíodh a dheimhniú.

def conditional_workflow(page):
    """Workflow with conditional branching."""
    # Step 1: Read status
    status = run_agent(
        "Read the order status. "
        "Return only: processing, delivered, or canceled.",
        page=page
    )

    # Branch based on result
    match status.strip().lower():
        case "processing":
            return run_agent("Click 'Track package' and note the displayed stage.", page=page)
        case "delivered":
            return run_agent("Note the displayed delivery date.", page=page)
        case "canceled":
            return run_agent("Note the displayed cancellation reason.", page=page)
        case _:
            raise ValueError(f"Unexpected status: {status!r}")

Comhthreomharú

Nuair a bhíonn tascanna neamhspleách, níl aon ghá iad a phróiseáil go seicheamhach. Tógann sé i bhfad níos lú ama sonraí a bhaint as trí bhileog táirge má oibríonn trí ghníomhaire comhuaineach, gach ceann acu ina chluaisín féin. Is leor leagan async Playwright agus asyncio.gather: comhroutine amháin in aghaidh an URL, new_page amháin in aghaidh na comhroutine, agus dúnadh córasach leathanaigh chun carnadh cluaisíní sa chuimhne a sheachaint. Is é run_agent_async an lúb ó Cheacht 4 atá athscríofa leis an gcliant AsyncOpenAI agus API async Playwright: an loighic chéanna, le await roimh gach glao. Cuimhnigh go méadaíonn comhthreomharú do thréchur glaonna API freisin, rud a mhéadaíonn an riosca go mbuailfidh tú do theorainneacha ráta (Ceacht 11), agus do luchtú ar an suíomh sprioc—ní thugtar faoi deara trí chluaisín, ach tugtar faoi deara caoga i bhfad níos mó.

import asyncio
from playwright.async_api import async_playwright

async def parallel_extraction(urls: list[str]):
    """Extracts data from multiple pages in parallel."""
    async with async_playwright() as pw:
        browser = await pw.chromium.launch(headless=True)

        async def extract_one(url: str):
            page = await browser.new_page(
                viewport={"width": 1280, "height": 720}
            )
            try:
                await page.goto(url)
                result = await run_agent_async(
                    "Extract the product title and price.", page=page
                )
            finally:
                await page.close()
            return {"url": url, "data": result}

        results = await asyncio.gather(
            *[extract_one(url) for url in urls]
        )

    return results

# Run
urls = [
    "https://shop.example.com/product/1",
    "https://shop.example.com/product/2",
    "https://shop.example.com/product/3",
]
data = asyncio.run(parallel_extraction(urls))

Príomhphointí

  • Brise sreabha oibre síos ina gcéimeanna adamhacha le critéir ratha sainráite
  • Déan athsheinm uathoibríoch ar chéimeanna is féidir a athiarradh go sábháilte, ach riamh ar chinn a chruthaíonn sonraí
  • Úsáid comhthéacs roinnte chun sonraí a rith idir céimeanna
  • Oiriúnaíonn sreabha oibre coinníollacha d’ábhar an leathanaigh; éilíonn craobhacha a chuireann an t-úsáideoir faoi dhliteanas a dheimhniú
  • Déan tascanna neamhspleácha a chomhthreomharú chun am a shábháil