update_map_run async ¶

async def update_map_run(
    self,
    map_run_arn: "capo_sfn.types.long_arn.LongArn",
    *,
    config_overrides: Optional[AsyncSFNClientConfig] = None,
    max_concurrency: Optional[
        "capo_sfn.types.max_concurrency.MaxConcurrency"
    ] = None,
    tolerated_failure_percentage: Optional[
        "capo_sfn.types.tolerated_failure_percentage.ToleratedFailurePercentage"
    ] = None,
    tolerated_failure_count: Optional[
        "capo_sfn.types.tolerated_failure_count.ToleratedFailureCount"
    ] = None,
) -> "capo_sfn.types.update_map_run_output.UpdateMapRunOutput":
    """<p>Updates an in-progress Map Run's configuration to include changes to the settings that control maximum concurrency and Map Run failure.</p>

    Args:
        map_run_arn: <p>The Amazon Resource Name (ARN) of a Map Run.</p>
        max_concurrency: <p>The maximum number of child workflow executions that can be specified to run in parallel for the Map Run at the same time.</p>
        tolerated_failure_percentage: <p>The maximum percentage of failed items before the Map Run fails.</p>
        tolerated_failure_count: <p>The maximum number of failed items before the Map Run fails.</p>

    Raises:
        capo_sfn.errors.invalid_arn.InvalidArn: <p>The provided Amazon Resource Name (ARN) is not valid.</p>
        capo_sfn.errors.resource_not_found.ResourceNotFound: <p>Could not find the referenced resource.</p>
        capo_sfn.errors.validation_exception.ValidationException: <p>The input does not satisfy the constraints specified by an Amazon Web Services service.</p>
        capo_sfn.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_sfn.types.update_map_run_input.UpdateMapRunInput]",
    ) -> AsyncOperationResponse[
        "capo_sfn.types.update_map_run_output.UpdateMapRunOutput"
    ]:
        import capo_sfn._operations.aws_step_functions.update_map_run

        (
            output,
            http_response,
        ) = await capo_sfn._operations.aws_step_functions.update_map_run.async_update_map_run(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("UpdateMapRun")
    )
    input_: capo_sfn.types.update_map_run_input.UpdateMapRunInput = {
        "map_run_arn": map_run_arn
    }
    if max_concurrency is not None:
        input_["max_concurrency"] = max_concurrency
    if tolerated_failure_percentage is not None:
        input_["tolerated_failure_percentage"] = tolerated_failure_percentage
    if tolerated_failure_count is not None:
        input_["tolerated_failure_count"] = tolerated_failure_count

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