update_content async ¶

async def update_content(
    self,
    knowledge_base_id: "capo_qconnect.types.uuid_or_arn.UuidOrArn",
    content_id: "capo_qconnect.types.uuid_or_arn.UuidOrArn",
    *,
    config_overrides: Optional[AsyncQConnectClientConfig] = None,
    revision_id: Optional[
        "capo_qconnect.types.non_empty_string.NonEmptyString"
    ] = None,
    title: Optional["capo_qconnect.types.content_title.ContentTitle"] = None,
    override_link_out_uri: Optional["capo_qconnect.types.uri.Uri"] = None,
    remove_override_link_out_uri: Optional[bool] = None,
    metadata: Optional[
        "capo_qconnect.types.content_metadata.ContentMetadata"
    ] = None,
    upload_id: Optional["capo_qconnect.types.upload_id.UploadId"] = None,
) -> "capo_qconnect.types.update_content_response.UpdateContentResponse":
    """<p>Updates information about the content.</p>

    Args:
        knowledge_base_id: <p>The identifier of the knowledge base. This should not be a QUICK_RESPONSES type knowledge base. Can be either the ID or the ARN</p>
        content_id: <p>The identifier of the content. Can be either the ID or the ARN. URLs cannot contain the ARN.</p>
        revision_id: <p>The <code>revisionId</code> of the content resource to update, taken from an earlier call to <code>GetContent</code>, <code>GetContentSummary</code>, <code>SearchContent</code>, or <code>ListContents</code>. If included, this argument acts as an optimistic lock to ensure content was not modified since it was last read. If it has been modified, this API throws a <code>PreconditionFailedException</code>.</p>
        title: <p>The title of the content.</p>
        override_link_out_uri: <p>The URI for the article. If the knowledge base has a templateUri, setting this argument overrides it for this piece of content. To remove an existing <code>overrideLinkOurUri</code>, exclude this argument and set <code>removeOverrideLinkOutUri</code> to true.</p>
        remove_override_link_out_uri: <p>Unset the existing <code>overrideLinkOutUri</code> if it exists.</p>
        metadata: <p>A key/value map to store attributes without affecting tagging or recommendations. For example, when synchronizing data between an external system and Amazon Q in Connect, you can store an external version identifier as metadata to utilize for determining drift.</p>
        upload_id: <p>A pointer to the uploaded asset. This value is returned by <a href="https://docs.aws.amazon.com/amazon-q-connect/latest/APIReference/API_StartContentUpload.html">StartContentUpload</a>. </p>

    Raises:
        capo_qconnect.errors.access_denied_exception.AccessDeniedException: <p>You do not have sufficient access to perform this action.</p>
        capo_qconnect.errors.precondition_failed_exception.PreconditionFailedException: <p>The provided <code>revisionId</code> does not match, indicating the content has been modified since it was last read.</p>
        capo_qconnect.errors.resource_not_found_exception.ResourceNotFoundException: <p>The specified resource does not exist.</p>
        capo_qconnect.errors.unauthorized_exception.UnauthorizedException: <p>You do not have permission to perform this action.</p>
        capo_qconnect.errors.validation_exception.ValidationException: <p>The input fails to satisfy the constraints specified by a service.</p>
        capo_qconnect.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_qconnect.types.update_content_request.UpdateContentRequest]",
    ) -> AsyncOperationResponse[
        "capo_qconnect.types.update_content_response.UpdateContentResponse"
    ]:
        import capo_qconnect._operations.wisdom_service.update_content

        (
            output,
            http_response,
        ) = await capo_qconnect._operations.wisdom_service.update_content.async_update_content(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    def _redact_output(
        output: "capo_qconnect.types.update_content_response.UpdateContentResponse",
    ) -> dict[str, Any]:
        import capo_qconnect.types.update_content_response

        return capo_qconnect.types.update_content_response.redact_sensitive(output)

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging("UpdateContent", redact_output=_redact_output),
    )
    input_: capo_qconnect.types.update_content_request.UpdateContentRequest = {
        "knowledge_base_id": knowledge_base_id,
        "content_id": content_id,
    }
    if revision_id is not None:
        input_["revision_id"] = revision_id
    if title is not None:
        input_["title"] = title
    if override_link_out_uri is not None:
        input_["override_link_out_uri"] = override_link_out_uri
    if remove_override_link_out_uri is not None:
        input_["remove_override_link_out_uri"] = remove_override_link_out_uri
    if metadata is not None:
        input_["metadata"] = metadata
    if upload_id is not None:
        input_["upload_id"] = upload_id

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