fastrag.ingestion.steps.parsing.audio#

Speech transcription through an OpenAI-compatible /audio/transcriptions endpoint.

Module Attributes

AUDIO_MEDIA_TYPES

Audio media types AudioParser is meant to be routed to, including the aliases different platforms' mimetypes tables report.

audio_filter

The filter a ParserRouter route to AudioParser matches against.

Classes

AudioParser(*, model, api_key, base_url[, ...])

Transcribe audio sources to text with an OpenAI-compatible Whisper endpoint.
fastrag.ingestion.steps.parsing.audio.AUDIO_MEDIA_TYPES: frozenset[str] = frozenset({'audio/aac', 'audio/flac', 'audio/m4a', 'audio/mp3', 'audio/mp4', 'audio/mpeg', 'audio/ogg', 'audio/opus', 'audio/vnd.wave', 'audio/wav', 'audio/wave', 'audio/webm', 'audio/x-flac', 'audio/x-m4a', 'audio/x-wav'})#

Audio media types AudioParser is meant to be routed to, including the aliases different platforms’ mimetypes tables report.

fastrag.ingestion.steps.parsing.audio.audio_filter = <fastrag.ingestion.filters.mediatype.MediaTypeFilter object>#

The filter a ParserRouter route to AudioParser matches against.

parser = ParserRouter(cache=cache).route(audio_filter, AudioParser(...))
Parameters:

item (T_contra)

Return type:

bool

class fastrag.ingestion.steps.parsing.audio.AudioParser(*, model, api_key, base_url, language=None, prompt=None, timeout=600, extra_body=None, cache=None, policy=None)[source]#

Bases: Parser

Transcribe audio sources to text with an OpenAI-compatible Whisper endpoint.

base_url is the API root (e.g. https://host/v1); the request goes to {base_url}/audio/transcriptions as multipart form data. Credentials are excluded from cache identity; model, endpoint, language, prompt and extra form fields are included.

Parameters:

  • model (str)

  • api_key (str)

  • base_url (str)

  • language (str | None)

  • prompt (str | None)

  • timeout (float)

  • extra_body (Mapping[str, Any] | None)

  • cache (CacheStore | Literal[False] | None)

  • policy (Policy | None)

accepted_media_types: frozenset[str] | None = frozenset({'audio/*', 'video/mp4', 'video/webm'})#

None retains legacy permissiveness; MIME patterns may use type/*.

config()[source]#

Return transcription-affecting settings without credentials.

Return type:

Mapping[str, Any]

async transcribe(content, filename, content_type)[source]#

POST audio bytes to the transcription endpoint and return the text.

Parameters:
Return type:

str

async transform(item, context)[source]#

Yield one transcript document for an audio source.

Parameters:
Return type:

AsyncIterator[Document]

build_document(source, content, metadata=None, *, content_format=None)#

Build one document from source’s parsed content.

Sets id (a hash of the source identity and parsed content), source_id, step_config_hash (this parser’s own config_hash), and the reserved metadata keys every parser gets right without writing them itself: source_uri, content_type (source’s own, as declared or guessed upstream), and content_format (what kind of string content is — content_format unless overridden for this one call). The site_name/favicon_url a fetcher found on source are carried over too, unless metadata sets its own.

Parameters:

  • source (Source) – The source content was parsed from.

  • content (str) – The parsed text.

  • metadata (dict[str, Any] | None) – Extra metadata to carry, e.g. an HTML page’s title.

  • content_format (ContentFormat | None) – Overrides content_format for this one document, for a parser whose output format depends on its own configuration rather than being fixed per class.

Return type:

Document

property cache: CacheStore | Literal[False] | None#

Return the cache explicitly configured for this step.

property config_hash: str#

Invalidate cached documents created before source-aware identities.

content_format: ContentFormat = 'text'#

The ContentFormat this parser’s documents carry by default, stamped by build_document() into metadata["content_format"]. Override on a subclass whose output is always one format (HtmlParser/DocusaurusParser set MARKDOWN); pass content_format= to a single build_document() call instead for a parser whose output format depends on its own configuration.

effective_policy(context)#

Resolve this step’s policy over the one inherited from context.

The step’s own explicitly-set fields take priority; everything else falls through to the pipeline (or enclosing router/aggregator) policy.

Parameters:

context (ExecutionContext)

Return type:

Policy

async evaluate(context)#

Emit DocumentParsed per document.

Wraps DocumentStep’s concrete evaluate (which already resolved, per item, whether the document came from cache or a fresh transform() call — document.cached is trustworthy either way) rather than emitting inside a concrete parser’s own transform(), so the event fires the same way for a cache hit as for a fresh parse, and exactly once regardless of how many layers of routing (e.g. ParserRouter) produced the document.

Parameters:

context (ExecutionContext)

Return type:

AsyncIterator[Document]

async evaluate_items(items, context)#

Transform a bounded cache window independently of worker concurrency.

Parameters:
Return type:

AsyncIterator[Document]

event_name: str = 'Parsing'#

The stage this step’s work belongs to, e.g. "Chunking".

Declared as a plain class attribute by a family base class, and inherited by every concrete step in that family:

class Chunker(DocumentStep, ABC):
    event_name = "Chunking"


class ChunkerRouter(RoutedStep[Document], Chunker):
    ...  # -> "Chunking", inherited from `Chunker`

A concrete step overrides it to opt out of its family’s label:

class ChunkerRouter(RoutedStep[Document], Chunker):
    event_name = "ChunkerRouter"  # -> "ChunkerRouter"

Resolution walks the MRO for the first class that declares it in its own class body (so a mixin listed first, e.g. RoutedStep, contributes nothing unless it declares one itself), and falls back to the class’s own name when nothing in the MRO does — a step family that never declares an event_name still labels each of its steps distinctly rather than collapsing them under one blank heading. That fallback is computed per instance rather than assigned onto the class: assigning it would make it look “declared” to every subclass, which would then inherit their base’s name instead of getting their own.

property policy: Policy | None#

Return the policy explicitly configured for this step.

replay_needs_content: bool = False#

Set by a step whose cached replay reads the full documents anyway (e.g. to re-validate them): its cache reads then skip the header-only projection rather than fetching every entry twice.

async run()#

Execute this step independently and collect every item.

Builds a default ExecutionContext when none is installed (this step’s own policy, or a fresh Policy). Intended primarily for testing and standalone use — pipeline-wide event observation is Pipeline’s job.

Return type:

list[T]

property upstream: PipelineStep[Any] | None#

Return the upstream step bound via __call__, or None.

Read-only counterpart to __call__’s self._upstream assignment — lets external code (e.g. Pipeline, walking a graph from its root to classify each step by position) introspect composition without reaching into a private attribute.

validate_input(item)#

Validate declared source capabilities before work and cache replay.

Parameters:

item (Source)

Return type:

None

name: str#