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

package/src/providers/AmazonAIInterpretPredictionsProvider.ts

@@ -0,0 +1,293 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Amplify, fetchAuthSession } from '@aws-amplify/core';
+import {
+	Category,
+	PredictionsAction,
+	getAmplifyUserAgentObject,
+} from '@aws-amplify/core/internals/utils';
+
+import {
+	ComprehendClient,
+	DetectDominantLanguageCommand,
+	DetectEntitiesCommand,
+	DetectKeyPhrasesCommand,
+	DetectSentimentCommand,
+	DetectSyntaxCommand,
+	Entity,
+	SyntaxToken,
+} from '@aws-sdk/client-comprehend';
+import { PredictionsValidationErrorCode } from '../errors/types/validation';
+import { assertValidationError } from '../errors/utils/assertValidationError';
+import {
+	DetectParams,
+	InterpretTextInput,
+	InterpretTextOthers,
+	InterpretTextOutput,
+	KeyPhrases,
+	TextEntities,
+	TextSentiment,
+	TextSyntax,
+	isInterpretTextOthers,
+	isValidInterpretInput,
+} from '../types';
+
+export class AmazonAIInterpretPredictionsProvider {
+	private comprehendClient?: ComprehendClient;
+
+	getProviderName() {
+		return 'AmazonAIInterpretPredictionsProvider';
+	}
+
+	interpret(input: InterpretTextInput): Promise<InterpretTextOutput> {
+		assertValidationError(
+			isValidInterpretInput(input),
+			PredictionsValidationErrorCode.InvalidInput
+		);
+
+		return this.interpretText(input);
+	}
+
+	async interpretText(input: InterpretTextInput): Promise<InterpretTextOutput> {
+		const { credentials } = await fetchAuthSession();
+		assertValidationError(
+			!!credentials,
+			PredictionsValidationErrorCode.NoCredentials
+		);
+
+		const { interpretText = {} } =
+			Amplify.getConfig().Predictions?.interpret ?? {};
+		const { region = '', defaults = {} } = interpretText;
+		const { type: defaultType = '' } = defaults;
+
+		const { text: textSource } = input;
+		const { source, type = defaultType } = textSource;
+		const { text } = source;
+		let language;
+		if (isInterpretTextOthers(textSource)) {
+			language = (textSource as InterpretTextOthers).source.language;
+		}
+
+		this.comprehendClient = new ComprehendClient({
+			credentials,
+			region,
+			customUserAgent: getAmplifyUserAgentObject({
+				category: Category.Predictions,
+				action: PredictionsAction.Interpret,
+			}),
+		});
+
+		const doAll = type === 'all';
+
+		let languageCode = language;
+		if (doAll || type === 'language') {
+			const languageDetectionParams = {
+				Text: text,
+			};
+			languageCode = await this.detectLanguage(languageDetectionParams);
+		}
+
+		let entitiesPromise: Promise<Array<TextEntities>> | undefined;
+		if (doAll || type === 'entities') {
+			assertValidationError(
+				!!languageCode,
+				PredictionsValidationErrorCode.NoLanguage
+			);
+			const entitiesDetectionParams = {
+				Text: text,
+				LanguageCode: languageCode,
+			};
+			entitiesPromise = this.detectEntities(entitiesDetectionParams);
+		}
+
+		let sentimentPromise: Promise<TextSentiment> | undefined;
+		if (doAll || type === 'sentiment') {
+			assertValidationError(
+				!!languageCode,
+				PredictionsValidationErrorCode.NoLanguage
+			);
+			const sentimentParams = {
+				Text: text,
+				LanguageCode: languageCode,
+			};
+			sentimentPromise = this.detectSentiment(sentimentParams);
+		}
+
+		let syntaxPromise: Promise<Array<TextSyntax>> | undefined;
+		if (doAll || type === 'syntax') {
+			assertValidationError(
+				!!languageCode,
+				PredictionsValidationErrorCode.NoLanguage
+			);
+			const syntaxParams = {
+				Text: text,
+				LanguageCode: languageCode,
+			};
+			syntaxPromise = this.detectSyntax(syntaxParams);
+		}
+
+		let keyPhrasesPromise: Promise<KeyPhrases> | undefined;
+		if (doAll || type === 'keyPhrases') {
+			assertValidationError(
+				!!languageCode,
+				PredictionsValidationErrorCode.NoLanguage
+			);
+
+			const keyPhrasesParams = {
+				Text: text,
+				LanguageCode: languageCode,
+			};
+			keyPhrasesPromise = this.detectKeyPhrases(keyPhrasesParams);
+		}
+		const [textEntities, sentiment, syntax, keyPhrases] = await Promise.all([
+			entitiesPromise,
+			sentimentPromise,
+			syntaxPromise,
+			keyPhrasesPromise,
+		]);
+		return {
+			textInterpretation: {
+				keyPhrases,
+				language: languageCode,
+				sentiment,
+				syntax,
+				textEntities,
+			},
+		};
+	}
+
+	private async detectKeyPhrases(params: DetectParams): Promise<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: any) {
+			if (err.code === 'AccessDeniedException') {
+				throw new Error(
+					'Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
+						'amplify predictions add'
+				);
+			} else {
+				throw err;
+			}
+		}
+	}
+
+	private async detectSyntax(params: DetectParams): 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: any) {
+			if (err.code === 'AccessDeniedException') {
+				throw new Error(
+					'Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
+						'amplify predictions add'
+				);
+			} else {
+				throw err;
+			}
+		}
+	}
+
+	private serializeSyntaxFromComprehend(
+		tokens: SyntaxToken[]
+	): Array<TextSyntax> {
+		let response: TextSyntax[] = [];
+		if (tokens && Array.isArray(tokens)) {
+			response = tokens.map(
+				({ Text: text = '', PartOfSpeech: { Tag: syntax = '' } = {} }) => {
+					return { text, syntax };
+				}
+			);
+		}
+		return response;
+	}
+
+	private async detectSentiment(params: DetectParams): 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: any) {
+			if (err.code === 'AccessDeniedException') {
+				throw new Error(
+					'Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
+						'amplify predictions add'
+				);
+			} else {
+				throw err;
+			}
+		}
+	}
+
+	private async detectEntities(
+		params: DetectParams
+	): 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: any) {
+			if (err.code === 'AccessDeniedException') {
+				throw new Error(
+					'Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
+						'amplify predictions add'
+				);
+			} else {
+				throw err;
+			}
+		}
+	}
+
+	private serializeEntitiesFromComprehend(data: Entity[]): Array<TextEntities> {
+		let response: TextEntities[] = [];
+		if (data && Array.isArray(data)) {
+			response = data.map(({ Type: type, Text: text }) => {
+				return { type, text };
+			});
+		}
+		return response;
+	}
+
+	private async detectLanguage(params: { Text: string }): Promise<string> {
+		try {
+			const detectDominantLanguageCommand = new DetectDominantLanguageCommand(
+				params
+			);
+			const data = await this.comprehendClient!.send(
+				detectDominantLanguageCommand
+			);
+			const { Languages: [{ LanguageCode }] = [{}] } = ({} = data || {});
+			assertValidationError(
+				!!LanguageCode,
+				PredictionsValidationErrorCode.NoLanguage
+			);
+
+			return LanguageCode;
+		} catch (err: any) {
+			if (err.code === 'AccessDeniedException') {
+				throw new Error(
+					'Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
+						'amplify predictions add'
+				);
+			} else {
+				throw err;
+			}
+		}
+	}
+}

package/src/{Providers → providers}/IdentifyTextUtils.ts

@@ -1,26 +1,25 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import {
+	BoundingBox,
+	Content,
+	Geometry,
 	IdentifyTextOutput,
-	Table,
 	KeyValue,
-	TableCell,
-	Content,
-	BoundingBox,
 	Polygon,
-	Geometry,
+	Table,
+	TableCell,
 } from '../types';
 import { Block, BlockList, TextDetectionList } from '../types/AWSTypes';
-import { makeCamelCaseArray, makeCamelCase } from './Utils';
+import { makeCamelCase, makeCamelCaseArray } from './Utils';
 
-function getBoundingBox(geometry: Geometry): BoundingBox {
-	if (!geometry) return undefined;
-	return makeCamelCase(geometry.BoundingBox);
+function getBoundingBox(geometry?: Geometry): BoundingBox | undefined {
+	return makeCamelCase(geometry?.BoundingBox);
 }
 
-function getPolygon(geometry: Geometry): Polygon {
-	if (!geometry) return undefined;
-	return makeCamelCaseArray(Array.from(geometry.Polygon));
+function getPolygon(geometry?: Geometry): Polygon | undefined {
+	if (!geometry?.Polygon) return undefined;
+	return makeCamelCaseArray(Array.from(geometry.Polygon)) as Polygon;
 }
 
 /**
@@ -45,12 +44,14 @@ export function categorizeRekognitionBlocks(
 	blocks.forEach(block => {
 		switch (block.Type) {
 			case 'LINE':
-				response.text.lines.push(block.DetectedText);
+				if (block.DetectedText) {
+					response.text.lines.push(block.DetectedText);
+				}
 				response.text.linesDetailed.push({
 					text: block.DetectedText,
 					polygon: getPolygon(block.Geometry),
 					boundingBox: getBoundingBox(block.Geometry),
-					page: null, // rekognition doesn't have this info
+					page: undefined, // rekognition doesn't have this info
 				});
 				break;
 			case 'WORD':
@@ -108,7 +109,9 @@ export function categorizeTextractBlocks(
 	blocks.forEach(block => {
 		switch (block.BlockType) {
 			case 'LINE':
-				response.text.lines.push(block.Text);
+				if (block.Text) {
+					response.text.lines.push(block.Text);
+				}
 				response.text.linesDetailed.push({
 					text: block.Text,
 					polygon: getPolygon(block.Geometry),
@@ -123,7 +126,9 @@ export function categorizeTextractBlocks(
 					polygon: getPolygon(block.Geometry),
 					boundingBox: getBoundingBox(block.Geometry),
 				});
-				blockMap[block.Id] = block;
+				if (block.Id) {
+					blockMap[block.Id] = block;
+				}
 				break;
 			case 'SELECTION_ELEMENT':
 				const selectionStatus =
@@ -131,20 +136,26 @@ export function categorizeTextractBlocks(
 				if (!response.text.selections) response.text.selections = [];
 				response.text.selections.push({
 					selected: selectionStatus,
-					polygon: getPolygon(block.Geometry),
-					boundingBox: getBoundingBox(block.Geometry),
+					polygon: getPolygon(block.Geometry)!,
+					boundingBox: getBoundingBox(block.Geometry)!,
 				});
-				blockMap[block.Id] = block;
+				if (block.Id) {
+					blockMap[block.Id] = block;
+				}
 				break;
 			case 'TABLE':
 				tableBlocks.push(block);
 				break;
 			case 'KEY_VALUE_SET':
 				keyValueBlocks.push(block);
-				blockMap[block.Id] = block;
+				if (block.Id) {
+					blockMap[block.Id] = block;
+				}
 				break;
 			default:
-				blockMap[block.Id] = block;
+				if (block.Id) {
+					blockMap[block.Id] = block;
+				}
 		}
 	});
 	// remove trailing space in fullText
@@ -165,9 +176,11 @@ export function categorizeTextractBlocks(
 		const keyValueResponse: KeyValue[] = Array();
 		keyValueBlocks.forEach(keyValue => {
 			// We need the KeyValue blocks of EntityType = `KEY`, which has both key and value references.
-			const entityTypes = Array.from(keyValue.EntityTypes);
-			if (entityTypes.indexOf('KEY') !== -1) {
-				keyValueResponse.push(constructKeyValue(keyValue, blockMap));
+			if (keyValue.EntityTypes) {
+				const entityTypes = Array.from(keyValue.EntityTypes);
+				if (entityTypes.indexOf('KEY') !== -1) {
+					keyValueResponse.push(constructKeyValue(keyValue, blockMap));
+				}
 			}
 		});
 		response.text.keyValues = keyValueResponse;
@@ -180,40 +193,44 @@ export function categorizeTextractBlocks(
  * @param {Block} table - Table block that has references (`Relationships`) to its cells
  * @param {[id: string]: Block} blockMap - Maps block Ids to blocks.
  */
-export function constructTable(
+function constructTable(
 	table: Block,
 	blockMap: { [key: string]: Block }
 ): Table {
 	let tableMatrix: TableCell[][];
 	tableMatrix = [];
 	// visit each of the cell associated with the table's relationship.
-	for (const tableRelation of table.Relationships) {
-		for (const cellId of tableRelation.Ids) {
+	for (const tableRelation of table.Relationships ?? []) {
+		for (const cellId of tableRelation.Ids ?? []) {
 			const cellBlock: Block = blockMap[cellId];
-			const row = cellBlock.RowIndex - 1; // textract starts indexing at 1, so subtract it by 1.
-			const col = cellBlock.ColumnIndex - 1; // textract starts indexing at 1, so subtract it by 1.
-			// extract data contained inside the cell.
-			const content = extractContentsFromBlock(cellBlock, blockMap);
-			const cell: TableCell = {
-				text: content.text,
-				boundingBox: getBoundingBox(cellBlock.Geometry),
-				polygon: getPolygon(cellBlock.Geometry),
-				selected: content.selected,
-				rowSpan: cellBlock.RowSpan,
-				columnSpan: cellBlock.ColumnSpan,
-			};
-			if (!tableMatrix[row]) tableMatrix[row] = [];
-			tableMatrix[row][col] = cell;
+			if (cellBlock.RowIndex && cellBlock.ColumnIndex) {
+				const row = cellBlock.RowIndex - 1; // textract starts indexing at 1, so subtract it by 1.
+				const col = cellBlock.ColumnIndex - 1; // textract starts indexing at 1, so subtract it by 1.
+				// extract data contained inside the cell.
+				const content = extractContentsFromBlock(cellBlock, blockMap);
+				const cell: TableCell = {
+					text: content.text,
+					boundingBox: getBoundingBox(cellBlock.Geometry),
+					polygon: getPolygon(cellBlock.Geometry),
+					selected: content.selected,
+					rowSpan: cellBlock.RowSpan,
+					columnSpan: cellBlock.ColumnSpan,
+				};
+				if (!tableMatrix[row]) tableMatrix[row] = [];
+				tableMatrix[row][col] = cell;
+			}
 		}
 	}
 	const rowSize = tableMatrix.length;
 	const columnSize = tableMatrix[0].length;
+	const boundingBox = getBoundingBox(table.Geometry);
+	const polygon = getPolygon(table.Geometry);
 	// Note that we leave spanned cells undefined for distinction
 	return {
 		size: { rows: rowSize, columns: columnSize },
 		table: tableMatrix,
-		boundingBox: getBoundingBox(table.Geometry),
-		polygon: getPolygon(table.Geometry),
+		boundingBox,
+		polygon,
 	};
 }
 
@@ -222,24 +239,24 @@ export function constructTable(
  * @param {Block} KeyValue - KeyValue block that has references (`Relationships`) to its children.
  * @param {[id: string]: Block} blockMap - Maps block Ids to blocks.
  */
-export function constructKeyValue(
+function constructKeyValue(
 	keyBlock: Block,
 	blockMap: { [key: string]: Block }
 ): KeyValue {
 	let keyText: string = '';
 	let valueText: string = '';
-	let valueSelected: boolean;
-	for (const keyValueRelation of keyBlock.Relationships) {
+	let valueSelected: boolean = false;
+	for (const keyValueRelation of keyBlock.Relationships ?? []) {
 		if (keyValueRelation.Type === 'CHILD') {
 			// relation refers to key
 			const contents = extractContentsFromBlock(keyBlock, blockMap);
-			keyText = contents.text;
+			keyText = contents.text ?? '';
 		} else if (keyValueRelation.Type === 'VALUE') {
 			// relation refers to value
-			for (const valueId of keyValueRelation.Ids) {
+			for (const valueId of keyValueRelation.Ids ?? []) {
 				const valueBlock = blockMap[valueId];
 				const contents = extractContentsFromBlock(valueBlock, blockMap);
-				valueText = contents.text;
+				valueText = contents.text ?? '';
 				if (contents.selected != null) valueSelected = contents.selected;
 			}
 		}
@@ -257,19 +274,19 @@ export function constructKeyValue(
  * @param {Block}} block - Block that we want to extract contents from.
  * @param {[id: string]: Block} blockMap - Maps block Ids to blocks.
  */
-export function extractContentsFromBlock(
+function extractContentsFromBlock(
 	block: Block,
 	blockMap: { [id: string]: Block }
 ): Content {
 	let words: string = '';
-	let isSelected: boolean;
+	let isSelected: boolean = false;
 
 	if (!block.Relationships) {
 		// some block might have no content
 		return { text: '', selected: undefined };
 	}
 	for (const relation of block.Relationships) {
-		for (const contentId of relation.Ids) {
+		for (const contentId of relation.Ids ?? []) {
 			const contentBlock = blockMap[contentId];
 			if (contentBlock.BlockType === 'WORD') {
 				words += contentBlock.Text + ' ';

package/src/{Providers → providers}/Utils.ts

@@ -4,7 +4,7 @@
  * Changes object keys to camel case. If optional parameter `keys` is given, then we extract only the
  * keys specified in `keys`.
  */
-export function makeCamelCase(obj: object, keys?: string[]) {
+export function makeCamelCase(obj?: any, keys?: string[]) {
 	if (!obj) return undefined;
 	const newObj = {};
 	const keysToRename = keys ? keys : Object.keys(obj);
@@ -21,7 +21,7 @@ export function makeCamelCase(obj: object, keys?: string[]) {
 /**
  * Given an array of object, call makeCamelCase(...) on each option.
  */
-export function makeCamelCaseArray(objArr: object[], keys?: string[]) {
+export function makeCamelCaseArray(objArr?: object[], keys?: string[]) {
 	if (!objArr) return undefined;
 	return objArr.map(obj => makeCamelCase(obj, keys));
 }

package/src/{Providers → providers}/index.ts

@@ -3,10 +3,8 @@
 import { AmazonAIConvertPredictionsProvider } from './AmazonAIConvertPredictionsProvider';
 import { AmazonAIIdentifyPredictionsProvider } from './AmazonAIIdentifyPredictionsProvider';
 import { AmazonAIInterpretPredictionsProvider } from './AmazonAIInterpretPredictionsProvider';
-import { AmazonAIPredictionsProvider } from './AmazonAIPredictionsProvider';
 export {
 	AmazonAIConvertPredictionsProvider,
 	AmazonAIIdentifyPredictionsProvider,
 	AmazonAIInterpretPredictionsProvider,
-	AmazonAIPredictionsProvider,
 };

package/src/types/AWSTypes.ts

@@ -83,7 +83,7 @@ export interface Block {
 
 export type TextDetectionList = TextDetection[];
 
-export interface TextDetection {
+interface TextDetection {
 	/**
 	 * <p>The word or line of text recognized by Amazon Rekognition. </p>
 	 */
@@ -127,9 +127,8 @@ export interface Image {
 	S3Object?: S3Object;
 }
 
-export type ImageBlob = Buffer | Uint8Array | Blob | string;
-export type S3Bucket = string;
-export interface S3Object {
+type S3Bucket = string;
+interface S3Object {
 	/**
 	 * Name of the S3 bucket.
 	 */
@@ -143,8 +142,8 @@ export interface S3Object {
 	 */
 	Version?: S3ObjectVersion;
 }
-export type S3ObjectName = string;
-export type S3ObjectVersion = string;
+type S3ObjectName = string;
+type S3ObjectVersion = string;
 
 /**
  * <p>The input document, either as bytes or as an S3 object.</p> <p>You pass image bytes to an Amazon Textract API operation by using the <code>Bytes</code> property. For example, you would use the <code>Bytes</code> property to pass a document loaded from a local file system. Image bytes passed by using the <code>Bytes</code> property must be base64 encoded. Your code might not need to encode document file bytes if you're using an AWS SDK to call Amazon Textract API operations. </p> <p>You pass images stored in an S3 bucket to an Amazon Textract API operation by using the <code>S3Object</code> property. Documents stored in an S3 bucket don't need to be base64 encoded.</p> <p>The AWS Region for the S3 bucket that contains the S3 object must match the AWS Region that you use for Amazon Textract operations.</p> <p>If you use the AWS CLI to call Amazon Textract operations, passing image bytes using the Bytes property isn't supported. You must first upload the document to an Amazon S3 bucket, and then call the operation using the S3Object property.</p> <p>For Amazon Textract to process an S3 object, the user must have permission to access the S3 object. </p>