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

Rith agus tástáil sreabha oibre

Ceacht 7 as 14 Nuashonraithe 3 Samhain 2026 Ardleibhéal
Ar an leathanach seo
  1. Sreabha oibre a thosú
  2. Tionscnamh tríd an SDK Python
  3. Tionscnamh trí cURL
  4. Sampla ó thús go deireadh
  5. Seiceáil torthaí
  6. Láimhseáil earráidí
  7. Tástáil áitiúil
  8. Príomhphointí

An ceacht nuashonraithe an 3 Samhain, 2026 bunaithe ar SDK mistralai 3.7.0: úsáideann rianú feidhmithe anois client.workflows.executions.get_workflow_execution_async, agus léitear an toradh ó result. Forlíonadh an lae chéanna: thagairt na samplaí roimhe seo do execution.id, execution.output, agus execution.error, nach bhfuil sa SDK, agus rinne siad comparáid idir stádas agus "completed" nó "failed" in litreacha beaga; úsáideann siad anois execution_id, result, wait_for_result=True, agus stádas in litreacha móra. Foinse: client-python.

Sreabha oibre a thosú

Tá do ghníomhaíochtaí scríofa agat, tá do shreabha oibre sainmhínithe, agus tá d’oibritheoir tosaithe. Anois, ní mór duit feidhmiú a sheoladh. Tá dhá rogha agat: an SDK Python nó glao cURL ar an API REST. Oireann an chéad cheann do do scripteanna agus seirbhísí Python; oibríonn an dara ceann do thástálacha tapa líne na hordaithe nó do thionscnaimh ó chórais nach Python iad—webhook, sceidealóir, nó backend scríofa i dteanga eile.

Ní mór trí choinníoll a bheith comhlíonta sula dtionscnóidh tú aon rud. Caithfidh d’oibritheoir a bheith ag rith (uv run python worker.py), caithfidh d’eochair API a bheith socraithe in MISTRAL_API_KEY, agus caithfidh an sreabha oibre a bheith cláraithe leis an oibritheoir sin, rud a chiallaíonn go bhfeictear é sa liosta a ritear chuig run_worker().

Tionscnamh tríd an SDK Python

Scríobh an tionscnamh i script ar leithligh ón oibritheoir, toisc nach dtugann próiseas an oibritheora smacht ar ais riamh:

import asyncio
from mistralai.client import Mistral

async def main():
    client = Mistral()

    execution = await client.workflows.execute_workflow_async(
        workflow_identifier="salutation_workflow",
        input={"nom": "Marie"},
        wait_for_result=True,  # fan le críochnú agus faigh an toradh
    )

    print(f"Execution ID: {execution.execution_id}")
    print(f"Result: {execution.result}")

if __name__ == "__main__":
    asyncio.run(main())

Freagraíonn an workflow_identifier go beacht don name a dheclaraíodh in @workflows.workflow.define(), agus freagraíonn na heochracha san fhearann input do pharaiméadair do mhodha run. Rith an script seo i deiriceal ar leith, ag fágáil an chéad cheann faoi ghlas ag an oibritheoir:

uv run python trigger.py

Le wait_for_result=True, fanann an SDK go gcríochnóidh an feidhmiú agus filleann sé an toradh go díreach, rud a fhágann go bhfuil tástáil an-inléite do shreafaí oibre gairide. Gan an paraiméadar seo, filleann an glao láithreach leis an aitheantóir feidhmithe, ar féidir leat é a rianú ansin (féach thíos).

Tionscnamh trí cURL

Chun tástálacha tapa nó comhtháthú le córais eile, nochtann an API REST an tionscnamh céanna:

curl -X POST https://api.mistral.ai/v1/workflows/salutation_workflow/execute \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input": {"nom": "Marie"}, "wait_for_result": true}'

Le wait_for_result, bíonn ainm an tsreabha oibre, an t-aitheantóir feidhmithe, agus a thoradh sa fhreagra; is iad seo réimsí mhúnla WorkflowExecutionSyncResponse an SDK:

{
  "workflow_name": "salutation_workflow",
  "execution_id": "…",
  "result": {
    "message": "Bonjour, Marie !"
  }
}

Coinnigh an execution_id seo: is é an eochair é a úsáidfidh tú níos déanaí chun an feidhmiú a fhiosrú nó chun a rianta a aisghabháil. Gan wait_for_result, déanann an freagra cur síos ar an bhfeidhmiú atá ag rith, lena n-áirítear a status (RUNNING ar dtús).

Sampla ó thús go deireadh

Déanaimis athbhreithniú ar an sampla píblíne anailíse doiciméad, an uair seo nasctha go hiomlán. Comhcheanglaíonn an chéad chomhad na sainmhínithe agus tosú an oibritheora; tabhair faoi deara an gearradh go 5000 carachtar, a chosnaíonn an teorainn méide gníomhaíochta agus do bhuiséad token araon.

Comhad workflow.py (oibritheoir + sainmhínithe)

import asyncio
import httpx
import mistralai.workflows as workflows
from mistralai.client import Mistral

@workflows.activity()
async def extraire_texte(url: str) -> dict:
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
    return {"texte": response.text[:5000]}  # Teorainn le 5000 carachtar

@workflows.activity()
async def resumer_texte(texte: str) -> dict:
    client = Mistral()
    response = await client.chat.complete_async(
        model="mistral-large-latest",
        messages=[
            {"role": "system", "content": "Summarize in 3 sentences."},
            {"role": "user", "content": texte}
        ]
    )
    return {"resume": response.choices[0].message.content}

@workflows.workflow.define(name="resume_page_web")
class ResumePageWeb:
    @workflows.workflow.entrypoint
    async def run(self, url: str) -> dict:
        extraction = await extraire_texte(url)
        resume = await resumer_texte(extraction["texte"])
        return {
            "url_source": url,
            "resume": resume["resume"]
        }

async def main() -> None:
    await workflows.run_worker([ResumePageWeb])

if __name__ == "__main__":
    asyncio.run(main())

Comhcheanglaíonn an dara comhad an sreabha oibre agus taispeánann sé an toradh, ag láimhseáil an cháis teipthe go sainráite—cleachtas le glacadh leis ó do chéad script:

Comhad trigger.py (tionscnamh)

import asyncio
from mistralai.client import Mistral

async def main():
    client = Mistral()

    print("Launching workflow...")
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier="resume_page_web",
        input={"url": "https://example.com/article"},
    )
    print(f"Execution launched: {execution.execution_id}")

    # Rianaigh an feidhmiú go dtí go gcríochnóidh sé
    while True:
        suivi = await client.workflows.executions.get_workflow_execution_async(
            execution_id=execution.execution_id
        )
        if suivi.status not in ("RUNNING", "RETRYING_AFTER_ERROR"):
            break
        await asyncio.sleep(2)

    if suivi.status == "COMPLETED":
        print(f"Summary: {suivi.result['resume']}")
    else:
        print(f"Execution finished with status {suivi.status}")

if __name__ == "__main__":
    asyncio.run(main())

Feidhmiú

Deiriceal 1 — Tosaigh an t-oibritheoir:

uv run python workflow.py

Deiriceal 2 — Tionscain an feidhmiú:

uv run python trigger.py

Seiceáil torthaí

Is é deiriceal an oibritheora do chéad phointe breathnóireachta: taispeánann sé gníomhaíochtaí curtha i gcrích i bhfíor-am, mar aon lena bhfad, ag taispeáint duit láithreach céim a ídíonn an t-am is mó.

[INFO] Executing activity: extraire_texte
[INFO] Activity completed: extraire_texte (1.2s)
[INFO] Executing activity: resumer_texte
[INFO] Activity completed: resumer_texte (3.4s)
[INFO] Workflow completed: resume_page_web

I gcás sreafaí oibre fada, ní fhanfaidh tú greamaithe don deiriceal ar ndóigh. Nuair a bheidh an t-aitheantóir feidhmithe agat, is féidir leat a stádas a fhiosrú ag am ar bith ó phróiseas eile:

execution = await client.workflows.executions.get_workflow_execution_async(
    execution_id="exec_abc123"
)
print(f"Status: {execution.status}")
print(f"Result: {execution.result}")

Tá an oibríocht chéanna ar fáil trí cURL, úsáideach i script faireachais:

curl https://api.mistral.ai/v1/workflows/executions/exec_abc123 \
  -H "Authorization: Bearer $MISTRAL_API_KEY"

Láimhseáil earráidí

Ní tharlaíonn teip ar an gcéad eisceacht: déanann an t-ardán iarracht arís ar an ngníomhaíocht ar dtús de réir a polasaí athiarrtha. Ní théann an feidhmiú go stádas FAILED ach amháin tar éis na hiarrachtaí athiarrtha a bheith ídithe (tá stádas an SDK in litreacha móra: RUNNING, COMPLETED, FAILED, CANCELED, TERMINATED, TIMED_OUT, srl.), agus caithfidh do chód glaonna an cás seo a láimhseáil in ionad glacadh leis go bhfuil result i gcónaí ann:

execution = await client.workflows.executions.get_workflow_execution_async(
    execution_id="exec_abc123"
)

if execution.status == "FAILED":
    print(f"Execution {execution.execution_id} failed")

Níl teachtaireacht earráide sa fhreagra: feictear an chúis i stair an fheidhmithe agus sna logaí (get_workflow_execution_history_async, get_workflow_execution_logs_async). Chun an ghníomhaíocht lochtach agus an seicheamh a thug chuici a shainaithint, déanfaidh tú anailís ar rianta OpenTelemetry, a chlúdaítear i gCeacht 14.

Tástáil áitiúil

Éiríonn an t-aistriú idir dhá dheiriceal tuirsiúil go tapa le linn forbartha. Chun críocha forbartha, is féidir le script amháin an t-oibritheoir a thosú sa chúlra, an sreabha oibre a thionscnamh, agus ansin gach rud a stopadh:

import asyncio
import mistralai.workflows as workflows

# ... sainmhínithe gníomhaíochta agus sreabha oibre ...

async def main():
    # Tosaigh oibritheoir sa chúlra
    worker_task = asyncio.create_task(
        workflows.run_worker([MonWorkflow])
    )

    # Fan go mbeidh an t-oibritheoir réidh
    await asyncio.sleep(2)

    # Tionscain sreabha oibre
    from mistralai.client import Mistral
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier="mon_workflow",
        input={"test": True},
        wait_for_result=True,
    )
    print(f"Result: {execution.result}")

    # Stop an t-oibritheoir
    worker_task.cancel()

if __name__ == "__main__":
    asyncio.run(main())

Tugann an asyncio.sleep(2) am don oibritheoir a nasc a bhunú sula dtionscnófar é, agus coscaíonn an worker_task.cancel() deireanach an script ó bheith ar crochadh go deo. Coinnigh an socrú seo don fhorbairt: i dtáirgeadh, fanann an t-oibritheoir agus na tionscnaimh ina bpróisis ar leith le saolréanna neamhspleácha.

Príomhphointí

  • Dhá mhodh tionscnaimh: SDK Python (execute_workflow_async) agus API REST (cURL)
  • Caithfidh an t-oibritheoir a bheith ag rith chun go bhfeidhmeoidh an sreabha oibre
  • Le wait_for_result=True, fanann an SDK go gcríochnóidh sé agus filleann sé an toradh (result); murach sin, filleann sé an execution_id le rianú
  • Úsáid client.workflows.executions.get_workflow_execution_async() chun stádas feidhmithe a sheiceáil
  • Tá stádas in litreacha móra (RUNNING, COMPLETED, FAILED, srl.); feictear cúiseanna teipe i stair an fheidhmithe, sna logaí, agus sna rianta
  • Chun críocha forbartha, comhcheangail an t-oibritheoir agus an tionscnamh i script amháin ag baint úsáide as asyncio