@aws-amplify/predictions 5.5.6-api-v6-models.b3abc9b.0 → 6.0.0

package/lib-esm/errors/utils/assertValidationError.d.ts

@@ -0,0 +1,2 @@
+import { PredictionsValidationErrorCode } from '../types/validation';
+export declare function assertValidationError(assertion: boolean, name: PredictionsValidationErrorCode): asserts assertion;

package/lib-esm/errors/utils/assertValidationError.js

@@ -0,0 +1,10 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { PredictionsError } from '../PredictionsError';
+import { validationErrorMap, } from '../types/validation';
+export function assertValidationError(assertion, name) {
+    if (!assertion) {
+        const { message, recoverySuggestion } = validationErrorMap[name];
+        throw new PredictionsError({ name, message, recoverySuggestion });
+    }
+}

package/lib-esm/index.d.ts

@@ -1,4 +1,2 @@
-import { Predictions } from './Predictions';
-import { AmazonAIConvertPredictionsProvider, AmazonAIIdentifyPredictionsProvider, AmazonAIPredictionsProvider, AmazonAIInterpretPredictionsProvider } from './Providers';
-export * from './types';
-export { Predictions, AmazonAIIdentifyPredictionsProvider, AmazonAIConvertPredictionsProvider, AmazonAIPredictionsProvider, AmazonAIInterpretPredictionsProvider, };
+export { Predictions } from './Predictions';
+export { IdentifyEntitiesInput, IdentifyEntitiesOutput, IdentifyLabelsInput, IdentifyLabelsOutput, IdentifyTextInput, IdentifyTextOutput, InterpretTextInput, InterpretTextOutput, SpeechToTextInput, SpeechToTextOutput, TextToSpeechInput, TextToSpeechOutput, TranslateTextInput, TranslateTextOutput, } from './types';

package/lib-esm/index.js

@@ -1,7 +1,3 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { Predictions } from './Predictions';
-import { AmazonAIConvertPredictionsProvider, AmazonAIIdentifyPredictionsProvider, AmazonAIPredictionsProvider, AmazonAIInterpretPredictionsProvider, } from './Providers';
-export * from './types';
-export { Predictions, AmazonAIIdentifyPredictionsProvider, AmazonAIConvertPredictionsProvider, AmazonAIPredictionsProvider, AmazonAIInterpretPredictionsProvider, };
-//# sourceMappingURL=index.js.map
+export { Predictions } from './Predictions';

package/{lib/Providers → lib-esm/providers}/AmazonAIConvertPredictionsProvider.d.ts

@@ -1,14 +1,13 @@
-import { AbstractConvertPredictionsProvider } from '../types/Providers/AbstractConvertPredictionsProvider';
-import { TranslateTextInput, TextToSpeechInput, SpeechToTextInput, TranslateTextOutput, TextToSpeechOutput, SpeechToTextOutput } from '../types';
-export declare class AmazonAIConvertPredictionsProvider extends AbstractConvertPredictionsProvider {
-    private translateClient;
-    private pollyClient;
-    constructor();
+import { SpeechToTextInput, SpeechToTextOutput, TextToSpeechInput, TextToSpeechOutput, TranslateTextInput, TranslateTextOutput } from '../types';
+export declare class AmazonAIConvertPredictionsProvider {
+    private translateClient?;
+    private pollyClient?;
     getProviderName(): string;
+    convert(input: TranslateTextInput | TextToSpeechInput | SpeechToTextInput): Promise<TextToSpeechOutput | TranslateTextOutput | SpeechToTextOutput>;
     protected translateText(input: TranslateTextInput): Promise<TranslateTextOutput>;
     protected convertTextToSpeech(input: TextToSpeechInput): Promise<TextToSpeechOutput>;
     protected convertSpeechToText(input: SpeechToTextInput): Promise<SpeechToTextOutput>;
-    static serializeDataFromTranscribe(message: any): string;
+    static serializeDataFromTranscribe(message: MessageEvent): string;
     private sendDataToTranscribe;
     private sendEncodedDataToTranscribe;
     private getAudioEventMessage;

package/lib-esm/providers/AmazonAIConvertPredictionsProvider.js

@@ -0,0 +1,303 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Amplify, ConsoleLogger as Logger, fetchAuthSession, } from '@aws-amplify/core';
+import { Category, PredictionsAction, Signer, getAmplifyUserAgentObject, } from '@aws-amplify/core/internals/utils';
+import { PollyClient, SynthesizeSpeechCommand } from '@aws-sdk/client-polly';
+import { TranslateClient, TranslateTextCommand, } from '@aws-sdk/client-translate';
+import { EventStreamCodec, } from '@smithy/eventstream-codec';
+import { fromUtf8, toUtf8 } from '@smithy/util-utf8';
+import { Buffer } from 'buffer';
+import { PredictionsValidationErrorCode } from '../errors/types/validation';
+import { assertValidationError } from '../errors/utils/assertValidationError';
+import { isConvertBytesSource, isTextToSpeechInput, isTranslateTextInput, isValidConvertInput, } from '../types';
+const logger = new Logger('AmazonAIConvertPredictionsProvider');
+const eventBuilder = new EventStreamCodec(toUtf8, fromUtf8);
+const LANGUAGES_CODE_IN_8KHZ = ['fr-FR', 'en-AU', 'en-GB', 'fr-CA'];
+export class AmazonAIConvertPredictionsProvider {
+    constructor() {
+        this.inputSampleRate = 44100;
+    }
+    getProviderName() {
+        return 'AmazonAIConvertPredictionsProvider';
+    }
+    convert(input) {
+        assertValidationError(isValidConvertInput(input), PredictionsValidationErrorCode.InvalidInput);
+        if (isTranslateTextInput(input)) {
+            logger.debug('translateText');
+            return this.translateText(input);
+        }
+        else if (isTextToSpeechInput(input)) {
+            logger.debug('textToSpeech');
+            return this.convertTextToSpeech(input);
+        }
+        else {
+            logger.debug('textToSpeech');
+            return this.convertSpeechToText(input);
+        }
+    }
+    async translateText(input) {
+        logger.debug('Starting translation');
+        const { translateText = {} } = Amplify.getConfig().Predictions?.convert ?? {};
+        assertValidationError(!!translateText.region, PredictionsValidationErrorCode.NoRegion);
+        const { defaults = {}, region } = translateText;
+        const { credentials } = await fetchAuthSession();
+        assertValidationError(!!credentials, PredictionsValidationErrorCode.NoCredentials);
+        const { sourceLanguage, targetLanguage } = defaults;
+        const sourceLanguageCode = input.translateText?.source?.language ?? sourceLanguage;
+        const targetLanguageCode = input.translateText?.targetLanguage ?? targetLanguage;
+        assertValidationError(!!sourceLanguageCode, PredictionsValidationErrorCode.NoSourceLanguage);
+        assertValidationError(!!targetLanguageCode, PredictionsValidationErrorCode.NoTargetLanguage);
+        this.translateClient = new TranslateClient({
+            region,
+            credentials,
+            customUserAgent: getAmplifyUserAgentObject({
+                category: Category.Predictions,
+                action: PredictionsAction.Convert,
+            }),
+        });
+        const translateTextCommand = new TranslateTextCommand({
+            SourceLanguageCode: sourceLanguageCode,
+            TargetLanguageCode: targetLanguageCode,
+            Text: input.translateText?.source?.text,
+        });
+        const data = await this.translateClient.send(translateTextCommand);
+        return {
+            text: data.TranslatedText,
+            language: data.TargetLanguageCode,
+        };
+    }
+    async convertTextToSpeech(input) {
+        const { credentials } = await fetchAuthSession();
+        assertValidationError(!!credentials, PredictionsValidationErrorCode.NoCredentials);
+        assertValidationError(!!input.textToSpeech?.source, PredictionsValidationErrorCode.NoSource);
+        const { speechGenerator } = Amplify.getConfig().Predictions?.convert ?? {};
+        assertValidationError(!!speechGenerator?.region, PredictionsValidationErrorCode.NoRegion);
+        const { defaults = {}, region } = speechGenerator;
+        const { voiceId: defaultVoiceId } = defaults;
+        const voiceId = input.textToSpeech?.voiceId ?? defaultVoiceId;
+        assertValidationError(!!voiceId, PredictionsValidationErrorCode.NoVoiceId);
+        this.pollyClient = new PollyClient({
+            region,
+            credentials,
+            customUserAgent: getAmplifyUserAgentObject({
+                category: Category.Predictions,
+                action: PredictionsAction.Convert,
+            }),
+        });
+        const synthesizeSpeechCommand = new SynthesizeSpeechCommand({
+            OutputFormat: 'mp3',
+            Text: input.textToSpeech?.source?.text,
+            VoiceId: voiceId,
+            TextType: 'text',
+            SampleRate: '24000',
+            // tslint:disable-next-line: align
+        });
+        const data = await this.pollyClient.send(synthesizeSpeechCommand);
+        const response = new Response(data.AudioStream);
+        const arrayBuffer = await response.arrayBuffer();
+        const blob = new Blob([arrayBuffer], {
+            type: data.ContentType,
+        });
+        const url = URL.createObjectURL(blob);
+        return {
+            speech: { url },
+            audioStream: arrayBuffer,
+            text: input.textToSpeech?.source?.text,
+        };
+    }
+    async convertSpeechToText(input) {
+        logger.debug('starting transcription..');
+        const { credentials } = await fetchAuthSession();
+        assertValidationError(!!credentials, PredictionsValidationErrorCode.NoCredentials);
+        const { transcription } = Amplify.getConfig().Predictions?.convert ?? {};
+        assertValidationError(!!transcription?.region, PredictionsValidationErrorCode.NoRegion);
+        const { defaults, region } = transcription;
+        const language = input.transcription?.language ?? defaults?.language;
+        assertValidationError(!!language, PredictionsValidationErrorCode.NoLanguage);
+        const source = input.transcription?.source;
+        assertValidationError(isConvertBytesSource(source), PredictionsValidationErrorCode.InvalidSource);
+        const connection = await this.openConnectionWithTranscribe({
+            credentials,
+            region,
+            languageCode: language,
+        });
+        const fullText = await this.sendDataToTranscribe({
+            connection,
+            raw: source.bytes,
+            languageCode: language,
+        });
+        return {
+            transcription: {
+                fullText,
+            },
+        };
+    }
+    static serializeDataFromTranscribe(message) {
+        let decodedMessage = '';
+        const transcribeMessage = eventBuilder.decode(Buffer.from(message.data));
+        const transcribeMessageJson = JSON.parse(toUtf8(transcribeMessage.body));
+        if (transcribeMessage.headers[':message-type'].value === 'exception') {
+            logger.debug('exception', JSON.stringify(transcribeMessageJson.Message, null, 2));
+            throw new Error(transcribeMessageJson.Message);
+        }
+        else if (transcribeMessage.headers[':message-type'].value === 'event') {
+            if (transcribeMessageJson.Transcript.Results.length > 0) {
+                if (transcribeMessageJson.Transcript.Results[0].Alternatives.length > 0) {
+                    if (transcribeMessageJson.Transcript.Results[0].Alternatives[0]
+                        .Transcript.length > 0) {
+                        if (transcribeMessageJson.Transcript.Results[0].IsPartial === false) {
+                            decodedMessage =
+                                transcribeMessageJson.Transcript.Results[0].Alternatives[0]
+                                    .Transcript + '\n';
+                            logger.debug({ decodedMessage });
+                        }
+                        else {
+                            logger.debug({
+                                transcript: transcribeMessageJson.Transcript.Results[0].Alternatives[0],
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return decodedMessage;
+    }
+    sendDataToTranscribe({ connection, raw, languageCode, }) {
+        return new Promise((res, rej) => {
+            let fullText = '';
+            connection.onmessage = message => {
+                try {
+                    const decodedMessage = AmazonAIConvertPredictionsProvider.serializeDataFromTranscribe(message);
+                    if (decodedMessage) {
+                        fullText += decodedMessage + ' ';
+                    }
+                }
+                catch (err) {
+                    logger.debug(err);
+                    rej(err);
+                }
+            };
+            connection.onerror = errorEvent => {
+                logger.debug({ errorEvent });
+                rej('failed to transcribe, network error');
+            };
+            connection.onclose = closeEvent => {
+                logger.debug({ closeEvent });
+                return res(fullText.trim());
+            };
+            logger.debug({ raw });
+            if (Array.isArray(raw)) {
+                for (let i = 0; i < raw.length - 1023; i += 1024) {
+                    const data = raw.slice(i, i + 1024);
+                    this.sendEncodedDataToTranscribe(connection, data, languageCode);
+                }
+            }
+            else {
+                // If Buffer
+                this.sendEncodedDataToTranscribe(connection, raw, languageCode);
+            }
+            // sending end frame
+            const endFrameEventMessage = this.getAudioEventMessage(Buffer.from([]));
+            const endFrameBinary = eventBuilder.encode(endFrameEventMessage);
+            connection.send(endFrameBinary);
+        });
+    }
+    sendEncodedDataToTranscribe(connection, data, languageCode) {
+        const downsampledBuffer = this.downsampleBuffer({
+            buffer: data,
+            outputSampleRate: LANGUAGES_CODE_IN_8KHZ.includes(languageCode)
+                ? 8000
+                : 16000,
+        });
+        const pcmEncodedBuffer = this.pcmEncode(downsampledBuffer);
+        const audioEventMessage = this.getAudioEventMessage(Buffer.from(pcmEncodedBuffer));
+        const binary = eventBuilder.encode(audioEventMessage);
+        connection.send(binary);
+    }
+    getAudioEventMessage(buffer) {
+        const audioEventMessage = {
+            body: buffer,
+            headers: {
+                ':message-type': {
+                    type: 'string',
+                    value: 'event',
+                },
+                ':event-type': {
+                    type: 'string',
+                    value: 'AudioEvent',
+                },
+            },
+        };
+        return audioEventMessage;
+    }
+    pcmEncode(input) {
+        let offset = 0;
+        // ArrayBuffer cannot be processed using length property
+        if (input instanceof ArrayBuffer) {
+            return input;
+        }
+        const buffer = new ArrayBuffer(input.length * 2);
+        const view = new DataView(buffer);
+        for (let i = 0; i < input.length; i++, offset += 2) {
+            const s = Math.max(-1, Math.min(1, input[i]));
+            view.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7fff, true);
+        }
+        return buffer;
+    }
+    downsampleBuffer({ buffer, outputSampleRate = 16000, }) {
+        // Cannot process ArrayBuffer using length property
+        if (outputSampleRate === this.inputSampleRate ||
+            buffer instanceof ArrayBuffer) {
+            return buffer;
+        }
+        const sampleRateRatio = this.inputSampleRate / outputSampleRate;
+        const newLength = Math.round(buffer.length / sampleRateRatio);
+        const result = new Float32Array(newLength);
+        let offsetResult = 0;
+        let offsetBuffer = 0;
+        while (offsetResult < result.length) {
+            const nextOffsetBuffer = Math.round((offsetResult + 1) * sampleRateRatio);
+            let accum = 0, count = 0;
+            for (let i = offsetBuffer; i < nextOffsetBuffer && i < buffer.length; i++) {
+                accum += buffer[i];
+                count++;
+            }
+            result[offsetResult] = accum / count;
+            offsetResult++;
+            offsetBuffer = nextOffsetBuffer;
+        }
+        return result;
+    }
+    openConnectionWithTranscribe({ credentials, region, languageCode, }) {
+        return new Promise(async (res, rej) => {
+            const signedUrl = this.generateTranscribeUrl({
+                credentials,
+                region,
+                languageCode,
+            });
+            logger.debug('connecting...');
+            const connection = new WebSocket(signedUrl);
+            connection.binaryType = 'arraybuffer';
+            connection.onopen = () => {
+                logger.debug('connected');
+                res(connection);
+            };
+        });
+    }
+    generateTranscribeUrl({ credentials: { accessKeyId, secretAccessKey, sessionToken }, region, languageCode, }) {
+        const credentials = {
+            access_key: accessKeyId,
+            secret_key: secretAccessKey,
+            session_token: sessionToken,
+        };
+        const url = [
+            `wss://transcribestreaming.${region}.amazonaws.com:8443`,
+            '/stream-transcription-websocket?',
+            `media-encoding=pcm&`,
+            `sample-rate=${LANGUAGES_CODE_IN_8KHZ.includes(languageCode) ? '8000' : '16000'}&`,
+            `language-code=${languageCode}`,
+        ].join('');
+        const signedUrl = Signer.signUrl(url, credentials, { region, service: 'transcribe' }, 300);
+        return signedUrl;
+    }
+}

package/lib-esm/{Providers → providers}/AmazonAIIdentifyPredictionsProvider.d.ts

@@ -1,10 +1,9 @@
-import { AbstractIdentifyPredictionsProvider } from '../types/Providers';
-import { IdentifyLabelsInput, IdentifyLabelsOutput, IdentifyEntitiesInput, IdentifyEntitiesOutput, IdentifyTextInput, IdentifyTextOutput } from '../types';
-export declare class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredictionsProvider {
-    private rekognitionClient;
-    private textractClient;
-    constructor();
+import { IdentifyEntitiesInput, IdentifyEntitiesOutput, IdentifyLabelsInput, IdentifyLabelsOutput, IdentifyTextInput, IdentifyTextOutput } from '../types';
+export declare class AmazonAIIdentifyPredictionsProvider {
+    private rekognitionClient?;
+    private textractClient?;
     getProviderName(): string;
+    identify(input: IdentifyTextInput | IdentifyLabelsInput | IdentifyEntitiesInput): Promise<IdentifyTextOutput | IdentifyLabelsOutput | IdentifyEntitiesOutput>;
     /**
      * Verify user input source and converts it into source object readable by Rekognition and Textract.
      * Note that Rekognition and Textract use the same source interface, so we need not worry about types.