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

package/src/Providers/AmazonAIInterpretPredictionsProvider.ts

@@ -1,281 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-import {
-	Category,
-	Credentials,
-	PredictionsAction,
-	getAmplifyUserAgentObject,
-} from '@aws-amplify/core';
-import { AbstractInterpretPredictionsProvider } from '../types/Providers';
-
-import {
-	InterpretTextInput,
-	InterpretTextOutput,
-	InterpretTextCategories,
-	TextEntities,
-	TextSentiment,
-	TextSyntax,
-	KeyPhrases,
-} from '../types';
-import {
-	ComprehendClient,
-	DetectSyntaxCommand,
-	DetectEntitiesCommand,
-	DetectDominantLanguageCommand,
-	DetectKeyPhrasesCommand,
-	DetectSentimentCommand,
-} from '@aws-sdk/client-comprehend';
-
-export class AmazonAIInterpretPredictionsProvider extends AbstractInterpretPredictionsProvider {
-	private comprehendClient: ComprehendClient;
-
-	constructor() {
-		super();
-	}
-
-	getProviderName() {
-		return 'AmazonAIInterpretPredictionsProvider';
-	}
-
-	interpretText(input: InterpretTextInput): Promise<InterpretTextOutput> {
-		return new Promise(async (res, rej) => {
-			const credentials = await Credentials.get();
-			if (!credentials) return rej('No credentials');
-			const {
-				interpretText: {
-					region = '',
-					defaults: { type: interpretTypeConfig = '' } = {},
-				} = {},
-			} = this._config;
-			const {
-				text: {
-					source: { text = '' } = {},
-					type: interpretType = interpretTypeConfig,
-				} = {},
-			} = ({} = input);
-
-			const { text: { source: { language = undefined } = {} } = {} } = ({} =
-				input as any); // language is only required for specific interpret types
-
-			this.comprehendClient = new ComprehendClient({
-				credentials,
-				region,
-				customUserAgent: getAmplifyUserAgentObject({
-					category: Category.Predictions,
-					action: PredictionsAction.Interpret,
-				}),
-			});
-
-			const doAll = interpretType === InterpretTextCategories.ALL;
-
-			let languagePromise: Promise<string>;
-			if (doAll || interpretType === InterpretTextCategories.LANGUAGE) {
-				const languageDetectionParams = {
-					Text: text,
-				};
-				languagePromise = this.detectLanguage(languageDetectionParams);
-			}
-
-			let entitiesPromise: Promise<Array<TextEntities>>;
-			if (doAll || interpretType === InterpretTextCategories.ENTITIES) {
-				const LanguageCode = language || (await languagePromise);
-				if (!LanguageCode) {
-					return rej('language code is required on source for this selection');
-				}
-				const entitiesDetectionParams = {
-					Text: text,
-					LanguageCode,
-				};
-				entitiesPromise = this.detectEntities(entitiesDetectionParams);
-			}
-
-			let sentimentPromise: Promise<TextSentiment>;
-			if (doAll || interpretType === InterpretTextCategories.SENTIMENT) {
-				const LanguageCode = language || (await languagePromise);
-				if (!LanguageCode) {
-					return rej('language code is required on source for this selection');
-				}
-				const sentimentParams = {
-					Text: text,
-					LanguageCode,
-				};
-				sentimentPromise = this.detectSentiment(sentimentParams);
-			}
-
-			let syntaxPromise: Promise<Array<TextSyntax>>;
-			if (doAll || interpretType === InterpretTextCategories.SYNTAX) {
-				const LanguageCode = language || (await languagePromise);
-				if (!LanguageCode) {
-					return rej('language code is required on source for this selection');
-				}
-				const syntaxParams = {
-					Text: text,
-					LanguageCode,
-				};
-				syntaxPromise = this.detectSyntax(syntaxParams);
-			}
-
-			let keyPhrasesPromise: Promise<Array<KeyPhrases>>;
-			if (doAll || interpretType === InterpretTextCategories.KEY_PHRASES) {
-				const LanguageCode = language || (await languagePromise);
-				if (!LanguageCode) {
-					return rej('language code is required on source for this selection');
-				}
-				const keyPhrasesParams = {
-					Text: text,
-					LanguageCode,
-				};
-				keyPhrasesPromise = this.detectKeyPhrases(keyPhrasesParams);
-			}
-			try {
-				const results = await Promise.all([
-					languagePromise,
-					entitiesPromise,
-					sentimentPromise,
-					syntaxPromise,
-					keyPhrasesPromise,
-				]);
-				res({
-					textInterpretation: {
-						keyPhrases: results[4] || [],
-						language: results[0] || '',
-						sentiment: results[2],
-						syntax: <TextSyntax[]>results[3] || [],
-						textEntities: <TextEntities[]>results[1] || [],
-					},
-				});
-			} catch (err) {
-				rej(err);
-			}
-		});
-	}
-
-	private async detectKeyPhrases(params): Promise<Array<KeyPhrases>> {
-		try {
-			const detectKeyPhrasesCommand = new DetectKeyPhrasesCommand(params);
-			const data = await this.comprehendClient.send(detectKeyPhrasesCommand);
-			const { KeyPhrases = [] } = data || {};
-			return KeyPhrases.map(({ Text: text }) => {
-				return { text };
-			});
-		} catch (err) {
-			if (err.code === 'AccessDeniedException') {
-				Promise.reject(
-					'Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
-						'amplify predictions add'
-				);
-			} else {
-				Promise.reject(err.message);
-			}
-		}
-	}
-
-	private async detectSyntax(params): Promise<Array<TextSyntax>> {
-		try {
-			const detectSyntaxCommand = new DetectSyntaxCommand(params);
-			const data = await this.comprehendClient.send(detectSyntaxCommand);
-			const { SyntaxTokens = [] } = data || {};
-			return this.serializeSyntaxFromComprehend(SyntaxTokens);
-		} catch (err) {
-			if (err.code === 'AccessDeniedException') {
-				Promise.reject(
-					'Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
-						'amplify predictions add'
-				);
-			} else {
-				Promise.reject(err.message);
-			}
-		}
-	}
-
-	private serializeSyntaxFromComprehend(tokens): Array<TextSyntax> {
-		let response = [];
-		if (tokens && Array.isArray(tokens)) {
-			response = tokens.map(
-				({ Text: text = '', PartOfSpeech: { Tag: syntax = '' } = {} }) => {
-					return { text, syntax };
-				}
-			);
-		}
-		return response;
-	}
-
-	private async detectSentiment(params): Promise<TextSentiment> {
-		try {
-			const detectSentimentCommand = new DetectSentimentCommand(params);
-			const data = await this.comprehendClient.send(detectSentimentCommand);
-			const {
-				Sentiment: predominant = '',
-				SentimentScore: {
-					Positive: positive = 0,
-					Negative: negative = 0,
-					Neutral: neutral = 0,
-					Mixed: mixed = 0,
-				} = {},
-			} = ({} = data);
-			return { predominant, positive, negative, neutral, mixed };
-		} catch (err) {
-			if (err.code === 'AccessDeniedException') {
-				Promise.reject(
-					'Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
-						'amplify predictions add'
-				);
-			} else {
-				Promise.reject(err.message);
-			}
-		}
-	}
-
-	private async detectEntities(params): Promise<Array<TextEntities>> {
-		try {
-			const detectEntitiesCommand = new DetectEntitiesCommand(params);
-			const data = await this.comprehendClient.send(detectEntitiesCommand);
-			const { Entities = [] } = data || {};
-			return this.serializeEntitiesFromComprehend(Entities);
-		} catch (err) {
-			if (err.code === 'AccessDeniedException') {
-				Promise.reject(
-					'Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
-						'amplify predictions add'
-				);
-			} else {
-				Promise.reject(err.message);
-			}
-		}
-	}
-
-	private serializeEntitiesFromComprehend(data): Array<TextEntities> {
-		let response = [];
-		if (data && Array.isArray(data)) {
-			response = data.map(({ Type: type, Text: text }) => {
-				return { type, text };
-			});
-		}
-		return response;
-	}
-
-	private async detectLanguage(params): Promise<string> {
-		try {
-			const detectDominantLanguageCommand = new DetectDominantLanguageCommand(
-				params
-			);
-			const data = await this.comprehendClient.send(
-				detectDominantLanguageCommand
-			);
-			const { Languages: [{ LanguageCode }] = [{}] } = ({} = data || {});
-			if (!LanguageCode) {
-				Promise.reject('Language not detected');
-			}
-			return data.Languages[0].LanguageCode;
-		} catch (err) {
-			if (err.code === 'AccessDeniedException') {
-				Promise.reject(
-					'Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
-						'amplify predictions add'
-				);
-			} else {
-				Promise.reject(err.message);
-			}
-		}
-	}
-}

package/src/Providers/AmazonAIPredictionsProvider.ts

@@ -1,69 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-import { AbstractPredictionsProvider } from '../types/Providers';
-import { AmazonAIConvertPredictionsProvider } from './AmazonAIConvertPredictionsProvider';
-import { AmazonAIInterpretPredictionsProvider } from './AmazonAIInterpretPredictionsProvider';
-import { AmazonAIIdentifyPredictionsProvider } from './AmazonAIIdentifyPredictionsProvider';
-import {
-	TranslateTextInput,
-	TextToSpeechInput,
-	SpeechToTextInput,
-	PredictionsOptions,
-	IdentifyTextInput,
-	IdentifyTextOutput,
-	IdentifyLabelsInput,
-	IdentifyLabelsOutput,
-	IdentifyEntitiesInput,
-	IdentifyEntitiesOutput,
-	TranslateTextOutput,
-	TextToSpeechOutput,
-	SpeechToTextOutput,
-	InterpretTextInput,
-	InterpretTextOutput,
-} from '../types';
-
-export class AmazonAIPredictionsProvider extends AbstractPredictionsProvider {
-	private convertProvider: AmazonAIConvertPredictionsProvider;
-	private identifyProvider: AmazonAIIdentifyPredictionsProvider;
-	private interpretProvider: AmazonAIInterpretPredictionsProvider;
-
-	constructor() {
-		super();
-		this.convertProvider = new AmazonAIConvertPredictionsProvider();
-		this.identifyProvider = new AmazonAIIdentifyPredictionsProvider();
-		this.interpretProvider = new AmazonAIInterpretPredictionsProvider();
-	}
-
-	getCategory(): string {
-		return 'Predictions';
-	}
-
-	getProviderName(): string {
-		return 'AmazonAIPredictionsProvider';
-	}
-
-	configure(config: PredictionsOptions) {
-		this.convertProvider.configure(config.convert);
-		this.identifyProvider.configure(config.identify);
-		this.interpretProvider.configure(config.interpret);
-		return config;
-	}
-
-	interpret(input: InterpretTextInput): Promise<InterpretTextOutput> {
-		return this.interpretProvider.interpret(input);
-	}
-
-	convert(
-		input: TranslateTextInput | TextToSpeechInput | SpeechToTextInput
-	): Promise<TextToSpeechOutput | TranslateTextOutput | SpeechToTextOutput> {
-		return this.convertProvider.convert(input);
-	}
-
-	identify(
-		input: IdentifyTextInput | IdentifyLabelsInput | IdentifyEntitiesInput
-	): Promise<
-		IdentifyTextOutput | IdentifyLabelsOutput | IdentifyEntitiesOutput
-	> {
-		return this.identifyProvider.identify(input);
-	}
-}

package/src/types/Providers/AbstractConvertPredictionsProvider.ts

@@ -1,55 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-import {
-	TranslateTextInput,
-	TextToSpeechInput,
-	SpeechToTextInput,
-	isTranslateTextInput,
-	isTextToSpeechInput,
-	isSpeechToTextInput,
-	TranslateTextOutput,
-	TextToSpeechOutput,
-	SpeechToTextOutput,
-} from '../Predictions';
-import { AbstractPredictionsProvider } from './AbstractPredictionsProvider';
-import { ConsoleLogger as Logger } from '@aws-amplify/core';
-const logger = new Logger('AbstractConvertPredictionsProvider');
-
-export abstract class AbstractConvertPredictionsProvider extends AbstractPredictionsProvider {
-	getCategory(): string {
-		return 'Convert';
-	}
-
-	convert(
-		input: TranslateTextInput | TextToSpeechInput | SpeechToTextInput
-	): Promise<TextToSpeechOutput | TranslateTextOutput | SpeechToTextOutput> {
-		if (isTranslateTextInput(input)) {
-			logger.debug('translateText');
-			return this.translateText(input);
-		} else if (isTextToSpeechInput(input)) {
-			logger.debug('textToSpeech');
-			return this.convertTextToSpeech(input);
-		} else if (isSpeechToTextInput(input)) {
-			logger.debug('textToSpeech');
-			return this.convertSpeechToText(input);
-		}
-	}
-
-	protected translateText(
-		translateTextInput: TranslateTextInput
-	): Promise<TranslateTextOutput> {
-		throw new Error('convertText is not implemented by this provider');
-	}
-
-	protected convertTextToSpeech(
-		textToSpeechInput: TextToSpeechInput
-	): Promise<TextToSpeechOutput> {
-		throw new Error('convertTextToSpeech is not implemented by this provider');
-	}
-
-	protected convertSpeechToText(
-		speechToTextInput: SpeechToTextInput
-	): Promise<SpeechToTextOutput> {
-		throw new Error('convertSpeechToText is not implemented by this provider');
-	}
-}

package/src/types/Providers/AbstractIdentifyPredictionsProvider.ts

@@ -1,57 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-import { AbstractPredictionsProvider } from './AbstractPredictionsProvider';
-import {
-	IdentifyLabelsInput,
-	IdentifyEntitiesInput,
-	isIdentifyLabelsInput,
-	isIdentifyEntitiesInput,
-	IdentifyTextInput,
-	isIdentifyTextInput,
-	IdentifyTextOutput,
-	IdentifyLabelsOutput,
-	IdentifyEntitiesOutput,
-} from '../Predictions';
-import { Logger } from '@aws-amplify/core';
-const logger = new Logger('AbstractIdentifyPredictionsProvider');
-
-export abstract class AbstractIdentifyPredictionsProvider extends AbstractPredictionsProvider {
-	getCategory(): string {
-		return 'Identify';
-	}
-
-	identify(
-		input: IdentifyTextInput | IdentifyLabelsInput | IdentifyEntitiesInput
-	): Promise<
-		IdentifyTextOutput | IdentifyLabelsOutput | IdentifyEntitiesOutput
-	> {
-		if (isIdentifyTextInput(input)) {
-			logger.debug('identifyText');
-			return this.identifyText(input);
-		} else if (isIdentifyLabelsInput(input)) {
-			logger.debug('identifyLabels');
-			return this.identifyLabels(input);
-		} else if (isIdentifyEntitiesInput(input)) {
-			logger.debug('identifyEntities');
-			return this.identifyEntities(input);
-		}
-	}
-
-	protected identifyText(
-		input: IdentifyTextInput
-	): Promise<IdentifyTextOutput> {
-		throw new Error('identifyText is not implemented by this provider.');
-	}
-
-	protected identifyLabels(
-		input: IdentifyLabelsInput
-	): Promise<IdentifyLabelsOutput> {
-		throw new Error('identifyLabels is not implemented by this provider');
-	}
-
-	protected identifyEntities(
-		input: IdentifyEntitiesInput
-	): Promise<IdentifyEntitiesOutput> {
-		throw new Error('identifyEntities is not implemented by this provider');
-	}
-}

package/src/types/Providers/AbstractInterpretPredictionsProvider.ts

@@ -1,26 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-import { AbstractPredictionsProvider } from './AbstractPredictionsProvider';
-import {
-	InterpretTextInput,
-	InterpretTextOutput,
-	isInterpretTextInput,
-} from '../Predictions';
-
-export abstract class AbstractInterpretPredictionsProvider extends AbstractPredictionsProvider {
-	getCategory(): string {
-		return 'Interpret';
-	}
-
-	interpret(input: InterpretTextInput): Promise<InterpretTextOutput> {
-		if (isInterpretTextInput(input)) {
-			return this.interpretText(input);
-		}
-	}
-
-	protected interpretText(
-		input: InterpretTextInput
-	): Promise<InterpretTextOutput> {
-		throw new Error('interpretText is not implement by this provider');
-	}
-}

package/src/types/Providers/AbstractPredictionsProvider.ts

@@ -1,20 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-import { PredictionsOptions } from '..';
-import { ConsoleLogger as Logger } from '@aws-amplify/core';
-
-const logger = new Logger('Amplify');
-
-export abstract class AbstractPredictionsProvider {
-	protected _config: PredictionsOptions;
-
-	configure(config: PredictionsOptions) {
-		logger.debug('configure AbstractPredictionsProvider', { config });
-		this._config = config;
-		return config;
-	}
-
-	abstract getProviderName(): string;
-
-	abstract getCategory(): string;
-}

package/src/types/Providers/index.ts

@@ -1,6 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-export * from './AbstractPredictionsProvider';
-export * from './AbstractConvertPredictionsProvider';
-export * from './AbstractIdentifyPredictionsProvider';
-export * from './AbstractInterpretPredictionsProvider';