put_signing_profile async ¶

async def put_signing_profile(
    self,
    profile_name: "capo_signer.types.profile_name.ProfileName",
    platform_id: "capo_signer.types.platform_id.PlatformId",
    *,
    config_overrides: Optional[AsyncsignerClientConfig] = None,
    signing_material: Optional[
        "capo_signer.types.signing_material.SigningMaterial"
    ] = None,
    signature_validity_period: Optional[
        "capo_signer.types.signature_validity_period.SignatureValidityPeriod"
    ] = None,
    overrides: Optional[
        "capo_signer.types.signing_platform_overrides.SigningPlatformOverrides"
    ] = None,
    signing_parameters: Optional[
        "capo_signer.types.signing_parameters.SigningParameters"
    ] = None,
    tags: Optional["capo_signer.types.tag_map.TagMap"] = None,
) -> "capo_signer.types.put_signing_profile_response.PutSigningProfileResponse":
    """<p>Creates a signing profile. A signing profile is a code-signing template that can be used to carry out a pre-defined signing job. </p>

    Args:
        profile_name: <p>The name of the signing profile to be created.</p>
        signing_material: <p>The AWS Certificate Manager certificate that will be used to sign code with the new signing profile.</p>
        signature_validity_period: <p>The default validity period override for any signature generated using this signing profile. If unspecified, the default is 135 months.</p>
        platform_id: <p>The ID of the signing platform to be created.</p>
        overrides: <p>A subfield of <code>platform</code>. This specifies any different configuration options that you want to apply to the chosen platform (such as a different <code>hash-algorithm</code> or <code>signing-algorithm</code>).</p>
        signing_parameters: <p>Map of key-value pairs for signing. These can include any information that you want to use during signing.</p>
        tags: <p>Tags to be associated with the signing profile that is being created.</p>

    Raises:
        capo_signer.errors.access_denied_exception.AccessDeniedException: <p>You do not have sufficient access to perform this action.</p>
        capo_signer.errors.internal_service_error_exception.InternalServiceErrorException: <p>An internal error occurred.</p>
        capo_signer.errors.resource_not_found_exception.ResourceNotFoundException: <p>A specified resource could not be found.</p>
        capo_signer.errors.too_many_requests_exception.TooManyRequestsException: <p>The allowed number of job-signing requests has been exceeded.</p> <p>This error supersedes the error <code>ThrottlingException</code>.</p>
        capo_signer.errors.validation_exception.ValidationException: <p>You signing certificate could not be validated.</p>
        capo_signer.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_signer.types.put_signing_profile_request.PutSigningProfileRequest]",
    ) -> AsyncOperationResponse[
        "capo_signer.types.put_signing_profile_response.PutSigningProfileResponse"
    ]:
        import capo_signer._operations.wallaby_service.put_signing_profile

        (
            output,
            http_response,
        ) = await capo_signer._operations.wallaby_service.put_signing_profile.async_put_signing_profile(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("PutSigningProfile")
    )
    input_: capo_signer.types.put_signing_profile_request.PutSigningProfileRequest = {
        "profile_name": profile_name,
        "platform_id": platform_id,
    }
    if signing_material is not None:
        input_["signing_material"] = signing_material
    if signature_validity_period is not None:
        input_["signature_validity_period"] = signature_validity_period
    if overrides is not None:
        input_["overrides"] = overrides
    if signing_parameters is not None:
        input_["signing_parameters"] = signing_parameters
    if tags is not None:
        input_["tags"] = tags

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