252 lines
6.7 KiB
Go
252 lines
6.7 KiB
Go
package schema
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"math"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type SourceSegment struct {
|
|
ID *sourceID `json:"id,omitempty"`
|
|
Speaker string `json:"speaker"`
|
|
Start float64 `json:"start"`
|
|
End float64 `json:"end"`
|
|
Text string `json:"text"`
|
|
Categories []string `json:"categories,omitempty"`
|
|
}
|
|
|
|
type Segment struct {
|
|
ID int `json:"id"`
|
|
Speaker string `json:"speaker"`
|
|
Start float64 `json:"start"`
|
|
End float64 `json:"end"`
|
|
Text string `json:"text"`
|
|
Categories []string `json:"categories,omitempty"`
|
|
}
|
|
|
|
type Transcript struct {
|
|
Segments []Segment `json:"segments"`
|
|
}
|
|
|
|
type SourceTranscript struct {
|
|
Segments []SourceSegment `json:"segments"`
|
|
}
|
|
|
|
func ParseSourceTranscriptJSON(raw []byte) (*SourceTranscript, error) {
|
|
if !json.Valid(raw) {
|
|
return nil, &ParseError{Message: "transcript is not valid JSON"}
|
|
}
|
|
|
|
segmentsRaw, err := extractSegments(bytes.TrimSpace(raw))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var segments []SourceSegment
|
|
if err := json.Unmarshal(segmentsRaw, &segments); err != nil {
|
|
return nil, &ParseError{Message: fmt.Sprintf("failed to parse segments: %v", err)}
|
|
}
|
|
if len(segments) == 0 {
|
|
return nil, &ParseError{Message: "transcript must contain at least one segment"}
|
|
}
|
|
|
|
if err := validateSourceSegments(segments); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &SourceTranscript{Segments: segments}, nil
|
|
}
|
|
|
|
// Canonical gives segments without source IDs their one-based position.
|
|
func (t *SourceTranscript) Canonical() *Transcript {
|
|
segments := make([]Segment, len(t.Segments))
|
|
for i, s := range t.Segments {
|
|
id := i + 1
|
|
if s.ID != nil {
|
|
id = int(*s.ID)
|
|
}
|
|
segments[i] = Segment{ID: id, Speaker: s.Speaker, Start: s.Start, End: s.End, Text: s.Text, Categories: slices.Clone(s.Categories)}
|
|
}
|
|
return &Transcript{Segments: segments}
|
|
}
|
|
|
|
// Clone copies the segment and category slices for independent mutation.
|
|
func (t *Transcript) Clone() *Transcript {
|
|
if t == nil {
|
|
return &Transcript{}
|
|
}
|
|
segments := slices.Clone(t.Segments)
|
|
for i := range segments {
|
|
segments[i].Categories = slices.Clone(segments[i].Categories)
|
|
}
|
|
return &Transcript{Segments: segments}
|
|
}
|
|
|
|
func extractSegments(raw []byte) (json.RawMessage, error) {
|
|
switch raw[0] {
|
|
case '[':
|
|
return raw, nil
|
|
case '{':
|
|
var envelope map[string]json.RawMessage
|
|
if err := json.Unmarshal(raw, &envelope); err != nil {
|
|
return nil, &ParseError{Message: fmt.Sprintf("failed to parse transcript JSON: %v", err)}
|
|
}
|
|
segments, ok := envelope["segments"]
|
|
if !ok {
|
|
return nil, &ParseError{Message: "transcript object must contain a segments array"}
|
|
}
|
|
segments = bytes.TrimSpace(segments)
|
|
if len(segments) == 0 || segments[0] != '[' {
|
|
return nil, &ParseError{Message: "segments field must be an array"}
|
|
}
|
|
return segments, nil
|
|
default:
|
|
return nil, &ParseError{Message: "transcript must be a JSON array or an object with a segments array"}
|
|
}
|
|
}
|
|
|
|
// sourceID decodes native integers without routing them through float64.
|
|
// Decimal and exponent spellings are accepted if they denote an exact integer.
|
|
type sourceID int
|
|
|
|
func (id *sourceID) UnmarshalJSON(raw []byte) error {
|
|
spelling := string(raw)
|
|
if value, err := strconv.Atoi(spelling); err == nil {
|
|
*id = sourceID(value)
|
|
return nil
|
|
}
|
|
if value, ok := integralDecimal(spelling); ok {
|
|
*id = sourceID(value)
|
|
return nil
|
|
}
|
|
return json.Unmarshal(raw, (*int)(id))
|
|
}
|
|
|
|
func integralDecimal(value string) (int, bool) {
|
|
if value == "" || (value[0] != '-' && (value[0] < '0' || value[0] > '9')) || !strings.ContainsAny(value, ".eE") {
|
|
return 0, false
|
|
}
|
|
digits, negative := strings.CutPrefix(value, "-")
|
|
var exponentText string
|
|
if i := strings.IndexAny(digits, "eE"); i >= 0 {
|
|
exponentText, digits = digits[i+1:], digits[:i]
|
|
}
|
|
whole, fraction, _ := strings.Cut(digits, ".")
|
|
digits = strings.TrimLeft(whole+fraction, "0")
|
|
if digits == "" {
|
|
return 0, true
|
|
}
|
|
var exponent int
|
|
if exponentText != "" {
|
|
var err error
|
|
exponent, err = strconv.Atoi(exponentText)
|
|
if err != nil || exponent < -len(digits) || exponent > len(fraction)+19 {
|
|
return 0, false
|
|
}
|
|
}
|
|
shift := exponent - len(fraction)
|
|
if shift < 0 {
|
|
// A negative shift is integral only if every discarded digit is zero.
|
|
if -shift > len(digits)-len(strings.TrimRight(digits, "0")) {
|
|
return 0, false
|
|
}
|
|
digits = digits[:len(digits)+shift]
|
|
} else {
|
|
if len(digits)+shift > 19 {
|
|
return 0, false
|
|
}
|
|
digits += strings.Repeat("0", shift)
|
|
}
|
|
if negative {
|
|
digits = "-" + digits
|
|
}
|
|
integer, err := strconv.Atoi(digits)
|
|
return integer, err == nil
|
|
}
|
|
|
|
func validateSourceSegments(segments []SourceSegment) error {
|
|
for i, s := range segments {
|
|
segLabel := segmentLabel(i, s.ID)
|
|
|
|
if s.Speaker == "" {
|
|
return &ValidationError{Field: fmt.Sprintf("%s.speaker", segLabel), Message: "must not be empty"}
|
|
}
|
|
|
|
if s.Text == "" {
|
|
return &ValidationError{Field: fmt.Sprintf("%s.text", segLabel), Message: "must not be empty"}
|
|
}
|
|
|
|
if err := validateTime(s.Start, fmt.Sprintf("%s.start", segLabel)); err != nil {
|
|
return err
|
|
}
|
|
if err := validateTime(s.End, fmt.Sprintf("%s.end", segLabel)); err != nil {
|
|
return err
|
|
}
|
|
|
|
if s.End < s.Start {
|
|
return &ValidationError{
|
|
Field: fmt.Sprintf("%s.end", segLabel),
|
|
Message: fmt.Sprintf("end (%g) must be greater than or equal to start (%g)", s.End, s.Start),
|
|
}
|
|
}
|
|
|
|
for j, cat := range s.Categories {
|
|
if cat == "" {
|
|
return &ValidationError{
|
|
Field: fmt.Sprintf("%s.categories[%d]", segLabel, j),
|
|
Message: "must not be empty",
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
seenIDs := make(map[int]int)
|
|
for i, s := range segments {
|
|
if s.ID != nil {
|
|
if firstIdx, exists := seenIDs[int(*s.ID)]; exists {
|
|
return &ValidationError{
|
|
Field: fmt.Sprintf("segment[%d].id", i),
|
|
Message: fmt.Sprintf("duplicate id %d (first used at segment[%d])", *s.ID, firstIdx),
|
|
}
|
|
}
|
|
seenIDs[int(*s.ID)] = i
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func validateTime(t float64, field string) error {
|
|
if math.IsNaN(t) || math.IsInf(t, 0) {
|
|
return &ValidationError{Field: field, Message: "must be a finite number"}
|
|
}
|
|
if t < 0 {
|
|
return &ValidationError{Field: field, Message: "must be non-negative"}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func segmentLabel(index int, id *sourceID) string {
|
|
if id != nil {
|
|
return fmt.Sprintf("segment[%d] (id=%d)", index, *id)
|
|
}
|
|
return fmt.Sprintf("segment[%d]", index)
|
|
}
|
|
|
|
// OutputSegments supplies the typed segment array used by both output envelopes.
|
|
// An empty transcript is encoded as an empty JSON array.
|
|
func (t *Transcript) OutputSegments() []Segment {
|
|
if t == nil || t.Segments == nil {
|
|
return []Segment{}
|
|
}
|
|
return t.Segments
|
|
}
|
|
|
|
func TranscriptToJSON(t *Transcript) ([]byte, error) {
|
|
return json.MarshalIndent(t.OutputSegments(), "", " ")
|
|
}
|