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

Patrúin Chasta

Ceacht 11 as 14 Nuashonraithe 3 Samhain 2026 Ardleibhéal
Ar an leathanach seo
  1. Thar Shreabanna Oibre Líneacha
  2. Sreabanna Oibre a Shlabhrú
  3. Comhthreomhaireacht le asyncio.gather
  4. Cinntí a Dhéanamh sa Sreab Oibre
  5. Fan-out / Fan-in
  6. Príomhphointí

Nuashonraithe an 3 Samhain 2026: D’fhill an fho-shreab oibre roimhe seo execution.output, rud atá in easnamh i SDK mistralai leagan 3.7.0. Léitear an toradh anois ó result, ag baint úsáide as wait_for_result=True chun 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.gather duit 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