apply_guardrail

Operation

apply_guardrail async

apply_guardrail(input: ApplyGuardrailInput, plugins: list[Plugin] | None = None) -> ApplyGuardrailOutput

The action to apply a guardrail.

For troubleshooting some of the common errors you might encounter when using the ApplyGuardrail API, see Troubleshooting Amazon Bedrock API Error Codes in the Amazon Bedrock User Guide

Parameters:

Name	Type	Description	Default
input	ApplyGuardrailInput	An instance of ApplyGuardrailInput.	required
plugins	list[Plugin] | None	A list of callables that modify the configuration dynamically. Changes made by these plugins only apply for the duration of the operation execution and will not affect any other operation invocations.	None

Returns:

Type	Description
ApplyGuardrailOutput	An instance of ApplyGuardrailOutput.

Source code in src/aws_sdk_bedrock_runtime/client.py

async def apply_guardrail(
    self, input: ApplyGuardrailInput, plugins: list[Plugin] | None = None
) -> ApplyGuardrailOutput:
    """The action to apply a guardrail.

    For troubleshooting some of the common errors you might encounter when
    using the `ApplyGuardrail` API, see [Troubleshooting Amazon Bedrock API
    Error
    Codes](https://docs.aws.amazon.com/bedrock/latest/userguide/troubleshooting-api-error-codes.html)
    in the Amazon Bedrock User Guide

    Args:
        input:
            An instance of `ApplyGuardrailInput`.
        plugins:
            A list of callables that modify the configuration dynamically.
            Changes made by these plugins only apply for the duration of the
            operation execution and will not affect any other operation
            invocations.

    Returns:
        An instance of `ApplyGuardrailOutput`.
    """
    operation_plugins: list[Plugin] = []
    if plugins:
        operation_plugins.extend(plugins)
    config = deepcopy(self._config)
    for plugin in operation_plugins:
        plugin(config)
    if config.protocol is None or config.transport is None:
        raise ExpectationNotMetError(
            "protocol and transport MUST be set on the config to make calls."
        )
    pipeline = RequestPipeline(protocol=config.protocol, transport=config.transport)
    call = ClientCall(
        input=input,
        operation=APPLY_GUARDRAIL,
        context=TypedProperties({"config": config}),
        interceptor=InterceptorChain(config.interceptors),
        auth_scheme_resolver=config.auth_scheme_resolver,
        supported_auth_schemes=config.auth_schemes,
        endpoint_resolver=config.endpoint_resolver,
        retry_strategy=config.retry_strategy,
    )

    return await pipeline(call)

Input

ApplyGuardrailInput dataclass

Dataclass for ApplyGuardrailInput structure.

Source code in src/aws_sdk_bedrock_runtime/models.py

@dataclass(kw_only=True)
class ApplyGuardrailInput:
    """Dataclass for ApplyGuardrailInput structure."""

    guardrail_identifier: str | None = None
    """The guardrail identifier used in the request to apply the guardrail."""

    guardrail_version: str | None = None
    """The guardrail version used in the request to apply the guardrail."""

    source: str | None = None
    """The source of data used in the request to apply the guardrail."""

    content: list[GuardrailContentBlock] | None = None
    """The content details used in the request to apply the guardrail."""

    output_scope: str | None = None
    """Specifies the scope of the output that you get in the response. Set to
    `FULL` to return the entire output, including any detected and
    non-detected entries in the response for enhanced debugging.

    Note that the full output scope doesn't apply to word filters or regex
    in sensitive information filters. It does apply to all other filtering
    policies, including sensitive information with filters that can detect
    personally identifiable information (PII).
    """

    def serialize(self, serializer: ShapeSerializer):
        serializer.write_struct(_SCHEMA_APPLY_GUARDRAIL_INPUT, self)

    def serialize_members(self, serializer: ShapeSerializer):
        if self.guardrail_identifier is not None:
            serializer.write_string(
                _SCHEMA_APPLY_GUARDRAIL_INPUT.members["guardrailIdentifier"],
                self.guardrail_identifier,
            )

        if self.guardrail_version is not None:
            serializer.write_string(
                _SCHEMA_APPLY_GUARDRAIL_INPUT.members["guardrailVersion"],
                self.guardrail_version,
            )

        if self.source is not None:
            serializer.write_string(
                _SCHEMA_APPLY_GUARDRAIL_INPUT.members["source"], self.source
            )

        if self.content is not None:
            _serialize_guardrail_content_block_list(
                serializer,
                _SCHEMA_APPLY_GUARDRAIL_INPUT.members["content"],
                self.content,
            )

        if self.output_scope is not None:
            serializer.write_string(
                _SCHEMA_APPLY_GUARDRAIL_INPUT.members["outputScope"], self.output_scope
            )

    @classmethod
    def deserialize(cls, deserializer: ShapeDeserializer) -> Self:
        return cls(**cls.deserialize_kwargs(deserializer))

    @classmethod
    def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]:
        kwargs: dict[str, Any] = {}

        def _consumer(schema: Schema, de: ShapeDeserializer) -> None:
            match schema.expect_member_index():
                case 0:
                    kwargs["guardrail_identifier"] = de.read_string(
                        _SCHEMA_APPLY_GUARDRAIL_INPUT.members["guardrailIdentifier"]
                    )

                case 1:
                    kwargs["guardrail_version"] = de.read_string(
                        _SCHEMA_APPLY_GUARDRAIL_INPUT.members["guardrailVersion"]
                    )

                case 2:
                    kwargs["source"] = de.read_string(
                        _SCHEMA_APPLY_GUARDRAIL_INPUT.members["source"]
                    )

                case 3:
                    kwargs["content"] = _deserialize_guardrail_content_block_list(
                        de, _SCHEMA_APPLY_GUARDRAIL_INPUT.members["content"]
                    )

                case 4:
                    kwargs["output_scope"] = de.read_string(
                        _SCHEMA_APPLY_GUARDRAIL_INPUT.members["outputScope"]
                    )

                case _:
                    logger.debug("Unexpected member schema: %s", schema)

        deserializer.read_struct(_SCHEMA_APPLY_GUARDRAIL_INPUT, consumer=_consumer)
        return kwargs

Attributes

content class-attribute instance-attribute

content: list[GuardrailContentBlock] | None = None

The content details used in the request to apply the guardrail.

guardrail_identifier class-attribute instance-attribute

guardrail_identifier: str | None = None

The guardrail identifier used in the request to apply the guardrail.

guardrail_version class-attribute instance-attribute

guardrail_version: str | None = None

The guardrail version used in the request to apply the guardrail.

output_scope class-attribute instance-attribute

output_scope: str | None = None

Specifies the scope of the output that you get in the response. Set to FULL to return the entire output, including any detected and non-detected entries in the response for enhanced debugging.

Note that the full output scope doesn't apply to word filters or regex in sensitive information filters. It does apply to all other filtering policies, including sensitive information with filters that can detect personally identifiable information (PII).

source class-attribute instance-attribute

source: str | None = None

The source of data used in the request to apply the guardrail.

Output

ApplyGuardrailOutput dataclass

Dataclass for ApplyGuardrailOutput structure.

Source code in src/aws_sdk_bedrock_runtime/models.py

@dataclass(kw_only=True)
class ApplyGuardrailOutput:
    """Dataclass for ApplyGuardrailOutput structure."""

    usage: GuardrailUsage
    """The usage details in the response from the guardrail."""

    action: str
    """The action taken in the response from the guardrail."""

    outputs: list[GuardrailOutputContent]
    """The output details in the response from the guardrail."""

    assessments: list[GuardrailAssessment]
    """The assessment details in the response from the guardrail."""

    action_reason: str | None = None
    """The reason for the action taken when harmful content is detected."""

    guardrail_coverage: GuardrailCoverage | None = None
    """The guardrail coverage details in the apply guardrail response."""

    def serialize(self, serializer: ShapeSerializer):
        serializer.write_struct(_SCHEMA_APPLY_GUARDRAIL_OUTPUT, self)

    def serialize_members(self, serializer: ShapeSerializer):
        serializer.write_struct(
            _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["usage"], self.usage
        )
        serializer.write_string(
            _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["action"], self.action
        )
        if self.action_reason is not None:
            serializer.write_string(
                _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["actionReason"],
                self.action_reason,
            )

        _serialize_guardrail_output_content_list(
            serializer, _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["outputs"], self.outputs
        )
        _serialize_guardrail_assessment_list(
            serializer,
            _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["assessments"],
            self.assessments,
        )
        if self.guardrail_coverage is not None:
            serializer.write_struct(
                _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["guardrailCoverage"],
                self.guardrail_coverage,
            )

    @classmethod
    def deserialize(cls, deserializer: ShapeDeserializer) -> Self:
        return cls(**cls.deserialize_kwargs(deserializer))

    @classmethod
    def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]:
        kwargs: dict[str, Any] = {}

        def _consumer(schema: Schema, de: ShapeDeserializer) -> None:
            match schema.expect_member_index():
                case 0:
                    kwargs["usage"] = GuardrailUsage.deserialize(de)

                case 1:
                    kwargs["action"] = de.read_string(
                        _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["action"]
                    )

                case 2:
                    kwargs["action_reason"] = de.read_string(
                        _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["actionReason"]
                    )

                case 3:
                    kwargs["outputs"] = _deserialize_guardrail_output_content_list(
                        de, _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["outputs"]
                    )

                case 4:
                    kwargs["assessments"] = _deserialize_guardrail_assessment_list(
                        de, _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["assessments"]
                    )

                case 5:
                    kwargs["guardrail_coverage"] = GuardrailCoverage.deserialize(de)

                case _:
                    logger.debug("Unexpected member schema: %s", schema)

        deserializer.read_struct(_SCHEMA_APPLY_GUARDRAIL_OUTPUT, consumer=_consumer)
        return kwargs

Attributes

action instance-attribute

action: str

The action taken in the response from the guardrail.

action_reason class-attribute instance-attribute

action_reason: str | None = None

The reason for the action taken when harmful content is detected.

assessments instance-attribute

assessments: list[GuardrailAssessment]

The assessment details in the response from the guardrail.

guardrail_coverage class-attribute instance-attribute

guardrail_coverage: GuardrailCoverage | None = None

The guardrail coverage details in the apply guardrail response.

outputs instance-attribute

outputs: list[GuardrailOutputContent]

The output details in the response from the guardrail.

usage instance-attribute

usage: GuardrailUsage

The usage details in the response from the guardrail.

Errors

• AccessDeniedException

• InternalServerException

• ResourceNotFoundException

• ServiceQuotaExceededException

• ServiceUnavailableException

• ThrottlingException

• ValidationException