Bedrock / Client / get_automated_reasoning_policy_build_workflow_result_assets

get_automated_reasoning_policy_build_workflow_result_assets¶

Bedrock.Client.get_automated_reasoning_policy_build_workflow_result_assets(**kwargs)¶

Retrieves the resulting assets from a completed Automated Reasoning policy build workflow, including build logs, quality reports, and generated policy artifacts.

Request Syntax

response = client.get_automated_reasoning_policy_build_workflow_result_assets(
    policyArn='string',
    buildWorkflowId='string',
    assetType='BUILD_LOG'|'QUALITY_REPORT'|'POLICY_DEFINITION'
)

Parameters:

policyArn (string) –
[REQUIRED]

The Amazon Resource Name (ARN) of the Automated Reasoning policy whose build workflow assets you want to retrieve.
buildWorkflowId (string) –
[REQUIRED]

The unique identifier of the build workflow whose result assets you want to retrieve.
assetType (string) –
[REQUIRED]

The type of asset to retrieve (e.g., BUILD_LOG, QUALITY_REPORT, POLICY_DEFINITION).

Return type:

dict

Returns:

Response Syntax

{
    'policyArn': 'string',
    'buildWorkflowId': 'string',
    'buildWorkflowAssets': {
        'policyDefinition': {
            'version': 'string',
            'types': [
                {
                    'name': 'string',
                    'description': 'string',
                    'values': [
                        {
                            'value': 'string',
                            'description': 'string'
                        },
                    ]
                },
            ],
            'rules': [
                {
                    'id': 'string',
                    'expression': 'string',
                    'alternateExpression': 'string'
                },
            ],
            'variables': [
                {
                    'name': 'string',
                    'type': 'string',
                    'description': 'string'
                },
            ]
        },
        'qualityReport': {
            'typeCount': 123,
            'variableCount': 123,
            'ruleCount': 123,
            'unusedTypes': [
                'string',
            ],
            'unusedTypeValues': [
                {
                    'typeName': 'string',
                    'valueName': 'string'
                },
            ],
            'unusedVariables': [
                'string',
            ],
            'conflictingRules': [
                'string',
            ],
            'disjointRuleSets': [
                {
                    'variables': [
                        'string',
                    ],
                    'rules': [
                        'string',
                    ]
                },
            ]
        },
        'buildLog': {
            'entries': [
                {
                    'annotation': {
                        'addType': {
                            'name': 'string',
                            'description': 'string',
                            'values': [
                                {
                                    'value': 'string',
                                    'description': 'string'
                                },
                            ]
                        },
                        'updateType': {
                            'name': 'string',
                            'newName': 'string',
                            'description': 'string',
                            'values': [
                                {
                                    'addTypeValue': {
                                        'value': 'string',
                                        'description': 'string'
                                    },
                                    'updateTypeValue': {
                                        'value': 'string',
                                        'newValue': 'string',
                                        'description': 'string'
                                    },
                                    'deleteTypeValue': {
                                        'value': 'string'
                                    }
                                },
                            ]
                        },
                        'deleteType': {
                            'name': 'string'
                        },
                        'addVariable': {
                            'name': 'string',
                            'type': 'string',
                            'description': 'string'
                        },
                        'updateVariable': {
                            'name': 'string',
                            'newName': 'string',
                            'description': 'string'
                        },
                        'deleteVariable': {
                            'name': 'string'
                        },
                        'addRule': {
                            'expression': 'string'
                        },
                        'updateRule': {
                            'ruleId': 'string',
                            'expression': 'string'
                        },
                        'deleteRule': {
                            'ruleId': 'string'
                        },
                        'addRuleFromNaturalLanguage': {
                            'naturalLanguage': 'string'
                        },
                        'updateFromRulesFeedback': {
                            'ruleIds': [
                                'string',
                            ],
                            'feedback': 'string'
                        },
                        'updateFromScenarioFeedback': {
                            'ruleIds': [
                                'string',
                            ],
                            'scenarioExpression': 'string',
                            'feedback': 'string'
                        },
                        'ingestContent': {
                            'content': 'string'
                        }
                    },
                    'status': 'APPLIED'|'FAILED',
                    'buildSteps': [
                        {
                            'context': {
                                'planning': {},
                                'mutation': {
                                    'addType': {
                                        'type': {
                                            'name': 'string',
                                            'description': 'string',
                                            'values': [
                                                {
                                                    'value': 'string',
                                                    'description': 'string'
                                                },
                                            ]
                                        }
                                    },
                                    'updateType': {
                                        'type': {
                                            'name': 'string',
                                            'description': 'string',
                                            'values': [
                                                {
                                                    'value': 'string',
                                                    'description': 'string'
                                                },
                                            ]
                                        }
                                    },
                                    'deleteType': {
                                        'name': 'string'
                                    },
                                    'addVariable': {
                                        'variable': {
                                            'name': 'string',
                                            'type': 'string',
                                            'description': 'string'
                                        }
                                    },
                                    'updateVariable': {
                                        'variable': {
                                            'name': 'string',
                                            'type': 'string',
                                            'description': 'string'
                                        }
                                    },
                                    'deleteVariable': {
                                        'name': 'string'
                                    },
                                    'addRule': {
                                        'rule': {
                                            'id': 'string',
                                            'expression': 'string',
                                            'alternateExpression': 'string'
                                        }
                                    },
                                    'updateRule': {
                                        'rule': {
                                            'id': 'string',
                                            'expression': 'string',
                                            'alternateExpression': 'string'
                                        }
                                    },
                                    'deleteRule': {
                                        'id': 'string'
                                    }
                                }
                            },
                            'priorElement': {
                                'policyDefinitionVariable': {
                                    'name': 'string',
                                    'type': 'string',
                                    'description': 'string'
                                },
                                'policyDefinitionType': {
                                    'name': 'string',
                                    'description': 'string',
                                    'values': [
                                        {
                                            'value': 'string',
                                            'description': 'string'
                                        },
                                    ]
                                },
                                'policyDefinitionRule': {
                                    'id': 'string',
                                    'expression': 'string',
                                    'alternateExpression': 'string'
                                }
                            },
                            'messages': [
                                {
                                    'message': 'string',
                                    'messageType': 'INFO'|'WARNING'|'ERROR'
                                },
                            ]
                        },
                    ]
                },
            ]
        }
    }
}

Response Structure

(dict) –
- policyArn (string) –
  
  The Amazon Resource Name (ARN) of the Automated Reasoning policy.
- buildWorkflowId (string) –
  
  The unique identifier of the build workflow.
- buildWorkflowAssets (dict) –
  
  The requested build workflow asset. This is a union type that returns only one of the available asset types (logs, reports, or generated artifacts) based on the specific asset type requested in the API call.
  Note
  This is a Tagged Union structure. Only one of the following top level keys will be set: policyDefinition, qualityReport, buildLog. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
  'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
  - policyDefinition (dict) –
    
    The complete policy definition generated by the build workflow, containing all rules, variables, and custom types extracted from the source documents.
    - version (string) –
      
      The version of the policy definition format.
    - types (list) –
      
      The custom user-defined vairable types used in the policy. Types are enum-based variable types that provide additional context beyond the predefined variable types.
      - (dict) –
        
        Represents a custom user-defined viarble type in an Automated Reasoning policy. Types are enum-based and provide additional context beyond predefined variable types.
        
        name (string) –
        
        The name of the custom type.
        
        description (string) –
        
        The description of what the custom type represents.
        
        values (list) –
        
        The possible values for this enum-based type, each with its own description.
        
        (dict) –
        
        Represents a single value within a custom type definition, including its identifier and description.
        
        value (string) –
        
        The actual value or identifier for this type value.
        
        description (string) –
        
        A human-readable description explaining what this type value represents and when it should be used.
    - rules (list) –
      
      The formal logic rules extracted from the source document. Rules define the logical constraints that determine whether model responses are valid, invalid, or satisfiable.
      - (dict) –
        
        Represents a formal logic rule in an Automated Reasoning policy. For example, rules can be expressed as if-then statements that define logical constraints.
        
        id (string) –
        
        The unique identifier of the rule within the policy.
        
        expression (string) –
        
        The formal logic expression of the rule.
        
        alternateExpression (string) –
        
        The human-readable form of the rule expression, often in natural language or simplified notation.
    - variables (list) –
      
      The variables that represent concepts in the policy. Variables can have values assigned when translating natural language into formal logic. Their descriptions are crucial for accurate translation.
      - (dict) –
        
        Represents a variable in an Automated Reasoning policy. Variables represent concepts that can have values assigned during natural language translation.
        
        name (string) –
        
        The name of the variable. Use descriptive names that clearly indicate the concept being represented.
        
        type (string) –
        
        The data type of the variable. Valid types include bool, int, real, enum, and custom types that you can provide.
        
        description (string) –
        
        The description of the variable that explains what it represents and how users might refer to it. Clear and comprehensive descriptions are essential for accurate natural language translation.
  - qualityReport (dict) –
    
    A comprehensive report analyzing the quality of the generated policy, including metrics about rule coverage, potential conflicts, and unused elements.
    - typeCount (integer) –
      
      The total number of custom types defined in the policy.
    - variableCount (integer) –
      
      The total number of variables defined in the policy.
    - ruleCount (integer) –
      
      The total number of rules defined in the policy.
    - unusedTypes (list) –
      
      A list of custom types that are defined but not referenced by any variables or rules, suggesting they may be unnecessary.
      - (string) –
    - unusedTypeValues (list) –
      
      A list of type values that are defined but never used in any rules, indicating potential cleanup opportunities.
      - (dict) –
        
        Associates a type name with a specific value name, used for referencing type values in rules and other policy elements.
        
        typeName (string) –
        
        The name of the custom type that contains the referenced value.
        
        valueName (string) –
        
        The name of the specific value within the type.
    - unusedVariables (list) –
      
      A list of variables that are defined but not referenced by any rules, suggesting they may be unnecessary.
      - (string) –
    - conflictingRules (list) –
      
      A list of rules that may conflict with each other, potentially leading to inconsistent policy behavior.
      - (string) –
    - disjointRuleSets (list) –
      
      Groups of rules that operate on completely separate sets of variables, indicating the policy may be addressing multiple unrelated concerns.
      - (dict) –
        
        Represents a set of rules that operate on completely separate variables, indicating they address different concerns or domains within the policy.
        
        variables (list) –
        
        The set of variables that are used by the rules in this disjoint set.
        
        (string) –
        
        rules (list) –
        
        The list of rules that form this disjoint set, all operating on the same set of variables.
        
        (string) –
  - buildLog (dict) –
    
    The complete build log containing detailed information about each step in the policy generation process.
    - entries (list) –
      
      A list of log entries documenting each step in the policy build process, including timestamps, status, and detailed messages.
      - (dict) –
        
        Represents a single entry in the policy build log, containing information about a specific step or event in the build process.
        
        annotation (dict) –
        
        The annotation or operation that was being processed when this log entry was created.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: addType, updateType, deleteType, addVariable, updateVariable, deleteVariable, addRule, updateRule, deleteRule, addRuleFromNaturalLanguage, updateFromRulesFeedback, updateFromScenarioFeedback, ingestContent. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
        
        addType (dict) –
        
        An operation to add a new custom type to the policy, defining a set of possible values for policy variables.
        
        name (string) –
        
        The name of the new custom type. This name will be used to reference the type in variable definitions and rules.
        
        description (string) –
        
        A description of what the custom type represents and how it should be used in the policy.
        
        values (list) –
        
        The list of possible values that variables of this type can take, each with its own description and identifier.
        
        (dict) –
        
        Represents a single value within a custom type definition, including its identifier and description.
        
        value (string) –
        
        The actual value or identifier for this type value.
        
        description (string) –
        
        A human-readable description explaining what this type value represents and when it should be used.
        
        updateType (dict) –
        
        An operation to modify an existing custom type in the policy, such as changing its name, description, or allowed values.
        
        name (string) –
        
        The current name of the custom type to update.
        
        newName (string) –
        
        The new name for the custom type, if you want to rename it. If not provided, the name remains unchanged.
        
        description (string) –
        
        The new description for the custom type, replacing the previous description.
        
        values (list) –
        
        The updated list of values for the custom type, which can include additions, modifications, or removals.
        
        (dict) –
        
        An annotation for managing values within custom types, including adding, updating, or removing specific type values.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: addTypeValue, updateTypeValue, deleteTypeValue. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
        
        addTypeValue (dict) –
        
        An operation to add a new value to an existing custom type.
        
        value (string) –
        
        The identifier or name of the new value to add to the type.
        
        description (string) –
        
        A description of what this new type value represents and when it should be used.
        
        updateTypeValue (dict) –
        
        An operation to modify an existing value within a custom type.
        
        value (string) –
        
        The current identifier or name of the type value to update.
        
        newValue (string) –
        
        The new identifier or name for the type value, if you want to rename it.
        
        description (string) –
        
        The new description for the type value, replacing the previous description.
        
        deleteTypeValue (dict) –
        
        An operation to remove a value from an existing custom type.
        
        value (string) –
        
        The identifier or name of the value to remove from the type.
        
        deleteType (dict) –
        
        An operation to remove a custom type from the policy. The type must not be referenced by any variables or rules.
        
        name (string) –
        
        The name of the custom type to delete from the policy. The type must not be referenced by any variables or rules.
        
        addVariable (dict) –
        
        An operation to add a new variable to the policy, which can be used in rule expressions to represent dynamic values.
        
        name (string) –
        
        The name of the new variable. This name will be used to reference the variable in rule expressions.
        
        type (string) –
        
        The type of the variable, which can be a built-in type (like string or number) or a custom type defined in the policy.
        
        description (string) –
        
        A description of what the variable represents and how it should be used in rules.
        
        updateVariable (dict) –
        
        An operation to modify an existing variable in the policy, such as changing its name, type, or description.
        
        name (string) –
        
        The current name of the variable to update.
        
        newName (string) –
        
        The new name for the variable, if you want to rename it. If not provided, the name remains unchanged.
        
        description (string) –
        
        The new description for the variable, replacing the previous description.
        
        deleteVariable (dict) –
        
        An operation to remove a variable from the policy. The variable must not be referenced by any rules.
        
        name (string) –
        
        The name of the variable to delete from the policy. The variable must not be referenced by any rules.
        
        addRule (dict) –
        
        An operation to add a new logical rule to the policy using formal mathematical expressions.
        
        expression (string) –
        
        The formal logical expression that defines the rule, using mathematical notation and referencing policy variables and types.
        
        updateRule (dict) –
        
        An operation to modify an existing rule in the policy, such as changing its logical expression or conditions.
        
        ruleId (string) –
        
        The unique identifier of the rule to update.
        
        expression (string) –
        
        The new formal logical expression for the rule, replacing the previous expression.
        
        deleteRule (dict) –
        
        An operation to remove a rule from the policy.
        
        ruleId (string) –
        
        The unique identifier of the rule to delete from the policy.
        
        addRuleFromNaturalLanguage (dict) –
        
        An operation to add a new rule by converting natural language descriptions into formal logical expressions.
        
        naturalLanguage (string) –
        
        The natural language description of the rule that should be converted into a formal logical expression.
        
        updateFromRulesFeedback (dict) –
        
        An operation to update the policy based on feedback about how specific rules performed during testing or validation.
        
        ruleIds (list) –
        
        The list of rule identifiers that the feedback applies to.
        
        (string) –
        
        feedback (string) –
        
        The feedback information about rule performance, including suggestions for improvements or corrections.
        
        updateFromScenarioFeedback (dict) –
        
        An operation to update the policy based on feedback about how it performed on specific test scenarios.
        
        ruleIds (list) –
        
        The list of rule identifiers that were involved in the scenario being evaluated.
        
        (string) –
        
        scenarioExpression (string) –
        
        The logical expression that defines the test scenario that generated this feedback.
        
        feedback (string) –
        
        The feedback information about scenario performance, including any issues or improvements identified.
        
        ingestContent (dict) –
        
        An operation to process and incorporate new content into the policy, extracting additional rules and concepts.
        
        content (string) –
        
        The new content to be analyzed and incorporated into the policy, such as additional documents or rule descriptions.
        
        status (string) –
        
        The status of the build step (e.g., SUCCESS, FAILED, IN_PROGRESS).
        
        buildSteps (list) –
        
        Detailed information about the specific build steps that were executed, including any sub-operations or transformations.
        
        (dict) –
        
        Represents a single step in the policy build process, containing context about what was being processed and any messages or results.
        
        context (dict) –
        
        Contextual information about what was being processed during this build step, such as the type of operation or the source material being analyzed.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: planning, mutation. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
        
        planning (dict) –
        
        Indicates that this build step was part of the planning phase, where the system determines what operations to perform.
        
        mutation (dict) –
        
        Indicates that this build step involved modifying the policy structure, such as adding or updating rules, variables, or types.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: addType, updateType, deleteType, addVariable, updateVariable, deleteVariable, addRule, updateRule, deleteRule. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
        
        addType (dict) –
        
        A mutation to add a new custom type to the policy.
        
        type (dict) –
        
        The type definition that specifies the name, description, and possible values for the new custom type being added to the policy.
        
        name (string) –
        
        The name of the custom type.
        
        description (string) –
        
        The description of what the custom type represents.
        
        values (list) –
        
        The possible values for this enum-based type, each with its own description.
        
        (dict) –
        
        Represents a single value within a custom type definition, including its identifier and description.
        
        value (string) –
        
        The actual value or identifier for this type value.
        
        description (string) –
        
        A human-readable description explaining what this type value represents and when it should be used.
        
        updateType (dict) –
        
        A mutation to modify an existing custom type in the policy.
        
        type (dict) –
        
        The updated type definition containing the modified name, description, or values for the existing custom type.
        
        name (string) –
        
        The name of the custom type.
        
        description (string) –
        
        The description of what the custom type represents.
        
        values (list) –
        
        The possible values for this enum-based type, each with its own description.
        
        (dict) –
        
        Represents a single value within a custom type definition, including its identifier and description.
        
        value (string) –
        
        The actual value or identifier for this type value.
        
        description (string) –
        
        A human-readable description explaining what this type value represents and when it should be used.
        
        deleteType (dict) –
        
        A mutation to remove a custom type from the policy.
        
        name (string) –
        
        The name of the custom type to delete.
        
        addVariable (dict) –
        
        A mutation to add a new variable to the policy.
        
        variable (dict) –
        
        The variable definition that specifies the name, type, and description for the new variable being added to the policy.
        
        name (string) –
        
        The name of the variable. Use descriptive names that clearly indicate the concept being represented.
        
        type (string) –
        
        The data type of the variable. Valid types include bool, int, real, enum, and custom types that you can provide.
        
        description (string) –
        
        The description of the variable that explains what it represents and how users might refer to it. Clear and comprehensive descriptions are essential for accurate natural language translation.
        
        updateVariable (dict) –
        
        A mutation to modify an existing variable in the policy.
        
        variable (dict) –
        
        The updated variable definition containing the modified name, type, or description for the existing variable.
        
        name (string) –
        
        The name of the variable. Use descriptive names that clearly indicate the concept being represented.
        
        type (string) –
        
        The data type of the variable. Valid types include bool, int, real, enum, and custom types that you can provide.
        
        description (string) –
        
        The description of the variable that explains what it represents and how users might refer to it. Clear and comprehensive descriptions are essential for accurate natural language translation.
        
        deleteVariable (dict) –
        
        A mutation to remove a variable from the policy.
        
        name (string) –
        
        The name of the variable to delete.
        
        addRule (dict) –
        
        A mutation to add a new rule to the policy.
        
        rule (dict) –
        
        The rule definition that specifies the formal logical expression and metadata for the new rule being added to the policy.
        
        id (string) –
        
        The unique identifier of the rule within the policy.
        
        expression (string) –
        
        The formal logic expression of the rule.
        
        alternateExpression (string) –
        
        The human-readable form of the rule expression, often in natural language or simplified notation.
        
        updateRule (dict) –
        
        A mutation to modify an existing rule in the policy.
        
        rule (dict) –
        
        The updated rule definition containing the modified formal logical expression and any changed metadata for the existing rule.
        
        id (string) –
        
        The unique identifier of the rule within the policy.
        
        expression (string) –
        
        The formal logic expression of the rule.
        
        alternateExpression (string) –
        
        The human-readable form of the rule expression, often in natural language or simplified notation.
        
        deleteRule (dict) –
        
        A mutation to remove a rule from the policy.
        
        id (string) –
        
        The unique identifier of the rule to delete.
        
        priorElement (dict) –
        
        Reference to the previous element or step in the build process, helping to trace the sequence of operations.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: policyDefinitionVariable, policyDefinitionType, policyDefinitionRule. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
        
        policyDefinitionVariable (dict) –
        
        A variable element within the policy definition that represents a concept used in logical expressions and rules.
        
        name (string) –
        
        The name of the variable. Use descriptive names that clearly indicate the concept being represented.
        
        type (string) –
        
        The data type of the variable. Valid types include bool, int, real, enum, and custom types that you can provide.
        
        description (string) –
        
        The description of the variable that explains what it represents and how users might refer to it. Clear and comprehensive descriptions are essential for accurate natural language translation.
        
        policyDefinitionType (dict) –
        
        A custom type element within the policy definition that defines a set of possible values for variables.
        
        name (string) –
        
        The name of the custom type.
        
        description (string) –
        
        The description of what the custom type represents.
        
        values (list) –
        
        The possible values for this enum-based type, each with its own description.
        
        (dict) –
        
        Represents a single value within a custom type definition, including its identifier and description.
        
        value (string) –
        
        The actual value or identifier for this type value.
        
        description (string) –
        
        A human-readable description explaining what this type value represents and when it should be used.
        
        policyDefinitionRule (dict) –
        
        A rule element within the policy definition that contains a formal logical expression used for validation.
        
        id (string) –
        
        The unique identifier of the rule within the policy.
        
        expression (string) –
        
        The formal logic expression of the rule.
        
        alternateExpression (string) –
        
        The human-readable form of the rule expression, often in natural language or simplified notation.
        
        messages (list) –
        
        A list of messages generated during this build step, including informational messages, warnings, and error details.
        
        (dict) –
        
        Represents a message generated during a build step, providing information about what happened or any issues encountered.
        
        message (string) –
        
        The content of the message, describing what occurred during the build step.
        
        messageType (string) –
        
        The type of message (e.g., INFO, WARNING, ERROR) indicating its severity and purpose.

Exceptions

Bedrock.Client.exceptions.ResourceNotFoundException
Bedrock.Client.exceptions.AccessDeniedException
Bedrock.Client.exceptions.ValidationException
Bedrock.Client.exceptions.InternalServerException
Bedrock.Client.exceptions.ThrottlingException