Skip to content

Speakr is a personal, self-hosted web application designed for transcribing audio recordings

Python
4.6 KB
Raw Blame
"""Read a stored transcript as segments, whatever key set it was saved with.

Transcripts are stored as JSON lists of segments. Older connectors and edits
saved 'start'/'end'/'text' where newer ones save 'start_time'/'end_time'/
'sentence'. Every reader that needs segments goes through segments_of(), so
the key sets are handled in one place.
"""

import json


def _number(value):
    """Seconds as a float from a number, a numeric string or "[hh:]mm:ss[.f]"."""
    if value is None or isinstance(value, bool):
        return None
    try:
        return float(value)
    except (TypeError, ValueError):
        pass
    if isinstance(value, str) and ':' in value:
        try:
            seconds = 0.0
            for part in value.strip().split(':'):
                seconds = seconds * 60 + float(part)
            return seconds
        except ValueError:
            return None
    return None


def segments_of(transcription):
    """[{index, speaker, text, start_time, end_time}] for a JSON transcript,
    None for a plain-text transcript or no transcript."""
    if not transcription:
        return None
    try:
        data = json.loads(transcription)
    except (TypeError, ValueError):
        return None
    if not isinstance(data, list):
        return None
    segments = []
    for index, seg in enumerate(data):
        if not isinstance(seg, dict):
            continue
        text = seg.get('sentence')
        if text is None:
            text = seg.get('text', '')
        segments.append({
            'index': index,
            'speaker': seg.get('speaker') or None,
            'text': str(text or ''),
            'start_time': _number(seg.get('start_time', seg.get('start'))),
            'end_time': _number(seg.get('end_time', seg.get('end'))),
        })
    return segments


def canonical_segments(recording):
    """The documented API shape of a JSON transcript (mailr spec G12), or None
    for a plain-text transcript.

    Every segment has index, speaker, speaker_label, speaker_id, text,
    sentence, start_time and end_time. speaker is the linked saved speaker's
    current name when the segment is linked; speaker_label is the
    diarization label, recovered from the label map after a rename.
    """
    from src.services.speaker_links import (LABEL, _labels_by_name, _sample_speakers, owner_speakers,
                                            resolve_id)
    import json as _json
    segments = segments_of(recording.transcription)
    if segments is None:
        return None
    try:
        raw = [s for s in _json.loads(recording.transcription) if isinstance(s, dict)]
    except (TypeError, ValueError):
        raw = []
    by_name, by_id = owner_speakers(recording.user_id) if recording.user_id else ({}, {})
    samples = _sample_speakers(recording)
    labels_by_name = _labels_by_name(recording)
    label_of_speaker = {}
    for label, sid in samples.items():
        label_of_speaker.setdefault(sid, label)
    result = []
    for seg, stored in zip(segments, raw):
        name = seg['speaker']
        name_text = name.strip() if isinstance(name, str) else None
        stored_id = stored.get('speaker_id')
        # A valid stored link wins: the name in the segment may be an older
        # spelling of the same person.
        sid = stored_id if stored_id in by_id else resolve_id(name, None, by_name, by_id, samples, labels_by_name)
        if name_text and LABEL.match(name_text):
            label = name_text
        else:
            labels = labels_by_name.get((name_text or '').lower(), [])
            label = labels[0] if labels else label_of_speaker.get(sid)
        result.append({
            'index': seg['index'],
            'speaker': by_id[sid].name if sid in by_id else name,
            'speaker_label': label,
            'speaker_id': sid,
            'text': seg['text'],
            'sentence': seg['text'],
            'start_time': seg['start_time'],
            'end_time': seg['end_time'],
        })
    return result


def window(segments, start=None, end=None, max_segments=None):
    """Segments overlapping [start, end] seconds, at most max_segments.
    Returns (segments, next_start or None)."""
    picked = []
    for seg in segments:
        s_time = seg['start_time']
        e_time = seg['end_time'] if seg['end_time'] is not None else s_time
        if start is not None and (e_time is None or e_time < start):
            continue
        if end is not None and (s_time is None or s_time > end):
            continue
        picked.append(seg)
    if max_segments is not None and len(picked) > max_segments:
        following = picked[max_segments]
        return picked[:max_segments], following['start_time']
    return picked, None