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

Cur síos Fíor-Amsach a Chur i bhFeidhm i bPython

Ceacht 10 as 16 Nuashonraithe 3 Samhain 2026 Forbróir
Ar an leathanach seo
  1. An Sruth Asincronach Python Iomlán
  2. Ailtireacht an Chláir Sruthaithe
  3. Bunúsú
  4. Próiseáil a Struchtúrú don Táirgeadh
  5. Maireachtáil ar Bhriseadh Líonra
  6. Comhad Reatha a Ullmhú
  7. Príomhphointí

An cúrsa nuashonraithe an 3 Samhain, 2026 do Voxtral 3, bunaithe ar threoir Migrate from Voxtral 2 ó Mistral: Tá samhlacha Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), a díhógraíodh an 31 Deireadh Fómhair, 2026 agus a scoireadh an 30 Aibreán, 2027, curtha in ionad sna samplaí ag voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3, agus voxtral-mini-tts-3-0. Príomhathruithe: níl ach stampaí ama deighilte ann (fillfidh word earráid 400), tá dé-aitheantas (diarization) indéanta i bhfíor-am, tá socruithe seisiúin fíor-ama glasáilte tar éis an chéad smután fuaime, agus tá ionchuir context_bias saorchruthach (frásaí le spásanna). Foinse: Migrate from Voxtral 2(https://docs.mistral.ai/studio/audio/migrate-from-voxtral-2) · Speech to Text.

An Sruth Asincronach Python Iomlán

Tá tú chun píblíne iomlán cur síos fíor-ama a scríobh anois, ón gcéad bheart fuaime go dtí an comhad téacs deiridh. Braitheann gach rud ar asyncio: caithfidh an clár fuaime a léamh agus imeachtaí samhaltaithe a fháil ag an am céanna, gan ceachtar den dá oibríocht an ceann eile a bhac. Dá mba ghnáthchód comhthreomhar é, bheadh sé ag fanacht anseo go simplí, agus d’imíodh an moill a chumraigh tú go cúramach isteach san am marbh de do chlár féin.

Ailtireacht an Chláir Sruthaithe

Beag beann ar an bhfeidhmchlár, fanann an struchtúr mar an gcéanna agus léitear ó chlé go deas é. Ag barr an tsrutha, tá foinse fuaime: gineadóir asincronach a tháirgeann smutánna fuaime PCM. B’fhéidir gur comhad é inniu, micreafón nó sruth líonra amárach. Sa lár, tá cliant Voxtral, is é sin an SDK, a bhrúnn na smutánna seo chuig an tsamhail agus a sheachadann imeachtaí chugat. Ag bun an tsrutha, tá próiseáil imeachtaí: do loighic ghnó, a thaispeánann an téacs, a charnann é, a shábhálann é, nó a chuireann ar aghaidh chuig seirbhís eile é.

Audio Source → [PCM chunks] → Mistral SDK → [events] → Your Code

Tá tairbhe phraiticiúil ag baint leis an deighilt seo: tá an fhoinse fuaime in-idirmhalartaithe. Oibreoidh an cód cur síos a scríobhann tú thíos go díreach mar an gcéanna leis an ngineadóir micreafóin ón gcéad cheacht eile, gan líne amháin a athrú.

Bunúsú

Tá dhá shonra sa chéad chlár seo a thuilleann do aire. Gearrann an gineadóir source_audio_fichier an comhad ina bhloic de 32,000 beart, rud a fhreagraíonn go beacht do shoicind amháin d’fhuaime PCM monó 16-giotán ag 16 kHz: 16,000 sampla méadaithe faoi 2 bheart. Déanann an await asyncio.sleep a leanann gach yield aithris ar fhíor-am; tráchtáil an líne seo agus rith an clár ar eastóscán cúpla nóiméad, agus feicfidh tú an comhad ithe i gcuid bheag de shoicind, rud nach múineann duit faoi iompar sruthaithe ar bith. Ar an taobh glactha, carnann texte_complet blúirí ionas go mbeidh an téacs iomlán ar fáil agat ag an deireadh, chomh maith leis an taispeáint bheo.

import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)

async def source_audio_fichier(chemin: str, taille_chunk: int = 32000):
    """Asynchronous generator that reads a PCM file in chunks.

    taille_chunk = 32000 bytes = 1 second of 16-bit mono PCM audio at 16kHz
    (16000 samples × 2 bytes = 32000 bytes)
    """
    with open(chemin, "rb") as f:
        while True:
            chunk = f.read(taille_chunk)
            if not chunk:
                break
            yield chunk
            # Simulate real time (1 chunk = 1 second)
            await asyncio.sleep(len(chunk) / 32000)

async def transcrire_realtime(source_audio):
    """Transcribes an audio stream in real time with Voxtral."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

    audio_format = AudioFormat(
        encoding="pcm_s16le",
        sample_rate=16000
    )

    texte_complet = []

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=source_audio,
        model="voxtral-mini-transcribe-realtime-3",
        audio_format=audio_format,
    ):
        if isinstance(event, TranscriptionStreamTextDelta):
            print(event.text, end="", flush=True)
            texte_complet.append(event.text)

        elif isinstance(event, TranscriptionStreamDone):
            print("\n\n--- Transcription finished ---")

    return "".join(texte_complet)

async def main():
    source = source_audio_fichier("audio.pcm")
    texte = await transcrire_realtime(source)

    # Save the result
    with open("transcription_realtime.txt", "w", encoding="utf-8") as f:
        f.write(texte)
    print(f"\nText saved ({len(texte)} characters)")

asyncio.run(main())

Braitheann an taispeáint bheo ar print(event.text, end="", flush=True). Gan flush=True, déanann Python maolánú ar an aschur agus bheadh an téacs le feiceáil i mbaitseanna: bheadh do chur síos teicniúil fíor-ama, ach go radharcach bheadh sé leathnach.

Próiseáil a Struchtúrú don Táirgeadh

A luaithe a théann d’fheidhmchlár thar léiriú, éiríonn an lúb if/elif míchompordach: ba mhaith leat blúirí a chomhaireamh, fad a thomhas, scáileán a nascadh, nó bunachar sonraí a bheathú. Réitíonn an loighic a chapsúlú i rang an fhadhb uair amháin agus go deo. Faigheann gach cineál imeachta a mhodh tiomnaithe féin, agus is féidir leat iompar a chur leis – mar shampla, gach delta a sheoladh chuig comhéadan gréasáin – gan an lúb glactha a bhaint.

class GestionnaireTranscription:
    """Handles real-time transcription events."""

    def __init__(self):
        self.texte_complet = []
        self.nb_deltas = 0
        self.debut = None

    async def traiter(self, source_audio):
        """Starts transcription and processes events."""
        import time
        self.debut = time.time()

        client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
        audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=source_audio,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                self._on_text_delta(event)
            elif isinstance(event, TranscriptionStreamDone):
                self._on_done(event)

        return self.obtenir_resultat()

    def _on_text_delta(self, event):
        """Called for each new text fragment."""
        self.texte_complet.append(event.text)
        self.nb_deltas += 1
        # Live display
        print(event.text, end="", flush=True)

    def _on_done(self, event):
        """Called at the end of transcription."""
        import time
        duree = time.time() - self.debut
        print(f"\n\nFinished in {duree:.1f}s")
        print(f"Fragments received: {self.nb_deltas}")

    def obtenir_resultat(self) -> str:
        """Returns the full transcribed text."""
        return "".join(self.texte_complet)

async def main():
    gestionnaire = GestionnaireTranscription()
    source = source_audio_fichier("audio.pcm")
    texte = await gestionnaire.traiter(source)
    print(f"Result: {len(texte)} characters")

asyncio.run(main())

Ní cleas é an comhaireamhóir nb_deltas: i gcoibhneas le fad na fuaime, léiríonn sé ráta astaithe na samhla agus tugann sé rabhadh duit má thagann meath ar an sruth.

Maireachtáil ar Bhriseadh Líonra

Fanann nasc sruthaithe oscailte ar feadh ré an óráide ar fad, rud a nochtann é i bhfad níos mó ná iarratas as líne cúpla soicind. D’fhéadfadh Wi-Fi atá ag preabadh, lasc líonra ar ghléas soghluaiste, nó briseadh oibreora an sruth a bhriseadh. Tosaíonn an patrún thíos an cur síos arís suas le trí huaire, le moill a mhéadaíonn le gach iarracht chun am a thabhairt don líonra teacht chuige féin. Thairis sin, scaiptear an eisceacht: is fearr teip shoiléir ná feidhmchlár a bhfuil cuma air go bhfuil sé ag éisteacht le faic.

import asyncio
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)

MAX_TENTATIVES = 3
DELAI_RECONNEXION = 2  # seconds

async def transcrire_avec_retry(source_audio, tentative=1):
    """Transcription with automatic reconnection."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    try:
        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=source_audio,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                print(event.text, end="", flush=True)
            elif isinstance(event, TranscriptionStreamDone):
                print("\n[Finished]")

    except ConnectionError as e:
        if tentative < MAX_TENTATIVES:
            print(f"\nNetwork error (attempt {tentative}/{MAX_TENTATIVES})")
            await asyncio.sleep(DELAI_RECONNEXION * tentative)
            await transcrire_avec_retry(source_audio, tentative + 1)
        else:
            print(f"\nFailed after {MAX_TENTATIVES} attempts: {e}")
            raise

Comhad Reatha a Ullmhú

Chun tástáil le comhad MP3 nó WAV atá agat cheana féin, is féidir leat an tiontú go PCM a uathoibriú ó Python seachas é a rith de láimh. Tarmligean an fheidhm thíos an obair do FFmpeg, díorthaíonn sé an t-ainm aschuir ón ainm ionchuir, agus filleann sé an cosán mar thoradh, réidh le cur chuig source_audio_fichier.

import subprocess

def convertir_en_pcm(chemin_entree: str, chemin_sortie: str = None) -> str:
    """Converts an audio file to 16-bit 16kHz mono PCM via FFmpeg."""
    if chemin_sortie is None:
        chemin_sortie = chemin_entree.rsplit(".", 1)[0] + ".pcm"

    subprocess.run([
        "ffmpeg", "-y",
        "-i", chemin_entree,
        "-f", "s16le",
        "-acodec", "pcm_s16le",
        "-ar", "16000",
        "-ac", "1",
        chemin_sortie
    ], check=True, capture_output=True)

    return chemin_sortie

# Usage
chemin_pcm = convertir_en_pcm("reunion.mp3")
# Then use source_audio_fichier(chemin_pcm)

Tá dhá réamhchúram leis an bhfeidhm seo. Ardaíonn check=True eisceacht má theipeann ar FFmpeg, rud atá níos fearr ná comhad PCM folamh a fháil amach níos déanaí sa sruth; agus folaíonn capture_output=True aschur an uirlis, ionas go mbeidh cuma reoite ar an gclár má tá tiontú fada ar siúl. Do thaifeadtaí a mhaireann uair an chloig, pleanáil teachtaireacht a phriontáil roimh agus tar éis an glaonna.

Príomhphointí

  • Úsáideann sruthú gineadóirí asincronacha (async for, yield)
  • Is ionann smután 32,000 beart agus soicind amháin d’fhuaime PCM monó 16-giotán ag 16 kHz
  • Struchtúraigh próiseáil imeachtaí i rang don táirgeadh
  • Cuir meicníocht athiarrtha i bhfeidhm chun earráidí líonra a láimhseáil
  • Bain úsáid as FFmpeg chun comhaid fuaime atá ann cheana a thiontú go PCM
  • Úsáideann taispeáint bheo print(text, end="", flush=True)