service Identity {
    rpc Login(LoginRequest) returns (LoginResponse) {}
}

message LoginRequest {
    string device_id = 1;
    string app_id = 2;
}

const identity = new Speechly.v1.Identity(host, credentials);
identity.login({ appId, deviceId }, (err, response) => {
  if (err) {
    return reject(err);
  }
  const token = response.token;
});

message LoginResponse {
    string token = 1; 
}

service SLU {
    rpc Stream(stream SLURequest) returns (stream SLUResponse) {}
}

const metadata = new grpc.Metadata();
metadata.add("Authorization", `Bearer ${token}`);
const client = new Speechly.v1.SLU(host, credentials);
const slu = client.Stream(metadata);

message SLURequest {
    oneof streaming_request {
        SLUConfig config = 1;
        SLUEvent event = 2;
        bytes audio = 3;
    }
}

slu.write({ config: { channels: 1, sampleRateHertz: 16000 } });
slu.write({ event: { event: "START" } });
const audio = new wav.Reader();
audio.on("data", audioData => {
  if (slu.writable) {
    slu.write({ audio: audioData });
  }
});
slu.on("data", data => {
  console.dir(data, { depth: null });
});
audio.on("end", () => {
  slu.write({ event: { event: "STOP" } });
  slu.end();
});
fs.createReadStream("../audio.wav").pipe(audio);

message SLURequest {
    enum Encoding {
        LINEAR16 = 0; 
    }
    Encoding encoding = 1;
    int32 channels = 2;
    int32 sample_rate_hertz = 3;
    string language_code = 4;
  }
}

message SLUEvent {
    enum Event {
        START = 0; 
        STOP = 1; 
    }
    Event event = 1;
}

message SLUResponse {
    string audio_context = 1;  
    int32 segment_id = 2;
    oneof streaming_response {
        SLUTranscript transcript = 3;
        SLUEntity entity = 4;
        SLUIntent intent = 5;
        SLUSegmentEnd segment_end = 6;

        SLUTentativeTranscript tentative_transcript = 7;
        SLUTentativeEntities tentative_entities = 8;
        SLUIntent tentative_intent = 9;

        SLUStarted started = 10;
        SLUFinished finished = 11;
    }
}

message SLUTentativeTranscript {
    string tentative_transcript = 1;
    repeated SLUTranscript tentative_words = 2;
}

message SLUTentativeEntities {
    repeated SLUEntity tentative_entities = 1;
}

message SLUEntity {
    string entity = 1;
    string value = 2;
    int32 start_position = 3;
    int32 end_position = 4;
}

message SLUIntent {
    string intent = 1;
}

message SLUSegmentEnd {
}

message SLUStarted {
}

message SLUFinished {
    // If the audio context finished with an error, then this field
    // contains a value.
    SLUError error = 2;
}

message SLUError {
    string code = 1; 
    string message = 2; 
}

const fs = require("fs");
const protoLoader = require("@grpc/proto-loader");
const grpc = require("grpc");
const wav = require("wav");

const appId = process.env.APP_ID;
if (appId === undefined) {
  throw new Error("APP_ID environment variable needs to be set");
}

let host = "api.speechgrinder.com";
let credentials = grpc.credentials.createSsl();

const SgGrpc = grpc.loadPackageDefinition(
  protoLoader.loadSync("../sg.proto", {
    keepCase: false,
    longs: String,
    enums: String,
    defaults: true,
    oneofs: true
  })
);

const login = (deviceId, appId) => {
  return new Promise((resolve, reject) => {
    const identity = new SgGrpc.speechgrinder.sgapi.v1.Identity(host, credentials);
    identity.login({ appId, deviceId }, (err, response) => {
      if (err) {
        return reject(err);
      }
      return resolve(response.token);
    });
  });
};

const start = slu => {
  const audio = new wav.Reader();

  slu.write({ config: { channels: 1, sampleRateHertz: 16000 } });
  slu.write({ event: { event: "START" } });

  audio.on("data", audioData => {
    if (slu.writable) {
      slu.write({ audio: audioData });
    }
  });
  slu.on("data", data => {
    console.dir(data, { depth: null });
  });
  audio.on("end", () => {
    slu.write({ event: { event: "STOP" } });
    slu.end();
  });
  fs.createReadStream("../audio.wav").pipe(audio);
};

Promise.resolve()
  .then(() => login("node-simple-test", appId))
  .catch(err => {
    console.error(err);
    process.exit();
  })
  .then(token => {
    const metadata = new grpc.Metadata();
    metadata.add("Authorization", `Bearer ${token}`);
    const client = new SgGrpc.speechgrinder.sgapi.v1.Slu(host, credentials);
    const slu = client.Stream(metadata);
    return start(slu);
  })
  .catch(err => {
    console.error(err);
  });

  

import os
import wave
import uuid

import grpc

from speechly_pb2 import SLURequest, SLUConfig, SLUEvent, LoginRequest
from speechly_pb2_grpc import IdentityStub as IdentityService
from speechly_pb2_grpc import SLUStub as SLUService

chunk_size = 8000

def audio_iterator():
    yield SLURequest(config=SLUConfig(channels=1, sample_rate_hertz=16000))
    yield SLURequest(event=SLUEvent(event='START'))
    with wave.open('output.wav', mode='r') as audio_file:
        audio_bytes = audio_file.readframes(chunk_size)
        while audio_bytes:
            yield SLURequest(audio=audio_bytes)
            audio_bytes = audio_file.readframes(chunk_size)
    yield SLURequest(event=SLUEvent(event='STOP'))

with grpc.secure_channel('api.speechly.com', grpc.ssl_channel_credentials()) as channel:
    token = IdentityService(channel) \
        .Login(LoginRequest(device_id=str(uuid.uuid4()), app_id=os.environ['APP_ID'])) \
        .token

with grpc.secure_channel('api.speechly.com', grpc.ssl_channel_credentials()) as channel:
    slu = SLUService(channel)
    responses = slu.Stream(
        audio_iterator(),
        None,
        [('authorization', 'Bearer {}'.format(token))])
    for response in responses:
        print(response)

service WLU { 
    rpc Text(WLURequest) returns (WLUResponse) {}
}

message WLURequest {
    string language_code = 1;
    string text = 2;
}

message WLUResponse {
    repeated WLUSegment segments = 1;
}

message WLUSegment {
    string text = 1;
    repeated WLUToken tokens = 2;
    repeated WLUEntity entities = 3;
    WLUIntent intent = 4;
}

message WLUToken {
    string word = 1;
    int32 index = 2;
}

message WLUEntity {
    string entity = 1;
    string value = 2;
    int32 start_position = 3;
    int32 end_position = 4;
}

message WLUIntent {
    string intent = 1;
}