update_queue ¶

def update_queue(
    self,
    name: "capo_mediaconvert.types.__string.__string",
    *,
    config_overrides: Optional[MediaConvertClientConfig] = None,
    concurrent_jobs: Optional["capo_mediaconvert.types.__integer.__integer"] = None,
    description: Optional["capo_mediaconvert.types.__string.__string"] = None,
    maximum_concurrent_feeds: Optional[
        "capo_mediaconvert.types.__integer_min0.__integerMin0"
    ] = None,
    reservation_plan_settings: Optional[
        "capo_mediaconvert.types.reservation_plan_settings.ReservationPlanSettings"
    ] = None,
    status: Optional["capo_mediaconvert.types.queue_status.QueueStatus"] = None,
) -> "capo_mediaconvert.types.update_queue_response.UpdateQueueResponse":
    """Modify one of your existing queues.

    Args:
        concurrent_jobs: Specify the maximum number of jobs your queue can process concurrently. For on-demand queues, the value you enter is constrained by your service quotas for Maximum concurrent jobs, per on-demand queue and Maximum concurrent jobs, per account. For reserved queues, update your reservation plan instead in order to increase your yearly commitment.
        description: The new description for the queue, if you are changing it.
        maximum_concurrent_feeds: Specify the maximum number of Elemental Inference feeds MediaConvert can process concurrently.
        name: The name of the queue that you are modifying.
        reservation_plan_settings: The new details of your pricing plan for your reserved queue. When you set up a new pricing plan to replace an expired one, you enter into another 12-month commitment. When you add capacity to your queue by increasing the number of RTS, you extend the term of your commitment to 12 months from when you add capacity. After you make these commitments, you can't cancel them.
        status: Pause or activate a queue by changing its status between ACTIVE and PAUSED. If you pause a queue, jobs in that queue won't begin. Jobs that are running when you pause the queue continue to run until they finish or result in an error.

    Raises:
        capo_mediaconvert.errors.bad_request_exception.BadRequestException: The service can't process your request because of a problem in the request. Please check your request form and syntax.
        capo_mediaconvert.errors.conflict_exception.ConflictException: The service couldn't complete your request because there is a conflict with the current state of the resource.
        capo_mediaconvert.errors.forbidden_exception.ForbiddenException: You don't have permissions for this action with the credentials you sent.
        capo_mediaconvert.errors.internal_server_error_exception.InternalServerErrorException: The service encountered an unexpected condition and can't fulfill your request.
        capo_mediaconvert.errors.not_found_exception.NotFoundException: The resource you requested doesn't exist.
        capo_mediaconvert.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: You attempted to create more resources than the service allows based on service quotas.
        capo_mediaconvert.errors.too_many_requests_exception.TooManyRequestsException: Too many requests have been sent in too short of a time. The service limits the rate at which it will accept requests.
        capo_mediaconvert.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    def _handler(
        req: "OperationRequest[capo_mediaconvert.types.update_queue_request.UpdateQueueRequest]",
    ) -> OperationResponse[
        "capo_mediaconvert.types.update_queue_response.UpdateQueueResponse"
    ]:
        import capo_mediaconvert._operations.media_convert.update_queue

        output, http_response = (
            capo_mediaconvert._operations.media_convert.update_queue.update_queue(
                req.options, req.input
            )
        )
        return OperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("UpdateQueue")
    )
    input_: capo_mediaconvert.types.update_queue_request.UpdateQueueRequest = {
        "name": name
    }
    if concurrent_jobs is not None:
        input_["concurrent_jobs"] = concurrent_jobs
    if description is not None:
        input_["description"] = description
    if maximum_concurrent_feeds is not None:
        input_["maximum_concurrent_feeds"] = maximum_concurrent_feeds
    if reservation_plan_settings is not None:
        input_["reservation_plan_settings"] = reservation_plan_settings
    if status is not None:
        input_["status"] = status

    response = execute_pipeline(
        OperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    response.response.close()
    return response.output