update_rule async ¶

async def update_rule(
    self,
    domain_identifier: "capo_datazone.types.domain_id.DomainId",
    identifier: "capo_datazone.types.rule_id.RuleId",
    *,
    config_overrides: Optional[AsyncDataZoneClientConfig] = None,
    name: Optional["capo_datazone.types.rule_name.RuleName"] = None,
    description: Optional["capo_datazone.types.description.Description"] = None,
    scope: Optional["capo_datazone.types.rule_scope.RuleScope"] = None,
    detail: Optional["capo_datazone.types.rule_detail.RuleDetail"] = None,
    include_child_domain_units: Optional[bool] = None,
) -> "capo_datazone.types.update_rule_output.UpdateRuleOutput":
    """<p>Updates a rule. In Amazon DataZone, a rule is a formal agreement that enforces specific requirements across user workflows (e.g., publishing assets to the catalog, requesting subscriptions, creating projects) within the Amazon DataZone data portal. These rules help maintain consistency, ensure compliance, and uphold governance standards in data management processes. For instance, a metadata enforcement rule can specify the required information for creating a subscription request or publishing a data asset to the catalog, ensuring alignment with organizational standards.</p>

    Args:
        domain_identifier: <p>The ID of the domain in which a rule is to be updated.</p>
        identifier: <p>The ID of the rule that is to be updated</p>
        name: <p>The name of the rule.</p>
        description: <p>The description of the rule.</p>
        scope: <p>The scrope of the rule.</p>
        detail: <p>The detail of the rule.</p>
        include_child_domain_units: <p>Specifies whether to update this rule in the child domain units.</p>

    Raises:
        capo_datazone.errors.access_denied_exception.AccessDeniedException: <p>You do not have sufficient access to perform this action.</p>
        capo_datazone.errors.throttling_exception.ThrottlingException: <p>The request was denied due to request throttling.</p>
        capo_datazone.errors.unauthorized_exception.UnauthorizedException: <p>You do not have permission to perform this action.</p>
        capo_datazone.errors.conflict_exception.ConflictException: <p>There is a conflict while performing this action.</p>
        capo_datazone.errors.internal_server_exception.InternalServerException: <p>The request has failed because of an unknown error, exception or failure.</p>
        capo_datazone.errors.resource_not_found_exception.ResourceNotFoundException: <p>The specified resource cannot be found.</p>
        capo_datazone.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: <p>The request has exceeded the specified service quota.</p>
        capo_datazone.errors.validation_exception.ValidationException: <p>The input fails to satisfy the constraints specified by the Amazon Web Services service.</p>
        capo_datazone.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_datazone.types.update_rule_input.UpdateRuleInput]",
    ) -> AsyncOperationResponse[
        "capo_datazone.types.update_rule_output.UpdateRuleOutput"
    ]:
        import capo_datazone._operations.data_zone.update_rule

        (
            output,
            http_response,
        ) = await capo_datazone._operations.data_zone.update_rule.async_update_rule(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    def _redact_input(
        input_: "capo_datazone.types.update_rule_input.UpdateRuleInput",
    ) -> dict[str, Any]:
        import capo_datazone.types.update_rule_input

        return capo_datazone.types.update_rule_input.redact_sensitive(input_)

    def _redact_output(
        output: "capo_datazone.types.update_rule_output.UpdateRuleOutput",
    ) -> dict[str, Any]:
        import capo_datazone.types.update_rule_output

        return capo_datazone.types.update_rule_output.redact_sensitive(output)

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging(
            "UpdateRule", redact_input=_redact_input, redact_output=_redact_output
        ),
    )
    input_: capo_datazone.types.update_rule_input.UpdateRuleInput = {
        "domain_identifier": domain_identifier,
        "identifier": identifier,
    }
    if name is not None:
        input_["name"] = name
    if description is not None:
        input_["description"] = description
    if scope is not None:
        input_["scope"] = scope
    if detail is not None:
        input_["detail"] = detail
    if include_child_domain_units is not None:
        input_["include_child_domain_units"] = include_child_domain_units

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output