Patrúin Chasta
Ar an leathanach seo
Nuashonraithe an 3 Samhain 2026: D’fhill an fho-shreab oibre roimhe seo
execution.output, rud atá in easnamh i SDKmistralaileagan 3.7.0. Léitear an toradh anois óresult, ag baint úsáide aswait_for_result=Truechun fanacht go mbeidh sé críochnaithe.
Thar Shreabanna Oibre Líneacha
Go dtí seo, táimid tar éis breathnú ar shreabanna oibre a fheidhmíonn gníomhaíochtaí go seicheamhach. Sa chleachtas, éilíonn cásanna úsáide sa saol mór patrúin níos sofaisticiúla: sreabanna oibre a shlabhrú, gníomhaíochtaí a rith i gcomhthreomhar, nó cinntí coinníollacha casta a dhéanamh. Clúdaíonn na ceithre phatrún seo—slabhrú, leanúnachas, comhthreomhaireacht, agus fan-out/fan-in—beagnach gach ailtireacht a bheidh ort a thógáil.
Sreabanna Oibre a Shlabhrú
Is féidir le sreab oibre sreab oibre eile a thosú. Freastalaíonn an cumas seo ar dhá sprioc ar leith: loighic chasta a bhriseadh síos ina bhfo-shreabanna oibre in-athúsáidte, agus teorainn 51,200 imeacht in aghaidh an fheidhmithe a shárú, ós rud é go bhfaigheann gach sreab oibre páiste a bhuiséad féin. Braitheann an mheicníocht ar ghníomhaíocht, an t-aon áit ar féidir leis an SDK glao líonra a dhéanamh go dlisteanach.
import mistralai.workflows as workflows
from mistralai.client import Mistral
@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
"""Launches a child workflow and waits for its result."""
client = Mistral()
execution = await client.workflows.execute_workflow_async(
workflow_identifier=workflow_name,
input=input_data,
wait_for_result=True, # wait for the child workflow result
)
return execution.result
@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
# Step 1: Data collection (dedicated sub-workflow)
data = await launch_sub_workflow(
"data_collection",
{"sources": params["sources"]}
)
# Step 2: Analysis (dedicated sub-workflow)
analysis = await launch_sub_workflow(
"content_analysis",
{"data": data}
)
# Step 3: Report generation (dedicated sub-workflow)
report = await launch_sub_workflow(
"report_generation",
{"analysis": analysis, "format": params["format"]}
)
return report
Téann an tairbhe thar inléiteacht shimplí: déantar data_collection ina shreab oibre neamhspleách, in-ghabhálach le tástáil ar leithligh agus in-athúsáidte ag píblínte eile, lena chuid teorainneacha ama agus polasaithe athiarrtha féin.
Cruthaíonn an mheicníocht chéanna, nuair a chuirtear i bhfeidhm í ar shreab oibre a ghlaonn air féin, an patrún leanúnachais. In ionad céad míle mír a phróiseáil in fheidhmiú amháin—rud a chuireann an cap imeachta cosc air—próiseálann an sreab oibre baisc agus tarmligíonn sé an chuid eile d’fhochás nua.
@workflows.workflow.define(name="batch_processing")
class BatchProcessing:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
offset = params.get("offset", 0)
batch_size = 100
# Retrieve the current batch
batch = await retrieve_batch(offset, batch_size)
if not batch["items"]:
# All batches processed
return {"status": "completed", "total_processed": offset}
# Process the current batch
await process_batch(batch["items"])
# Launch the next batch via a new workflow
next_batch = await launch_sub_workflow(
"batch_processing",
{"offset": offset + batch_size}
)
return next_batch
Tosaíonn gach feidhmiú nua le dialann ghlan. Éiríonn líon na míreanna in-phróiseáilte gan teorainn, agus is é an coinníoll stoptha ná baisc fholamh go simplí.
Comhthreomhaireacht le asyncio.gather
Nuair atá gníomhaíochtaí neamhspleách ar a chéile, níl aon ghá leo a rith go seicheamhach. Cuireann asyncio.gather faoi bhráid an ardáin iad go comhuaineach, agus tagraíonn an t-am iomlán do luas na gníomhaíochta is moille seachas suim na ngníomhaíochtaí go léir.
import asyncio
import mistralai.workflows as workflows
@workflows.activity()
async def analyze_source(url: str) -> dict:
"""Analyzes a data source."""
async with httpx.AsyncClient() as client:
response = await client.get(url)
return {"url": url, "size": len(response.text)}
@workflows.workflow.define(name="parallel_analysis")
class ParallelAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# Launch all analyses in parallel
results = await asyncio.gather(
*[analyze_source(url) for url in urls]
)
return {
"source_count": len(results),
"results": list(results)
}
Tá rabhadh amháin ann, áfach: de réir réamhshocraithe, scaipeann gather an chéad eisceacht a thagann chun cinn agus toirmisceann sé an tacar iomlán. Má tá tú ag déanamh anailíse ar cheithre fhoinse sheachtracha, is leor ceann amháin a bheith as líne chun an tríocha naoi eile a chailleadh. Athraíonn an paraiméadar return_exceptions=True an iompar seo: filleann earráidí mar ghnáthluachanna, ag fágáil duitse iad a shórtáil amach.
@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# return_exceptions=True prevents one error from blocking the others
results = await asyncio.gather(
*[analyze_source(url) for url in urls],
return_exceptions=True
)
successes = []
errors = []
for i, result in enumerate(results):
if isinstance(result, Exception):
errors.append({"url": urls[i], "error": str(result)})
else:
successes.append(result)
return {
"successes": successes,
"errors": errors,
"success_rate": len(successes) / len(urls)
}
Filleann an sreab oibre seo toradh páirteach mar aon le ráta ratha, rud a ligeann do phróisis síos an srutha a chinneadh an bhfuil an cháilíocht leordhóthanach nó an bhfuil gá le hiarracht athnuaite.
Cinntí a Dhéanamh sa Sreab Oibre
Ní hamháin go gceadaítear brainsíocht chasta, ach is minic gurb é príomhphointe úsáid sreabanna oibre é, ar choinníoll go dtagann na coinníollacha ó thorthaí gníomhaíochta. Léiríonn an cás measúnaithe ábhair an loighic chascáideach seo go maith: cinneadh uathoibríoch nuair atá an tsamhail an-mhuiníneach, dara tuairim nuair atá an mhuinín measartha, agus éalú go dtí duine i gcás easaontais nó muiníne ísle.
@workflows.workflow.define(name="content_moderation")
class ContentModeration:
@workflows.workflow.entrypoint
async def run(self, content: dict) -> dict:
# Step 1: Automatic analysis
analysis = await auto_analyze_content(content["text"])
if analysis["confidence_score"] > 0.95:
# High confidence: automatic decision
if analysis["category"] == "acceptable":
await publish_content(content["id"])
return {"decision": "published", "method": "automatic"}
else:
await reject_content(content["id"], analysis["reason"])
return {"decision": "rejected", "method": "automatic"}
elif analysis["confidence_score"] > 0.7:
# Moderate confidence: second analysis with a different model
second_analysis = await analyze_content_model_b(content["text"])
if analysis["category"] == second_analysis["category"]:
# Both models agree
if analysis["category"] == "acceptable":
await publish_content(content["id"])
return {"decision": "published", "method": "ai_consensus"}
else:
await reject_content(content["id"], analysis["reason"])
return {"decision": "rejected", "method": "ai_consensus"}
else:
# Disagreement: human escalation
await escalate_moderation(content["id"], analysis, second_analysis)
return {"decision": "pending", "method": "human_escalation"}
else:
# Low confidence: direct escalation
await escalate_moderation(content["id"], analysis, None)
return {"decision": "pending", "method": "human_escalation"}
Tabhair faoi deara an réimse method a fhilltear ag gach pointe scortha: ligeann sé duit a thomhas go haisghabhálach cén chuid den ábhar a próiseáladh gan idirghabháil dhaonna, agus na tairseacha a choigeartú dá réir.
Fan-out / Fan-in
Comhcheanglaíonn an patrún deireanach na cinn roimhe: dáil obair i gcomhthreomhar, ansin comhiománaigh na torthaí ag pointe amháin. Anseo, aistrítear doiciméad go comhuaineach go dtí trí theanga, déantar anailís ar gach aistriúchán i gcomhthreomhar, agus tagann gach rud le chéile in achoimre.
@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
@workflows.workflow.entrypoint
async def run(self, document: dict) -> dict:
# Fan-out: translate in parallel into 3 languages
translations = await asyncio.gather(
translate(document["text"], "en"),
translate(document["text"], "de"),
translate(document["text"], "es")
)
# Fan-out: analyze each translation in parallel
analyses = await asyncio.gather(
*[analyze_sentiment(trad["translated_text"]) for trad in translations]
)
# Fan-in: aggregate results
summary = await aggregate_analyses(list(analyses))
return summary
Tá an dá thonnta comhthreomhaireachta leantach toisc go mbraitheann an dara ceann ar thorthaí an chéad cheann. I seicheamh docht, d’éileodh an sreab oibre seo seacht nglao slabhraithe; anseo, ní chosnaíonn sé ach trí chéim eagraíochta.
Go hachomair, bris síos sreabanna oibre casta ina bhfo-shreabanna oibre in-athúsáidte, déan comhthreomhaireacht ar ghníomhaíochtaí neamhspleácha, cumasaigh return_exceptions=True nuair atá teipeanna páirteacha inghlactha, coinnigh leanúnachas i dtaisce do phróisis an-fhada, agus bí cinnte i gcónaí go mbraitheann do bhrainsíocht ar thorthaí gníomhaíochta seachas luachanna neamhchinntitheacha.
Príomhphointí
- Is féidir le sreab oibre sreabanna oibre eile a thosú trí ghníomhaíocht a ghlaonn ar an SDK
- Ligeann an patrún leanúnachais próiseáil a dhéanamh ar líon gan teorainn míreanna i mbaisc leantacha
- Ligeann
asyncio.gatherduit gníomhaíochtaí a rith i gcomhthreomhar chun an t-am iomlán a laghdú - Tacaítear le brainsíocht choinníollach chasta fad is a bhraitheann sí ar thorthaí gníomhaíochta
- Dáileann an patrún fan-out / fan-in obair agus comhiománaíonn sé na torthaí ina dhiaidh sin