SupplyChain *********** Client ====== class SupplyChain.Client A low-level client representing AWS Supply Chain AWS Supply Chain is a cloud-based application that works with your enterprise resource planning (ERP) and supply chain management systems. Using AWS Supply Chain, you can connect and extract your inventory, supply, and demand related data from existing ERP or supply chain systems into a single data model. The AWS Supply Chain API supports configuration data import for Supply Planning. All AWS Supply chain API operations are Amazon-authenticated and certificate-signed. They not only require the use of the AWS SDK, but also allow for the exclusive use of AWS Identity and Access Management users and roles to help facilitate access, trust, and permission policies. import boto3 client = boto3.client('supplychain') These are the available methods: * can_paginate * close * create_bill_of_materials_import_job * create_data_integration_flow * create_data_lake_dataset * create_data_lake_namespace * create_instance * delete_data_integration_flow * delete_data_lake_dataset * delete_data_lake_namespace * delete_instance * get_bill_of_materials_import_job * get_data_integration_event * get_data_integration_flow * get_data_integration_flow_execution * get_data_lake_dataset * get_data_lake_namespace * get_instance * get_paginator * get_waiter * list_data_integration_events * list_data_integration_flow_executions * list_data_integration_flows * list_data_lake_datasets * list_data_lake_namespaces * list_instances * list_tags_for_resource * send_data_integration_event * tag_resource * untag_resource * update_data_integration_flow * update_data_lake_dataset * update_data_lake_namespace * update_instance Paginators ========== Paginators are available on a client instance via the "get_paginator" method. For more detailed instructions and examples on the usage of paginators, see the paginators user guide. The available paginators are: * ListDataIntegrationEvents * ListDataIntegrationFlowExecutions * ListDataIntegrationFlows * ListDataLakeDatasets * ListDataLakeNamespaces * ListInstances SupplyChain / Paginator / ListDataIntegrationEvents ListDataIntegrationEvents ************************* class SupplyChain.Paginator.ListDataIntegrationEvents paginator = client.get_paginator('list_data_integration_events') paginate(**kwargs) Creates an iterator that will paginate through responses from "SupplyChain.Client.list_data_integration_events()". See also: AWS API Documentation **Request Syntax** response_iterator = paginator.paginate( instanceId='string', eventType='scn.data.forecast'|'scn.data.inventorylevel'|'scn.data.inboundorder'|'scn.data.inboundorderline'|'scn.data.inboundorderlineschedule'|'scn.data.outboundorderline'|'scn.data.outboundshipment'|'scn.data.processheader'|'scn.data.processoperation'|'scn.data.processproduct'|'scn.data.reservation'|'scn.data.shipment'|'scn.data.shipmentstop'|'scn.data.shipmentstoporder'|'scn.data.supplyplan'|'scn.data.dataset', PaginationConfig={ 'MaxItems': 123, 'PageSize': 123, 'StartingToken': 'string' } ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **eventType** (*string*) -- List data integration events for the specified eventType. * **PaginationConfig** (*dict*) -- A dictionary that provides parameters to control pagination. * **MaxItems** *(integer) --* The total number of items to return. If the total number of items available is more than the value specified in max-items then a "NextToken" will be provided in the output that you can use to resume pagination. * **PageSize** *(integer) --* The size of each page. * **StartingToken** *(string) --* A token to specify where to start paginating. This is the "NextToken" from a previous response. Return type: dict Returns: **Response Syntax** { 'events': [ { 'instanceId': 'string', 'eventId': 'string', 'eventType': 'scn.data.forecast'|'scn.data.inventorylevel'|'scn.data.inboundorder'|'scn.data.inboundorderline'|'scn.data.inboundorderlineschedule'|'scn.data.outboundorderline'|'scn.data.outboundshipment'|'scn.data.processheader'|'scn.data.processoperation'|'scn.data.processproduct'|'scn.data.reservation'|'scn.data.shipment'|'scn.data.shipmentstop'|'scn.data.shipmentstoporder'|'scn.data.supplyplan'|'scn.data.dataset', 'eventGroupId': 'string', 'eventTimestamp': datetime(2015, 1, 1), 'datasetTargetDetails': { 'datasetIdentifier': 'string', 'operationType': 'APPEND'|'UPSERT'|'DELETE', 'datasetLoadExecution': { 'status': 'SUCCEEDED'|'IN_PROGRESS'|'FAILED', 'message': 'string' } } }, ], 'NextToken': 'string' } **Response Structure** * *(dict) --* The response parameters for ListDataIntegrationEvents. * **events** *(list) --* The list of data integration events. * *(dict) --* The data integration event details. * **instanceId** *(string) --* The AWS Supply Chain instance identifier. * **eventId** *(string) --* The unique event identifier. * **eventType** *(string) --* The data event type. * **eventGroupId** *(string) --* Event identifier (for example, orderId for InboundOrder) used for data sharding or partitioning. * **eventTimestamp** *(datetime) --* The event timestamp (in epoch seconds). * **datasetTargetDetails** *(dict) --* The target dataset details for a DATASET event type. * **datasetIdentifier** *(string) --* The datalake dataset ARN identifier. * **operationType** *(string) --* The target dataset load operation type. The available options are: * **APPEND** - Add new records to the dataset. Noted that this operation type will just try to append records as-is without any primary key or partition constraints. * **UPSERT** - Modify existing records in the dataset with primary key configured, events for datasets without primary keys are not allowed. If event data contains primary keys that match records in the dataset within same partition, then those existing records (in that partition) will be updated. If primary keys do not match, new records will be added. Note that if dataset contain records with duplicate primary key values in the same partition, those duplicate records will be deduped into one updated record. * **DELETE** - Remove existing records in the dataset with primary key configured, events for datasets without primary keys are not allowed. If event data contains primary keys that match records in the dataset within same partition, then those existing records (in that partition) will be deleted. If primary keys do not match, no actions will be done. Note that if dataset contain records with duplicate primary key values in the same partition, all those duplicates will be removed. * **datasetLoadExecution** *(dict) --* The target dataset load execution. * **status** *(string) --* The event load execution status to target dataset. * **message** *(string) --* The failure message (if any) of failed event load execution to dataset. * **NextToken** *(string) --* A token to resume pagination. SupplyChain / Paginator / ListInstances ListInstances ************* class SupplyChain.Paginator.ListInstances paginator = client.get_paginator('list_instances') paginate(**kwargs) Creates an iterator that will paginate through responses from "SupplyChain.Client.list_instances()". See also: AWS API Documentation **Request Syntax** response_iterator = paginator.paginate( instanceNameFilter=[ 'string', ], instanceStateFilter=[ 'Initializing'|'Active'|'CreateFailed'|'DeleteFailed'|'Deleting'|'Deleted', ], PaginationConfig={ 'MaxItems': 123, 'PageSize': 123, 'StartingToken': 'string' } ) Parameters: * **instanceNameFilter** (*list*) -- The filter to ListInstances based on their names. * *(string) --* * **instanceStateFilter** (*list*) -- The filter to ListInstances based on their state. * *(string) --* * **PaginationConfig** (*dict*) -- A dictionary that provides parameters to control pagination. * **MaxItems** *(integer) --* The total number of items to return. If the total number of items available is more than the value specified in max-items then a "NextToken" will be provided in the output that you can use to resume pagination. * **PageSize** *(integer) --* The size of each page. * **StartingToken** *(string) --* A token to specify where to start paginating. This is the "NextToken" from a previous response. Return type: dict Returns: **Response Syntax** { 'instances': [ { 'instanceId': 'string', 'awsAccountId': 'string', 'state': 'Initializing'|'Active'|'CreateFailed'|'DeleteFailed'|'Deleting'|'Deleted', 'errorMessage': 'string', 'webAppDnsDomain': 'string', 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1), 'instanceName': 'string', 'instanceDescription': 'string', 'kmsKeyArn': 'string', 'versionNumber': 123.0 }, ], 'NextToken': 'string' } **Response Structure** * *(dict) --* The response parameters for ListInstances. * **instances** *(list) --* The list of instances resource data details. * *(dict) --* The details of the instance. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **awsAccountId** *(string) --* The Amazon Web Services account ID that owns the instance. * **state** *(string) --* The state of the instance. * **errorMessage** *(string) --* The Amazon Web Services Supply Chain instance error message. If the instance results in an unhealthy state, customers need to check the error message, delete the current instance, and recreate a new one based on the mitigation from the error message. * **webAppDnsDomain** *(string) --* The WebApp DNS domain name of the instance. * **createdTime** *(datetime) --* The instance creation timestamp. * **lastModifiedTime** *(datetime) --* The instance last modified timestamp. * **instanceName** *(string) --* The Amazon Web Services Supply Chain instance name. * **instanceDescription** *(string) --* The Amazon Web Services Supply Chain instance description. * **kmsKeyArn** *(string) --* The ARN (Amazon Resource Name) of the Key Management Service (KMS) key you optionally provided for encryption. If you did not provide anything here, AWS Supply Chain uses the Amazon Web Services owned KMS key and nothing is returned. * **versionNumber** *(float) --* The version number of the instance. * **NextToken** *(string) --* A token to resume pagination. SupplyChain / Paginator / ListDataLakeNamespaces ListDataLakeNamespaces ********************** class SupplyChain.Paginator.ListDataLakeNamespaces paginator = client.get_paginator('list_data_lake_namespaces') paginate(**kwargs) Creates an iterator that will paginate through responses from "SupplyChain.Client.list_data_lake_namespaces()". See also: AWS API Documentation **Request Syntax** response_iterator = paginator.paginate( instanceId='string', PaginationConfig={ 'MaxItems': 123, 'PageSize': 123, 'StartingToken': 'string' } ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **PaginationConfig** (*dict*) -- A dictionary that provides parameters to control pagination. * **MaxItems** *(integer) --* The total number of items to return. If the total number of items available is more than the value specified in max-items then a "NextToken" will be provided in the output that you can use to resume pagination. * **PageSize** *(integer) --* The size of each page. * **StartingToken** *(string) --* A token to specify where to start paginating. This is the "NextToken" from a previous response. Return type: dict Returns: **Response Syntax** { 'namespaces': [ { 'instanceId': 'string', 'name': 'string', 'arn': 'string', 'description': 'string', 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) }, ], 'NextToken': 'string' } **Response Structure** * *(dict) --* The response parameters of ListDataLakeNamespaces. * **namespaces** *(list) --* The list of fetched namespace details. Noted it only contains custom namespaces, pre-defined namespaces are not included. * *(dict) --* The data lake namespace details. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **name** *(string) --* The name of the namespace. * **arn** *(string) --* The arn of the namespace. * **description** *(string) --* The description of the namespace. * **createdTime** *(datetime) --* The creation time of the namespace. * **lastModifiedTime** *(datetime) --* The last modified time of the namespace. * **NextToken** *(string) --* A token to resume pagination. SupplyChain / Paginator / ListDataIntegrationFlowExecutions ListDataIntegrationFlowExecutions ********************************* class SupplyChain.Paginator.ListDataIntegrationFlowExecutions paginator = client.get_paginator('list_data_integration_flow_executions') paginate(**kwargs) Creates an iterator that will paginate through responses from "SupplyChain.Client.list_data_integration_flow_executions()". See also: AWS API Documentation **Request Syntax** response_iterator = paginator.paginate( instanceId='string', flowName='string', PaginationConfig={ 'MaxItems': 123, 'PageSize': 123, 'StartingToken': 'string' } ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The AWS Supply Chain instance identifier. * **flowName** (*string*) -- **[REQUIRED]** The flow name. * **PaginationConfig** (*dict*) -- A dictionary that provides parameters to control pagination. * **MaxItems** *(integer) --* The total number of items to return. If the total number of items available is more than the value specified in max-items then a "NextToken" will be provided in the output that you can use to resume pagination. * **PageSize** *(integer) --* The size of each page. * **StartingToken** *(string) --* A token to specify where to start paginating. This is the "NextToken" from a previous response. Return type: dict Returns: **Response Syntax** { 'flowExecutions': [ { 'instanceId': 'string', 'flowName': 'string', 'executionId': 'string', 'status': 'SUCCEEDED'|'IN_PROGRESS'|'FAILED', 'sourceInfo': { 'sourceType': 'S3'|'DATASET', 's3Source': { 'bucketName': 'string', 'key': 'string' }, 'datasetSource': { 'datasetIdentifier': 'string' } }, 'message': 'string', 'startTime': datetime(2015, 1, 1), 'endTime': datetime(2015, 1, 1), 'outputMetadata': { 'diagnosticReportsRootS3URI': 'string' } }, ], 'NextToken': 'string' } **Response Structure** * *(dict) --* The response parameters of ListFlowExecutions. * **flowExecutions** *(list) --* The list of flow executions. * *(dict) --* The flow execution details. * **instanceId** *(string) --* The flow execution's instanceId. * **flowName** *(string) --* The flow execution's flowName. * **executionId** *(string) --* The flow executionId. * **status** *(string) --* The status of flow execution. * **sourceInfo** *(dict) --* The source information for a flow execution. * **sourceType** *(string) --* The data integration flow execution source type. * **s3Source** *(dict) --* The source details of a flow execution with S3 source. * **bucketName** *(string) --* The S3 bucket name of the S3 source. * **key** *(string) --* The S3 object key of the S3 source. * **datasetSource** *(dict) --* The source details of a flow execution with dataset source. * **datasetIdentifier** *(string) --* The ARN of the dataset source. * **message** *(string) --* The failure message (if any) of failed flow execution. * **startTime** *(datetime) --* The flow execution start timestamp. * **endTime** *(datetime) --* The flow execution end timestamp. * **outputMetadata** *(dict) --* The flow execution output metadata. * **diagnosticReportsRootS3URI** *(string) --* The S3 URI under which all diagnostic files (such as deduped records if any) are stored. * **NextToken** *(string) --* A token to resume pagination. SupplyChain / Paginator / ListDataLakeDatasets ListDataLakeDatasets ******************** class SupplyChain.Paginator.ListDataLakeDatasets paginator = client.get_paginator('list_data_lake_datasets') paginate(**kwargs) Creates an iterator that will paginate through responses from "SupplyChain.Client.list_data_lake_datasets()". See also: AWS API Documentation **Request Syntax** response_iterator = paginator.paginate( instanceId='string', namespace='string', PaginationConfig={ 'MaxItems': 123, 'PageSize': 123, 'StartingToken': 'string' } ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **namespace** (*string*) -- **[REQUIRED]** The namespace of the dataset, besides the custom defined namespace, every instance comes with below pre-defined namespaces: * **asc** - For information on the Amazon Web Services Supply Chain supported datasets see https://docs.aws.amazon.com/aws-supply- chain/latest/userguide/data-model-asc.html. * **default** - For datasets with custom user-defined schemas. * **PaginationConfig** (*dict*) -- A dictionary that provides parameters to control pagination. * **MaxItems** *(integer) --* The total number of items to return. If the total number of items available is more than the value specified in max-items then a "NextToken" will be provided in the output that you can use to resume pagination. * **PageSize** *(integer) --* The size of each page. * **StartingToken** *(string) --* A token to specify where to start paginating. This is the "NextToken" from a previous response. Return type: dict Returns: **Response Syntax** { 'datasets': [ { 'instanceId': 'string', 'namespace': 'string', 'name': 'string', 'arn': 'string', 'schema': { 'name': 'string', 'fields': [ { 'name': 'string', 'type': 'INT'|'DOUBLE'|'STRING'|'TIMESTAMP'|'LONG', 'isRequired': True|False }, ], 'primaryKeys': [ { 'name': 'string' }, ] }, 'description': 'string', 'partitionSpec': { 'fields': [ { 'name': 'string', 'transform': { 'type': 'YEAR'|'MONTH'|'DAY'|'HOUR'|'IDENTITY' } }, ] }, 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) }, ], 'NextToken': 'string' } **Response Structure** * *(dict) --* The response parameters of ListDataLakeDatasets. * **datasets** *(list) --* The list of fetched dataset details. * *(dict) --* The data lake dataset details. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **namespace** *(string) --* The namespace of the dataset, besides the custom defined namespace, every instance comes with below pre-defined namespaces: * **asc** - For information on the Amazon Web Services Supply Chain supported datasets see https://docs.aws.amazon.com/aws-supply- chain/latest/userguide/data-model-asc.html. * **default** - For datasets with custom user-defined schemas. * **name** *(string) --* The name of the dataset. For **asc** namespace, the name must be one of the supported data entities under https://docs.aws.amazon.com/aws-supply- chain/latest/userguide/data-model-asc.html. * **arn** *(string) --* The arn of the dataset. * **schema** *(dict) --* The schema of the dataset. * **name** *(string) --* The name of the dataset schema. * **fields** *(list) --* The list of field details of the dataset schema. * *(dict) --* The dataset field details. * **name** *(string) --* The dataset field name. * **type** *(string) --* The dataset field type. * **isRequired** *(boolean) --* Indicate if the field is required or not. * **primaryKeys** *(list) --* The list of primary key fields for the dataset. Primary keys defined can help data ingestion methods to ensure data uniqueness: CreateDataIntegrationFlow's dedupe strategy will leverage primary keys to perform records deduplication before write to dataset; SendDataIntegrationEvent's UPSERT and DELETE can only work with dataset with primary keys. For more details, refer to those data ingestion documentations. Note that defining primary keys does not necessarily mean the dataset cannot have duplicate records, duplicate records can still be ingested if CreateDataIntegrationFlow's dedupe disabled or through SendDataIntegrationEvent's APPEND operation. * *(dict) --* The detail of the primary key field. * **name** *(string) --* The name of the primary key field. * **description** *(string) --* The description of the dataset. * **partitionSpec** *(dict) --* The partition specification for a dataset. * **fields** *(list) --* The fields on which to partition a dataset. The partitions will be applied hierarchically based on the order of this list. * *(dict) --* The detail of the partition field. * **name** *(string) --* The name of the partition field. * **transform** *(dict) --* The transformation of the partition field. A transformation specifies how to partition on a given field. For example, with timestamp you can specify that you'd like to partition fields by day, e.g. data record with value 2025-01-03T00:00:00Z in partition field is in 2025-01-03 partition. Also noted that data record without any value in optional partition field is in NULL partition. * **type** *(string) --* The type of partitioning transformation for this field. The available options are: * **IDENTITY** - Partitions data on a given field by its exact values. * **YEAR** - Partitions data on a timestamp field using year granularity. * **MONTH** - Partitions data on a timestamp field using month granularity. * **DAY** - Partitions data on a timestamp field using day granularity. * **HOUR** - Partitions data on a timestamp field using hour granularity. * **createdTime** *(datetime) --* The creation time of the dataset. * **lastModifiedTime** *(datetime) --* The last modified time of the dataset. * **NextToken** *(string) --* A token to resume pagination. SupplyChain / Paginator / ListDataIntegrationFlows ListDataIntegrationFlows ************************ class SupplyChain.Paginator.ListDataIntegrationFlows paginator = client.get_paginator('list_data_integration_flows') paginate(**kwargs) Creates an iterator that will paginate through responses from "SupplyChain.Client.list_data_integration_flows()". See also: AWS API Documentation **Request Syntax** response_iterator = paginator.paginate( instanceId='string', PaginationConfig={ 'MaxItems': 123, 'PageSize': 123, 'StartingToken': 'string' } ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **PaginationConfig** (*dict*) -- A dictionary that provides parameters to control pagination. * **MaxItems** *(integer) --* The total number of items to return. If the total number of items available is more than the value specified in max-items then a "NextToken" will be provided in the output that you can use to resume pagination. * **PageSize** *(integer) --* The size of each page. * **StartingToken** *(string) --* A token to specify where to start paginating. This is the "NextToken" from a previous response. Return type: dict Returns: **Response Syntax** { 'flows': [ { 'instanceId': 'string', 'name': 'string', 'sources': [ { 'sourceType': 'S3'|'DATASET', 'sourceName': 'string', 's3Source': { 'bucketName': 'string', 'prefix': 'string', 'options': { 'fileType': 'CSV'|'PARQUET'|'JSON' } }, 'datasetSource': { 'datasetIdentifier': 'string', 'options': { 'loadType': 'INCREMENTAL'|'REPLACE', 'dedupeRecords': True|False, 'dedupeStrategy': { 'type': 'FIELD_PRIORITY', 'fieldPriority': { 'fields': [ { 'name': 'string', 'sortOrder': 'ASC'|'DESC' }, ] } } } } }, ], 'transformation': { 'transformationType': 'SQL'|'NONE', 'sqlTransformation': { 'query': 'string' } }, 'target': { 'targetType': 'S3'|'DATASET', 's3Target': { 'bucketName': 'string', 'prefix': 'string', 'options': { 'fileType': 'CSV'|'PARQUET'|'JSON' } }, 'datasetTarget': { 'datasetIdentifier': 'string', 'options': { 'loadType': 'INCREMENTAL'|'REPLACE', 'dedupeRecords': True|False, 'dedupeStrategy': { 'type': 'FIELD_PRIORITY', 'fieldPriority': { 'fields': [ { 'name': 'string', 'sortOrder': 'ASC'|'DESC' }, ] } } } } }, 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) }, ], 'NextToken': 'string' } **Response Structure** * *(dict) --* The response parameters for ListDataIntegrationFlows. * **flows** *(list) --* The response parameters for ListDataIntegrationFlows. * *(dict) --* The DataIntegrationFlow details. * **instanceId** *(string) --* The DataIntegrationFlow instance ID. * **name** *(string) --* The DataIntegrationFlow name. * **sources** *(list) --* The DataIntegrationFlow source configurations. * *(dict) --* The DataIntegrationFlow source parameters. * **sourceType** *(string) --* The DataIntegrationFlow source type. * **sourceName** *(string) --* The DataIntegrationFlow source name that can be used as table alias in SQL transformation query. * **s3Source** *(dict) --* The S3 DataIntegrationFlow source. * **bucketName** *(string) --* The bucketName of the S3 source objects. * **prefix** *(string) --* The prefix of the S3 source objects. To trigger data ingestion, S3 files need to be put under "s3://bucketName/prefix/". * **options** *(dict) --* The other options of the S3 DataIntegrationFlow source. * **fileType** *(string) --* The Amazon S3 file type in S3 options. * **datasetSource** *(dict) --* The dataset DataIntegrationFlow source. * **datasetIdentifier** *(string) --* The ARN of the dataset. * **options** *(dict) --* The dataset DataIntegrationFlow source options. * **loadType** *(string) --* The target dataset's data load type. This only affects how source S3 files are selected in the S3-to-dataset flow. * **REPLACE** - Target dataset will get replaced with the new file added under the source s3 prefix. * **INCREMENTAL** - Target dataset will get updated with the up-to-date content under S3 prefix incorporating any file additions or removals there. * **dedupeRecords** *(boolean) --* The option to perform deduplication on data records sharing same primary key values. If disabled, transformed data with duplicate primary key values will ingest into dataset, for datasets within **asc** namespace, such duplicates will cause ingestion fail. If enabled without dedupeStrategy, deduplication is done by retaining a random data record among those sharing the same primary key values. If enabled with dedupeStragtegy, the deduplication is done following the strategy. Note that target dataset may have partition configured, when dedupe is enabled, it only dedupe against primary keys and retain only one record out of those duplicates regardless of its partition status. * **dedupeStrategy** *(dict) --* The deduplication strategy to dedupe the data records sharing same primary key values of the target dataset. This strategy only applies to target dataset with primary keys and with dedupeRecords option enabled. If transformed data still got duplicates after the dedupeStrategy evaluation, a random data record is chosen to be retained. * **type** *(string) --* The type of the deduplication strategy. * **FIELD_PRIORITY** - Field priority configuration for the deduplication strategy specifies an ordered list of fields used to tie-break the data records sharing the same primary key values. Fields earlier in the list have higher priority for evaluation. For each field, the sort order determines whether to retain data record with larger or smaller field value. * **fieldPriority** *(dict) --* The field priority deduplication strategy. * **fields** *(list) --* The list of field names and their sort order for deduplication, arranged in descending priority from highest to lowest. * *(dict) --* The field used in the field priority deduplication strategy. * **name** *(string) --* The name of the deduplication field. Must exist in the dataset and not be a primary key. * **sortOrder** *(string) --* The sort order for the deduplication field. * **transformation** *(dict) --* The DataIntegrationFlow transformation configurations. * **transformationType** *(string) --* The DataIntegrationFlow transformation type. * **sqlTransformation** *(dict) --* The SQL DataIntegrationFlow transformation configuration. * **query** *(string) --* The transformation SQL query body based on SparkSQL. * **target** *(dict) --* The DataIntegrationFlow target configuration. * **targetType** *(string) --* The DataIntegrationFlow target type. * **s3Target** *(dict) --* The S3 DataIntegrationFlow target. * **bucketName** *(string) --* The bucketName of the S3 target objects. * **prefix** *(string) --* The prefix of the S3 target objects. * **options** *(dict) --* The S3 DataIntegrationFlow target options. * **fileType** *(string) --* The Amazon S3 file type in S3 options. * **datasetTarget** *(dict) --* The dataset DataIntegrationFlow target. Note that for AWS Supply Chain dataset under **asc** namespace, it has a connection_id internal field that is not allowed to be provided by client directly, they will be auto populated. * **datasetIdentifier** *(string) --* The dataset ARN. * **options** *(dict) --* The dataset DataIntegrationFlow target options. * **loadType** *(string) --* The target dataset's data load type. This only affects how source S3 files are selected in the S3-to-dataset flow. * **REPLACE** - Target dataset will get replaced with the new file added under the source s3 prefix. * **INCREMENTAL** - Target dataset will get updated with the up-to-date content under S3 prefix incorporating any file additions or removals there. * **dedupeRecords** *(boolean) --* The option to perform deduplication on data records sharing same primary key values. If disabled, transformed data with duplicate primary key values will ingest into dataset, for datasets within **asc** namespace, such duplicates will cause ingestion fail. If enabled without dedupeStrategy, deduplication is done by retaining a random data record among those sharing the same primary key values. If enabled with dedupeStragtegy, the deduplication is done following the strategy. Note that target dataset may have partition configured, when dedupe is enabled, it only dedupe against primary keys and retain only one record out of those duplicates regardless of its partition status. * **dedupeStrategy** *(dict) --* The deduplication strategy to dedupe the data records sharing same primary key values of the target dataset. This strategy only applies to target dataset with primary keys and with dedupeRecords option enabled. If transformed data still got duplicates after the dedupeStrategy evaluation, a random data record is chosen to be retained. * **type** *(string) --* The type of the deduplication strategy. * **FIELD_PRIORITY** - Field priority configuration for the deduplication strategy specifies an ordered list of fields used to tie-break the data records sharing the same primary key values. Fields earlier in the list have higher priority for evaluation. For each field, the sort order determines whether to retain data record with larger or smaller field value. * **fieldPriority** *(dict) --* The field priority deduplication strategy. * **fields** *(list) --* The list of field names and their sort order for deduplication, arranged in descending priority from highest to lowest. * *(dict) --* The field used in the field priority deduplication strategy. * **name** *(string) --* The name of the deduplication field. Must exist in the dataset and not be a primary key. * **sortOrder** *(string) --* The sort order for the deduplication field. * **createdTime** *(datetime) --* The DataIntegrationFlow creation timestamp. * **lastModifiedTime** *(datetime) --* The DataIntegrationFlow last modified timestamp. * **NextToken** *(string) --* A token to resume pagination. SupplyChain / Client / list_data_integration_events list_data_integration_events **************************** SupplyChain.Client.list_data_integration_events(**kwargs) Enables you to programmatically list all data integration events for the provided Amazon Web Services Supply Chain instance. See also: AWS API Documentation **Request Syntax** response = client.list_data_integration_events( instanceId='string', eventType='scn.data.forecast'|'scn.data.inventorylevel'|'scn.data.inboundorder'|'scn.data.inboundorderline'|'scn.data.inboundorderlineschedule'|'scn.data.outboundorderline'|'scn.data.outboundshipment'|'scn.data.processheader'|'scn.data.processoperation'|'scn.data.processproduct'|'scn.data.reservation'|'scn.data.shipment'|'scn.data.shipmentstop'|'scn.data.shipmentstoporder'|'scn.data.supplyplan'|'scn.data.dataset', nextToken='string', maxResults=123 ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **eventType** (*string*) -- List data integration events for the specified eventType. * **nextToken** (*string*) -- The pagination token to fetch the next page of the data integration events. * **maxResults** (*integer*) -- Specify the maximum number of data integration events to fetch in one paginated request. Return type: dict Returns: **Response Syntax** { 'events': [ { 'instanceId': 'string', 'eventId': 'string', 'eventType': 'scn.data.forecast'|'scn.data.inventorylevel'|'scn.data.inboundorder'|'scn.data.inboundorderline'|'scn.data.inboundorderlineschedule'|'scn.data.outboundorderline'|'scn.data.outboundshipment'|'scn.data.processheader'|'scn.data.processoperation'|'scn.data.processproduct'|'scn.data.reservation'|'scn.data.shipment'|'scn.data.shipmentstop'|'scn.data.shipmentstoporder'|'scn.data.supplyplan'|'scn.data.dataset', 'eventGroupId': 'string', 'eventTimestamp': datetime(2015, 1, 1), 'datasetTargetDetails': { 'datasetIdentifier': 'string', 'operationType': 'APPEND'|'UPSERT'|'DELETE', 'datasetLoadExecution': { 'status': 'SUCCEEDED'|'IN_PROGRESS'|'FAILED', 'message': 'string' } } }, ], 'nextToken': 'string' } **Response Structure** * *(dict) --* The response parameters for ListDataIntegrationEvents. * **events** *(list) --* The list of data integration events. * *(dict) --* The data integration event details. * **instanceId** *(string) --* The AWS Supply Chain instance identifier. * **eventId** *(string) --* The unique event identifier. * **eventType** *(string) --* The data event type. * **eventGroupId** *(string) --* Event identifier (for example, orderId for InboundOrder) used for data sharding or partitioning. * **eventTimestamp** *(datetime) --* The event timestamp (in epoch seconds). * **datasetTargetDetails** *(dict) --* The target dataset details for a DATASET event type. * **datasetIdentifier** *(string) --* The datalake dataset ARN identifier. * **operationType** *(string) --* The target dataset load operation type. The available options are: * **APPEND** - Add new records to the dataset. Noted that this operation type will just try to append records as-is without any primary key or partition constraints. * **UPSERT** - Modify existing records in the dataset with primary key configured, events for datasets without primary keys are not allowed. If event data contains primary keys that match records in the dataset within same partition, then those existing records (in that partition) will be updated. If primary keys do not match, new records will be added. Note that if dataset contain records with duplicate primary key values in the same partition, those duplicate records will be deduped into one updated record. * **DELETE** - Remove existing records in the dataset with primary key configured, events for datasets without primary keys are not allowed. If event data contains primary keys that match records in the dataset within same partition, then those existing records (in that partition) will be deleted. If primary keys do not match, no actions will be done. Note that if dataset contain records with duplicate primary key values in the same partition, all those duplicates will be removed. * **datasetLoadExecution** *(dict) --* The target dataset load execution. * **status** *(string) --* The event load execution status to target dataset. * **message** *(string) --* The failure message (if any) of failed event load execution to dataset. * **nextToken** *(string) --* The pagination token to fetch the next page of the ListDataIntegrationEvents. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / get_paginator get_paginator ************* SupplyChain.Client.get_paginator(operation_name) Create a paginator for an operation. Parameters: **operation_name** (*string*) -- The operation name. This is the same name as the method name on the client. For example, if the method name is "create_foo", and you'd normally invoke the operation as "client.create_foo(**kwargs)", if the "create_foo" operation can be paginated, you can use the call "client.get_paginator("create_foo")". Raises: **OperationNotPageableError** -- Raised if the operation is not pageable. You can use the "client.can_paginate" method to check if an operation is pageable. Return type: "botocore.paginate.Paginator" Returns: A paginator object. SupplyChain / Client / create_bill_of_materials_import_job create_bill_of_materials_import_job *********************************** SupplyChain.Client.create_bill_of_materials_import_job(**kwargs) CreateBillOfMaterialsImportJob creates an import job for the Product Bill Of Materials (BOM) entity. For information on the product_bom entity, see the AWS Supply Chain User Guide. The CSV file must be located in an Amazon S3 location accessible to AWS Supply Chain. It is recommended to use the same Amazon S3 bucket created during your AWS Supply Chain instance creation. See also: AWS API Documentation **Request Syntax** response = client.create_bill_of_materials_import_job( instanceId='string', s3uri='string', clientToken='string' ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The AWS Supply Chain instance identifier. * **s3uri** (*string*) -- **[REQUIRED]** The S3 URI of the CSV file to be imported. The bucket must grant permissions for AWS Supply Chain to read the file. * **clientToken** (*string*) -- An idempotency token ensures the API request is only completed no more than once. This way, retrying the request will not trigger the operation multiple times. A client token is a unique, case-sensitive string of 33 to 128 ASCII characters. To make an idempotent API request, specify a client token in the request. You should not reuse the same client token for other requests. If you retry a successful request with the same client token, the request will succeed with no further actions being taken, and you will receive the same API response as the original successful request. This field is autopopulated if not provided. Return type: dict Returns: **Response Syntax** { 'jobId': 'string' } **Response Structure** * *(dict) --* The response parameters of CreateBillOfMaterialsImportJob. * **jobId** *(string) --* The new BillOfMaterialsImportJob identifier. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / delete_data_integration_flow delete_data_integration_flow **************************** SupplyChain.Client.delete_data_integration_flow(**kwargs) Enable you to programmatically delete an existing data pipeline for the provided Amazon Web Services Supply Chain instance and DataIntegrationFlow name. See also: AWS API Documentation **Request Syntax** response = client.delete_data_integration_flow( instanceId='string', name='string' ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **name** (*string*) -- **[REQUIRED]** The name of the DataIntegrationFlow to be deleted. Return type: dict Returns: **Response Syntax** { 'instanceId': 'string', 'name': 'string' } **Response Structure** * *(dict) --* The response parameters for DeleteDataIntegrationFlow. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **name** *(string) --* The name of the DataIntegrationFlow deleted. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / delete_data_lake_namespace delete_data_lake_namespace ************************** SupplyChain.Client.delete_data_lake_namespace(**kwargs) Enables you to programmatically delete an Amazon Web Services Supply Chain data lake namespace and its underling datasets. Developers can delete the existing namespaces for a given instance ID and namespace name. See also: AWS API Documentation **Request Syntax** response = client.delete_data_lake_namespace( instanceId='string', name='string' ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The AWS Supply Chain instance identifier. * **name** (*string*) -- **[REQUIRED]** The name of the namespace. Noted you cannot delete pre-defined namespace like **asc**, **default** which are only deleted through instance deletion. Return type: dict Returns: **Response Syntax** { 'instanceId': 'string', 'name': 'string' } **Response Structure** * *(dict) --* The response parameters of DeleteDataLakeNamespace. * **instanceId** *(string) --* The AWS Supply Chain instance identifier. * **name** *(string) --* The name of deleted namespace. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / list_data_integration_flows list_data_integration_flows *************************** SupplyChain.Client.list_data_integration_flows(**kwargs) Enables you to programmatically list all data pipelines for the provided Amazon Web Services Supply Chain instance. See also: AWS API Documentation **Request Syntax** response = client.list_data_integration_flows( instanceId='string', nextToken='string', maxResults=123 ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **nextToken** (*string*) -- The pagination token to fetch the next page of the DataIntegrationFlows. * **maxResults** (*integer*) -- Specify the maximum number of DataIntegrationFlows to fetch in one paginated request. Return type: dict Returns: **Response Syntax** { 'flows': [ { 'instanceId': 'string', 'name': 'string', 'sources': [ { 'sourceType': 'S3'|'DATASET', 'sourceName': 'string', 's3Source': { 'bucketName': 'string', 'prefix': 'string', 'options': { 'fileType': 'CSV'|'PARQUET'|'JSON' } }, 'datasetSource': { 'datasetIdentifier': 'string', 'options': { 'loadType': 'INCREMENTAL'|'REPLACE', 'dedupeRecords': True|False, 'dedupeStrategy': { 'type': 'FIELD_PRIORITY', 'fieldPriority': { 'fields': [ { 'name': 'string', 'sortOrder': 'ASC'|'DESC' }, ] } } } } }, ], 'transformation': { 'transformationType': 'SQL'|'NONE', 'sqlTransformation': { 'query': 'string' } }, 'target': { 'targetType': 'S3'|'DATASET', 's3Target': { 'bucketName': 'string', 'prefix': 'string', 'options': { 'fileType': 'CSV'|'PARQUET'|'JSON' } }, 'datasetTarget': { 'datasetIdentifier': 'string', 'options': { 'loadType': 'INCREMENTAL'|'REPLACE', 'dedupeRecords': True|False, 'dedupeStrategy': { 'type': 'FIELD_PRIORITY', 'fieldPriority': { 'fields': [ { 'name': 'string', 'sortOrder': 'ASC'|'DESC' }, ] } } } } }, 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) }, ], 'nextToken': 'string' } **Response Structure** * *(dict) --* The response parameters for ListDataIntegrationFlows. * **flows** *(list) --* The response parameters for ListDataIntegrationFlows. * *(dict) --* The DataIntegrationFlow details. * **instanceId** *(string) --* The DataIntegrationFlow instance ID. * **name** *(string) --* The DataIntegrationFlow name. * **sources** *(list) --* The DataIntegrationFlow source configurations. * *(dict) --* The DataIntegrationFlow source parameters. * **sourceType** *(string) --* The DataIntegrationFlow source type. * **sourceName** *(string) --* The DataIntegrationFlow source name that can be used as table alias in SQL transformation query. * **s3Source** *(dict) --* The S3 DataIntegrationFlow source. * **bucketName** *(string) --* The bucketName of the S3 source objects. * **prefix** *(string) --* The prefix of the S3 source objects. To trigger data ingestion, S3 files need to be put under "s3://bucketName/prefix/". * **options** *(dict) --* The other options of the S3 DataIntegrationFlow source. * **fileType** *(string) --* The Amazon S3 file type in S3 options. * **datasetSource** *(dict) --* The dataset DataIntegrationFlow source. * **datasetIdentifier** *(string) --* The ARN of the dataset. * **options** *(dict) --* The dataset DataIntegrationFlow source options. * **loadType** *(string) --* The target dataset's data load type. This only affects how source S3 files are selected in the S3-to-dataset flow. * **REPLACE** - Target dataset will get replaced with the new file added under the source s3 prefix. * **INCREMENTAL** - Target dataset will get updated with the up-to-date content under S3 prefix incorporating any file additions or removals there. * **dedupeRecords** *(boolean) --* The option to perform deduplication on data records sharing same primary key values. If disabled, transformed data with duplicate primary key values will ingest into dataset, for datasets within **asc** namespace, such duplicates will cause ingestion fail. If enabled without dedupeStrategy, deduplication is done by retaining a random data record among those sharing the same primary key values. If enabled with dedupeStragtegy, the deduplication is done following the strategy. Note that target dataset may have partition configured, when dedupe is enabled, it only dedupe against primary keys and retain only one record out of those duplicates regardless of its partition status. * **dedupeStrategy** *(dict) --* The deduplication strategy to dedupe the data records sharing same primary key values of the target dataset. This strategy only applies to target dataset with primary keys and with dedupeRecords option enabled. If transformed data still got duplicates after the dedupeStrategy evaluation, a random data record is chosen to be retained. * **type** *(string) --* The type of the deduplication strategy. * **FIELD_PRIORITY** - Field priority configuration for the deduplication strategy specifies an ordered list of fields used to tie-break the data records sharing the same primary key values. Fields earlier in the list have higher priority for evaluation. For each field, the sort order determines whether to retain data record with larger or smaller field value. * **fieldPriority** *(dict) --* The field priority deduplication strategy. * **fields** *(list) --* The list of field names and their sort order for deduplication, arranged in descending priority from highest to lowest. * *(dict) --* The field used in the field priority deduplication strategy. * **name** *(string) --* The name of the deduplication field. Must exist in the dataset and not be a primary key. * **sortOrder** *(string) --* The sort order for the deduplication field. * **transformation** *(dict) --* The DataIntegrationFlow transformation configurations. * **transformationType** *(string) --* The DataIntegrationFlow transformation type. * **sqlTransformation** *(dict) --* The SQL DataIntegrationFlow transformation configuration. * **query** *(string) --* The transformation SQL query body based on SparkSQL. * **target** *(dict) --* The DataIntegrationFlow target configuration. * **targetType** *(string) --* The DataIntegrationFlow target type. * **s3Target** *(dict) --* The S3 DataIntegrationFlow target. * **bucketName** *(string) --* The bucketName of the S3 target objects. * **prefix** *(string) --* The prefix of the S3 target objects. * **options** *(dict) --* The S3 DataIntegrationFlow target options. * **fileType** *(string) --* The Amazon S3 file type in S3 options. * **datasetTarget** *(dict) --* The dataset DataIntegrationFlow target. Note that for AWS Supply Chain dataset under **asc** namespace, it has a connection_id internal field that is not allowed to be provided by client directly, they will be auto populated. * **datasetIdentifier** *(string) --* The dataset ARN. * **options** *(dict) --* The dataset DataIntegrationFlow target options. * **loadType** *(string) --* The target dataset's data load type. This only affects how source S3 files are selected in the S3 -to-dataset flow. * **REPLACE** - Target dataset will get replaced with the new file added under the source s3 prefix. * **INCREMENTAL** - Target dataset will get updated with the up-to-date content under S3 prefix incorporating any file additions or removals there. * **dedupeRecords** *(boolean) --* The option to perform deduplication on data records sharing same primary key values. If disabled, transformed data with duplicate primary key values will ingest into dataset, for datasets within **asc** namespace, such duplicates will cause ingestion fail. If enabled without dedupeStrategy, deduplication is done by retaining a random data record among those sharing the same primary key values. If enabled with dedupeStragtegy, the deduplication is done following the strategy. Note that target dataset may have partition configured, when dedupe is enabled, it only dedupe against primary keys and retain only one record out of those duplicates regardless of its partition status. * **dedupeStrategy** *(dict) --* The deduplication strategy to dedupe the data records sharing same primary key values of the target dataset. This strategy only applies to target dataset with primary keys and with dedupeRecords option enabled. If transformed data still got duplicates after the dedupeStrategy evaluation, a random data record is chosen to be retained. * **type** *(string) --* The type of the deduplication strategy. * **FIELD_PRIORITY** - Field priority configuration for the deduplication strategy specifies an ordered list of fields used to tie-break the data records sharing the same primary key values. Fields earlier in the list have higher priority for evaluation. For each field, the sort order determines whether to retain data record with larger or smaller field value. * **fieldPriority** *(dict) --* The field priority deduplication strategy. * **fields** *(list) --* The list of field names and their sort order for deduplication, arranged in descending priority from highest to lowest. * *(dict) --* The field used in the field priority deduplication strategy. * **name** *(string) --* The name of the deduplication field. Must exist in the dataset and not be a primary key. * **sortOrder** *(string) --* The sort order for the deduplication field. * **createdTime** *(datetime) --* The DataIntegrationFlow creation timestamp. * **lastModifiedTime** *(datetime) --* The DataIntegrationFlow last modified timestamp. * **nextToken** *(string) --* The pagination token to fetch the next page of the DataIntegrationFlows. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / update_data_integration_flow update_data_integration_flow **************************** SupplyChain.Client.update_data_integration_flow(**kwargs) Enables you to programmatically update an existing data pipeline to ingest data from the source systems such as, Amazon S3 buckets, to a predefined Amazon Web Services Supply Chain dataset (product, inbound_order) or a temporary dataset along with the data transformation query provided with the API. See also: AWS API Documentation **Request Syntax** response = client.update_data_integration_flow( instanceId='string', name='string', sources=[ { 'sourceType': 'S3'|'DATASET', 'sourceName': 'string', 's3Source': { 'bucketName': 'string', 'prefix': 'string', 'options': { 'fileType': 'CSV'|'PARQUET'|'JSON' } }, 'datasetSource': { 'datasetIdentifier': 'string', 'options': { 'loadType': 'INCREMENTAL'|'REPLACE', 'dedupeRecords': True|False, 'dedupeStrategy': { 'type': 'FIELD_PRIORITY', 'fieldPriority': { 'fields': [ { 'name': 'string', 'sortOrder': 'ASC'|'DESC' }, ] } } } } }, ], transformation={ 'transformationType': 'SQL'|'NONE', 'sqlTransformation': { 'query': 'string' } }, target={ 'targetType': 'S3'|'DATASET', 's3Target': { 'bucketName': 'string', 'prefix': 'string', 'options': { 'fileType': 'CSV'|'PARQUET'|'JSON' } }, 'datasetTarget': { 'datasetIdentifier': 'string', 'options': { 'loadType': 'INCREMENTAL'|'REPLACE', 'dedupeRecords': True|False, 'dedupeStrategy': { 'type': 'FIELD_PRIORITY', 'fieldPriority': { 'fields': [ { 'name': 'string', 'sortOrder': 'ASC'|'DESC' }, ] } } } } } ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **name** (*string*) -- **[REQUIRED]** The name of the DataIntegrationFlow to be updated. * **sources** (*list*) -- The new source configurations for the DataIntegrationFlow. * *(dict) --* The DataIntegrationFlow source parameters. * **sourceType** *(string) --* **[REQUIRED]** The DataIntegrationFlow source type. * **sourceName** *(string) --* **[REQUIRED]** The DataIntegrationFlow source name that can be used as table alias in SQL transformation query. * **s3Source** *(dict) --* The S3 DataIntegrationFlow source. * **bucketName** *(string) --* **[REQUIRED]** The bucketName of the S3 source objects. * **prefix** *(string) --* **[REQUIRED]** The prefix of the S3 source objects. To trigger data ingestion, S3 files need to be put under "s3://bucketName/prefix/". * **options** *(dict) --* The other options of the S3 DataIntegrationFlow source. * **fileType** *(string) --* The Amazon S3 file type in S3 options. * **datasetSource** *(dict) --* The dataset DataIntegrationFlow source. * **datasetIdentifier** *(string) --* **[REQUIRED]** The ARN of the dataset. * **options** *(dict) --* The dataset DataIntegrationFlow source options. * **loadType** *(string) --* The target dataset's data load type. This only affects how source S3 files are selected in the S3-to-dataset flow. * **REPLACE** - Target dataset will get replaced with the new file added under the source s3 prefix. * **INCREMENTAL** - Target dataset will get updated with the up-to-date content under S3 prefix incorporating any file additions or removals there. * **dedupeRecords** *(boolean) --* The option to perform deduplication on data records sharing same primary key values. If disabled, transformed data with duplicate primary key values will ingest into dataset, for datasets within **asc** namespace, such duplicates will cause ingestion fail. If enabled without dedupeStrategy, deduplication is done by retaining a random data record among those sharing the same primary key values. If enabled with dedupeStragtegy, the deduplication is done following the strategy. Note that target dataset may have partition configured, when dedupe is enabled, it only dedupe against primary keys and retain only one record out of those duplicates regardless of its partition status. * **dedupeStrategy** *(dict) --* The deduplication strategy to dedupe the data records sharing same primary key values of the target dataset. This strategy only applies to target dataset with primary keys and with dedupeRecords option enabled. If transformed data still got duplicates after the dedupeStrategy evaluation, a random data record is chosen to be retained. * **type** *(string) --* **[REQUIRED]** The type of the deduplication strategy. * **FIELD_PRIORITY** - Field priority configuration for the deduplication strategy specifies an ordered list of fields used to tie-break the data records sharing the same primary key values. Fields earlier in the list have higher priority for evaluation. For each field, the sort order determines whether to retain data record with larger or smaller field value. * **fieldPriority** *(dict) --* The field priority deduplication strategy. * **fields** *(list) --* **[REQUIRED]** The list of field names and their sort order for deduplication, arranged in descending priority from highest to lowest. * *(dict) --* The field used in the field priority deduplication strategy. * **name** *(string) --* **[REQUIRED]** The name of the deduplication field. Must exist in the dataset and not be a primary key. * **sortOrder** *(string) --* **[REQUIRED]** The sort order for the deduplication field. * **transformation** (*dict*) -- The new transformation configurations for the DataIntegrationFlow. * **transformationType** *(string) --* **[REQUIRED]** The DataIntegrationFlow transformation type. * **sqlTransformation** *(dict) --* The SQL DataIntegrationFlow transformation configuration. * **query** *(string) --* **[REQUIRED]** The transformation SQL query body based on SparkSQL. * **target** (*dict*) -- The new target configurations for the DataIntegrationFlow. * **targetType** *(string) --* **[REQUIRED]** The DataIntegrationFlow target type. * **s3Target** *(dict) --* The S3 DataIntegrationFlow target. * **bucketName** *(string) --* **[REQUIRED]** The bucketName of the S3 target objects. * **prefix** *(string) --* **[REQUIRED]** The prefix of the S3 target objects. * **options** *(dict) --* The S3 DataIntegrationFlow target options. * **fileType** *(string) --* The Amazon S3 file type in S3 options. * **datasetTarget** *(dict) --* The dataset DataIntegrationFlow target. Note that for AWS Supply Chain dataset under **asc** namespace, it has a connection_id internal field that is not allowed to be provided by client directly, they will be auto populated. * **datasetIdentifier** *(string) --* **[REQUIRED]** The dataset ARN. * **options** *(dict) --* The dataset DataIntegrationFlow target options. * **loadType** *(string) --* The target dataset's data load type. This only affects how source S3 files are selected in the S3-to-dataset flow. * **REPLACE** - Target dataset will get replaced with the new file added under the source s3 prefix. * **INCREMENTAL** - Target dataset will get updated with the up-to-date content under S3 prefix incorporating any file additions or removals there. * **dedupeRecords** *(boolean) --* The option to perform deduplication on data records sharing same primary key values. If disabled, transformed data with duplicate primary key values will ingest into dataset, for datasets within **asc** namespace, such duplicates will cause ingestion fail. If enabled without dedupeStrategy, deduplication is done by retaining a random data record among those sharing the same primary key values. If enabled with dedupeStragtegy, the deduplication is done following the strategy. Note that target dataset may have partition configured, when dedupe is enabled, it only dedupe against primary keys and retain only one record out of those duplicates regardless of its partition status. * **dedupeStrategy** *(dict) --* The deduplication strategy to dedupe the data records sharing same primary key values of the target dataset. This strategy only applies to target dataset with primary keys and with dedupeRecords option enabled. If transformed data still got duplicates after the dedupeStrategy evaluation, a random data record is chosen to be retained. * **type** *(string) --* **[REQUIRED]** The type of the deduplication strategy. * **FIELD_PRIORITY** - Field priority configuration for the deduplication strategy specifies an ordered list of fields used to tie-break the data records sharing the same primary key values. Fields earlier in the list have higher priority for evaluation. For each field, the sort order determines whether to retain data record with larger or smaller field value. * **fieldPriority** *(dict) --* The field priority deduplication strategy. * **fields** *(list) --* **[REQUIRED]** The list of field names and their sort order for deduplication, arranged in descending priority from highest to lowest. * *(dict) --* The field used in the field priority deduplication strategy. * **name** *(string) --* **[REQUIRED]** The name of the deduplication field. Must exist in the dataset and not be a primary key. * **sortOrder** *(string) --* **[REQUIRED]** The sort order for the deduplication field. Return type: dict Returns: **Response Syntax** { 'flow': { 'instanceId': 'string', 'name': 'string', 'sources': [ { 'sourceType': 'S3'|'DATASET', 'sourceName': 'string', 's3Source': { 'bucketName': 'string', 'prefix': 'string', 'options': { 'fileType': 'CSV'|'PARQUET'|'JSON' } }, 'datasetSource': { 'datasetIdentifier': 'string', 'options': { 'loadType': 'INCREMENTAL'|'REPLACE', 'dedupeRecords': True|False, 'dedupeStrategy': { 'type': 'FIELD_PRIORITY', 'fieldPriority': { 'fields': [ { 'name': 'string', 'sortOrder': 'ASC'|'DESC' }, ] } } } } }, ], 'transformation': { 'transformationType': 'SQL'|'NONE', 'sqlTransformation': { 'query': 'string' } }, 'target': { 'targetType': 'S3'|'DATASET', 's3Target': { 'bucketName': 'string', 'prefix': 'string', 'options': { 'fileType': 'CSV'|'PARQUET'|'JSON' } }, 'datasetTarget': { 'datasetIdentifier': 'string', 'options': { 'loadType': 'INCREMENTAL'|'REPLACE', 'dedupeRecords': True|False, 'dedupeStrategy': { 'type': 'FIELD_PRIORITY', 'fieldPriority': { 'fields': [ { 'name': 'string', 'sortOrder': 'ASC'|'DESC' }, ] } } } } }, 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) } } **Response Structure** * *(dict) --* The response parameters for UpdateDataIntegrationFlow. * **flow** *(dict) --* The details of the updated DataIntegrationFlow. * **instanceId** *(string) --* The DataIntegrationFlow instance ID. * **name** *(string) --* The DataIntegrationFlow name. * **sources** *(list) --* The DataIntegrationFlow source configurations. * *(dict) --* The DataIntegrationFlow source parameters. * **sourceType** *(string) --* The DataIntegrationFlow source type. * **sourceName** *(string) --* The DataIntegrationFlow source name that can be used as table alias in SQL transformation query. * **s3Source** *(dict) --* The S3 DataIntegrationFlow source. * **bucketName** *(string) --* The bucketName of the S3 source objects. * **prefix** *(string) --* The prefix of the S3 source objects. To trigger data ingestion, S3 files need to be put under "s3://bucketName/prefix/". * **options** *(dict) --* The other options of the S3 DataIntegrationFlow source. * **fileType** *(string) --* The Amazon S3 file type in S3 options. * **datasetSource** *(dict) --* The dataset DataIntegrationFlow source. * **datasetIdentifier** *(string) --* The ARN of the dataset. * **options** *(dict) --* The dataset DataIntegrationFlow source options. * **loadType** *(string) --* The target dataset's data load type. This only affects how source S3 files are selected in the S3 -to-dataset flow. * **REPLACE** - Target dataset will get replaced with the new file added under the source s3 prefix. * **INCREMENTAL** - Target dataset will get updated with the up-to-date content under S3 prefix incorporating any file additions or removals there. * **dedupeRecords** *(boolean) --* The option to perform deduplication on data records sharing same primary key values. If disabled, transformed data with duplicate primary key values will ingest into dataset, for datasets within **asc** namespace, such duplicates will cause ingestion fail. If enabled without dedupeStrategy, deduplication is done by retaining a random data record among those sharing the same primary key values. If enabled with dedupeStragtegy, the deduplication is done following the strategy. Note that target dataset may have partition configured, when dedupe is enabled, it only dedupe against primary keys and retain only one record out of those duplicates regardless of its partition status. * **dedupeStrategy** *(dict) --* The deduplication strategy to dedupe the data records sharing same primary key values of the target dataset. This strategy only applies to target dataset with primary keys and with dedupeRecords option enabled. If transformed data still got duplicates after the dedupeStrategy evaluation, a random data record is chosen to be retained. * **type** *(string) --* The type of the deduplication strategy. * **FIELD_PRIORITY** - Field priority configuration for the deduplication strategy specifies an ordered list of fields used to tie-break the data records sharing the same primary key values. Fields earlier in the list have higher priority for evaluation. For each field, the sort order determines whether to retain data record with larger or smaller field value. * **fieldPriority** *(dict) --* The field priority deduplication strategy. * **fields** *(list) --* The list of field names and their sort order for deduplication, arranged in descending priority from highest to lowest. * *(dict) --* The field used in the field priority deduplication strategy. * **name** *(string) --* The name of the deduplication field. Must exist in the dataset and not be a primary key. * **sortOrder** *(string) --* The sort order for the deduplication field. * **transformation** *(dict) --* The DataIntegrationFlow transformation configurations. * **transformationType** *(string) --* The DataIntegrationFlow transformation type. * **sqlTransformation** *(dict) --* The SQL DataIntegrationFlow transformation configuration. * **query** *(string) --* The transformation SQL query body based on SparkSQL. * **target** *(dict) --* The DataIntegrationFlow target configuration. * **targetType** *(string) --* The DataIntegrationFlow target type. * **s3Target** *(dict) --* The S3 DataIntegrationFlow target. * **bucketName** *(string) --* The bucketName of the S3 target objects. * **prefix** *(string) --* The prefix of the S3 target objects. * **options** *(dict) --* The S3 DataIntegrationFlow target options. * **fileType** *(string) --* The Amazon S3 file type in S3 options. * **datasetTarget** *(dict) --* The dataset DataIntegrationFlow target. Note that for AWS Supply Chain dataset under **asc** namespace, it has a connection_id internal field that is not allowed to be provided by client directly, they will be auto populated. * **datasetIdentifier** *(string) --* The dataset ARN. * **options** *(dict) --* The dataset DataIntegrationFlow target options. * **loadType** *(string) --* The target dataset's data load type. This only affects how source S3 files are selected in the S3 -to-dataset flow. * **REPLACE** - Target dataset will get replaced with the new file added under the source s3 prefix. * **INCREMENTAL** - Target dataset will get updated with the up-to-date content under S3 prefix incorporating any file additions or removals there. * **dedupeRecords** *(boolean) --* The option to perform deduplication on data records sharing same primary key values. If disabled, transformed data with duplicate primary key values will ingest into dataset, for datasets within **asc** namespace, such duplicates will cause ingestion fail. If enabled without dedupeStrategy, deduplication is done by retaining a random data record among those sharing the same primary key values. If enabled with dedupeStragtegy, the deduplication is done following the strategy. Note that target dataset may have partition configured, when dedupe is enabled, it only dedupe against primary keys and retain only one record out of those duplicates regardless of its partition status. * **dedupeStrategy** *(dict) --* The deduplication strategy to dedupe the data records sharing same primary key values of the target dataset. This strategy only applies to target dataset with primary keys and with dedupeRecords option enabled. If transformed data still got duplicates after the dedupeStrategy evaluation, a random data record is chosen to be retained. * **type** *(string) --* The type of the deduplication strategy. * **FIELD_PRIORITY** - Field priority configuration for the deduplication strategy specifies an ordered list of fields used to tie- break the data records sharing the same primary key values. Fields earlier in the list have higher priority for evaluation. For each field, the sort order determines whether to retain data record with larger or smaller field value. * **fieldPriority** *(dict) --* The field priority deduplication strategy. * **fields** *(list) --* The list of field names and their sort order for deduplication, arranged in descending priority from highest to lowest. * *(dict) --* The field used in the field priority deduplication strategy. * **name** *(string) --* The name of the deduplication field. Must exist in the dataset and not be a primary key. * **sortOrder** *(string) --* The sort order for the deduplication field. * **createdTime** *(datetime) --* The DataIntegrationFlow creation timestamp. * **lastModifiedTime** *(datetime) --* The DataIntegrationFlow last modified timestamp. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / can_paginate can_paginate ************ SupplyChain.Client.can_paginate(operation_name) Check if an operation can be paginated. Parameters: **operation_name** (*string*) -- The operation name. This is the same name as the method name on the client. For example, if the method name is "create_foo", and you'd normally invoke the operation as "client.create_foo(**kwargs)", if the "create_foo" operation can be paginated, you can use the call "client.get_paginator("create_foo")". Returns: "True" if the operation can be paginated, "False" otherwise. SupplyChain / Client / list_data_lake_datasets list_data_lake_datasets *********************** SupplyChain.Client.list_data_lake_datasets(**kwargs) Enables you to programmatically view the list of Amazon Web Services Supply Chain data lake datasets. Developers can view the datasets and the corresponding information such as namespace, schema, and so on for a given instance ID and namespace. See also: AWS API Documentation **Request Syntax** response = client.list_data_lake_datasets( instanceId='string', namespace='string', nextToken='string', maxResults=123 ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **namespace** (*string*) -- **[REQUIRED]** The namespace of the dataset, besides the custom defined namespace, every instance comes with below pre-defined namespaces: * **asc** - For information on the Amazon Web Services Supply Chain supported datasets see https://docs.aws.amazon.com /aws-supply-chain/latest/userguide/data-model-asc.html. * **default** - For datasets with custom user-defined schemas. * **nextToken** (*string*) -- The pagination token to fetch next page of datasets. * **maxResults** (*integer*) -- The max number of datasets to fetch in this paginated request. Return type: dict Returns: **Response Syntax** { 'datasets': [ { 'instanceId': 'string', 'namespace': 'string', 'name': 'string', 'arn': 'string', 'schema': { 'name': 'string', 'fields': [ { 'name': 'string', 'type': 'INT'|'DOUBLE'|'STRING'|'TIMESTAMP'|'LONG', 'isRequired': True|False }, ], 'primaryKeys': [ { 'name': 'string' }, ] }, 'description': 'string', 'partitionSpec': { 'fields': [ { 'name': 'string', 'transform': { 'type': 'YEAR'|'MONTH'|'DAY'|'HOUR'|'IDENTITY' } }, ] }, 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) }, ], 'nextToken': 'string' } **Response Structure** * *(dict) --* The response parameters of ListDataLakeDatasets. * **datasets** *(list) --* The list of fetched dataset details. * *(dict) --* The data lake dataset details. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **namespace** *(string) --* The namespace of the dataset, besides the custom defined namespace, every instance comes with below pre-defined namespaces: * **asc** - For information on the Amazon Web Services Supply Chain supported datasets see https://docs.aws.amazon.com/aws-supply- chain/latest/userguide/data-model-asc.html. * **default** - For datasets with custom user-defined schemas. * **name** *(string) --* The name of the dataset. For **asc** namespace, the name must be one of the supported data entities under https://docs.aws.amazon.com/aws-supply- chain/latest/userguide/data-model-asc.html. * **arn** *(string) --* The arn of the dataset. * **schema** *(dict) --* The schema of the dataset. * **name** *(string) --* The name of the dataset schema. * **fields** *(list) --* The list of field details of the dataset schema. * *(dict) --* The dataset field details. * **name** *(string) --* The dataset field name. * **type** *(string) --* The dataset field type. * **isRequired** *(boolean) --* Indicate if the field is required or not. * **primaryKeys** *(list) --* The list of primary key fields for the dataset. Primary keys defined can help data ingestion methods to ensure data uniqueness: CreateDataIntegrationFlow's dedupe strategy will leverage primary keys to perform records deduplication before write to dataset; SendDataIntegrationEvent's UPSERT and DELETE can only work with dataset with primary keys. For more details, refer to those data ingestion documentations. Note that defining primary keys does not necessarily mean the dataset cannot have duplicate records, duplicate records can still be ingested if CreateDataIntegrationFlow's dedupe disabled or through SendDataIntegrationEvent's APPEND operation. * *(dict) --* The detail of the primary key field. * **name** *(string) --* The name of the primary key field. * **description** *(string) --* The description of the dataset. * **partitionSpec** *(dict) --* The partition specification for a dataset. * **fields** *(list) --* The fields on which to partition a dataset. The partitions will be applied hierarchically based on the order of this list. * *(dict) --* The detail of the partition field. * **name** *(string) --* The name of the partition field. * **transform** *(dict) --* The transformation of the partition field. A transformation specifies how to partition on a given field. For example, with timestamp you can specify that you'd like to partition fields by day, e.g. data record with value 2025-01-03T00:00:00Z in partition field is in 2025-01-03 partition. Also noted that data record without any value in optional partition field is in NULL partition. * **type** *(string) --* The type of partitioning transformation for this field. The available options are: * **IDENTITY** - Partitions data on a given field by its exact values. * **YEAR** - Partitions data on a timestamp field using year granularity. * **MONTH** - Partitions data on a timestamp field using month granularity. * **DAY** - Partitions data on a timestamp field using day granularity. * **HOUR** - Partitions data on a timestamp field using hour granularity. * **createdTime** *(datetime) --* The creation time of the dataset. * **lastModifiedTime** *(datetime) --* The last modified time of the dataset. * **nextToken** *(string) --* The pagination token to fetch next page of datasets. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / get_data_lake_namespace get_data_lake_namespace *********************** SupplyChain.Client.get_data_lake_namespace(**kwargs) Enables you to programmatically view an Amazon Web Services Supply Chain data lake namespace. Developers can view the data lake namespace information such as description for a given instance ID and namespace name. See also: AWS API Documentation **Request Syntax** response = client.get_data_lake_namespace( instanceId='string', name='string' ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **name** (*string*) -- **[REQUIRED]** The name of the namespace. Besides the namespaces user created, you can also specify the pre-defined namespaces: * **asc** - Pre-defined namespace containing Amazon Web Services Supply Chain supported datasets, see https://docs.aws.amazon.com/aws-supply- chain/latest/userguide/data-model-asc.html. * **default** - Pre-defined namespace containing datasets with custom user-defined schemas. Return type: dict Returns: **Response Syntax** { 'namespace': { 'instanceId': 'string', 'name': 'string', 'arn': 'string', 'description': 'string', 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) } } **Response Structure** * *(dict) --* The response parameters for GetDataLakeNamespace. * **namespace** *(dict) --* The fetched namespace details. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **name** *(string) --* The name of the namespace. * **arn** *(string) --* The arn of the namespace. * **description** *(string) --* The description of the namespace. * **createdTime** *(datetime) --* The creation time of the namespace. * **lastModifiedTime** *(datetime) --* The last modified time of the namespace. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / create_data_lake_dataset create_data_lake_dataset ************************ SupplyChain.Client.create_data_lake_dataset(**kwargs) Enables you to programmatically create an Amazon Web Services Supply Chain data lake dataset. Developers can create the datasets using their pre-defined or custom schema for a given instance ID, namespace, and dataset name. See also: AWS API Documentation **Request Syntax** response = client.create_data_lake_dataset( instanceId='string', namespace='string', name='string', schema={ 'name': 'string', 'fields': [ { 'name': 'string', 'type': 'INT'|'DOUBLE'|'STRING'|'TIMESTAMP'|'LONG', 'isRequired': True|False }, ], 'primaryKeys': [ { 'name': 'string' }, ] }, description='string', partitionSpec={ 'fields': [ { 'name': 'string', 'transform': { 'type': 'YEAR'|'MONTH'|'DAY'|'HOUR'|'IDENTITY' } }, ] }, tags={ 'string': 'string' } ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **namespace** (*string*) -- **[REQUIRED]** The namespace of the dataset, besides the custom defined namespace, every instance comes with below pre-defined namespaces: * **asc** - For information on the Amazon Web Services Supply Chain supported datasets see https://docs.aws.amazon.com /aws-supply-chain/latest/userguide/data-model-asc.html. * **default** - For datasets with custom user-defined schemas. * **name** (*string*) -- **[REQUIRED]** The name of the dataset. For **asc** name space, the name must be one of the supported data entities under https://docs.aws.amazon.com/aws-supply-chain/latest/userguide /data-model-asc.html. * **schema** (*dict*) -- The custom schema of the data lake dataset and required for dataset in **default** and custom namespaces. * **name** *(string) --* **[REQUIRED]** The name of the dataset schema. * **fields** *(list) --* **[REQUIRED]** The list of field details of the dataset schema. * *(dict) --* The dataset field details. * **name** *(string) --* **[REQUIRED]** The dataset field name. * **type** *(string) --* **[REQUIRED]** The dataset field type. * **isRequired** *(boolean) --* **[REQUIRED]** Indicate if the field is required or not. * **primaryKeys** *(list) --* The list of primary key fields for the dataset. Primary keys defined can help data ingestion methods to ensure data uniqueness: CreateDataIntegrationFlow's dedupe strategy will leverage primary keys to perform records deduplication before write to dataset; SendDataIntegrationEvent's UPSERT and DELETE can only work with dataset with primary keys. For more details, refer to those data ingestion documentations. Note that defining primary keys does not necessarily mean the dataset cannot have duplicate records, duplicate records can still be ingested if CreateDataIntegrationFlow's dedupe disabled or through SendDataIntegrationEvent's APPEND operation. * *(dict) --* The detail of the primary key field. * **name** *(string) --* **[REQUIRED]** The name of the primary key field. * **description** (*string*) -- The description of the dataset. * **partitionSpec** (*dict*) -- The partition specification of the dataset. Partitioning can effectively improve the dataset query performance by reducing the amount of data scanned during query execution. But partitioning or not will affect how data get ingested by data ingestion methods, such as SendDataIntegrationEvent's dataset UPSERT will upsert records within partition (instead of within whole dataset). For more details, refer to those data ingestion documentations. * **fields** *(list) --* **[REQUIRED]** The fields on which to partition a dataset. The partitions will be applied hierarchically based on the order of this list. * *(dict) --* The detail of the partition field. * **name** *(string) --* **[REQUIRED]** The name of the partition field. * **transform** *(dict) --* **[REQUIRED]** The transformation of the partition field. A transformation specifies how to partition on a given field. For example, with timestamp you can specify that you'd like to partition fields by day, e.g. data record with value 2025-01-03T00:00:00Z in partition field is in 2025-01-03 partition. Also noted that data record without any value in optional partition field is in NULL partition. * **type** *(string) --* **[REQUIRED]** The type of partitioning transformation for this field. The available options are: * **IDENTITY** - Partitions data on a given field by its exact values. * **YEAR** - Partitions data on a timestamp field using year granularity. * **MONTH** - Partitions data on a timestamp field using month granularity. * **DAY** - Partitions data on a timestamp field using day granularity. * **HOUR** - Partitions data on a timestamp field using hour granularity. * **tags** (*dict*) -- The tags of the dataset. * *(string) --* * *(string) --* Return type: dict Returns: **Response Syntax** { 'dataset': { 'instanceId': 'string', 'namespace': 'string', 'name': 'string', 'arn': 'string', 'schema': { 'name': 'string', 'fields': [ { 'name': 'string', 'type': 'INT'|'DOUBLE'|'STRING'|'TIMESTAMP'|'LONG', 'isRequired': True|False }, ], 'primaryKeys': [ { 'name': 'string' }, ] }, 'description': 'string', 'partitionSpec': { 'fields': [ { 'name': 'string', 'transform': { 'type': 'YEAR'|'MONTH'|'DAY'|'HOUR'|'IDENTITY' } }, ] }, 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) } } **Response Structure** * *(dict) --* The response parameters of CreateDataLakeDataset. * **dataset** *(dict) --* The detail of created dataset. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **namespace** *(string) --* The namespace of the dataset, besides the custom defined namespace, every instance comes with below pre-defined namespaces: * **asc** - For information on the Amazon Web Services Supply Chain supported datasets see https://docs.aws.amazon.com/aws-supply- chain/latest/userguide/data-model-asc.html. * **default** - For datasets with custom user-defined schemas. * **name** *(string) --* The name of the dataset. For **asc** namespace, the name must be one of the supported data entities under https://docs.aws.amazon.com/aws-supply- chain/latest/userguide/data-model-asc.html. * **arn** *(string) --* The arn of the dataset. * **schema** *(dict) --* The schema of the dataset. * **name** *(string) --* The name of the dataset schema. * **fields** *(list) --* The list of field details of the dataset schema. * *(dict) --* The dataset field details. * **name** *(string) --* The dataset field name. * **type** *(string) --* The dataset field type. * **isRequired** *(boolean) --* Indicate if the field is required or not. * **primaryKeys** *(list) --* The list of primary key fields for the dataset. Primary keys defined can help data ingestion methods to ensure data uniqueness: CreateDataIntegrationFlow's dedupe strategy will leverage primary keys to perform records deduplication before write to dataset; SendDataIntegrationEvent's UPSERT and DELETE can only work with dataset with primary keys. For more details, refer to those data ingestion documentations. Note that defining primary keys does not necessarily mean the dataset cannot have duplicate records, duplicate records can still be ingested if CreateDataIntegrationFlow's dedupe disabled or through SendDataIntegrationEvent's APPEND operation. * *(dict) --* The detail of the primary key field. * **name** *(string) --* The name of the primary key field. * **description** *(string) --* The description of the dataset. * **partitionSpec** *(dict) --* The partition specification for a dataset. * **fields** *(list) --* The fields on which to partition a dataset. The partitions will be applied hierarchically based on the order of this list. * *(dict) --* The detail of the partition field. * **name** *(string) --* The name of the partition field. * **transform** *(dict) --* The transformation of the partition field. A transformation specifies how to partition on a given field. For example, with timestamp you can specify that you'd like to partition fields by day, e.g. data record with value 2025-01-03T00:00:00Z in partition field is in 2025-01-03 partition. Also noted that data record without any value in optional partition field is in NULL partition. * **type** *(string) --* The type of partitioning transformation for this field. The available options are: * **IDENTITY** - Partitions data on a given field by its exact values. * **YEAR** - Partitions data on a timestamp field using year granularity. * **MONTH** - Partitions data on a timestamp field using month granularity. * **DAY** - Partitions data on a timestamp field using day granularity. * **HOUR** - Partitions data on a timestamp field using hour granularity. * **createdTime** *(datetime) --* The creation time of the dataset. * **lastModifiedTime** *(datetime) --* The last modified time of the dataset. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / list_tags_for_resource list_tags_for_resource ********************** SupplyChain.Client.list_tags_for_resource(**kwargs) List all the tags for an Amazon Web ServicesSupply Chain resource. You can list all the tags added to a resource. By listing the tags, developers can view the tag level information on a resource and perform actions such as, deleting a resource associated with a particular tag. See also: AWS API Documentation **Request Syntax** response = client.list_tags_for_resource( resourceArn='string' ) Parameters: **resourceArn** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply chain resource ARN that needs tags to be listed. Return type: dict Returns: **Response Syntax** { 'tags': { 'string': 'string' } } **Response Structure** * *(dict) --* The response parameters of ListTagsForResource. * **tags** *(dict) --* The tags added to an Amazon Web Services Supply Chain resource. * *(string) --* * *(string) --* **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / create_instance create_instance *************** SupplyChain.Client.create_instance(**kwargs) Enables you to programmatically create an Amazon Web Services Supply Chain instance by applying KMS keys and relevant information associated with the API without using the Amazon Web Services console. This is an asynchronous operation. Upon receiving a CreateInstance request, Amazon Web Services Supply Chain immediately returns the instance resource, instance ID, and the initializing state while simultaneously creating all required Amazon Web Services resources for an instance creation. You can use GetInstance to check the status of the instance. If the instance results in an unhealthy state, you need to check the error message, delete the current instance, and recreate a new one based on the mitigation from the error message. See also: AWS API Documentation **Request Syntax** response = client.create_instance( instanceName='string', instanceDescription='string', kmsKeyArn='string', webAppDnsDomain='string', tags={ 'string': 'string' }, clientToken='string' ) Parameters: * **instanceName** (*string*) -- The AWS Supply Chain instance name. * **instanceDescription** (*string*) -- The AWS Supply Chain instance description. * **kmsKeyArn** (*string*) -- The ARN (Amazon Resource Name) of the Key Management Service (KMS) key you provide for encryption. This is required if you do not want to use the Amazon Web Services owned KMS key. If you don't provide anything here, AWS Supply Chain uses the Amazon Web Services owned KMS key. * **webAppDnsDomain** (*string*) -- The DNS subdomain of the web app. This would be "example" in the URL "example.scn.global.on.aws". You can set this to a custom value, as long as the domain isn't already being used by someone else. The name may only include alphanumeric characters and hyphens. * **tags** (*dict*) -- The Amazon Web Services tags of an instance to be created. * *(string) --* * *(string) --* * **clientToken** (*string*) -- The client token for idempotency. This field is autopopulated if not provided. Return type: dict Returns: **Response Syntax** { 'instance': { 'instanceId': 'string', 'awsAccountId': 'string', 'state': 'Initializing'|'Active'|'CreateFailed'|'DeleteFailed'|'Deleting'|'Deleted', 'errorMessage': 'string', 'webAppDnsDomain': 'string', 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1), 'instanceName': 'string', 'instanceDescription': 'string', 'kmsKeyArn': 'string', 'versionNumber': 123.0 } } **Response Structure** * *(dict) --* The response parameters for CreateInstance. * **instance** *(dict) --* The AWS Supply Chain instance resource data details. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **awsAccountId** *(string) --* The Amazon Web Services account ID that owns the instance. * **state** *(string) --* The state of the instance. * **errorMessage** *(string) --* The Amazon Web Services Supply Chain instance error message. If the instance results in an unhealthy state, customers need to check the error message, delete the current instance, and recreate a new one based on the mitigation from the error message. * **webAppDnsDomain** *(string) --* The WebApp DNS domain name of the instance. * **createdTime** *(datetime) --* The instance creation timestamp. * **lastModifiedTime** *(datetime) --* The instance last modified timestamp. * **instanceName** *(string) --* The Amazon Web Services Supply Chain instance name. * **instanceDescription** *(string) --* The Amazon Web Services Supply Chain instance description. * **kmsKeyArn** *(string) --* The ARN (Amazon Resource Name) of the Key Management Service (KMS) key you optionally provided for encryption. If you did not provide anything here, AWS Supply Chain uses the Amazon Web Services owned KMS key and nothing is returned. * **versionNumber** *(float) --* The version number of the instance. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / untag_resource untag_resource ************** SupplyChain.Client.untag_resource(**kwargs) You can delete tags for an Amazon Web Services Supply chain resource such as instance, data flow, or dataset in AWS Supply Chain. During the data ingestion process, you can delete tags such as dev, test, or prod to data flows created during the data ingestion process in the AWS Supply Chain datasets. See also: AWS API Documentation **Request Syntax** response = client.untag_resource( resourceArn='string', tagKeys=[ 'string', ] ) Parameters: * **resourceArn** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply chain resource ARN that needs to be untagged. * **tagKeys** (*list*) -- **[REQUIRED]** The list of tag keys to be deleted for an Amazon Web Services Supply Chain resource. * *(string) --* Return type: dict Returns: **Response Syntax** {} **Response Structure** * *(dict) --* The response parameters of UntagResource. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / update_data_lake_dataset update_data_lake_dataset ************************ SupplyChain.Client.update_data_lake_dataset(**kwargs) Enables you to programmatically update an Amazon Web Services Supply Chain data lake dataset. Developers can update the description of a data lake dataset for a given instance ID, namespace, and dataset name. See also: AWS API Documentation **Request Syntax** response = client.update_data_lake_dataset( instanceId='string', namespace='string', name='string', description='string' ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Chain instance identifier. * **namespace** (*string*) -- **[REQUIRED]** The namespace of the dataset, besides the custom defined namespace, every instance comes with below pre-defined namespaces: * **asc** - For information on the Amazon Web Services Supply Chain supported datasets see https://docs.aws.amazon.com /aws-supply-chain/latest/userguide/data-model-asc.html. * **default** - For datasets with custom user-defined schemas. * **name** (*string*) -- **[REQUIRED]** The name of the dataset. For **asc** namespace, the name must be one of the supported data entities under https://docs.aws.amazon.com/aws-supply-chain/latest/userguide /data-model-asc.html. * **description** (*string*) -- The updated description of the data lake dataset. Return type: dict Returns: **Response Syntax** { 'dataset': { 'instanceId': 'string', 'namespace': 'string', 'name': 'string', 'arn': 'string', 'schema': { 'name': 'string', 'fields': [ { 'name': 'string', 'type': 'INT'|'DOUBLE'|'STRING'|'TIMESTAMP'|'LONG', 'isRequired': True|False }, ], 'primaryKeys': [ { 'name': 'string' }, ] }, 'description': 'string', 'partitionSpec': { 'fields': [ { 'name': 'string', 'transform': { 'type': 'YEAR'|'MONTH'|'DAY'|'HOUR'|'IDENTITY' } }, ] }, 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) } } **Response Structure** * *(dict) --* The response parameters of UpdateDataLakeDataset. * **dataset** *(dict) --* The updated dataset details. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **namespace** *(string) --* The namespace of the dataset, besides the custom defined namespace, every instance comes with below pre-defined namespaces: * **asc** - For information on the Amazon Web Services Supply Chain supported datasets see https://docs.aws.amazon.com/aws-supply- chain/latest/userguide/data-model-asc.html. * **default** - For datasets with custom user-defined schemas. * **name** *(string) --* The name of the dataset. For **asc** namespace, the name must be one of the supported data entities under https://docs.aws.amazon.com/aws-supply- chain/latest/userguide/data-model-asc.html. * **arn** *(string) --* The arn of the dataset. * **schema** *(dict) --* The schema of the dataset. * **name** *(string) --* The name of the dataset schema. * **fields** *(list) --* The list of field details of the dataset schema. * *(dict) --* The dataset field details. * **name** *(string) --* The dataset field name. * **type** *(string) --* The dataset field type. * **isRequired** *(boolean) --* Indicate if the field is required or not. * **primaryKeys** *(list) --* The list of primary key fields for the dataset. Primary keys defined can help data ingestion methods to ensure data uniqueness: CreateDataIntegrationFlow's dedupe strategy will leverage primary keys to perform records deduplication before write to dataset; SendDataIntegrationEvent's UPSERT and DELETE can only work with dataset with primary keys. For more details, refer to those data ingestion documentations. Note that defining primary keys does not necessarily mean the dataset cannot have duplicate records, duplicate records can still be ingested if CreateDataIntegrationFlow's dedupe disabled or through SendDataIntegrationEvent's APPEND operation. * *(dict) --* The detail of the primary key field. * **name** *(string) --* The name of the primary key field. * **description** *(string) --* The description of the dataset. * **partitionSpec** *(dict) --* The partition specification for a dataset. * **fields** *(list) --* The fields on which to partition a dataset. The partitions will be applied hierarchically based on the order of this list. * *(dict) --* The detail of the partition field. * **name** *(string) --* The name of the partition field. * **transform** *(dict) --* The transformation of the partition field. A transformation specifies how to partition on a given field. For example, with timestamp you can specify that you'd like to partition fields by day, e.g. data record with value 2025-01-03T00:00:00Z in partition field is in 2025-01-03 partition. Also noted that data record without any value in optional partition field is in NULL partition. * **type** *(string) --* The type of partitioning transformation for this field. The available options are: * **IDENTITY** - Partitions data on a given field by its exact values. * **YEAR** - Partitions data on a timestamp field using year granularity. * **MONTH** - Partitions data on a timestamp field using month granularity. * **DAY** - Partitions data on a timestamp field using day granularity. * **HOUR** - Partitions data on a timestamp field using hour granularity. * **createdTime** *(datetime) --* The creation time of the dataset. * **lastModifiedTime** *(datetime) --* The last modified time of the dataset. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / create_data_integration_flow create_data_integration_flow **************************** SupplyChain.Client.create_data_integration_flow(**kwargs) Enables you to programmatically create a data pipeline to ingest data from source systems such as Amazon S3 buckets, to a predefined Amazon Web Services Supply Chain dataset (product, inbound_order) or a temporary dataset along with the data transformation query provided with the API. See also: AWS API Documentation **Request Syntax** response = client.create_data_integration_flow( instanceId='string', name='string', sources=[ { 'sourceType': 'S3'|'DATASET', 'sourceName': 'string', 's3Source': { 'bucketName': 'string', 'prefix': 'string', 'options': { 'fileType': 'CSV'|'PARQUET'|'JSON' } }, 'datasetSource': { 'datasetIdentifier': 'string', 'options': { 'loadType': 'INCREMENTAL'|'REPLACE', 'dedupeRecords': True|False, 'dedupeStrategy': { 'type': 'FIELD_PRIORITY', 'fieldPriority': { 'fields': [ { 'name': 'string', 'sortOrder': 'ASC'|'DESC' }, ] } } } } }, ], transformation={ 'transformationType': 'SQL'|'NONE', 'sqlTransformation': { 'query': 'string' } }, target={ 'targetType': 'S3'|'DATASET', 's3Target': { 'bucketName': 'string', 'prefix': 'string', 'options': { 'fileType': 'CSV'|'PARQUET'|'JSON' } }, 'datasetTarget': { 'datasetIdentifier': 'string', 'options': { 'loadType': 'INCREMENTAL'|'REPLACE', 'dedupeRecords': True|False, 'dedupeStrategy': { 'type': 'FIELD_PRIORITY', 'fieldPriority': { 'fields': [ { 'name': 'string', 'sortOrder': 'ASC'|'DESC' }, ] } } } } }, tags={ 'string': 'string' } ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **name** (*string*) -- **[REQUIRED]** Name of the DataIntegrationFlow. * **sources** (*list*) -- **[REQUIRED]** The source configurations for DataIntegrationFlow. * *(dict) --* The DataIntegrationFlow source parameters. * **sourceType** *(string) --* **[REQUIRED]** The DataIntegrationFlow source type. * **sourceName** *(string) --* **[REQUIRED]** The DataIntegrationFlow source name that can be used as table alias in SQL transformation query. * **s3Source** *(dict) --* The S3 DataIntegrationFlow source. * **bucketName** *(string) --* **[REQUIRED]** The bucketName of the S3 source objects. * **prefix** *(string) --* **[REQUIRED]** The prefix of the S3 source objects. To trigger data ingestion, S3 files need to be put under "s3://bucketName/prefix/". * **options** *(dict) --* The other options of the S3 DataIntegrationFlow source. * **fileType** *(string) --* The Amazon S3 file type in S3 options. * **datasetSource** *(dict) --* The dataset DataIntegrationFlow source. * **datasetIdentifier** *(string) --* **[REQUIRED]** The ARN of the dataset. * **options** *(dict) --* The dataset DataIntegrationFlow source options. * **loadType** *(string) --* The target dataset's data load type. This only affects how source S3 files are selected in the S3-to-dataset flow. * **REPLACE** - Target dataset will get replaced with the new file added under the source s3 prefix. * **INCREMENTAL** - Target dataset will get updated with the up-to-date content under S3 prefix incorporating any file additions or removals there. * **dedupeRecords** *(boolean) --* The option to perform deduplication on data records sharing same primary key values. If disabled, transformed data with duplicate primary key values will ingest into dataset, for datasets within **asc** namespace, such duplicates will cause ingestion fail. If enabled without dedupeStrategy, deduplication is done by retaining a random data record among those sharing the same primary key values. If enabled with dedupeStragtegy, the deduplication is done following the strategy. Note that target dataset may have partition configured, when dedupe is enabled, it only dedupe against primary keys and retain only one record out of those duplicates regardless of its partition status. * **dedupeStrategy** *(dict) --* The deduplication strategy to dedupe the data records sharing same primary key values of the target dataset. This strategy only applies to target dataset with primary keys and with dedupeRecords option enabled. If transformed data still got duplicates after the dedupeStrategy evaluation, a random data record is chosen to be retained. * **type** *(string) --* **[REQUIRED]** The type of the deduplication strategy. * **FIELD_PRIORITY** - Field priority configuration for the deduplication strategy specifies an ordered list of fields used to tie-break the data records sharing the same primary key values. Fields earlier in the list have higher priority for evaluation. For each field, the sort order determines whether to retain data record with larger or smaller field value. * **fieldPriority** *(dict) --* The field priority deduplication strategy. * **fields** *(list) --* **[REQUIRED]** The list of field names and their sort order for deduplication, arranged in descending priority from highest to lowest. * *(dict) --* The field used in the field priority deduplication strategy. * **name** *(string) --* **[REQUIRED]** The name of the deduplication field. Must exist in the dataset and not be a primary key. * **sortOrder** *(string) --* **[REQUIRED]** The sort order for the deduplication field. * **transformation** (*dict*) -- **[REQUIRED]** The transformation configurations for DataIntegrationFlow. * **transformationType** *(string) --* **[REQUIRED]** The DataIntegrationFlow transformation type. * **sqlTransformation** *(dict) --* The SQL DataIntegrationFlow transformation configuration. * **query** *(string) --* **[REQUIRED]** The transformation SQL query body based on SparkSQL. * **target** (*dict*) -- **[REQUIRED]** The target configurations for DataIntegrationFlow. * **targetType** *(string) --* **[REQUIRED]** The DataIntegrationFlow target type. * **s3Target** *(dict) --* The S3 DataIntegrationFlow target. * **bucketName** *(string) --* **[REQUIRED]** The bucketName of the S3 target objects. * **prefix** *(string) --* **[REQUIRED]** The prefix of the S3 target objects. * **options** *(dict) --* The S3 DataIntegrationFlow target options. * **fileType** *(string) --* The Amazon S3 file type in S3 options. * **datasetTarget** *(dict) --* The dataset DataIntegrationFlow target. Note that for AWS Supply Chain dataset under **asc** namespace, it has a connection_id internal field that is not allowed to be provided by client directly, they will be auto populated. * **datasetIdentifier** *(string) --* **[REQUIRED]** The dataset ARN. * **options** *(dict) --* The dataset DataIntegrationFlow target options. * **loadType** *(string) --* The target dataset's data load type. This only affects how source S3 files are selected in the S3-to-dataset flow. * **REPLACE** - Target dataset will get replaced with the new file added under the source s3 prefix. * **INCREMENTAL** - Target dataset will get updated with the up-to-date content under S3 prefix incorporating any file additions or removals there. * **dedupeRecords** *(boolean) --* The option to perform deduplication on data records sharing same primary key values. If disabled, transformed data with duplicate primary key values will ingest into dataset, for datasets within **asc** namespace, such duplicates will cause ingestion fail. If enabled without dedupeStrategy, deduplication is done by retaining a random data record among those sharing the same primary key values. If enabled with dedupeStragtegy, the deduplication is done following the strategy. Note that target dataset may have partition configured, when dedupe is enabled, it only dedupe against primary keys and retain only one record out of those duplicates regardless of its partition status. * **dedupeStrategy** *(dict) --* The deduplication strategy to dedupe the data records sharing same primary key values of the target dataset. This strategy only applies to target dataset with primary keys and with dedupeRecords option enabled. If transformed data still got duplicates after the dedupeStrategy evaluation, a random data record is chosen to be retained. * **type** *(string) --* **[REQUIRED]** The type of the deduplication strategy. * **FIELD_PRIORITY** - Field priority configuration for the deduplication strategy specifies an ordered list of fields used to tie-break the data records sharing the same primary key values. Fields earlier in the list have higher priority for evaluation. For each field, the sort order determines whether to retain data record with larger or smaller field value. * **fieldPriority** *(dict) --* The field priority deduplication strategy. * **fields** *(list) --* **[REQUIRED]** The list of field names and their sort order for deduplication, arranged in descending priority from highest to lowest. * *(dict) --* The field used in the field priority deduplication strategy. * **name** *(string) --* **[REQUIRED]** The name of the deduplication field. Must exist in the dataset and not be a primary key. * **sortOrder** *(string) --* **[REQUIRED]** The sort order for the deduplication field. * **tags** (*dict*) -- The tags of the DataIntegrationFlow to be created * *(string) --* * *(string) --* Return type: dict Returns: **Response Syntax** { 'instanceId': 'string', 'name': 'string' } **Response Structure** * *(dict) --* The response parameters for CreateDataIntegrationFlow. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **name** *(string) --* The name of the DataIntegrationFlow created. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / get_waiter get_waiter ********** SupplyChain.Client.get_waiter(waiter_name) Returns an object that can wait for some condition. Parameters: **waiter_name** (*str*) -- The name of the waiter to get. See the waiters section of the service docs for a list of available waiters. Returns: The specified waiter object. Return type: "botocore.waiter.Waiter" SupplyChain / Client / get_bill_of_materials_import_job get_bill_of_materials_import_job ******************************** SupplyChain.Client.get_bill_of_materials_import_job(**kwargs) Get status and details of a BillOfMaterialsImportJob. See also: AWS API Documentation **Request Syntax** response = client.get_bill_of_materials_import_job( instanceId='string', jobId='string' ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The AWS Supply Chain instance identifier. * **jobId** (*string*) -- **[REQUIRED]** The BillOfMaterialsImportJob identifier. Return type: dict Returns: **Response Syntax** { 'job': { 'instanceId': 'string', 'jobId': 'string', 'status': 'NEW'|'FAILED'|'IN_PROGRESS'|'QUEUED'|'SUCCESS', 's3uri': 'string', 'message': 'string' } } **Response Structure** * *(dict) --* The response parameters for GetBillOfMaterialsImportJob. * **job** *(dict) --* The BillOfMaterialsImportJob. * **instanceId** *(string) --* The BillOfMaterialsImportJob instanceId. * **jobId** *(string) --* The BillOfMaterialsImportJob jobId. * **status** *(string) --* The BillOfMaterialsImportJob ConfigurationJobStatus. * **s3uri** *(string) --* The S3 URI from which the CSV is read. * **message** *(string) --* When the BillOfMaterialsImportJob has reached a terminal state, there will be a message. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / get_data_integration_event get_data_integration_event ************************** SupplyChain.Client.get_data_integration_event(**kwargs) Enables you to programmatically view an Amazon Web Services Supply Chain Data Integration Event. Developers can view the eventType, eventGroupId, eventTimestamp, datasetTarget, datasetLoadExecution. See also: AWS API Documentation **Request Syntax** response = client.get_data_integration_event( instanceId='string', eventId='string' ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **eventId** (*string*) -- **[REQUIRED]** The unique event identifier. Return type: dict Returns: **Response Syntax** { 'event': { 'instanceId': 'string', 'eventId': 'string', 'eventType': 'scn.data.forecast'|'scn.data.inventorylevel'|'scn.data.inboundorder'|'scn.data.inboundorderline'|'scn.data.inboundorderlineschedule'|'scn.data.outboundorderline'|'scn.data.outboundshipment'|'scn.data.processheader'|'scn.data.processoperation'|'scn.data.processproduct'|'scn.data.reservation'|'scn.data.shipment'|'scn.data.shipmentstop'|'scn.data.shipmentstoporder'|'scn.data.supplyplan'|'scn.data.dataset', 'eventGroupId': 'string', 'eventTimestamp': datetime(2015, 1, 1), 'datasetTargetDetails': { 'datasetIdentifier': 'string', 'operationType': 'APPEND'|'UPSERT'|'DELETE', 'datasetLoadExecution': { 'status': 'SUCCEEDED'|'IN_PROGRESS'|'FAILED', 'message': 'string' } } } } **Response Structure** * *(dict) --* The response parameters for GetDataIntegrationEvent. * **event** *(dict) --* The details of the DataIntegrationEvent returned. * **instanceId** *(string) --* The AWS Supply Chain instance identifier. * **eventId** *(string) --* The unique event identifier. * **eventType** *(string) --* The data event type. * **eventGroupId** *(string) --* Event identifier (for example, orderId for InboundOrder) used for data sharding or partitioning. * **eventTimestamp** *(datetime) --* The event timestamp (in epoch seconds). * **datasetTargetDetails** *(dict) --* The target dataset details for a DATASET event type. * **datasetIdentifier** *(string) --* The datalake dataset ARN identifier. * **operationType** *(string) --* The target dataset load operation type. The available options are: * **APPEND** - Add new records to the dataset. Noted that this operation type will just try to append records as-is without any primary key or partition constraints. * **UPSERT** - Modify existing records in the dataset with primary key configured, events for datasets without primary keys are not allowed. If event data contains primary keys that match records in the dataset within same partition, then those existing records (in that partition) will be updated. If primary keys do not match, new records will be added. Note that if dataset contain records with duplicate primary key values in the same partition, those duplicate records will be deduped into one updated record. * **DELETE** - Remove existing records in the dataset with primary key configured, events for datasets without primary keys are not allowed. If event data contains primary keys that match records in the dataset within same partition, then those existing records (in that partition) will be deleted. If primary keys do not match, no actions will be done. Note that if dataset contain records with duplicate primary key values in the same partition, all those duplicates will be removed. * **datasetLoadExecution** *(dict) --* The target dataset load execution. * **status** *(string) --* The event load execution status to target dataset. * **message** *(string) --* The failure message (if any) of failed event load execution to dataset. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / update_instance update_instance *************** SupplyChain.Client.update_instance(**kwargs) Enables you to programmatically update an Amazon Web Services Supply Chain instance description by providing all the relevant information such as account ID, instance ID and so on without using the AWS console. See also: AWS API Documentation **Request Syntax** response = client.update_instance( instanceId='string', instanceName='string', instanceDescription='string' ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The AWS Supply Chain instance identifier. * **instanceName** (*string*) -- The AWS Supply Chain instance name. * **instanceDescription** (*string*) -- The AWS Supply Chain instance description. Return type: dict Returns: **Response Syntax** { 'instance': { 'instanceId': 'string', 'awsAccountId': 'string', 'state': 'Initializing'|'Active'|'CreateFailed'|'DeleteFailed'|'Deleting'|'Deleted', 'errorMessage': 'string', 'webAppDnsDomain': 'string', 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1), 'instanceName': 'string', 'instanceDescription': 'string', 'kmsKeyArn': 'string', 'versionNumber': 123.0 } } **Response Structure** * *(dict) --* The response parameters for UpdateInstance. * **instance** *(dict) --* The instance resource data details. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **awsAccountId** *(string) --* The Amazon Web Services account ID that owns the instance. * **state** *(string) --* The state of the instance. * **errorMessage** *(string) --* The Amazon Web Services Supply Chain instance error message. If the instance results in an unhealthy state, customers need to check the error message, delete the current instance, and recreate a new one based on the mitigation from the error message. * **webAppDnsDomain** *(string) --* The WebApp DNS domain name of the instance. * **createdTime** *(datetime) --* The instance creation timestamp. * **lastModifiedTime** *(datetime) --* The instance last modified timestamp. * **instanceName** *(string) --* The Amazon Web Services Supply Chain instance name. * **instanceDescription** *(string) --* The Amazon Web Services Supply Chain instance description. * **kmsKeyArn** *(string) --* The ARN (Amazon Resource Name) of the Key Management Service (KMS) key you optionally provided for encryption. If you did not provide anything here, AWS Supply Chain uses the Amazon Web Services owned KMS key and nothing is returned. * **versionNumber** *(float) --* The version number of the instance. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / update_data_lake_namespace update_data_lake_namespace ************************** SupplyChain.Client.update_data_lake_namespace(**kwargs) Enables you to programmatically update an Amazon Web Services Supply Chain data lake namespace. Developers can update the description of a data lake namespace for a given instance ID and namespace name. See also: AWS API Documentation **Request Syntax** response = client.update_data_lake_namespace( instanceId='string', name='string', description='string' ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Chain instance identifier. * **name** (*string*) -- **[REQUIRED]** The name of the namespace. Noted you cannot update namespace with name starting with **asc**, **default**, **scn**, **aws**, **amazon**, **amzn** * **description** (*string*) -- The updated description of the data lake namespace. Return type: dict Returns: **Response Syntax** { 'namespace': { 'instanceId': 'string', 'name': 'string', 'arn': 'string', 'description': 'string', 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) } } **Response Structure** * *(dict) --* The response parameters of UpdateDataLakeNamespace. * **namespace** *(dict) --* The updated namespace details. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **name** *(string) --* The name of the namespace. * **arn** *(string) --* The arn of the namespace. * **description** *(string) --* The description of the namespace. * **createdTime** *(datetime) --* The creation time of the namespace. * **lastModifiedTime** *(datetime) --* The last modified time of the namespace. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / send_data_integration_event send_data_integration_event *************************** SupplyChain.Client.send_data_integration_event(**kwargs) Send the data payload for the event with real-time data for analysis or monitoring. The real-time data events are stored in an Amazon Web Services service before being processed and stored in data lake. See also: AWS API Documentation **Request Syntax** response = client.send_data_integration_event( instanceId='string', eventType='scn.data.forecast'|'scn.data.inventorylevel'|'scn.data.inboundorder'|'scn.data.inboundorderline'|'scn.data.inboundorderlineschedule'|'scn.data.outboundorderline'|'scn.data.outboundshipment'|'scn.data.processheader'|'scn.data.processoperation'|'scn.data.processproduct'|'scn.data.reservation'|'scn.data.shipment'|'scn.data.shipmentstop'|'scn.data.shipmentstoporder'|'scn.data.supplyplan'|'scn.data.dataset', data='string', eventGroupId='string', eventTimestamp=datetime(2015, 1, 1), clientToken='string', datasetTarget={ 'datasetIdentifier': 'string', 'operationType': 'APPEND'|'UPSERT'|'DELETE' } ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The AWS Supply Chain instance identifier. * **eventType** (*string*) -- **[REQUIRED]** The data event type. * **scn.data.dataset** - Send data directly to any specified dataset. * **scn.data.supplyplan** - Send data to supply_plan dataset. * **scn.data.shipmentstoporder** - Send data to shipment_stop_order dataset. * **scn.data.shipmentstop** - Send data to shipment_stop dataset. * **scn.data.shipment** - Send data to shipment dataset. * **scn.data.reservation** - Send data to reservation dataset. * **scn.data.processproduct** - Send data to process_product dataset. * **scn.data.processoperation** - Send data to process_operation dataset. * **scn.data.processheader** - Send data to process_header dataset. * **scn.data.forecast** - Send data to forecast dataset. * **scn.data.inventorylevel** - Send data to inv_level dataset. * **scn.data.inboundorder** - Send data to inbound_order dataset. * **scn.data.inboundorderline** - Send data to inbound_order_line dataset. * **scn.data.inboundorderlineschedule** - Send data to inbound_order_line_schedule dataset. * **scn.data.outboundorderline** - Send data to outbound_order_line dataset. * **scn.data.outboundshipment** - Send data to outbound_shipment dataset. * **data** (*string*) -- **[REQUIRED]** The data payload of the event, should follow the data schema of the target dataset, or see Data entities supported in AWS Supply Chain. To send single data record, use JsonObject format; to send multiple data records, use JsonArray format. Note that for AWS Supply Chain dataset under **asc** namespace, it has a connection_id internal field that is not allowed to be provided by client directly, they will be auto populated. * **eventGroupId** (*string*) -- **[REQUIRED]** Event identifier (for example, orderId for InboundOrder) used for data sharding or partitioning. Noted under one eventGroupId of same eventType and instanceId, events are processed sequentially in the order they are received by the server. * **eventTimestamp** (*datetime*) -- The timestamp (in epoch seconds) associated with the event. If not provided, it will be assigned with current timestamp. * **clientToken** (*string*) -- The idempotent client token. The token is active for 8 hours, and within its lifetime, it ensures the request completes only once upon retry with same client token. If omitted, the AWS SDK generates a unique value so that AWS SDK can safely retry the request upon network errors. This field is autopopulated if not provided. * **datasetTarget** (*dict*) -- The target dataset configuration for **scn.data.dataset** event type. * **datasetIdentifier** *(string) --* **[REQUIRED]** The datalake dataset ARN identifier. * **operationType** *(string) --* **[REQUIRED]** The target dataset load operation type. Return type: dict Returns: **Response Syntax** { 'eventId': 'string' } **Response Structure** * *(dict) --* The response parameters for SendDataIntegrationEvent. * **eventId** *(string) --* The unique event identifier. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / get_data_integration_flow_execution get_data_integration_flow_execution *********************************** SupplyChain.Client.get_data_integration_flow_execution(**kwargs) Get the flow execution. See also: AWS API Documentation **Request Syntax** response = client.get_data_integration_flow_execution( instanceId='string', flowName='string', executionId='string' ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The AWS Supply Chain instance identifier. * **flowName** (*string*) -- **[REQUIRED]** The flow name. * **executionId** (*string*) -- **[REQUIRED]** The flow execution identifier. Return type: dict Returns: **Response Syntax** { 'flowExecution': { 'instanceId': 'string', 'flowName': 'string', 'executionId': 'string', 'status': 'SUCCEEDED'|'IN_PROGRESS'|'FAILED', 'sourceInfo': { 'sourceType': 'S3'|'DATASET', 's3Source': { 'bucketName': 'string', 'key': 'string' }, 'datasetSource': { 'datasetIdentifier': 'string' } }, 'message': 'string', 'startTime': datetime(2015, 1, 1), 'endTime': datetime(2015, 1, 1), 'outputMetadata': { 'diagnosticReportsRootS3URI': 'string' } } } **Response Structure** * *(dict) --* The response parameters of GetFlowExecution. * **flowExecution** *(dict) --* The flow execution details. * **instanceId** *(string) --* The flow execution's instanceId. * **flowName** *(string) --* The flow execution's flowName. * **executionId** *(string) --* The flow executionId. * **status** *(string) --* The status of flow execution. * **sourceInfo** *(dict) --* The source information for a flow execution. * **sourceType** *(string) --* The data integration flow execution source type. * **s3Source** *(dict) --* The source details of a flow execution with S3 source. * **bucketName** *(string) --* The S3 bucket name of the S3 source. * **key** *(string) --* The S3 object key of the S3 source. * **datasetSource** *(dict) --* The source details of a flow execution with dataset source. * **datasetIdentifier** *(string) --* The ARN of the dataset source. * **message** *(string) --* The failure message (if any) of failed flow execution. * **startTime** *(datetime) --* The flow execution start timestamp. * **endTime** *(datetime) --* The flow execution end timestamp. * **outputMetadata** *(dict) --* The flow execution output metadata. * **diagnosticReportsRootS3URI** *(string) --* The S3 URI under which all diagnostic files (such as deduped records if any) are stored. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / list_instances list_instances ************** SupplyChain.Client.list_instances(**kwargs) List all Amazon Web Services Supply Chain instances for a specific account. Enables you to programmatically list all Amazon Web Services Supply Chain instances based on their account ID, instance name, and state of the instance (active or delete). See also: AWS API Documentation **Request Syntax** response = client.list_instances( nextToken='string', maxResults=123, instanceNameFilter=[ 'string', ], instanceStateFilter=[ 'Initializing'|'Active'|'CreateFailed'|'DeleteFailed'|'Deleting'|'Deleted', ] ) Parameters: * **nextToken** (*string*) -- The pagination token to fetch the next page of instances. * **maxResults** (*integer*) -- Specify the maximum number of instances to fetch in this paginated request. * **instanceNameFilter** (*list*) -- The filter to ListInstances based on their names. * *(string) --* * **instanceStateFilter** (*list*) -- The filter to ListInstances based on their state. * *(string) --* Return type: dict Returns: **Response Syntax** { 'instances': [ { 'instanceId': 'string', 'awsAccountId': 'string', 'state': 'Initializing'|'Active'|'CreateFailed'|'DeleteFailed'|'Deleting'|'Deleted', 'errorMessage': 'string', 'webAppDnsDomain': 'string', 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1), 'instanceName': 'string', 'instanceDescription': 'string', 'kmsKeyArn': 'string', 'versionNumber': 123.0 }, ], 'nextToken': 'string' } **Response Structure** * *(dict) --* The response parameters for ListInstances. * **instances** *(list) --* The list of instances resource data details. * *(dict) --* The details of the instance. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **awsAccountId** *(string) --* The Amazon Web Services account ID that owns the instance. * **state** *(string) --* The state of the instance. * **errorMessage** *(string) --* The Amazon Web Services Supply Chain instance error message. If the instance results in an unhealthy state, customers need to check the error message, delete the current instance, and recreate a new one based on the mitigation from the error message. * **webAppDnsDomain** *(string) --* The WebApp DNS domain name of the instance. * **createdTime** *(datetime) --* The instance creation timestamp. * **lastModifiedTime** *(datetime) --* The instance last modified timestamp. * **instanceName** *(string) --* The Amazon Web Services Supply Chain instance name. * **instanceDescription** *(string) --* The Amazon Web Services Supply Chain instance description. * **kmsKeyArn** *(string) --* The ARN (Amazon Resource Name) of the Key Management Service (KMS) key you optionally provided for encryption. If you did not provide anything here, AWS Supply Chain uses the Amazon Web Services owned KMS key and nothing is returned. * **versionNumber** *(float) --* The version number of the instance. * **nextToken** *(string) --* The pagination token to fetch the next page of instances. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / list_data_integration_flow_executions list_data_integration_flow_executions ************************************* SupplyChain.Client.list_data_integration_flow_executions(**kwargs) List flow executions. See also: AWS API Documentation **Request Syntax** response = client.list_data_integration_flow_executions( instanceId='string', flowName='string', nextToken='string', maxResults=123 ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The AWS Supply Chain instance identifier. * **flowName** (*string*) -- **[REQUIRED]** The flow name. * **nextToken** (*string*) -- The pagination token to fetch next page of flow executions. * **maxResults** (*integer*) -- The number to specify the max number of flow executions to fetch in this paginated request. Return type: dict Returns: **Response Syntax** { 'flowExecutions': [ { 'instanceId': 'string', 'flowName': 'string', 'executionId': 'string', 'status': 'SUCCEEDED'|'IN_PROGRESS'|'FAILED', 'sourceInfo': { 'sourceType': 'S3'|'DATASET', 's3Source': { 'bucketName': 'string', 'key': 'string' }, 'datasetSource': { 'datasetIdentifier': 'string' } }, 'message': 'string', 'startTime': datetime(2015, 1, 1), 'endTime': datetime(2015, 1, 1), 'outputMetadata': { 'diagnosticReportsRootS3URI': 'string' } }, ], 'nextToken': 'string' } **Response Structure** * *(dict) --* The response parameters of ListFlowExecutions. * **flowExecutions** *(list) --* The list of flow executions. * *(dict) --* The flow execution details. * **instanceId** *(string) --* The flow execution's instanceId. * **flowName** *(string) --* The flow execution's flowName. * **executionId** *(string) --* The flow executionId. * **status** *(string) --* The status of flow execution. * **sourceInfo** *(dict) --* The source information for a flow execution. * **sourceType** *(string) --* The data integration flow execution source type. * **s3Source** *(dict) --* The source details of a flow execution with S3 source. * **bucketName** *(string) --* The S3 bucket name of the S3 source. * **key** *(string) --* The S3 object key of the S3 source. * **datasetSource** *(dict) --* The source details of a flow execution with dataset source. * **datasetIdentifier** *(string) --* The ARN of the dataset source. * **message** *(string) --* The failure message (if any) of failed flow execution. * **startTime** *(datetime) --* The flow execution start timestamp. * **endTime** *(datetime) --* The flow execution end timestamp. * **outputMetadata** *(dict) --* The flow execution output metadata. * **diagnosticReportsRootS3URI** *(string) --* The S3 URI under which all diagnostic files (such as deduped records if any) are stored. * **nextToken** *(string) --* The pagination token to fetch next page of flow executions. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / get_data_integration_flow get_data_integration_flow ************************* SupplyChain.Client.get_data_integration_flow(**kwargs) Enables you to programmatically view a specific data pipeline for the provided Amazon Web Services Supply Chain instance and DataIntegrationFlow name. See also: AWS API Documentation **Request Syntax** response = client.get_data_integration_flow( instanceId='string', name='string' ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **name** (*string*) -- **[REQUIRED]** The name of the DataIntegrationFlow created. Return type: dict Returns: **Response Syntax** { 'flow': { 'instanceId': 'string', 'name': 'string', 'sources': [ { 'sourceType': 'S3'|'DATASET', 'sourceName': 'string', 's3Source': { 'bucketName': 'string', 'prefix': 'string', 'options': { 'fileType': 'CSV'|'PARQUET'|'JSON' } }, 'datasetSource': { 'datasetIdentifier': 'string', 'options': { 'loadType': 'INCREMENTAL'|'REPLACE', 'dedupeRecords': True|False, 'dedupeStrategy': { 'type': 'FIELD_PRIORITY', 'fieldPriority': { 'fields': [ { 'name': 'string', 'sortOrder': 'ASC'|'DESC' }, ] } } } } }, ], 'transformation': { 'transformationType': 'SQL'|'NONE', 'sqlTransformation': { 'query': 'string' } }, 'target': { 'targetType': 'S3'|'DATASET', 's3Target': { 'bucketName': 'string', 'prefix': 'string', 'options': { 'fileType': 'CSV'|'PARQUET'|'JSON' } }, 'datasetTarget': { 'datasetIdentifier': 'string', 'options': { 'loadType': 'INCREMENTAL'|'REPLACE', 'dedupeRecords': True|False, 'dedupeStrategy': { 'type': 'FIELD_PRIORITY', 'fieldPriority': { 'fields': [ { 'name': 'string', 'sortOrder': 'ASC'|'DESC' }, ] } } } } }, 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) } } **Response Structure** * *(dict) --* The response parameters for GetDataIntegrationFlow. * **flow** *(dict) --* The details of the DataIntegrationFlow returned. * **instanceId** *(string) --* The DataIntegrationFlow instance ID. * **name** *(string) --* The DataIntegrationFlow name. * **sources** *(list) --* The DataIntegrationFlow source configurations. * *(dict) --* The DataIntegrationFlow source parameters. * **sourceType** *(string) --* The DataIntegrationFlow source type. * **sourceName** *(string) --* The DataIntegrationFlow source name that can be used as table alias in SQL transformation query. * **s3Source** *(dict) --* The S3 DataIntegrationFlow source. * **bucketName** *(string) --* The bucketName of the S3 source objects. * **prefix** *(string) --* The prefix of the S3 source objects. To trigger data ingestion, S3 files need to be put under "s3://bucketName/prefix/". * **options** *(dict) --* The other options of the S3 DataIntegrationFlow source. * **fileType** *(string) --* The Amazon S3 file type in S3 options. * **datasetSource** *(dict) --* The dataset DataIntegrationFlow source. * **datasetIdentifier** *(string) --* The ARN of the dataset. * **options** *(dict) --* The dataset DataIntegrationFlow source options. * **loadType** *(string) --* The target dataset's data load type. This only affects how source S3 files are selected in the S3 -to-dataset flow. * **REPLACE** - Target dataset will get replaced with the new file added under the source s3 prefix. * **INCREMENTAL** - Target dataset will get updated with the up-to-date content under S3 prefix incorporating any file additions or removals there. * **dedupeRecords** *(boolean) --* The option to perform deduplication on data records sharing same primary key values. If disabled, transformed data with duplicate primary key values will ingest into dataset, for datasets within **asc** namespace, such duplicates will cause ingestion fail. If enabled without dedupeStrategy, deduplication is done by retaining a random data record among those sharing the same primary key values. If enabled with dedupeStragtegy, the deduplication is done following the strategy. Note that target dataset may have partition configured, when dedupe is enabled, it only dedupe against primary keys and retain only one record out of those duplicates regardless of its partition status. * **dedupeStrategy** *(dict) --* The deduplication strategy to dedupe the data records sharing same primary key values of the target dataset. This strategy only applies to target dataset with primary keys and with dedupeRecords option enabled. If transformed data still got duplicates after the dedupeStrategy evaluation, a random data record is chosen to be retained. * **type** *(string) --* The type of the deduplication strategy. * **FIELD_PRIORITY** - Field priority configuration for the deduplication strategy specifies an ordered list of fields used to tie-break the data records sharing the same primary key values. Fields earlier in the list have higher priority for evaluation. For each field, the sort order determines whether to retain data record with larger or smaller field value. * **fieldPriority** *(dict) --* The field priority deduplication strategy. * **fields** *(list) --* The list of field names and their sort order for deduplication, arranged in descending priority from highest to lowest. * *(dict) --* The field used in the field priority deduplication strategy. * **name** *(string) --* The name of the deduplication field. Must exist in the dataset and not be a primary key. * **sortOrder** *(string) --* The sort order for the deduplication field. * **transformation** *(dict) --* The DataIntegrationFlow transformation configurations. * **transformationType** *(string) --* The DataIntegrationFlow transformation type. * **sqlTransformation** *(dict) --* The SQL DataIntegrationFlow transformation configuration. * **query** *(string) --* The transformation SQL query body based on SparkSQL. * **target** *(dict) --* The DataIntegrationFlow target configuration. * **targetType** *(string) --* The DataIntegrationFlow target type. * **s3Target** *(dict) --* The S3 DataIntegrationFlow target. * **bucketName** *(string) --* The bucketName of the S3 target objects. * **prefix** *(string) --* The prefix of the S3 target objects. * **options** *(dict) --* The S3 DataIntegrationFlow target options. * **fileType** *(string) --* The Amazon S3 file type in S3 options. * **datasetTarget** *(dict) --* The dataset DataIntegrationFlow target. Note that for AWS Supply Chain dataset under **asc** namespace, it has a connection_id internal field that is not allowed to be provided by client directly, they will be auto populated. * **datasetIdentifier** *(string) --* The dataset ARN. * **options** *(dict) --* The dataset DataIntegrationFlow target options. * **loadType** *(string) --* The target dataset's data load type. This only affects how source S3 files are selected in the S3 -to-dataset flow. * **REPLACE** - Target dataset will get replaced with the new file added under the source s3 prefix. * **INCREMENTAL** - Target dataset will get updated with the up-to-date content under S3 prefix incorporating any file additions or removals there. * **dedupeRecords** *(boolean) --* The option to perform deduplication on data records sharing same primary key values. If disabled, transformed data with duplicate primary key values will ingest into dataset, for datasets within **asc** namespace, such duplicates will cause ingestion fail. If enabled without dedupeStrategy, deduplication is done by retaining a random data record among those sharing the same primary key values. If enabled with dedupeStragtegy, the deduplication is done following the strategy. Note that target dataset may have partition configured, when dedupe is enabled, it only dedupe against primary keys and retain only one record out of those duplicates regardless of its partition status. * **dedupeStrategy** *(dict) --* The deduplication strategy to dedupe the data records sharing same primary key values of the target dataset. This strategy only applies to target dataset with primary keys and with dedupeRecords option enabled. If transformed data still got duplicates after the dedupeStrategy evaluation, a random data record is chosen to be retained. * **type** *(string) --* The type of the deduplication strategy. * **FIELD_PRIORITY** - Field priority configuration for the deduplication strategy specifies an ordered list of fields used to tie- break the data records sharing the same primary key values. Fields earlier in the list have higher priority for evaluation. For each field, the sort order determines whether to retain data record with larger or smaller field value. * **fieldPriority** *(dict) --* The field priority deduplication strategy. * **fields** *(list) --* The list of field names and their sort order for deduplication, arranged in descending priority from highest to lowest. * *(dict) --* The field used in the field priority deduplication strategy. * **name** *(string) --* The name of the deduplication field. Must exist in the dataset and not be a primary key. * **sortOrder** *(string) --* The sort order for the deduplication field. * **createdTime** *(datetime) --* The DataIntegrationFlow creation timestamp. * **lastModifiedTime** *(datetime) --* The DataIntegrationFlow last modified timestamp. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / close close ***** SupplyChain.Client.close() Closes underlying endpoint connections. SupplyChain / Client / get_instance get_instance ************ SupplyChain.Client.get_instance(**kwargs) Enables you to programmatically retrieve the information related to an Amazon Web Services Supply Chain instance ID. See also: AWS API Documentation **Request Syntax** response = client.get_instance( instanceId='string' ) Parameters: **instanceId** (*string*) -- **[REQUIRED]** The AWS Supply Chain instance identifier Return type: dict Returns: **Response Syntax** { 'instance': { 'instanceId': 'string', 'awsAccountId': 'string', 'state': 'Initializing'|'Active'|'CreateFailed'|'DeleteFailed'|'Deleting'|'Deleted', 'errorMessage': 'string', 'webAppDnsDomain': 'string', 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1), 'instanceName': 'string', 'instanceDescription': 'string', 'kmsKeyArn': 'string', 'versionNumber': 123.0 } } **Response Structure** * *(dict) --* The response parameters for GetInstance. * **instance** *(dict) --* The instance resource data details. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **awsAccountId** *(string) --* The Amazon Web Services account ID that owns the instance. * **state** *(string) --* The state of the instance. * **errorMessage** *(string) --* The Amazon Web Services Supply Chain instance error message. If the instance results in an unhealthy state, customers need to check the error message, delete the current instance, and recreate a new one based on the mitigation from the error message. * **webAppDnsDomain** *(string) --* The WebApp DNS domain name of the instance. * **createdTime** *(datetime) --* The instance creation timestamp. * **lastModifiedTime** *(datetime) --* The instance last modified timestamp. * **instanceName** *(string) --* The Amazon Web Services Supply Chain instance name. * **instanceDescription** *(string) --* The Amazon Web Services Supply Chain instance description. * **kmsKeyArn** *(string) --* The ARN (Amazon Resource Name) of the Key Management Service (KMS) key you optionally provided for encryption. If you did not provide anything here, AWS Supply Chain uses the Amazon Web Services owned KMS key and nothing is returned. * **versionNumber** *(float) --* The version number of the instance. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / delete_data_lake_dataset delete_data_lake_dataset ************************ SupplyChain.Client.delete_data_lake_dataset(**kwargs) Enables you to programmatically delete an Amazon Web Services Supply Chain data lake dataset. Developers can delete the existing datasets for a given instance ID, namespace, and instance name. See also: AWS API Documentation **Request Syntax** response = client.delete_data_lake_dataset( instanceId='string', namespace='string', name='string' ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The AWS Supply Chain instance identifier. * **namespace** (*string*) -- **[REQUIRED]** The namespace of the dataset, besides the custom defined namespace, every instance comes with below pre-defined namespaces: * **asc** - For information on the Amazon Web Services Supply Chain supported datasets see https://docs.aws.amazon.com /aws-supply-chain/latest/userguide/data-model-asc.html. * **default** - For datasets with custom user-defined schemas. * **name** (*string*) -- **[REQUIRED]** The name of the dataset. For **asc** namespace, the name must be one of the supported data entities under https://docs.aws.amazon.com/aws-supply-chain/latest/userguide /data-model-asc.html. Return type: dict Returns: **Response Syntax** { 'instanceId': 'string', 'namespace': 'string', 'name': 'string' } **Response Structure** * *(dict) --* The response parameters of DeleteDataLakeDataset. * **instanceId** *(string) --* The AWS Supply Chain instance identifier. * **namespace** *(string) --* The namespace of deleted dataset. * **name** *(string) --* The name of deleted dataset. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / delete_instance delete_instance *************** SupplyChain.Client.delete_instance(**kwargs) Enables you to programmatically delete an Amazon Web Services Supply Chain instance by deleting the KMS keys and relevant information associated with the API without using the Amazon Web Services console. This is an asynchronous operation. Upon receiving a DeleteInstance request, Amazon Web Services Supply Chain immediately returns a response with the instance resource, delete state while cleaning up all Amazon Web Services resources created during the instance creation process. You can use the GetInstance action to check the instance status. See also: AWS API Documentation **Request Syntax** response = client.delete_instance( instanceId='string' ) Parameters: **instanceId** (*string*) -- **[REQUIRED]** The AWS Supply Chain instance identifier. Return type: dict Returns: **Response Syntax** { 'instance': { 'instanceId': 'string', 'awsAccountId': 'string', 'state': 'Initializing'|'Active'|'CreateFailed'|'DeleteFailed'|'Deleting'|'Deleted', 'errorMessage': 'string', 'webAppDnsDomain': 'string', 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1), 'instanceName': 'string', 'instanceDescription': 'string', 'kmsKeyArn': 'string', 'versionNumber': 123.0 } } **Response Structure** * *(dict) --* The response parameters for DeleteInstance. * **instance** *(dict) --* The AWS Supply Chain instance resource data details. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **awsAccountId** *(string) --* The Amazon Web Services account ID that owns the instance. * **state** *(string) --* The state of the instance. * **errorMessage** *(string) --* The Amazon Web Services Supply Chain instance error message. If the instance results in an unhealthy state, customers need to check the error message, delete the current instance, and recreate a new one based on the mitigation from the error message. * **webAppDnsDomain** *(string) --* The WebApp DNS domain name of the instance. * **createdTime** *(datetime) --* The instance creation timestamp. * **lastModifiedTime** *(datetime) --* The instance last modified timestamp. * **instanceName** *(string) --* The Amazon Web Services Supply Chain instance name. * **instanceDescription** *(string) --* The Amazon Web Services Supply Chain instance description. * **kmsKeyArn** *(string) --* The ARN (Amazon Resource Name) of the Key Management Service (KMS) key you optionally provided for encryption. If you did not provide anything here, AWS Supply Chain uses the Amazon Web Services owned KMS key and nothing is returned. * **versionNumber** *(float) --* The version number of the instance. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / get_data_lake_dataset get_data_lake_dataset ********************* SupplyChain.Client.get_data_lake_dataset(**kwargs) Enables you to programmatically view an Amazon Web Services Supply Chain data lake dataset. Developers can view the data lake dataset information such as namespace, schema, and so on for a given instance ID, namespace, and dataset name. See also: AWS API Documentation **Request Syntax** response = client.get_data_lake_dataset( instanceId='string', namespace='string', name='string' ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **namespace** (*string*) -- **[REQUIRED]** The namespace of the dataset, besides the custom defined namespace, every instance comes with below pre-defined namespaces: * **asc** - For information on the Amazon Web Services Supply Chain supported datasets see https://docs.aws.amazon.com /aws-supply-chain/latest/userguide/data-model-asc.html. * **default** - For datasets with custom user-defined schemas. * **name** (*string*) -- **[REQUIRED]** The name of the dataset. For **asc** namespace, the name must be one of the supported data entities under https://docs.aws.amazon.com/aws-supply-chain/latest/userguide /data-model-asc.html. Return type: dict Returns: **Response Syntax** { 'dataset': { 'instanceId': 'string', 'namespace': 'string', 'name': 'string', 'arn': 'string', 'schema': { 'name': 'string', 'fields': [ { 'name': 'string', 'type': 'INT'|'DOUBLE'|'STRING'|'TIMESTAMP'|'LONG', 'isRequired': True|False }, ], 'primaryKeys': [ { 'name': 'string' }, ] }, 'description': 'string', 'partitionSpec': { 'fields': [ { 'name': 'string', 'transform': { 'type': 'YEAR'|'MONTH'|'DAY'|'HOUR'|'IDENTITY' } }, ] }, 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) } } **Response Structure** * *(dict) --* The response parameters for GetDataLakeDataset. * **dataset** *(dict) --* The fetched dataset details. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **namespace** *(string) --* The namespace of the dataset, besides the custom defined namespace, every instance comes with below pre-defined namespaces: * **asc** - For information on the Amazon Web Services Supply Chain supported datasets see https://docs.aws.amazon.com/aws-supply- chain/latest/userguide/data-model-asc.html. * **default** - For datasets with custom user-defined schemas. * **name** *(string) --* The name of the dataset. For **asc** namespace, the name must be one of the supported data entities under https://docs.aws.amazon.com/aws-supply- chain/latest/userguide/data-model-asc.html. * **arn** *(string) --* The arn of the dataset. * **schema** *(dict) --* The schema of the dataset. * **name** *(string) --* The name of the dataset schema. * **fields** *(list) --* The list of field details of the dataset schema. * *(dict) --* The dataset field details. * **name** *(string) --* The dataset field name. * **type** *(string) --* The dataset field type. * **isRequired** *(boolean) --* Indicate if the field is required or not. * **primaryKeys** *(list) --* The list of primary key fields for the dataset. Primary keys defined can help data ingestion methods to ensure data uniqueness: CreateDataIntegrationFlow's dedupe strategy will leverage primary keys to perform records deduplication before write to dataset; SendDataIntegrationEvent's UPSERT and DELETE can only work with dataset with primary keys. For more details, refer to those data ingestion documentations. Note that defining primary keys does not necessarily mean the dataset cannot have duplicate records, duplicate records can still be ingested if CreateDataIntegrationFlow's dedupe disabled or through SendDataIntegrationEvent's APPEND operation. * *(dict) --* The detail of the primary key field. * **name** *(string) --* The name of the primary key field. * **description** *(string) --* The description of the dataset. * **partitionSpec** *(dict) --* The partition specification for a dataset. * **fields** *(list) --* The fields on which to partition a dataset. The partitions will be applied hierarchically based on the order of this list. * *(dict) --* The detail of the partition field. * **name** *(string) --* The name of the partition field. * **transform** *(dict) --* The transformation of the partition field. A transformation specifies how to partition on a given field. For example, with timestamp you can specify that you'd like to partition fields by day, e.g. data record with value 2025-01-03T00:00:00Z in partition field is in 2025-01-03 partition. Also noted that data record without any value in optional partition field is in NULL partition. * **type** *(string) --* The type of partitioning transformation for this field. The available options are: * **IDENTITY** - Partitions data on a given field by its exact values. * **YEAR** - Partitions data on a timestamp field using year granularity. * **MONTH** - Partitions data on a timestamp field using month granularity. * **DAY** - Partitions data on a timestamp field using day granularity. * **HOUR** - Partitions data on a timestamp field using hour granularity. * **createdTime** *(datetime) --* The creation time of the dataset. * **lastModifiedTime** *(datetime) --* The last modified time of the dataset. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / list_data_lake_namespaces list_data_lake_namespaces ************************* SupplyChain.Client.list_data_lake_namespaces(**kwargs) Enables you to programmatically view the list of Amazon Web Services Supply Chain data lake namespaces. Developers can view the namespaces and the corresponding information such as description for a given instance ID. Note that this API only return custom namespaces, instance pre-defined namespaces are not included. See also: AWS API Documentation **Request Syntax** response = client.list_data_lake_namespaces( instanceId='string', nextToken='string', maxResults=123 ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **nextToken** (*string*) -- The pagination token to fetch next page of namespaces. * **maxResults** (*integer*) -- The max number of namespaces to fetch in this paginated request. Return type: dict Returns: **Response Syntax** { 'namespaces': [ { 'instanceId': 'string', 'name': 'string', 'arn': 'string', 'description': 'string', 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) }, ], 'nextToken': 'string' } **Response Structure** * *(dict) --* The response parameters of ListDataLakeNamespaces. * **namespaces** *(list) --* The list of fetched namespace details. Noted it only contains custom namespaces, pre-defined namespaces are not included. * *(dict) --* The data lake namespace details. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **name** *(string) --* The name of the namespace. * **arn** *(string) --* The arn of the namespace. * **description** *(string) --* The description of the namespace. * **createdTime** *(datetime) --* The creation time of the namespace. * **lastModifiedTime** *(datetime) --* The last modified time of the namespace. * **nextToken** *(string) --* The pagination token to fetch next page of namespaces. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / tag_resource tag_resource ************ SupplyChain.Client.tag_resource(**kwargs) You can create tags during or after creating a resource such as instance, data flow, or dataset in AWS Supply chain. During the data ingestion process, you can add tags such as dev, test, or prod to data flows created during the data ingestion process in the AWS Supply Chain datasets. You can use these tags to identify a group of resources or a single resource used by the developer. See also: AWS API Documentation **Request Syntax** response = client.tag_resource( resourceArn='string', tags={ 'string': 'string' } ) Parameters: * **resourceArn** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply chain resource ARN that needs to be tagged. * **tags** (*dict*) -- **[REQUIRED]** The tags of the Amazon Web Services Supply chain resource to be created. * *(string) --* * *(string) --* Return type: dict Returns: **Response Syntax** {} **Response Structure** * *(dict) --* The response parameters for TagResource. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException" SupplyChain / Client / create_data_lake_namespace create_data_lake_namespace ************************** SupplyChain.Client.create_data_lake_namespace(**kwargs) Enables you to programmatically create an Amazon Web Services Supply Chain data lake namespace. Developers can create the namespaces for a given instance ID. See also: AWS API Documentation **Request Syntax** response = client.create_data_lake_namespace( instanceId='string', name='string', description='string', tags={ 'string': 'string' } ) Parameters: * **instanceId** (*string*) -- **[REQUIRED]** The Amazon Web Services Supply Chain instance identifier. * **name** (*string*) -- **[REQUIRED]** The name of the namespace. Noted you cannot create namespace with name starting with **asc**, **default**, **scn**, **aws**, **amazon**, **amzn** * **description** (*string*) -- The description of the namespace. * **tags** (*dict*) -- The tags of the namespace. * *(string) --* * *(string) --* Return type: dict Returns: **Response Syntax** { 'namespace': { 'instanceId': 'string', 'name': 'string', 'arn': 'string', 'description': 'string', 'createdTime': datetime(2015, 1, 1), 'lastModifiedTime': datetime(2015, 1, 1) } } **Response Structure** * *(dict) --* The response parameters of CreateDataLakeNamespace. * **namespace** *(dict) --* The detail of created namespace. * **instanceId** *(string) --* The Amazon Web Services Supply Chain instance identifier. * **name** *(string) --* The name of the namespace. * **arn** *(string) --* The arn of the namespace. * **description** *(string) --* The description of the namespace. * **createdTime** *(datetime) --* The creation time of the namespace. * **lastModifiedTime** *(datetime) --* The last modified time of the namespace. **Exceptions** * "SupplyChain.Client.exceptions.ServiceQuotaExceededException" * "SupplyChain.Client.exceptions.ThrottlingException" * "SupplyChain.Client.exceptions.ResourceNotFoundException" * "SupplyChain.Client.exceptions.AccessDeniedException" * "SupplyChain.Client.exceptions.ValidationException" * "SupplyChain.Client.exceptions.InternalServerException" * "SupplyChain.Client.exceptions.ConflictException"