slu

type AudioContext ¶

type AudioContext struct {
	ID          uuid.UUID `json:"id"`
	Segments    Segments  `json:"segments"`
	IsFinalised bool      `json:"is_finalised"`
}

AudioContext represents a single SLU audio context, which can have multiple segments. See Speechly documentation for more information about audio contexts.

func NewAudioContext() AudioContext

func (c *AudioContext) AddEntity(segmentID int32, e Entity) error

func (c *AudioContext) AddTranscript(segmentID int32, t Transcript) error

func (c AudioContext) CheckID(id string) error

func (c *AudioContext) Finalise() error

func (c *AudioContext) FinaliseSegment(segmentID int32) error

func (c *AudioContext) SetID(id string) error

func (c *AudioContext) SetIntent(segmentID int32, i Intent) error

type AudioContextHandler ¶

type AudioContextHandler interface {
	// Read reads the next AudioContext state from the handler.
	// If the context has been stopped, this will return io.EOF.
	// If any error has happened while handling the context, this will return it.
	Read() (AudioContext, error)

	// Close closes the handler by signalling it to send the StopContext event and exit the loop.
	Close() error
}

AudioContextHandler is a handler for a single AudioContext stream. It handles the sending of audio data by starting a new audio context, sending audio data and stopping the context. It handles the receiving of SLU responses by processing them into an AudioContext state and exposing an API to access the snapshots of that state.

An example of such state progression is something like this:

* First state:

{
  "id": "ae275a56-66b6-49a3-addb-90df03edb946",
  "segments": [],
  "is_finalised": false
}

* Second state:

{
  "id": "ae275a56-66b6-49a3-addb-90df03edb946",
  "segments": [
    {
      "id": 0,
      "is_finalised": false,
      "transcripts": [
        {
          "word": "TURN",
          "index": 2,
          "start_time": 480,
          "end_time": 720,
          "is_finalised": false
        }
      ],
      "entities": [],
      "intent": {
        "value": "",
        "is_finalised": false
      }
    }
  ],
  "is_finalised": false
}

* Third state:

{
  "id": "ae275a56-66b6-49a3-addb-90df03edb946",
  "segments": [
    {
      "id": 0,
      "is_finalised": false,
      "transcripts": [
        {
          "word": "TURN",
          "index": 2,
          "start_time": 480,
          "end_time": 900,
          "is_finalised": false
        },
        {
          "word": "OFF",
          "index": 3,
          "start_time": 900,
          "end_time": 1020,
          "is_finalised": false
        }
      ],
      "entities": [],
      "intent": {
        "value": "turn_off",
        "is_finalised": true
      }
    }
  ],
  "is_finalised": false
}

And so forth, until eventually the context is finalised by the API.

type AudioSource ¶

type AudioSource interface {
	io.WriterTo
	io.Closer
}

AudioSource is the interface that represents the audio data source that is sent to SLU API within a particular audio context.

type Client ¶

type Client struct {
	*pgrpc.Client
	// contains filtered or unexported fields
}

Client is a client for Speechly SLU API.

func NewClient(u url.URL, t speechly.AccessToken, log logger.Logger) (*Client, error)

func (c *Client) StreamingRecognise(ctx context.Context, fmt Config) (RecogniseStream, error)

type Config ¶

type Config struct {
	NumChannels     int32
	SampleRateHertz int32
	LanguageCode    language.Tag
}

Config is the configuration of an SLU recognition stream. It is used by the client to send Config requests when starting new streams. For more information, check the Speechly SLU API documentation.

type Entities ¶ added in v1.0.2

type Entities map[EntityIndex]Entity

Entities is a map of SLU entities.

func NewEntities(e []Entity) Entities

func (e Entities) MarshalJSON() ([]byte, error)

type Entity ¶

type Entity struct {
	Type        string `json:"type"`
	Value       string `json:"value"`
	StartIndex  int32  `json:"start_index"`
	EndIndex    int32  `json:"end_index"`
	IsFinalised bool   `json:"is_finalised"`
}

Entity is the entity detected by SLU API.

func (e *Entity) Parse(v *sluv1.SLUEntity, isTentative bool) error

type EntityIndex ¶ added in v1.0.2

type EntityIndex struct {
	StartIndex, EndIndex int32
}

EntityIndex is a struct used for indexing entities.

type EntityIndexList ¶ added in v1.0.4

type EntityIndexList []EntityIndex

EntityIndexList is a list of entity indices. It implements the sort.Interface, so it can be used for obtaining sorted list of entity indices.

func SortedEntityIndexList(e Entities) EntityIndexList

func (e EntityIndexList) Len() int

func (e EntityIndexList) Less(i, j int) bool

func (e EntityIndexList) Swap(i, j int)

type Intent ¶

type Intent struct {
	Value       string `json:"value"`
	IsFinalised bool   `json:"is_finalised"`
}

Intent is the intent detected by SLU API.

func (i *Intent) Parse(v *sluv1.SLUIntent, isTentative bool) error

type RecogniseStream ¶

type RecogniseStream interface {
	// NewAudioContext starts a new audio context by sending a START even to SLU API.
	// If there is already an audio context running,
	// this will block until the running context is stopped, or the stream closed.
	NewAudioContext(context.Context, AudioSource, int) (AudioContextHandler, error)

	// Close closes the stream by closing the sending part of gRPC stream.
	// It will wait for current audio context (if any) to be stopped, before closing the stream.
	Close() error
}

RecogniseStream is a single SLU recognition stream, which maps to a gRPC stream. Since one stream can have multiple contexts RecogniseStream provides an API for launching these. However, only a single audio context can be active at a time, which is controlled and guaranteed by the stream.

type Segment ¶

type Segment struct {
	ID          int32       `json:"id"`
	IsFinalised bool        `json:"is_finalised"`
	Transcripts Transcripts `json:"transcripts"`
	Entities    Entities    `json:"entities"`
	Intent      Intent      `json:"intent"`
}

Segment represents a single SLU segment, which is bounded by a single SLU intent. See Speechly documentation for more information about segments.

func NewSegment(id int32) Segment

func (s *Segment) AddEntity(e Entity) error

func (s *Segment) AddTranscript(t Transcript) error

func (s *Segment) Finalise() error

func (s *Segment) SetIntent(i Intent) error

type Segments ¶ added in v1.0.2

type Segments map[int32]Segment

Segments is a map of SLU segments.

func NewSegments(s []Segment) Segments

func (s Segments) Get(id int32) Segment

func (s Segments) MarshalJSON() ([]byte, error)

type Transcript ¶

type Transcript struct {
	Word        string `json:"word"`
	Index       int32  `json:"index"`
	StartTime   int32  `json:"start_time"`
	EndTime     int32  `json:"end_time"`
	IsFinalised bool   `json:"is_finalised"`
}

Transcript is a transcript of a word, detected by Speechly SLU API.

func (t *Transcript) Parse(v *sluv1.SLUTranscript, isTentative bool) error

type Transcripts ¶ added in v1.0.2

type Transcripts map[int32]Transcript

Transcripts is a map of SLU transcripts.

func NewTranscripts(t []Transcript) Transcripts

func (t Transcripts) MarshalJSON() ([]byte, error)